Почему людям нравится учитывать регистр символов?[закрыто]
https://stackoverflow.com/questions/165455
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Просто интересно, почему людям нравится чувствительность к регистру в языке программирования?Я не пытаюсь развязать пламенную войну, просто любопытствую, вот и все.
Лично мне это никогда по-настоящему не нравилось, потому что я обнаружил, что моя производительность снижается всякий раз, когда я пробовал язык с чувствительностью к регистру, имейте в виду, я постепенно разогреваюсь / привыкаю к нему теперь, когда я использую C # и F # намного больше, чем раньше.
Так почему же тебе это нравится?
Ваше здоровье
Решение
Последовательность.Код более сложен для чтения, если "foo", "Foo", "fOO" и "fOo" считаются идентичными.
НЕКОТОРЫЕ ЛЮДИ ПИШУТ ВСЕ ЗАГЛАВНЫМИ БУКВАМИ, ДЕЛАЯ ВСЕ МЕНЕЕ ЧИТАБЕЛЬНЫМ.
Учет регистра позволяет легко использовать "одно и то же имя" по-разному, в соответствии с соглашением о заглавных буквах, например,
Foo foo = ... // "Foo" is a type, "foo" is a variable with that type
Другие советы
Преимущество VB.NET заключается в том, что, хотя он не чувствителен к регистру, IDE автоматически переформатирует все в "официальный" регистр для используемого вами идентификатора - так что его легко согласовать и легко прочитать.
Недостатком является то, что я ненавижу синтаксис в стиле VB и предпочитаю операторы, знаки препинания и синтаксис в стиле C.
В C # я обнаружил, что всегда нажимаю Ctrl-Пробел, чтобы избежать необходимости использовать правильный тип.
Просто потому, что вы можете называть вещи, которые отличаются только регистром, не означает, что это хорошая идея, потому что это может привести к недоразумениям, если многое из этого просочится в более широкие области, поэтому я рекомендую избегать этого на уровне приложения или подсистемы, но разрешать это только внутренне для функции, метода или класса.
Чувствительность к регистру не обеспечивает соблюдения стилей кодирования или согласованности.Если вы введете в регистр pascal константу, компилятор не будет жаловаться.Это просто заставит вас вводить его в регистре pascal каждый раз, когда вы его используете.Лично меня раздражает необходимость пытаться провести различие между двумя пунктами, которые отличаются только регистром.Это легко сделать в коротком блоке кода, но очень трудно сохранить правильность в очень большом блоке кода.Также обратите внимание, что единственный способ, которым люди действительно могут использовать чувствительность к регистру, не сходя с ума, - это если все они строго следуют одним и тем же соглашениям об именовании.Это соглашение об именовании добавило значение, а не чувствительность к регистру.
Я поддерживаю внутренний компилятор для своей компании, и у меня возникает соблазн сделать его гибридным - вы можете использовать любой регистр для идентификатора, и вы должны ссылаться на него с тем же регистром, но присвоение чего-либо другого с тем же именем и другим регистром приведет к ошибке.
Dim abc = 1 Dim y = Abc - 1 ' error, case doesn't match "abc" Dim ABC = False ' error, can't redeclare variable "abc"
В настоящее время он не чувствителен к регистру, так что я, вероятно, мог бы исправить несколько существующих ошибок, и никто не стал бы слишком жаловаться...
Много людей, которым нравится кейс-чувствительность неправильно понимаете, в каком случае-вчувствительность означает.
VB .NET не чувствителен к регистру.Это не означает, что вы можете объявить переменную как abc, а затем ссылаться на нее позже как ABC, Abc и aBc.Это означает, что если вы введете его как любой другой, IDE автоматически изменит его на правильный вид.
Нечувствительность к регистру означает, что вы можете вводить
dim a as string
и VS автоматически изменит его на правильно оформленный
Dim a As String
На практике это означает, что вам почти никогда не придется нажимать клавишу Shift, потому что вы можете вводить все строчные буквы и позволить IDE скорректировать их за вас.
Но C # в этом отношении не так плох, как раньше.Intellisense в C # намного более агрессивен, чем это было в VS 2002 и 2003, так что количество нажатий клавиш значительно снижается.
Я считаю, что это обеспечивает согласованность, что улучшает читабельность кода и позволяет вашему глазу лучше разбирать фрагменты.
class Doohickey {
public void doSomethingWith(string things) {
print(things);
}
}
Использование условных обозначений делает этот код очень стандартизированным для любого программиста.Вы можете легко выбирать классы, типы, методы.Это было бы гораздо сложнее сделать, если бы кто-то мог каким-либо образом извлечь из этого выгоду:
Class DOOHICKEY {
Public Void dosomethingwith(string Things) {
Print(things);
}
}
Нельзя сказать, что люди писали бы уродливый код, но во многом так, как правила заглавных букв и пунктуации облегчают чтение текста, чувствительность к регистру или стандарты написания в конце текста облегчают чтение кода.
Я считаю, важно, чтобы вы понимали разницу между чувствительностью к регистру и удобочитаемостью, чтобы правильно ответить на этот вопрос.Хотя использование различных стратегий оформления полезно, вы можете использовать их в языке, который не учитывает регистр.
Например, foo может использоваться как переменная, а FOO - как константа как в java, так и в VB.Существует незначительное отличие в том, что VB позволит вам вводить fOo позже, но это в основном вопрос удобства чтения и, надеюсь, исправляется какой-либо формой завершения кода.
Что может быть чрезвычайно полезно, так это когда вы хотите иметь экземпляры ваших объектов.Если вы используете согласованное соглашение об именовании, может стать очень легко увидеть, откуда берутся ваши объекты.
Например:FooBar fooBar = новый FooBar();
Когда требуется только один объект определенного типа, читаемость значительно повышается, поскольку сразу становится ясно, что это за объект.Когда требуется несколько экземпляров, вам, очевидно, придется выбирать новые (надеюсь, значимые имена), но в небольших разделах кода имеет смысл использовать имя класса со строчным первым символом, а не систему, такую как myFooBar, x или какое-либо другое произвольное значение, которое вы забудете, что оно делает.
Конечно, все это зависит от контекста, однако в данном контексте я бы сказал, что в 9 случаях из 10 это окупается.
Здесь есть много ответов, но я удивлен, что никто не указал на очевидный пример, который также высмеивает конкурента stackoverflow:
expertSexChange != expertsExchange
Регистр очень важен, когда вы используете имена переменных в верблюжьем регистре.
Это дает вам больше возможностей.
Колокол колокол Колокол
все они разные.
Кроме того, это сводит с ума новичков, которые только что были наняты, пытаясь выяснить, почему итоги получаются неправильными; о)))
Потому что теперь вам действительно нужно вводить все последовательно.И тогда все внезапно начинает обретать смысл.
Если у вас есть приличный редактор - тот, который поддерживает IntelliSense или то же самое под другим именем, - у вас не должно возникнуть никаких проблем с определением имен, чувствительных к регистру.
Чувствительность к регистру - это безумие!Какой безумный программист стал бы использовать переменные с именами foo, foO, fOo и fOO в одной и той же области видимости?Вы никогда не убедите меня, что есть причина для чувствительности к регистру!
Я думаю, что здесь также замешан вопрос психологии.Мы программисты, мы до мелочей различаем разные вещи.'a' - это не то же самое значение ASCII, что и 'A', и я чувствовал бы себя странно, если бы мой компилятор считал их одинаковыми.Вот почему, когда я печатаю
(список "a", "b", "c")
в LISP (в REPL), и он отвечает
(A B C)
мой разум тут же восклицает: "Это не то, что я сказал!".Когда вещи не те же самые, они являются разные, и их следует считать таковыми...
Обычно я провожу некоторое время за программированием на Delphi во время отпуска, а большую часть остального времени использую только C ++ и MASM.И еще одна странная вещь:когда я работаю на Delphi, мне не нравится чувствительность к регистру, но когда я работаю на C ++ - нравится.Мне нравится чувствительность к регистру, потому что это делает похожие слова (функции, переменные) похожими, и мне нравится чувствительность к регистру, потому что это не накладывает чрезмерных ограничений на синтаксис.
От Руководство разработчика .NET Framework Соглашения о капитализации, Чувствительность к регистру:
Правила использования заглавных букв существуют исключительно для того, чтобы упростить чтение и распознавание идентификаторов .Оболочка не может быть использована как средство предотвращения конфликтов имен между элементами библиотеки.
Не думайте, что все языки программирования чувствительны к регистру.Это не так.Имена не могут отличаться только по регистру .
Это полезно для различения типов в коде.
Например, в Java:Если оно начинается с заглавной буквы, то, вероятно, это класс.если это ALL_CAPS, то, вероятно, это константа.
Это придает больше универсальности.
Похоже на более профессиональный способ кодирования.Не нужно, чтобы компилятор понял, что вы имели в виду.
Я чувствовал то же самое, что и вы, давным-давно, когда гораздо чаще использовал VB3 / 4.Сейчас я работаю в основном на C #.Но теперь я нахожу, что IDE отлично справляются с поиском символов и предоставляют хороший intellisense в разных случаях.Это также дает мне больше гибкости в моем собственном коде, поскольку я могу придавать различное значение элементам с разными падежами, что я сейчас часто делаю.
Также хорошая привычка, если вы работаете в Linux, где ссылки на имена файлов чувствительны к регистру.Мне пришлось портировать приложение Windows ColdFusion для работы в Linux, и это был сущий кошмар.Кроме того, в некоторых базах данных включена чувствительность к регистру, представьте себе, какая это радость.
Однако это хорошая привычка, независимо от платформы, и, безусловно, приводит к более последовательному стилю разработки.
ИМХО, это полностью вопрос привычки.Какой бы из них вы ни использовали, он покажется вам естественным и правильным.
Вы можете придумать множество оправданий тому, почему это хорошо или плохо, но ни одно из них не выдерживает критики.Например:
- Вы получаете больше возможных идентификаторов, например.
fooпротивFooпротивFOO. - Но иметь идентификаторы, которые отличаются только регистром, не очень хорошая идея
- Вы можете закодировать информацию о типе в имя (например.
FooBar=имя типа,fooBar=функция,foo_bar=переменная,FOO_BAR=макрос) - Но вы все равно можете сделать это с помощью венгерской нотации
Потому что именно так работает естественный язык.
При программировании нужно кое-что сказать о чувствительности к регистру, например, наличие общедоступного свойства Foo и соответствующего частного / защищенного поля foo.С IntelliSense не так уж трудно не совершать ошибок.
Однако в операционной системе чувствительность к регистру просто сумасшедшая.Я действительно не хочу иметь файл Foo и фу и fOO в том же каталоге.Это сводит меня с ума каждый раз, когда я занимаюсь * nix-вещами.
Для меня чувствительность к регистру - это просто игра с такими областями, как thisValue для аргумента и thisValue для общедоступного свойства или функции.
Чаще всего вам приходится использовать одно и то же имя переменной (поскольку оно представляет одно и то же) в разных областях, и учет регистра помогает вам делать это, не прибегая к префиксам.
Фух, по крайней мере, мы больше не используем венгерскую нотацию.
После многих лет работы с устаревшим кодом VBScript ASP, когда мы перешли на .NET, мы выбрали C #, и одной из главных причин была чувствительность к регистру.Старый код был нечитабельным, потому что люди не следовали никаким соглашениям:код представлял собой нечитаемый беспорядок (ну, в этом помогли бедные IDE VBScript).
В C # мы можем определить соглашения об именовании, и все должны им следовать.Если что-то оформлено неправильно, вы можете переименовать это (с помощью рефакторинга, но это функция IDE), и никаких проблем не возникнет, потому что класс или переменная будут называться одинаково во всем коде.
Наконец, я думаю, что это гораздо более читабельно, если все оформлено правильно.Возможно, быстрее писать без учета регистра, но с точки зрения проверки и сопровождения кода это не самое лучшее, потому что проще просматривать код в поисках чего-либо.Например, проще найти все строки 'foo' одним взглядом, чем искать 'foo', 'Foo', 'FOO', 'FOo'FOo...
Языки, не чувствительные к регистру, нелегко обобщить на наборы символов, отличные от ASCII.Правильное преобразование регистра для языка, отличного от английского, является непростой задачей и, помимо прочего, зависит от языкового стандарта системы.
Нечувствительность к регистру очень сложна, если только вы не ограничиваете синтаксис ascii (или не применяете нечувствительность к регистру только к символам ascii), а также вам не нужно ограничивать языковой стандарт.
Правила определения верхнего и нижнего регистра символов не являются ни четко определенными, ни без потерь.
Некоторые символы могут иметь более одной "строчной" формы.Некоторые люди не согласятся с тем, какой должна быть правильная заглавная форма.
(Некоторые языки и среды допускают использование в именах почти всех символов)
Рассмотреть В C # в чем разница между ToUpper() и ToUpperInvariant()?
