Просто интересно, почему людям нравится чувствительность к регистру на языке программирования? Я не пытаюсь начать пламенную войну, просто любопытно, что все. Лично мне это никогда не нравилось, потому что я нахожу, что моя производительность снижается, когда я пробовал язык с чувствительностью к регистру, помните, что я медленно разогреваюсь/привыкаю к этому сейчас, когда я использую С# и F # Раньше я был.
Так почему вам это нравится?
Приветствия
Согласованность. Код сложнее читать, если "foo", "Foo", "fOO" и "fOo" считаются идентичными.
НЕКОТОРЫЕ ЛЮДИ БУДУТ НАПРАВЛЯТЬ ВСЕ ВСЕМ КАПСАМ, ИСПОЛЬЗУЯ ВСЕ ЕЩЕ МЕНЬШЕ ЧИТАЮТ.
Чувствительность к регистру позволяет легко использовать "одно и то же имя" по-разному, в соответствии с соглашением о капитализации, например,
Foo foo = ... // "Foo" is a type, "foo" is a variable with that type
Преимущество VB.NET заключается в том, что, хотя он не чувствителен к регистру, среда IDE автоматически переформатирует все в "официальном" случае для идентификатора, который вы используете, поэтому легко быть последовательным, легко читаемым.
Недостатком является то, что я ненавижу синтаксис VB-стиля и предпочитаю операторы стиля C, знаки препинания и синтаксиса.
В С# я нахожу, что я всегда нажимаю Ctrl-Space, чтобы сохранить необходимость использовать правильный тип.
Просто потому, что вы можете назвать вещи, которые отличаются друг от друга в отдельности, это не значит, что это хорошая идея, потому что это может привести к недоразумениям, если многие из них просачиваются в более крупные области, поэтому я рекомендую избегать этого в приложении или уровня подсистемы, но позволяя ему только внутренне функции, методу или классу.
Чувствительность к регистру не обеспечивает соблюдение стилей кодирования или согласованности. Если вы pascal case константа, компилятор не будет жаловаться. Это просто заставит вас вводить его в случае использования паскаля каждый раз, когда вы его используете. Я лично нахожу это раздражающим, чтобы попытаться различить два предмета, которые отличаются только в случае. Это легко сделать в коротком блоке кода, но очень сложно держать прямо в очень большом блоке кода. Также обратите внимание, что единственный способ, по которому люди могут использовать чувствительность к регистру без необходимости гайки, - это если они все жестко следуют тем же правилам именования. Это соглашение об именах, которое добавило значение, а не чувствительность к регистру.
Я поддерживаю внутренний компилятор для своей компании и испытываю соблазн сделать его гибридным - вы можете использовать любой случай, который вы хотите для идентификатора, и вы должны ссылаться на него с тем же корпусом, но называя что-то еще с помощью одно и то же имя и другой случай вызовет ошибку.
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 правильно для вас.
Но С# не так уж плох в этом, как раньше. Intellisense в С# гораздо более агрессивен, чем в 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 = new FooBar();
Когда требуется только один объект типа, читаемость значительно увеличивается, так как сразу видно, что такое объект. Когда вам нужно несколько экземпляров, вам, очевидно, придется выбирать новые (надеюсь, значимые имена), но в небольших разделах кода имеет смысл использовать имя класса с нижним строчным первым символом, а не с системой, например myFooBar, x или какое-то другое произвольное значение, которое вы забудете, что он делает.
Конечно, все это вопрос контекста, однако в этом контексте я бы сказал, что 9 раз из 10 он окупается.
Здесь много ответов, но я удивлен, что никто не указал на очевидный пример, который также высмеивает конкурента stackoverflow:
expertSexChange != expertsExchange
Случай очень важен, когда вы используете имена переменных верблюда.
Это дает вам больше возможностей.
Bell колокол BELL
все разные.
Кроме того, он управляет новичками, которые были просто нанятыми орехами, пытаясь выяснить, почему итоги не выходят правильно; o)))
Потому что теперь вам нужно набирать все последовательно. И тогда вещи вдруг начинают иметь смысл.
Если у вас есть достойный редактор - тот, который имеет IntelliSense или одно и то же с другим именем, у вас не должно возникнуть проблем с поиском имен, чувствительных к регистру.
Чувствительность к регистру - безумие! Какого рода безумный кодер будет использовать переменные с именем foo, foO, fOo и fOO в одной и той же области? Вы никогда не убедите меня, что есть причина для чувствительности к регистру!
Я думаю, что здесь есть проблема психологии. Мы программисты, мы четко различаем вещи. "a" - это не то же самое значение ASCII, что и "A", и я бы чувствовал себя странно, когда мой компилятор считает их одинаковыми. Вот почему, когда я печатаю
(список 'a' b 'c)
в LISP (в REPL), и он отвечает
(A B C)
Мой разум сразу восклицает: "Это не то, что я сказал!". Когда что-то не то же самое, они разные и должны рассматриваться так...
Я обычно провожу некоторое время с программированием Delphi в отпуске, и большую часть другого времени я использую только С++ и MASM. И одно странное: когда я нахожусь на Delphi, мне не нравится чувствительность к регистру, но когда я нахожусь на С++, я это делаю. Мне нравится чувствительность к регистру, потому что он делает похожие слова (функции, переменные) похожими, и мне нравится нечувствительность к регистру, потому что он не создает чрезмерных ограничений на синтаксис.
С Руководство разработчика .NET Framework Соглашения о капитализации, Чувствительность к регистру:
Существуют руководящие принципы капитализации исключительно для упрощения идентификации читать и распознавать. Корпус не может быть используется как способ избежать имени столкновений между элементами библиотеки.
Не предполагайте, что все программирование языки чувствительны к регистру. Они есть не. Имена не могут отличаться в каждом случае в одиночку.
Это полезно для различения типов в коде.
Например, в Java: Если он начинается с заглавной буквы, то это, вероятно, класс. если его ALL_CAPS, вероятно, является константой.
Это дает большую универсальность.
Чувствует себя более профессиональным способом кодирования. Не нужно компилятор, чтобы понять, что вы имели в виду.
Я чувствовал то же самое, что и вы, когда я использовал VB3/4 намного больше. Сейчас я работаю в основном на С#. Но теперь я считаю, что IDE отлично справляется с поиском символов и дает хороший интеллект в разных случаях. Это также дает мне большую гибкость в моем собственном коде, поскольку я могу иметь различный смысл для элементов с разными случаями, которые я делаю сейчас много.
ИМХО это полностью вопрос привычки. Какой бы вы привыкли ни казаться естественным и правильным.
Вы можете придумать множество оправданий относительно того, почему это хорошо или плохо, но ни один из них не содержит много воды. Например:
foo vs foo vs foo.FooBar= typename, FooBar= function, foo_bar= variable, foo_bar= macro)Также хорошая привычка, если ваша работа в Linux, где ссылки на имена файлов чувствительны к регистру. Мне пришлось подключить приложение Windows ColdFusion для работы в Linux, и это был полный кошмар. Также в некоторых базах данных чувствительность к регистру включена, представьте себе радость.
Это хорошая привычка, хотя независимо от платформы и, безусловно, ведет к более последовательному стилю разработки.
Потому что это так, как работает естественный язык.
В программировании есть что-то, что нужно сказать для чувствительности к регистру, например, с публичным свойством Foo и соответствующим частным/защищенным полем foo. С IntelliSense это не очень сложно не допускать ошибок.
Однако в ОС чувствительность к регистру просто сумасшедшая. Я действительно не хочу иметь файл Foo и foo и fOO в том же каталоге. Это заставляет меня резать каждый раз, когда я делаю * nix.
Для меня чувствительность к регистру - это просто игра в таких областях, как thisValue для аргумента и ThisValue для публичного свойства или функции.
Более часто вам нужно использовать одно и то же имя переменной (как оно представляет одно и то же) в разных областях, и чувствительность к регистру помогает вам это делать, не прибегая к префиксам.
Ну, по крайней мере, мы больше не используем венгерскую нотацию.
После много лет работы с устаревшим кодом VBScript ASP, когда мы перешли на .NET, мы выбрали С#, и одной из основных причин была чувствительность к регистру. Старый код был нечитабельным, потому что люди не придерживались какого-либо соглашения: код был нечитаемым беспорядком (ну, с этим справились бедные VBScript IDE).
В С# мы можем определить соглашения об именах, и все должны следовать им. Если что-то не так правильно, вы можете переименовать его (с рефакторингом, но с IDE-функцией), и проблем не будет, потому что класс или переменная будут называться одинаково по всему коду.
Наконец, я думаю, что это гораздо более читаемо, если все правильно обведено. Возможно, быстрее писать без чувствительности к регистру, но из обзора кода и поддержания точки это не лучшая вещь, потому что проще пропустить код, ищущий что-то. Например, проще всего найти все строки "foo", чем искать "foo", "Foo", "FOO", "FOo"...
Нечувствительные к регистру языки не просто обобщаются на не-ASCII-символьные множества. Правильное преобразование случаев для языка, отличного от английского, не является прямой задачей и зависит, в частности, от системного языка.
Нечувствительность к регистру очень сложна, если вы не ограничиваете синтаксис ascii (или применяете нечувствительность к символам ascii), а также вам нужно ограничить языковой стандарт.
Правила определения верхнего и нижнего регистра символов не определены никоим образом и не являются потерями.
Некоторые символы могут иметь более одной строчной формы. Некоторые люди не согласятся с тем, какова должна быть правильная форма верхнего регистра.
(Некоторые языки и среды допускают использование почти символа в именах)
Рассмотрим В С# в чем разница между ToUpper() и ToUpperInvariant()?