Подтвердить что ты не робот

Почему многие регионы чувствительны к регистру?

Почему многие регионы чувствительны к регистру?

Это просто вопрос наследования? С++ чувствителен к регистру, потому что C is, Java чувствителен к регистру, потому что С++ - это и т.д.? Или существует более прагматичная причина?

4b9b3361

ОТВЕТЫ

Ответ 1

Unix.

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

Компьютеры не прощают - символ верхнего регистра - это не то же самое, что и строчный символ, они совершенно разные. И назад, когда обработка циклов, ОЗУ и т.д. Была дорогостоящей, не было видно, что это стоит того, чтобы заставить компиляторы и компьютеры "прощать", люди просто пытались заставить все работать.

Обратите внимание, что нечувствительность к регистру действительно не стала чем-то полезной, пока не появились такие вещи, как Visual Basic - как только компании начали инвестировать в концепция, что получение масс для программы было хорошей вещью для их нижней линии (т.е. Microsoft зарабатывает больше денег, если есть больше программ в Windows), языки стали более дружелюбными и более прощающими.

Ответ 2

Я не думаю, что вы получите лучший ответ, чем "потому что автор этого языка считал, что так лучше". Лично я думаю, что они правы. Мне бы очень хотелось найти эти строки в одном и том же исходном файле (и ссылаться на один и тот же объект + метод)...

SomeObject.SomeMethod();
...
SOMEOBJECT.SOMEMETHOD();
...
someObject.someMethod();
...
sOmEoBjEcT.sOmEmEtHoD();

Я не думаю, что кто-то был бы счастлив увидеть это...

Ответ 3

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

Там большая разница (где я живу, во всяком случае, недалеко от города Рединг) между:

Мне нравится читать.

и

Мне нравится чтение.

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

Одним из отличительных преимуществ чувствительности к регистру для языков программирования является то, что текст также становится культурно нечувствительным. Это достаточно плохо, чтобы иногда рассказывать компилятору, какая кодировка текста используется для исходного файла, - чтобы указать, какая культура в нем будет еще хуже: (

Ответ 4

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

С точки зрения синтаксиса языка вы можете заставить определенные идентификаторы начинать с нижнего или верхнего регистра (например, имя класса Java). Это упрощает синтаксический анализ и, следовательно, помогает сохранить синтаксис в чистоте.

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

Ответ 5

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

MyClass myClass;

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

Ответ 6

Сложение флага простое на английском (и для всех символов < 128). Немецкий sz или "sharp s" (ß) не имеет варианта с верхним регистром в кодировке ISO 8859-1. Он получил только один из Unicode после десятилетия обсуждения (и теперь все шрифты должны быть обновлены...). Кандзи и Хирагана (японские алфавиты) даже не знают строчные буквы.

Чтобы избежать этого беспорядка, даже в этом возрасте Unicode, нецелесообразно разрешать свертывание кода и идентификаторы Unicode.

Ответ 7

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

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

Ответ 8

ExpertSexChange

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

Это хорошая причина того, что языки чувствительны к регистру. Меньше двусмысленности! Неоднозначность для программистов считается yucky.

Ответ 9

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

Person person = new Person("Bill");

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

Кроме того, наличие Person, person, PersoN, PeRsOn и PERSON, все будут эквивалентными токенами, дадут мне головную боль.:)

Ответ 10

What is the capital form of i? I (U+0049) or İ (U+0130)?

Капитализация зависит от языка.

Ответ 11

Многие (не программируемые) языки (например, европейские с использованием латинского алфавита) чувствительны к регистру, поэтому для носителей этих языков естественно использовать различия в верхнем и нижнем регистре.

Сама идея о том, что языки программирования не чувствительны к регистру, - это исторический артефакт, возникающий из-за ограничений аппаратного обеспечения раннего поколения (в том числе машин с телетайпом перед компьютером, которые использовали 5-битный код символа).

Люди, которые спорят о случайных языках, не должны различать

IAmNowHere

от

IAmNowHere

(Это шутка!; -)

Ответ 12

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

Когда FOOBAR = FooBar = foobar, вы можете выбрать свое соглашение, а другие кодеры могут делать то же самое, независимо от того, разделяют ли вы ваши предпочтения или нет. Нет путаницы.

Они также не могут уйти от гения гения, который имеет постоянную, функцию и переменную, все с тем же именем в одном файле, хотя и с разными шапками. Опять же, нет путаницы.

Вы вызываете свой переменный WebSite, они называют свой веб-сайт, и какая система запутывается? Непростая уловка при сканировании.

Что касается поисков, действительно ли это намного больше обработки для преобразования имени в нижний регистр, прежде чем искать его? Выполнение собственной преждевременной оптимизации - одно дело, ожидая, что это будет от разработчика вашего языка выбора, - это еще один уровень отсутствия точки.

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

Ответ 13

Как вы кричите, если у вас нет CAPS?! AHHH!

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

Ответ 14

Также существует Common Lisp, который является чувствительным к регистру, который многие люди ошибочно считают нечувствительным к регистру. Когда вы вводите (car x) в Listener, он превращается в (car x) для обработки. Можно определить символы с именами нижнего регистра, но их нужно процитировать с чем-то вроде |lower-case-symbol|. Поэтому ввод в (car x) или (car x) или (car x) все работает одинаково.

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

Ответ 15

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

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

Ответ 16

С Руководство разработчика .NET Framework Соглашения о капитализации, Чувствительность к регистру:

Существуют руководящие принципы капитализации исключительно для упрощения идентификации читать и распознавать. Корпус не может быть используется как способ избежать имени столкновений между элементами библиотеки.

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

Ответ 17

Чувствительность к регистру действительно не помогает согласовать регистр.

Foo.Bar  
foo.Bar  
fOO.bAR

В случае нечувствительного языка, который может быть легко исправлен редактором. В случае чувствительного к регистру языка, это более сложно, поскольку это может быть законным. Редактор сначала должен ckeck, если существуют foo.Bar и fOO.bAR, а также должен угадать, что вы набрали неверный случай, а не забываете объявить переменную (поскольку Foo отличается от fOO).

Ответ 18

Многие люди говорили, что было бы плохо, если бы несколько форм капитализации ссылались на одно и то же, например:

person
perSoN
PERSON

Что было бы очень плохо, если бы все они ссылались на разные объекты в коде. Если у вас есть переменные person, perSoN и PERSON все ссылаются на разные вещи, у вас есть проблема.

Ответ 19

Каждый пример, который я видел, поддерживает чувствительность к регистру, основан на желании написать плохой, неиндексирующий код. например аргумент "дата" и "myDate" - это как недобросовестная, так и плохая практика. Хорошая практика - назвать ее тем, чем она на самом деле является: birthDate, hireDate, invoiceDate, что угодно. И кто в здравом уме хотел бы написать код вроде:

Public Class Person
    Public Shared ReadOnly PERSON As Person
End Class
Public Class Employee
    Public person As Person = person.PERSON
End Class

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

Ответ 20

Поскольку многие люди находят employeeSocailSecurityNumber столь же читаемым, как employee_social_security_number, и он короче.

Ответ 21

Я думаю, что язык, чувствительный к регистру, ПОНИМАЕТ людей писать плохой код.

Const SHOESIZE = 9

Class ShoeSize

ShoeSize.shoesize = SHOESIZE

call shoeSize(ShoeSize);

function shoeSize(SHOEsize)
{
   int ShoeSIZE = 10
   return ShoeSize
}

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

Ответ 22

И вы могли бы (глупо) просто использовать одиночные буквы ( "a" и "b" и "c" ) для всех классов, переменных, функций и методов.

Но ПОЧЕМУ вы хотели бы?

Использовать имена, которые имеют смысл, а не:

function a(a)
{
    int a = a.a;
    return a
}

Ответ 23

Есть еще одна причина, по которой языки чувствительны к регистру. Идентификаторы могут храниться в хеш-таблице, а хеш-таблицы зависят от хэш-функций, которые будут давать разные хэши для разных случаев. И не может быть удобно преобразовать все идентификаторы во все верхние или все нижние, прежде чем запускать их через хеш-функцию. Я столкнулся с этой проблемой, когда писал свой собственный компилятор. Гораздо проще (ленивее) объявить мой язык чувствительным к регистру.

Ответ 24

Я прочитал всю эту тему. Я должен верить, что те, кто сообщает, что нашли ценность в случае чувствительности, никогда не запрограммированы на истинном языке высокого уровня (который по определению нечувствителен к регистру). K & R допускают, что C является средним уровнем. После программирования в Pascal, Delphi, Lazarus, ADA и т.д., Вы узнаете, что очень читаемый код прост в написании и быстро запускается, не зацикливаясь на сложных конструкциях, чувствительных к регистру. В конце концов, читаемость является первым и последним словом по этому вопросу. Код написан для человека, а не для компьютера. Нет проблем для отладки с кодом, нечувствительным к регистру. Когда человек переходит на уровень среднего уровня, можно обнаружить, что нет никаких преимуществ для чувствительности к регистру. Тем не менее, значительное количество часов, затрачиваемых на отладку, вызвало проблемы. Особенно при пакетировании модулей из разных кодеров. Также представляется, что большое число респондентов не понимают, что подразумевается под чувствительностью к регистру. На них влияют только символы a-z. Это последовательное подмножество символов ASCII. Три или четыре байта машинного кода делают компилятор равнодушным к случаю в этом диапазоне символов. Он не изменяет под-бар, цифры или что-то еще. Точки о других языках и наборах символов просто не применяются к этому обсуждению. Компилятор или прерыватель будут закодированы, чтобы временно преобразовать или не преобразовать символ для анализа во время компиляции на основе ASCII или нет.

Я шокирован новыми языками, такими как Python, которые выступили с повторением ошибки, сделанной K & R. Да, они сохранили полдюжины байтов в среде, где общая оперативная память для кода компилятора, источника и объекта составляла 1000 байт. Что было тогда. Теперь память не проблема. Теперь, без разумной причины, даже резервные слова на Python чувствительны к регистру! Я не думаю, что мне нужно будет использовать "For" of "Print" в качестве имени переменной или функции. Но эта возможность была сохранена из-за дорогостоящего времени, проведенного с помощью прерывателя над точным случаем каждого идентификатора. Думаю, плохая сделка.

Ближайшая вещь, которую я прочитал на сегодняшний день в поддержку чувствительности к регистру, - это комментарии к Hashing. Но эти редкие события кодирования, которые можно обрабатывать с уделением особого внимания деталям, похоже, не заслуживают бесцельного изучения, которое кодер должен использовать для написания кода, чувствительного к регистру. Два взгляда на проблему. Один поощряет плохое кодирование, устанавливает ловушки в коде и требует дополнительного внимания, чтобы отвлечься от более крупных концепций. У другого нет ни одной стороны, он работал безупречно на языках высокого уровня и допускает гибкость, если это не повредит. Мне кажется, что еще один случай VHS выигрывает над BETA. Здесь просто мои два цента.

Ответ 25

Обучение всегда проще на примере, так что вот оно:

С# (чувствительный к регистру, но используемый с 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 используют стиль, похожий на С#, но методы/функции/события объявляются как переменные 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

Использование только OneCase и префиксов для каждого типа имеет смысл на всех языках. Даже языки, которые запускались без префиксов, имеют более новые конструкции, такие как интерфейсы, которые не полагаются на случай, но вместо этого используют префикс.

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

Так как языки, чувствительные к регистру, начали использовать префиксы, разумно прекратить использовать случай с тем же именем идентификатора someIdentifier SomeIdentifier SOME_IDENTIFIER, ISomeIdentifier и просто использовать префиксы, где это имеет смысл.

Рассмотрим эту проблему: У вас есть член класса, который называется что-то, параметр method/function, который называется что-то, и локальная переменная называется чем-то, какое соглашение о случаях может использоваться, чтобы легко отличить их? Разве не проще просто использовать большинство ConsistentCaseStyle всюду и добавить префикс?

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

Оба чувствительных к регистру и нечувствительные языки требуют строгой дисциплины, имеет смысл иметь только один стиль во всем мире. Было бы лучше, если бы у нас был язык, который использовал только StrictCase, один стиль везде и префиксы.

Существует много плохого кода C, чувствительность к регистру не делает его доступным для чтения, и вы ничего не можете с этим поделать. В нечувствительном к регистру языке вы можете обеспечить хороший стиль в своем коде без перезаписи библиотеки. На языке StrictCase, который еще не существует, весь код будет иметь достойное качество:)

Ответ 26

Похоже, что люди в основном согласны с тем, что чувствительность к регистру важна, и я согласен.

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

Ответ 27

MyClass myClass; было бы невозможно с нечувствительным к регистру компилятором.

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

MyClass myCarDesign;

Duh.

Ответ 28

По типичным стандартам кодирования Person будет классом, человеком - имя переменной, а PERSON - константой. Часто полезно использовать одно и то же слово с различной капитализацией, чтобы означать нечто связанное, но немного другое.

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

Дайте им адреса электронной почты, такие как [email protected], [email protected] и [email protected], если ваша система электронной почты чувствительна к регистру?

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

Лучше назвать их Боба, Робби и Роберта. Еще лучше назвать их Роберт А, Роберт Б и Роберт С, если их фамилии были, например, Артур, Банки и Кларк

В самом деле - почему у нас есть соглашение об именах, которое предлагает ошибки или путаницу, которые полагаются на людей, которые очень настороженны? Вы так лишены слов в своем вулкане?

А что касается человека, который упоминает якобы удобный трюк "MyClass myClass" - почему, почему? Вы намеренно затрудняетесь с первого взгляда, является ли метод методом класса или методом экземпляра.

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

Например.

Клиент ПредыдущийКлиент

Клиент NewCustomer

Клиент CorporateCustomer

Ваше имя экземпляра должно идеально сказать вашему коллеге больше, чем просто класс, на котором он основан!

Ответ 29

Если разделение слов не важно, то почему мы помещаем пробелы между словами? Поэтому я считаю, что подчеркивания между словами в названии повышают читаемость. Также проще всего прочесть строчку с заглавной буквы соответствующих символов. И, наконец, гораздо легче, если все слова могут быть переданы из уст в уста - "Клиент корпоративного подражания", а не "Капитал C Нижний случай" и "Подчеркивание капитала C Нижний случай u s t o m e r"! - первое можно сказать "в одной голове", которое последнее не может - мне интересно, как люди, которые довольны чувствительностью к регистру, обрабатывают эти чувствительные к регистру имена в своих мозгах - я действительно боюсь. Поэтому я чувствую, что чувствительность к регистру совсем не нужна - шаг назад от COBOL, по-моему.

Ответ 30

Потому что люди всерьез задумываются над вещами.

Нечувствительность к регистру работает лучше всего, когда она также сохраняется и объединяется с разделом между пространствами имен типов и переменных. Это означает, что:

  • Если вы объявляете класс как "TextureImage", а затем пытаетесь использовать его как "TextureImage", среда IDE может автокорректировать вас. Это дает вам преимущество в том, что вам никогда не удастся нажать клавишу смены, если вы не объявляете идентификатор или не использовали символ подчеркивания.

  • Как и в Java и нескольких других языках; это совершенно верно для ввода "MyClass myClass". В IDE и компиляторе не должно быть проблем с различием между использованием типа и использованием переменной.

Кроме того, нечувствительность к регистру гарантирует, что "o" и "o" никогда не будут ссылаться на разные объекты. Общие аргументы:

  • "sOmEoNe wIlL tYpE cOdE lIkE tHiS"; = > и что кому-то не разрешено присоединиться к команде разработчиков, так что это аргумент соломона. даже если им это удалось, нечувствительность к регистру - это скорее решение, чем проблема, потому что это означает, что вам не нужно запоминать какую бы сумасшедшую комбинацию в верхнем и нижнем регистре они не использовали.

  • "вы не можете легко интернационализировать нечувствительность к регистру!"; = > более 95% языков программирования написаны на английском языке по очень веской причине. нет конкурирующих кодировок символов, и подавляющее большинство клавиатур на земле основаны на английском (частично или полностью). поддержка идентификаторов юникода, возможно, является самой тупой идеей, которую кто-либо придумал в 21 веке; потому что хорошая часть символов Юникода - невидимые сюрпризы фриккина, чтение кода достаточно сложно, без использования перевода google, и писать код достаточно сложно без необходимости копировать-вставить идентификаторы или использовать карту символов.

  • ", но регистры, чувствительные к регистру, имеют больше идентификаторов!"; = > нет, у них есть грамматически перегруженные идентификаторы, что значительно хуже.

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