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

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

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

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

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

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

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

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

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

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

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

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

dim a as string

и VS будет автоматически измените его на правильно-cased

Dim a As String

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

но C# не так плохо об этом, как раньше. Intellisense в C# намного агрессивнее, чем в 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

Case очень важен, когда вы используете имена переменных case camel.

Это дает вам больше возможностей.

Белл колокол Белл!--1-->

все разные.

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

потому что теперь вам действительно нужно вводить все последовательно. И вдруг все начинает обретать смысл.

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

чувствительность к регистру-это безумие! Какой безумный кодер будет использовать переменные с именами foo, foO, fOo и fOO в одной области? Вы никогда не убедите меня, что есть причина для чувствительности к случаю!

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

(список ' a ' b ' c)

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

(A B C)

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

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

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

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

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

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

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

Это дает больше гибкости.

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

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

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

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

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

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

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

потому что так работает и естественный язык.

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

однако в ОС, чувствительность к регистру-это просто безумие. Я действительно не хочу иметь файл Foo и фу и fOO в том же каталоге. Это сводит меня с ума каждый раз, когда я делаю *nix вещи.

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

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

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

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

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

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

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

нечувствительность к регистру очень сложна, если вы не ограничиваете синтаксис ascii (или только применяете нечувствительность к регистру к символам ascii), а также вам нужно ограничить локаль.

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

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

(некоторые языки и среды, позволяют почти символ, который будет использоваться в именах)

считают в C# в чем разница между ToUpper() и ToUpperInvariant()?