Почему людям нравится чувствительность к регистру? [закрытый]

Это дает Вам больше опций.

звонок BEll

Bell все отличаются.

Кроме того, это управляет новичками, которые были просто наняты гайки, пытающиеся узнать, почему общие количества не выходят право; o)))

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

(перечисляют ''b 'c)

в LISP (в REPL), и это отвечает

(B C)

, мой ум сразу восклицает, что 'Это не то, что я сказал!'. Когда вещами не является то же, они отличающиеся и должны быть рассмотрены так...

Чувствительность к регистру является безумием! Какой безумный кодер использовал бы переменные, названные нечто, нечто, нечто и НЕЧТО все в том же объеме? Вы никогда не будете убеждать меня, что существует причина чувствительности к регистру!

Поскольку теперь на самом деле необходимо ввести все последовательным способом. И затем вещи внезапно начинают иметь смысл.

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

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

, Например, нечто может использоваться для переменной и НЕЧТО как константа и в Java и в VB. Существуют незначительные различия, что VB позволит Вам вводить нечто позже, но это - главным образом вопрос удобочитаемости и надо надеяться фиксируется некоторой формой завершения кода.

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

, Например: FooBar fooBar = новый FooBar ();

, Когда только один объект типа необходим, удобочитаемость значительно увеличена, поскольку сразу очевидно, каков объект. Когда несколько экземпляров необходимы, необходимо будет, очевидно, выбрать новый (надо надеяться, понятные имена), но в маленьких секциях кода это имеет большой смысл использовать Имя класса со строчным первым символом, а не системой как myFooBar, x, или некоторым другим произвольным значением, что Вы забудете то, что это делает.

, Конечно, все это - вопрос контекста, однако в этом контексте, который я сказал бы 9 раз из 10, он окупается.

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

Dim abc = 1
Dim y = Abc - 1 ' error, case doesn't match "abc"
Dim ABC = False ' error, can't redeclare variable "abc"

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

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

class Doohickey {

  public void doSomethingWith(string things) {
     print(things);
  }
}

Используя случающиеся конвенции заставляет тот код появиться очень standarized любому программисту. Можно выбрать классы, типы, методы легко. Было бы намного более трудно сделать, если кто-либо мог бы использовать для своей выгоды его всегда:

Class DOOHICKEY {
  Public Void dosomethingwith(string Things) {
    Print(things);
  }
} 

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

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

.NET VB нечувствительна к регистру. Это не означает, что можно объявить переменную как abc, затем позже назвать ее ABC, Abc и aBc. Это означает, что при вводе его как какой-либо из тех других IDE автоматически изменит его на правильную форму.

Нечувствительность к регистру означает, что можно ввести

dim a as string

, и VS автоматически изменит ее на правильно в корпусе

Dim a As String

На практике, это означает, что Вы почти никогда не должны поражать клавишу Shift, потому что можно ввести во всем нижнем регистре и позволить IDE исправить для Вас.

, Но C# не так плохо об этом, как он раньше был. Intellisense в C# намного более агрессивен, чем это были в VS 2002 и 2003, так, чтобы количество нажатия клавиши упало вполне немного.

Преимущество VB.NET состоит в том, что, хотя это не чувствительно к регистру, IDE автоматически переформатировал все к "официальному" случаю для идентификатора, который Вы используете - таким образом, легко быть последовательным, легким читать.

Недостаток - то, что я ненавижу синтаксис VB-стиля и очень предпочитаю операторы C-стиля, пунктуацию и синтаксис.

В C# я нахожу, что всегда поражаю Ctrl-Space для сохранения необходимости использовать надлежащий тип.

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

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

Я обычно провожу некоторое время с программированием Delphi в отпуске, и большая часть другого времени, я использую только C++ и MASM. И одна нечетная вещь: когда я нахожусь на Delphi, мне не нравится чувствительность к регистру, но когда я нахожусь на C++ - я делаю. Мне нравится чувствительность к регистру, потому что она делает подобные слова (функции, переменные) выглядят подобными, и мне нравится нечувствительность к регистру, потому что она не помещает чрезмерные ограничения на syntaxis.

Для меня чувствительность к регистру является просто игрой на объемах как thisValue для аргумента и ThisValue для общественной собственности или функции.

Ух, по крайней мере, мы больше не используем Венгерскую запись.

В progamming существует что-то, чтобы быть сказанным для чувствительности к регистру, например, имея общественную собственность Foo и соответствующее частное нечто / нечто защищенного поля. С IntelliSense не очень трудно не сделать ошибки.

Однако в ОС, чувствительность к регистру является просто сумасшедшей. Я действительно не хочу иметь файл Foo и нечто и НЕЧТО в том же каталоге. Это управляет мной cray каждый раз, я делаю *, отклоняют материал.

Поскольку это - как естественный язык работает, также.

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

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

По моему скромному мнению, это - полностью вопрос привычки. Какой бы ни один Вы привыкли к, будет казаться естественным и правильным.

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

• Вы получаете более возможные идентификаторы, например, foo по сравнению с Foo по сравнению с FOO.
• , Но идентификаторы наличия, которые отличаются только в случае, если не хорошая идея
• , можно закодировать информацию типа на имя (например, FooBar =typename, fooBar =function, foo_bar =variable, FOO_BAR =macro)
• , Но можно сделать это так или иначе с Венгерской записью

Я чувствовал то же самое как Вы давным-давно, когда я использовал VB3/4 намного больше. Теперь я работаю в главным образом C#. Но теперь я нахожу, что IDE делает отличную работу по нахождению символов и предоставлению хорошего intellisense на различных случаях. Это также дает мне больше гибкости в моем собственном коде, поскольку у меня может быть значение differnt к объектам с различными случаями, которые я делаю много теперь.

Чувствует себя подобно более профессиональному способу кодировать. Не должен нуждаться в компиляторе для выяснения то, что Вы имели в виду.

От Руководства Разработчика инфраструктуры.NET Конвенции Капитализации , Чувствительность к регистру:

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

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

Это полезно для различения типов в коде.

, Например, в Java: Если это начинается с прописной буквы, то, вероятно, класс. если его ALL_CAPS, вероятно, константа.

Это дает больше универсальности.

После многих лет работы с устаревшим кодом VBScript ASP, когда мы перешли на .NET, мы выбрали C #, и одной из основных причин была чувствительность к регистру. Старый код был нечитаемым, потому что люди не следовали никаким соглашениям: код был нечитабельным (ну, в этом помогли плохие IDE VBScript).

В C # мы можем определять соглашения об именах, и все должны им следовать. Если что-то неправильно расположено, вы можете переименовать это (с рефакторингом, но это функция IDE), и не будет никаких проблем, потому что класс или переменная будут называться одинаково во всем коде.

Наконец, Думаю, намного читабельнее, если все правильно оформить. Может быть, быстрее писать без учета регистра, но с точки зрения проверки и поддержки кода - не самое лучшее, потому что пропустить код в поисках чего-то проще. Например, легче сразу найти все строки 'foo', чем искать 'foo', 'Foo', 'FOO', 'FOo' ...