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

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

Колокол колокол BEll

все разные.

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

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

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

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

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

Последовательность. Код труднее читать, если «foo», «Foo», «fOO» и «fOo» считаются идентичными.

НЕКОТОРЫЕ ЛЮДИ БЫЛИ ЗАПИСЫВАЛИ ВСЕ ВСЕ ЗАГЛАВНЫМИ ГЛАВНЫМИ ГЛАВНЫМИ ГЛАВНЫМИ ГЛАВНЫМИ ГЛАВНЫМИ ГЛАВНЫМИ БУКВАМИ, ДЕЛАЯ ВСЕ НЕЧТЕНИЕ

Чувствительность к регистру позволяет использовать одно и то же имя по-разному, в соответствии с соглашением о капитализации, например,

Foo foo = ...  // "Foo" is a type, "foo" is a variable with that type

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

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

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

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

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

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

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

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

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

class Doohickey {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Например, foo можно использовать для переменной, а FOO как константу как в java, так и в VB. Есть небольшая разница в том, что VB позволит вам набирать fOo позже, но в основном это вопрос удобочитаемости и, надеюсь, будет исправлен с помощью некоторой формы автозавершения кода.

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

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

Когда нужен только один объект типа, читаемость значительно увеличивается, так как сразу становится понятно, что это за объект. Когда требуется несколько экземпляров, вам, очевидно, придется выбрать новые (надеюсь, значащие имена), но в небольших частях кода имеет смысл использовать имя класса с первым символом в нижнем регистре, а не такую ​​систему, как myFooBar, x или какое-то другое произвольное значение, которое вы забудете, что оно делает.

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

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

(list 'a 'b 'c) 

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

(A B C)

Мой разум немедленно восклицает «Я не это сказал!». Когда вещи не одинаковы, они являются разные, и это нужно учитывать.

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

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

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

dim a as string

и VS автоматически изменит его на правильно оформленный

Dim a As String

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

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

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

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

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

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

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

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

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

Из Руководство разработчика .NET Framework Условные обозначения заглавных букв, чувствительность к регистру:

The capitalization guidelines exist solely to make identifiers easier to read and recognize. Casing cannot be used as a means of avoiding name collisions between library elements.

Do not assume that all programming languages are case-sensitive. They are not. Names cannot differ by case alone.

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

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

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

Здесь много ответов, но я удивлен, что никто не указал на очевидный пример, который также высмеивает конкурента stackoverflow:

expertSexChange != expertsExchange

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

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

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

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

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

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

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