Почему в некоторых языках программирования сохраняется чувствительность к регистру?

Я не вижу смысла в чувствительности к регистру в языке программирования, кроме запутывания кода.

Зачем реализовывать это на языке программирования?

Обновить:

Похоже, кто-то, кого вы знаете, сделал заявление по этому поводу .

Хотя сворачивание падежа довольно тривиально на английском языке, на некоторых других языках оно намного меньше. Если немецкий программист использует ßимя переменной, что вы собираетесь считать эквивалентом в верхнем регистре? Просто к сведению, «ß» используется только в нижнем регистре. Ото, «сс» является эквивалентом - Вы бы компилятор обязан сопоставить их? Когда вы попадаете в Unicode, вы сталкиваетесь с еще более интересными проблемами, такими как символы с предварительно составленными диакритическими знаками или отдельные комбинированные диакритические знаки. Затем вы попадаете на некоторые арабские сценарии с тремя отдельными формами из множества букв, а не только с двумя.

В темные времена большинство языков программирования были нечувствительны к регистру почти по необходимости. Например, Паскаль начинал с мэйнфреймов Control Data, которые использовали только шесть битов на символ (всего 64 кода). Большинство таких машин использовали набор символов "CDC Scientific", который содержал только символы верхнего регистра. Вы могли переключаться на другие наборы символов, но большинство из них имели прописные или строчные буквы, но не оба, но использовали одни и те же коды для обоих. То же самое относится и к древним кодам Бодо и таким считающимся стандартом в первые дни COBOL, FORTRAN, BASIC и т. Д. К тому времени, когда стали доступны более мощные аппаратные средства, их нечувствительность к регистру была настолько укоренилась, что изменить их было невозможно ,

Со временем реальная проблема нечувствительности к регистру стала более очевидной, и разработчики языка в основном решили («реализованный», вероятно, был бы более точный термин), что когда / если люди действительно хотят нечувствительность к регистру, то лучше справляться с помощью вспомогательных инструментов. чем в самом языке.

По крайней мере, IMO, компилятор должен принимать ввод в точности так, как он представлен, а не решать, что «вы написали это, но я собираюсь предположить, что вы действительно имели в виду что-то другое». Если вы хотите, чтобы переводы происходили, вам лучше делать их отдельно, с инструментами, созданными, чтобы справиться с этим.

Зачем кому-то ХОЧЕТ регистронезависимость? В каком сценарии полезно иметь возможность ссылаться на одну переменную как VARIABLEв одном месте, так и Variableв другом variable? Нечувствительность к регистру раздражает. Я бы предпочел получить ошибку компилятора, когда я случайно наберу текст VAriableвместо того Variable, чтобы позволять опечаткам, подобным этому, вставлять в мой код.

В заключение, многие языки программирования чувствительны к регистру не только по историческим / инерционным причинам, но и потому, что нечувствительность к регистру является плохой идеей.

В Java чувствительность к регистру НЕ используется для предоставления большего количества опций в коде, но для очень ясного и согласованного семантического значения. ClassesLookLikeThis. objectsLookLikeThis. methodsLookLikeThis (). STATIC_VARIABLES_LOOK_LIKE_THIS. Classes.WithInnerClassesLookLikeThis. Это НЕ дает большей свободы: оно позволяет вам сжато упаковать некоторую информацию в то, что в противном случае является слишком многословным языком.

Я думаю, что в явно статически типизированных языках с поддержкой компилятора mucho и IDE чувствительность к регистру является отличным способом передачи информации (например, Java). С такими языками, как Ruby, нечувствительность к регистру, вероятно, могла бы привести к еще БОЛЬШИМ неожиданным результатам, хотя я был бы открыт к пробам Ruby без учета регистра.

Я думаю, что чувствительность к регистру при строгой системе не запутывает код, но делает его более понятным. Рассмотрим возможный код Java:

      joe blah = new hUf();

это довольно ясно, но как насчет:

      hUf.WTF();

В Java как есть, вы автоматически знаете, что это такое. В Java без учета регистра это неоднозначно, поэтому вам придется прибегнуть к какому-то другому механизму, чтобы отличать классы от экземпляров, пакетов от методов. И этот механизм, вероятно, заставит вас рвать от того, насколько это ужасно :)

Я не думаю, что это было "реализовано" настолько, насколько "позволено". Чувствительность к регистру - это состояние сравнения строк по умолчанию; инженеру компилятора требуется дополнительная работа, чтобы сделать язык нечувствительным к регистру, так как вам нужно добавить дополнительный код для выполнения нечувствительных к регистру сравнений и сохранить исходные имена токенов для правильных отчетов об ошибках и предупреждениях.

Это почти наверняка, почему это закончилось в C; они хотели создать простой язык, для которого было бы легко реализовать компилятор, за счет удобства использования. Что касается того, почему это в современных языках? Конечно, потому что это на C, поэтому это должен быть правильный способ! </ режим сарказма>

Если ничего другого, это упрощает синтаксический анализ и позволяет вам больше комбинаций для имен переменных / классов.

При анализе без учета регистра вы будете вынуждены использовать уникальные идентификаторы, поскольку «myClass» и «MyClass» - это одно и то же. В качестве альтернативы вам придется добавить слои сложности в ваш анализатор, чтобы убедиться, что вы можете определить, какой идентификатор используется на основе контекста.

Рассмотрим случай, подобный этому:

XmlWriter xmlWriter = new XmlWriter();
xmlWriter.Write("blah");

Предположим, что класс XmlWriter также имеет статический метод с именем «Запись». Вы вызываете его в экземпляре или в классе, если здесь не применяется чувствительность к регистру?

Мне нравится чувствительность к регистру, если только по какой-то другой причине он делает код более самодокументированным:

this is a CONSTANT
this is a ClassName
this is a methodName
this is a local variablename

Обычно я программирую на Python, но в те дни, когда я занимался C #, мне было очень удобно называть экземпляры классов так же, как класс, но в нижнем (или верблюжьем) случае (как говорили другие):

Thing thing = new Thing();

Использование нечувствительных к регистру языков требует некоторого другого соглашения для этого, то есть некоторого вида символа, такого как:

Thing oThing = new Thing()
Thing instanceOfThing = new Thing()

Что является "плохой вещью".

Я также нахожу удобным для grep (чувствительно к регистру) найти ссылку на класс в сравнении с использованием переменной. С языком без учета регистра это было бы не так просто. То же самое для поиска и замены.

Наконец, как программист, когда я вижу слова с разными падежами, мне кажется, что это разные вещи ... У меня редко бывают ошибки, когда регистры переменных были неправильными, даже в динамических скриптовых языках, где помог бы компилятор.

Люди обращают внимание на форму слов, прежде чем они действительно читают их. Чувствительность к регистру сохраняет форму символа в коде. Я также согласен с тем, что выше указано, что разные условные обозначения обозначают разные типы символов. Чувствительностью к регистру и нечувствительностью можно злоупотреблять. Плохие программисты всегда будут генерировать плохой код ... они найдут способ.

Возьмите язык в качестве примера. Почему мы начинаем предложения и называем вещи прописными буквами ... Это тоже из-за unix?

Я думаю, что для статически типизированных языков, таких как C # и Java, это на самом деле не добавляет никакой ценности. Потому что в большинстве случаев у вас есть IDE, которая все равно будет автоматически исправлять для вас несоответствия регистра, поэтому в конце дня, если я введу «VAriable» случайно, моя IDE автоматически исправит это до » Переменная "для меня. Добавьте к этому MyClass myClass;соглашения о стиле, и вы увидите, что чувствительность к регистру не обязательно плохая вещь.

Для языков с динамической типизацией может быть больше аргументов, поскольку для IDE сложнее угадать автокоррекцию, но в случае языков с динамической типизацией вам уже нужно гораздо больше беспокоиться (с точки зрения опечатки), что использование согласованного соглашения об использовании обсадных труб не увеличит нагрузку.

Так что да, хотя нет никакой реальной причины, по которой языки не могут быть нечувствительными к регистру, также нет никакой реальной причины, по которой они должны быть.

Эта статья Скотта Хансельмана о «SignOn» и «Signon» была посвящена сравнению строк и не имела ничего общего с языками программирования. Я согласен с тем, что строки, которые вводят пользователи, всегда должны сравниваться без учета регистра, но я думаю, что это отличается от идентификаторов в языке программирования.

Когда язык чувствителен к регистру, я использую его для воспроизведения традиционного использования кейса в математике и естествознании. Вот список (отнюдь не исчерпывающий) некоторых условных обозначений:

• В теории вероятностей нижний регистр fобычно представляет функцию плотности вероятности (pdf), а верхний регистр Fпредставляет соответствующую кумулятивную функцию распределения (cdf).
• Также в теории вероятностей буквы в верхнем регистре обозначают случайные величины X, а соответствующие буквы в нижнем регистре обозначают их реализации x, как в $ Pr [X = x] \ leq 0.05 $.
• В линейной алгебре прописные буквы обычно используются для обозначения матриц, тогда как строчные буквы обычно используются для обозначения чисел, например, $ A = [a_ {ij}] $.
• Символы единиц измерения пишутся строчными буквами (например, m для метра), за исключением литра (L) и единиц измерения, полученных из имени человека (W для Ватта, Pa для Паскаля, N для Ньютона и т. Д.).
• Символы префиксов, которые означают миллион или более, пишутся с заглавной буквы (M для мега (миллионов)), а те, которые меньше миллиона, строчными (m для милли (тысячных)).

Я просто подумал, что это из-за Unix и C - но это своего рода проблема с курицей и яйцом, на которую только гизеры могут ответить правильно.

Я использую обоснование, которое цыплята в «Пасхальном кролике едут в город» использовали, когда их спрашивали, пришли ли они раньше яиц. Поскольку на Ноевом Ковчеге были цыплята, первыми были цыплята. Поэтому, поскольку GCC работает на Unix, Unix был на первом месте, поэтому Unix так заботится о case, C и всех его вариантах и ​​потомках, да, все, что связано с фигурными скобками, заботится о case.

Вероятно, существует связь между фигурными скобками и чувствительностью к регистру.

В дополнение к превосходным ответам, данным до сих пор, я хотел бы отметить, что чувствительность к регистру дает вам также дополнительные «пространства имен». Например Perl имеет некоторые специальные блоки , как BEGINи ENDкоторые работают в разное время , чем обычный код (НАЧАТЬ во время компиляции, END после нормальной программы прекращена), и с теми , как все шапки делает их выделиться, и означает , что нижняя часть корпуса варианты не являются зарезервированными словами.

Можно пойти еще дальше и зарезервировать все заглавные имена для будущего использования языком, и не причинить никакого вреда обычным программистам, которые обычно не кричат ​​в своем коде.

«Чувствительность к регистру» всегда лучше для технических специалистов, чтобы уменьшить двусмысленность. Возьмите имя файла в качестве примера. Работа с именем файла Windows является более сложной задачей, чем имя файла Unix, потому что имя файла в Windows нечувствительно к регистру, а имя файла в Unix чувствительно к регистру.

Вернуться к программированию. Для имени класса, имени метода, имени переменной большинство языков не применяют правило стиля именования. Иногда для простоты «отражения» мы можем просто использовать «чувствительное к регистру» имя для привязки к другому источнику данных без преобразования или для решения проблемы с тем же именем, но в другом случае.

Я удивлен этой напыщенной информацией. Теперь, когда никто не хочет, чтобы вы использовали подчеркивание или m_имя поля в C #, я только что использовал случай верблюда, и если имя поля совпадает с именем открытого свойства, просто имя открытого свойства является регистром Паскаля и подкрепление - верблюжий случай, я полагаю, «так и быть» - это то, чего, по-видимому, хочет сообщество программистов в целом. До сих пор это не вызвало никаких проблем.

Особенно некоторые программисты приходят с первых дней BASIC, где имя переменной может быть только 2 символа.

И поэтому, когда может быть любое количество персонажей, они становятся очень счастливыми. И наряду с чувствительностью к регистру - потому что они не хотят заботиться о SomeNameтом, чтобы быть случайно равными SOMENAMEи вызывать ошибку из-за таких вещей.