Почему многие языки чувствительны к регистру?
https://stackoverflow.com/questions/503218
-
20-08-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Почему многие языки чувствительны к регистру?
Это просто вопрос наследования?C ++ чувствителен к регистру, потому что C есть, Java чувствительна к регистру, потому что C ++ есть и т.д.?Или за этим стоит более прагматичная причина?
Решение
Unix.
Unix был чувствителен к регистру, и поэтому многие языки программирования, разработанные для использования в Unix, были чувствительны к регистру.
Компьютеры не прощают - символ верхнего регистра - это не то же самое, что символ нижнего регистра, они совершенно разные.И раньше, когда циклы обработки, оперативная память и так далее были дорогими, считалось, что не стоит прилагать усилий, чтобы заставить компиляторы и компьютеры быть "снисходительными", люди просто пытались заставить вещи работать.
Обратите внимание, что нечувствительность к регистру на самом деле не стала чем-то полезным, пока не появились такие вещи, как Visual Basic Визуальный Базовый пришло время - как только компании начали вкладываться в концепцию, что привлечение масс к программированию полезно для их прибыли (то есть Microsoft зарабатывает больше денег, если в Windows больше программ), языки стали более дружелюбными и снисходительными.
Другие советы
Я не думаю, что вы получите лучший ответ, чем "потому что автор (ы) этого языка посчитал, что так будет лучше".Лично я думаю, что они правы.Мне бы не хотелось находить эти строки где-либо в одном и том же исходном файле (и ссылаться на один и тот же объект + метод)...
SomeObject.SomeMethod();
...
SOMEOBJECT.SOMEMETHOD();
...
someObject.someMethod();
...
sOmEoBjEcT.sOmEmEtHoD();
Я не думаю, что кто-то был бы рад это увидеть...
Одна интересная вещь, которую следует учитывать, заключается в том, что английский язык также чувствителен к регистру.(Я подозреваю, что это верно для большинства естественных языков, но вполне возможно, что это верно не для всех.)
Есть большая разница (во всяком случае, там, где я живу, недалеко от города Рединг) между:
Я люблю читать.
и
Я люблю читать.
Точно так же, в то время как многие люди делай неправильно пишется с заглавной буквы, и вы обычно можете понять, что имеется в виду, это не означает, что такое написание считается правильный.Я сторонник, когда дело доходит до такого рода вещей, что, конечно, не означает, что я сам все делаю правильно.Я не знаю, является ли это частью наследования чувствительности языка программирования к регистру, но я подозреваю, что это может быть.
Одним из явных преимуществ чувствительности к регистру для языков программирования является то, что текст становится культурно к тому же бесчувственный.Достаточно плохо время от времени указывать компилятору, какая кодировка текста используется для исходного файла - указывать, какая Культура это в было бы еще хуже :(
На самом деле это чрезвычайно практично, как для разработчика, так и для спецификации синтаксиса языка:различие между нижним и верхним регистром придает большую выразительность именованию идентификатора.
С точки зрения синтаксиса языка, вы можете заставить определенные идентификаторы начинаться со нижнего или верхнего регистра (например, имя класса Java).Это облегчает синтаксический анализ и, следовательно, помогает поддерживать синтаксис в чистоте.
С точки зрения разработчика, это позволяет использовать огромное количество удобных соглашений о кодировании, делая ваш код более понятным.
Я предполагаю, что чувствительность к регистру увеличивает пространство имен.Хороший трюк, такой как
MyClass myClass;
было бы невозможно с компилятором, не чувствительным к регистру.
Сгибание регистра выполняется просто только на английском языке (и для всех символов < 128).Немецкий sz или "острый s" (β) не имеет варианта верхнего регистра в кодировке ISO 8859-1.Он получил только один в Юникоде примерно через десятилетие дискуссий (и теперь все шрифты должны быть обновлены ...).Кандзи и хирагана (японские алфавиты) даже не знают нижнего регистра.
Чтобы избежать этой путаницы, даже в наш век Юникода неразумно разрешать сворачивание регистра и идентификаторы в юникоде.
Раньше, когда синтаксический анализ и компиляция были очень дорогими и занимали всю ночь, компилятору было выгодно, если ему не приходилось беспокоиться о регистре.
Как только появились идентификаторы, которые были уникальны только по своему регистру, вернуться назад стало очень трудно.Многим разработчикам это понравилось, и, похоже, нет большого желания это отменять.
Обмен экспертами
Я считаю, что это конкурент Stack Overflow, где вам приходится платить за чтение ответов.Хм...из-за нечувствительности к регистру значение названия сайта неоднозначно.
Это веская причина для того, чтобы языки учитывали регистр.Меньше двусмысленности!Двусмысленность для программистов считается отвратительной.
Чувствительность к регистру повышает удобочитаемость языка за счет использования соглашений об именовании.Ты не можешь писать
Person person = new Person("Bill");
если ваш язык не чувствителен к регистру, потому что компилятор не смог бы отличить имя класса от имени переменной.
Кроме того, если бы Person, персона, PersoN, PeRsOn и PERSON были эквивалентными знаками, у меня бы разболелась голова.:)
Что такое заглавная форма i? Я (U+0049) или İ (U+0130)?
Заглавные буквы зависят от локали.
Многие (не связанные с программированием) языки (напримерЕвропейские языки, использующие латинский алфавит) чувствительны к регистру, поэтому для носителей этих языков естественно использовать различия в верхнем и нижнем регистре.
Сама идея о том, что языки программирования не стал бы учет регистра - это исторический артефакт, возникший из-за ограничений аппаратных средств раннего поколения (включая докомпьютерные телетайпные машины, которые использовали 5-битный символьный код).
Люди, которые выступают за языки без учета регистра, должно быть, не способны различать
IAmNowHere
От
IAmNowhere
(Это же шутка! ;-)
Потому что они такие же тупой, как коробка с лягушками, в точности по причинам, приведенным для противоположной точки зрения в этой теме (я даже не собираюсь спрашивать, о чем это.Древесина для деревьев и все такое).
Когда FOOBAR = FooBar = foobar, вы можете выбрать свое соглашение, и другие программисты могут сделать то же самое независимо от того, разделяют они ваши предпочтения или нет.Никакой путаницы.
Им также не сойдет с рук гениальный ход, заключающийся в том, что в одном файле есть константа, функция и переменная с одинаковым именем, хотя и с разными заглавными буквами.Опять же, никакой путаницы.
Вы вызываете свой переменный веб-сайт, они называют свой веб-сайт, и какая система путается?Это тоже нелегко уловить, когда вы сканируете.
Что касается поиска, действительно ли требуется гораздо больше времени для преобразования имени в нижний регистр перед его поиском?Делать свою собственную преждевременную оптимизацию - это одно, ожидать этого от разработчика выбранного вами языка - это совершенно другой уровень непонимания сути.
... и все же, все эти ответы, в которых говорится о чувствительности к регистру, уменьшают путаницу. Вздох
Существует также Common Lisp, язык, чувствительный к регистру, который многие люди ошибочно считают нечувствительным к регистру.Когда вы печатаете (car x) в Слушателя, это превращается в (CAR X) для обработки.Можно определить символы с именами в нижнем регистре, но они должны быть заключены в кавычки с чем-то вроде |lower-case-symbol|.Поэтому, набрав в (car x) или (CAR X) или (Car X) все работает одинаково.
(Franz Lisp в какой-то момент ввел то, что они назвали "современной" заглавной буквой, в которой Слушатель не складывал регистры, а ключевые слова CL были бы в нижнем регистре.Я никогда не следил за этим достаточно хорошо, чтобы знать, что там произошло.)
Верхний регистр буквы это не универсальная концепция.Java использует Unicode, поэтому, если вы хотите использовать Java без учета регистра, значение вашей программы может измениться в зависимости от того, в какой локали она была скомпилирована.
Большинство языков не позволяют ставить точки или запятые (или апострофы, или пробелы) в середине целочисленных литералов, вероятно, потому, что это также зависит от локали.
От Руководство разработчика .NET Framework Соглашения о капитализации, Чувствительность к регистру:
Правила использования заглавных букв существуют исключительно для того, чтобы упростить чтение и распознавание идентификаторов .Оболочка не может быть использована как средство предотвращения имен конфликтов между элементами библиотеки.
Не думайте, что все языки программирования чувствительны к регистру. языки чувствительны к регистру.Они такие нет.Имена не могут различаться по регистру только.
Как ты кричишь, если у тебя нет ШАПОК?!АААА!
Вы должны быть выразительными.Но, положа руку на сердце, из всех людей в мире те, кто работает с программной логикой, были бы первыми, кто настаивал бы на том, что различия на самом деле являются различиями.
Чувствительность к регистру на самом деле не способствует согласованности регистра.
Foo.Bar
foo.Bar
fOO.bAR
На языке без учета регистра, который может быть легко исправлен автоматически редактором.В языке, чувствительном к регистру, исправить это сложнее, так как это может быть законно.Редактор сначала должен проверить, является ли foo.Bar и fOO.bAR существуют, и они также должны догадаться, что вы ввели неправильный регистр, а не забыть объявить переменную (поскольку Foo отличается от fOO).
Многие люди здесь говорили, что было бы плохо, если бы несколько форм капитализации ссылались на одно и то же, например:
person
perSoN
PERSON
Что было бы действительно плохо, так это если бы все они ссылались на разные объекты в коде.Если у вас есть переменные person, perSoN и PERSON, которые относятся к разным вещам, у вас проблема.
Каждый пример, который я видел, поддерживающий учет регистра, основан на желании написать плохой, неописуемый код.например ,"свидание" противаргумент "myDate" - это оба столь же неописуемый и плохая практика.Хорошая практика - называть это так, как оно есть на самом деле:Дата рождения, дата найма, дата выставления счета, что угодно.И кто в здравом уме захотел бы писать такой код, как:
Public Class Person
Public Shared ReadOnly PERSON As Person
End Class
Public Class Employee
Public person As Person = person.PERSON
End Class
Удивительно, но это совершенно верный случай вчувствительный VB.Сетевой код.Мысль о том, что чувствительность к регистру позволяет вам еще более грубо нарушать правила хорошего тона в программировании, является аргументом против, а не за это.
Потому что многие люди находят employeeSocailSecurityNumber таким же читаемым, как employee_social_security_number, и он короче.
Я думаю, что наличие языка, чувствительного к регистру, ПОБУЖДАЕТ людей писать плохой код.
Const SHOESIZE = 9
Class ShoeSize
ShoeSize.shoesize = SHOESIZE
call shoeSize(ShoeSize);
function shoeSize(SHOEsize)
{
int ShoeSIZE = 10
return ShoeSize
}
Да.Вы не могли придумать лучшего имени переменной, чем "ShoeSize", для разных целей?Есть миллиард разных слов, которые вы могли бы использовать, но вы предпочитаете просто продолжать использовать ShoeSize вместо этого?
И вы также могли бы (по глупости) просто использовать одинарные буквы ("a", "b" и "c") для всех классов, переменных, функций и методов.
Но ПОЧЕМУ хотели бы вы этого?
Используйте имена, которые имеют смысл, не:
function a(a)
{
int a = a.a;
return a
}
Есть еще одна причина, по которой языки чувствительны к регистру.Идентификаторы могут храниться в хэш-таблице, а хэш-таблицы зависят от функций хеширования, которые будут выдавать разные хэши для разных регистров.И может быть неудобно преобразовывать все идентификаторы во все верхние или все нижние перед запуском их через хэш-функцию.Я столкнулся с этой проблемой, когда писал свой собственный компилятор.Было намного проще (ленивее) объявить мой язык чувствительным к регистру.
Я прочитал всю эту тему.Я должен полагать, что те, кто сообщает, что нашли значение в чувствительности к регистру, никогда не программировали на настоящем языке высокого уровня (который по определению не чувствителен к регистру).K & R признают, что C - это средний уровень.После программирования на Pascal, Delphi, Lazarus, ADA и т.д. Человек узнает, что хорошо читаемый код прост в написании и быстром запуске, не зацикливаясь на кратких конструкциях с учетом регистра.В конце концов, удобочитаемость - это первое и последнее слово по данному вопросу.Код пишется для человека, а не для компьютера.Никаких проблем при отладке с нечувствительным к регистру кодом.Когда кто-то переходит на язык среднего уровня, то обнаруживает, что чувствительность к регистру не дает НИКАКИХ преимуществ.Однако значительное количество часов, потраченных на отладку чувствительности к регистру, вызвало проблемы.Особенно при совместном использовании модулей от разных программистов.Также представляется, что большое число респондентов не понимают, что подразумевается под нечувствительностью к регистру.Затрагиваются только символы a-z.Это последовательное подмножество символов ASCII.Три или четыре байта машинного кода делают компилятор безразличным к регистру в этом диапазоне символов.Это не изменяет нижнюю панель, цифры или что-либо еще.Замечания о других языках и наборах символов просто не применимы к этому обсуждению.Компилятор или прерыватель будут закодированы так, чтобы временно преобразовывать или не преобразовывать символ для анализа во время компиляции на основе того, является он ASCII или нет.
Я шокирован появлением новых языков, таких как Python, которые повторяют ошибку, допущенную K & R.Да, они сэкономили полдюжины байт в среде, где общий объем оперативной памяти для компилятора, исходного кода и объектного кода составлял 1000 байт.Это было тогда.Теперь память - это не проблема.Теперь, без всякой разумной причины, даже резервные слова в Python чувствительны к регистру!Я не думаю, что мне нужно будет использовать "For" или "Print" в качестве имени переменной или функции.Но эта возможность была сохранена из-за дороговизны времени, затрачиваемого на то, чтобы довольствоваться прерывателем по точному регистру каждого идентификатора.Плохая сделка, я думаю.
Самое близкое, что я прочитал на сегодняшний день в поддержку учета регистра, - это комментарии к хэшированию.Но эти редкие события кодирования, которые могут быть обработаны с тщательным вниманием к деталям, похоже, не стоят бессмысленного изучения, которое программист должен использовать для написания кода с учетом регистра.Два взгляда на проблему.Один из них поощряет плохое кодирование, расставляет ловушки в коде и требует отвлечения дополнительного внимания от более масштабных концепций.Другой не имеет недостатков, безупречно работает на языках высокого уровня и обеспечивает гибкость, если это не причиняет вреда.Мне кажется, что еще один случай победы VHS над бета-версией.Это всего лишь мои два цента, которые стоят здесь.
Учиться всегда легче на примере, так что вот оно:
C # (чувствителен к регистру, но может использоваться из VB.NET который не чувствителен к регистру):
CONSTANT_NAME
IInterfaceName // Uses I prefix in all case sensitive and insensitive languages
ClassName // Readable in both case sensitive and insensitive languages
_classMember // sometimes m_classMember or just classMember
DoSomething(someParam) // Method with action name, params can be _someParam
PropertyName // Same style in case sensitive and insensitive languages
localVariable // Never using prefix
Java и JS используют стиль, аналогичный C #, но методы / функции / события объявляются как переменные doSomething, onEvent.
ObjectPascal(Delphi и Lazarus / FPC не чувствительны к регистру, как ADA и VB.NET)
CConstantName // One can use Def or no prefix, not a standard
IInterfaceName
TClassName // Non-atomic types/classes have T prefix e.g. TStructRecordName
PSomePointer // Pointers have types, safer low level stuff
FClassFieldMember // F means Field member similar to m
DoSomething(Parameter) // Older code uses prefix A for parameters instead
PropertyName
LLocalVariable // Older code uses prefix for parameters not local vars
Использование только одного случая и префиксов для каждого типа имеет смысл на всех языках.Даже языки, которые начинались без префиксов, имеют более новые конструкции, такие как интерфейсы, которые не полагаются на регистр, а вместо него используют префикс.
Так что на самом деле не важно, чувствителен язык к регистру или нет.В языки, чувствительные к регистру, были добавлены новые концепции, которые были слишком запутанными, чтобы их можно было выразить только с помощью регистра, и требовали использования префикса.
Поскольку языки, чувствительные к регистру, начали использовать префиксы, разумно прекратить использовать регистр с тем же именем идентификатора someIdentifier SomeIdentifier SOME_IDENTIFIER, ISomeIdentifier и просто использовать префиксы там, где это имеет смысл.
Рассмотрим эту проблему:У вас есть член класса с именем something, параметр метода / функции с именем something и локальная переменная с именем something, какое соглашение о регистре можно использовать, чтобы легко различать их?Не проще ли просто везде использовать наиболее согласованный casestyle и добавить префикс ?
Поклонники языков без учета регистра заботятся о качестве кода, им просто нужен один стиль.Иногда они принимают тот факт, что одна библиотека плохо написана и использует строгий стиль, в то время как у библиотеки может не быть стиля или плохой код.
Как чувствительные к регистру, так и нечувствительные языки требуют строгой дисциплины, поэтому более разумно везде использовать только один стиль.Было бы лучше, если бы у нас был язык, который использовал бы только StrictCase, везде один стиль и префиксы.
Существует много некачественного кода на C, чувствительность к регистру не делает его читабельным, и вы ничего не можете с этим поделать.На языке, не чувствительном к регистру, вы могли бы внедрить хороший стиль в свой код, не переписывая библиотеку.На языке StrictCase, который еще не существует, весь код имел бы приличное качество :)
Похоже, люди в основном согласны с тем, что чувствительность к регистру важна, и я согласен.
Однако это может раздражать, когда вам приходится вводить что-то в правильном регистре, поэтому я думаю, что IDE должна позволить вам вводить неправильный регистр, но если вы нажмете на ярлык автозаполнения, он должен выполнять сопоставление без учета регистра.Это дает нам лучшее из обоих миров.
По типичным стандартам кодирования Person будет классом, person - именем переменной, а PERSON - константой.Часто бывает полезно использовать одно и то же слово с разными заглавными буквами для обозначения чего-то родственного, но немного отличающегося.
Итак, если бы в вашем бизнесе было три сотрудника по имени Роберт, вы бы называли их Роберт, роберт и РОБЕРТ, не так ли?И полагаться на то, что люди точно поймут, что вы имели в виду?
Укажите им адреса электронной почты, такие как Robert@widgets.com, robert@widgets.com и ROBERT@widgets.com учитывала ли ваша система электронной почты регистр?
Вероятность несанкционированного нарушения персональных данных была бы огромной.Не говоря уже о том, что вы отправили пароль доступа к базе данных недовольному сотруднику, которого вот-вот уволят.
Лучше называть их Боб, Робби и Роберт.Еще лучше называть их Робертом А, Робертом Б и Робертом С, если их фамилии были, напримерАртур, Бэнкс и Кларк
Действительно - с какой стати существует соглашение об именовании, которое допускает ошибки или путаницу, которое зависит от того, что люди очень бдительны?Тебе так не хватает слов в твоем словаре?
А что касается человека, который упоминает якобы удобный трюк "MyClass MyClass" - почему, почему, почему?Вы намеренно затрудняете первое представление о том, является ли используемый метод методом класса или методом экземпляра.
Кроме того, вы потеряли шанс рассказать следующему человеку, читающему ваш код, больше о конкретном экземпляре класса.
Например.
Клиент Предыдущий клиент
Клиент Новый клиент
Клиент Корпоративный клиент
В идеале имя вашего экземпляра должно сообщать вашему коллеге больше, чем просто класс, на котором оно основано!
Если разделение слов не важно, то почему мы ставим пробелы между словами?Поэтому я думаю, что подчеркивания между словами в названии действительно повышают читабельность.Кроме того, легче всего читать строчные буквы с заглавными соответствующими символами.Наконец, безусловно, намного проще, если все слова можно передавать из уст в уста - "Корпоративный клиент с подчеркиванием", а не "Заглавная с прописной буквы о р о р а т е подчеркнутая заглавная с прописной буквы у с т о м е р"!- первое можно произнести "про себя", второе - нет - мне интересно, как люди, которые довольны чувствительностью к регистру, обрабатывают в своем мозгу эти чувствительные к регистру имена - мне действительно трудно.Поэтому я чувствую, что чувствительность к регистру совсем не помогает - на мой взгляд, шаг назад от COBOL.
Потому что люди серьезно переоценивают ситуацию.
Нечувствительность к регистру работает лучше всего, когда она также сохраняет регистр и сочетается с разделением между пространствами имен типов и переменных.Это означает , что:
Если вы объявляете класс как '
TextureImage" а затем попытайся использовать это как "textureImage', IDE может вас автоматически заменить.Это дает вам то преимущество, что вам никогда не придется нажимать клавишу shift, если вы не объявляете идентификатор или не используете символ подчеркивания.Точно так же, как в Java и нескольких других языках;это совершенно допустимо для ввода "
MyClass myClass".У IDE и компилятора не должно возникнуть проблем с различением между использованием типа и использованием переменной.
Кроме того, нечувствительность к регистру гарантирует, что 'o" и "O"никогда не будет ссылаться на разные объекты.Общие аргументы включают:
"
sOmEoNe wIlL tYpE cOdE lIkE tHiS"; => и что кому-то _never_ будет разрешено присоединиться к команде программистов, так что это соломенный аргумент.даже если бы им удалось это сделать, нечувствительность к регистру - это скорее решение, чем проблема, потому что это означает, что вам не нужно запоминать любую сумасшедшую комбинацию прописных и строчных букв, которую они используют."вы не можете легко интернационализировать нечувствительность к регистру!";=> более 95% языков программирования написаны на английском языке по очень веской причине.конкурирующих кодировок символов не существует, и подавляющее большинство клавиатур на земле основаны на английском языке (частично или полностью).поддержка идентификаторов unicode, пожалуй, самая глупая идея, которая кому-либо пришла в голову в 21 веке;поскольку значительная часть символов юникода является чертовски невидимыми заменителями, читать код достаточно сложно без использования Google translate, а писать код достаточно сложно без необходимости копировать-вставлять идентификаторы или использовать карту символов.
"но в языках, чувствительных к регистру, больше идентификаторов!";=> нет, у них грамматически перегруженные идентификаторы, что существенно хуже.
Я не использую языки, не чувствительные к регистру, но преимущества совершенно очевидны, если вы серьезно относитесь к такого рода вещам.
Разумным ответом могло бы быть то, что разработчики языка думали, что это сделало бы язык более понятным, думая о будущем :)
