CamelCase
CamelCase (рус. Верблю́жийРеги́стр , также Горба́тыйРеги́стр, Сти́льВерблю́да) — стиль написания составных слов, при котором несколько слов пишутся слитно без пробелов, при этом каждое слово пишется с заглавной буквы. Стиль получил название CamelCase, поскольку заглавные буквы внутри слова напоминают горбы верблюда (англ. Camel ).
Примеры
CamelCase-вывеска
Примеры CamelCase-написания: BackColor, backColor, CamelCase.
Иногда встречаются также следующие названия этого стиля:
Различают два варианта CamelCase-написания в зависимости от того, прописная или строчная первая буква: UpperCamelCase (PascalCase) и lowerCamelCase.
Применение
CamelCase широко используется в языках программирования:
- В языке Java принято использовать UpperCamelCase для наименования классов и lowerCamelCase наименования экземпляров классов и методов.
- В Microsoft .NET принято использовать UpperCamelCase для наименования классов и методов.
Использование CamelCase стиля в коде программы определяется личным вкусом программиста, если проект невелик по размеру. В крупных проектах, как правило, существует специальный документ, определяющий правило создания имён (переменных, функций, констант и проч.) для всех участников проекта.
Некоторые среды разработки (например, Qt Creator) предоставляют возможность автозаполнения по заглавным буквам при использовании CamelCase (sCM → setContentMargins).
Принято считать альтернативным способом создания имён в программном коде стиль_через_подчёркивание (или через-дефисы, в Лиспе). Тем не менее стили можно смешивать (например: среднее_КоличествоЯблок), поскольку стили создания имён всего лишь условная договорённость и никак не влияют на работу программы.
Собственно стили появились из-за того, что в коде программы желательно иметь осмысленные имена переменных (описывающие смысл содержащегося в переменной значения), но не слишком длинные, а правила синтаксиса языков программирования налагают ограничения на средства для создания имён (к примеру, в большинстве языков допускается использование только буквенных символов, цифр и знака подчёркивания).
В некоторых wiki-движках используются CamelCase-ссылки (текст в CamelCase-стиле автоматически отображается как ссылка на другую wiki-страницу). К таким движкам относятся, например, MoinMoin, TWiki, JSPWiki и FlexWiki.
См. также
Информация должна быть проверяема, иначе она может быть поставлена под сомнение и удалена.
Вы можете отредактировать эту статью, добавив ссылки на авторитетные источники.
Эта отметка установлена 28 июня 2010.
- Типографика
- Стандарт оформления кода
- Сотовая связь
- Небуквенные орфографические знаки
Wikimedia Foundation . 2010 .
Жизнь — это движение! А тестирование — это жизнь 🙂
CamelCase (с англ. — «ВерблюжийРегистр») — стиль написания составных слов, при котором несколько слов пишутся слитно без пробелов, при этом каждое слово внутри фразы пишется с прописной буквы. Стиль получил название CamelCase, поскольку прописные буквы внутри слова напоминают горбы верблюда.
Регистр CamelCase обычно используется внутри кода для названия переменных.
snake_case (с англ. — змеиный_регистр) — стиль написания составных слов, при котором несколько слов разделяются символом подчеркивания (_), и не имеют пробелов в записи, причём каждое слово обычно пишется с маленькой буквы — «foo_bar», «hello_world» и т. д.
- Вариант, в котором вместо символа подчёркивания используется дефис — kebab-case, или lisp-case
- Вариант-модификация kebab-case, в котором каждое новое слово пишется с большой буквы — Train-Case
- Вариант, в котором все буквы слов пишутся в верхнем регистре — SCREAMING_SNAKE_CASE
- Объектная модель — как поля записаны в java-классах, CamelCase
- Физическая модель — как поля хранятся в БД
lower case — все буквы написаны в нижнем регистре
UPPERCASE — все буквы написаны в верхнем регистре (Его же называют «записано в капслоке» (CAPSLOCK)
Когда это нужно тестировщику
Для любой проверки на регистрозависимость. Например, когда вы тестируете REST-метод. Верно ли, что заголовки регистронезависимы? Это не опция по умолчанию, а сознательный выбор разработчика.
Важно понимать, что «Newparam» ≠ «newparam» ≠ «NewParam» ≠ «NEWPARAM».
Поэтому можно проверить разные варианты написания заголовков, чтобы посмотреть, что работает, а что нет.
PS — статья написана в помощь студентам моей школы для тестировщиков
camelCase против under_score
В настоящее время существует много стандартов наименования переменных, но два из них являются наиболее популярными среди программистов: это camel case («Верблюжья» нотация) и underscore (именование переменных с использованием символа нижнего подчеркивания в качестве разделителя). Кто-то может возразить, что существуют и другие популярные стандарты, но в рамках данной статьи мы сравним эти два, и узнаем у программистов — какого стандарта придерживаются они. Конечно, некоторые программисты связаны рамками стандартов кодирования языка или фреймворка, который они используют, но мы постараемся сделать независимое сравнение.
Стандарт наименований с использованием нижнего подчеркивания заключается в том, что все слова записываются строчными буквами и разделяются символом нижнего подчеркивания (_). Обычно этот стандарт используется в названиях функций и переменных, а для названий классов, структур, интерфейсов используется стандарт Pascal (прим. переводчика: почему-то в статье про него ничего не говорится, но как я нашел в википедии Pascal style это UpperCamelCase, когда первое слово начинается с прописной буквы, пруф). Underscore изначально использовался программистами С, и потом был использован разработчиками С++ при наименовании ключевых слов и в библиотеке STL, а затем и в Boost, из-за чего данный стандарт приобрел большую популярность среди программистов С++, но не стал доминирующим. Также данный стандарт используется в названиях стандартных функций PHP, и является очень популярным среди PHP-программистов. Говорят, что в Руби тоже используется нижнее подчеркивание.
С другой стороны, верблюжья нотация является стандартом в языке Java и его младшей сестре JavaScript, хотя ее можно встретить также и в других местах. Согласно этому стандарту, все слова в названии начинаются с прописной буквы, кроме первого. При этом, естественно, не используется никаких разделителей вроде нижнего подчеркивания. Обычно данный стандарт применяют к именам функций и переменных, при этом в именах классов (структур, интерфейсов) используется стандарт Pascal. В языке С# camelCase используется частично: область его применения ограничена названиями параметров функций и локальными переменными.
- Нижнее подчеркивание лучше читается: сравните стандарт_с_нижним_подчеркиванием и стандартНаписанияПрописнымиБуквами
- Зато camel case делает более легким чтение строк, например:
my_first_var=my_second_var-my_third_var
и
myFirstVar=mySecondVar-myThirdVar
Очевидно, что camel case читается лучше: в случае с нижним подчеркиванием и оператором «минус» выражение с первого взгляда вообще можно принять за одну переменную, однако подсветка синтаксиса может решить эту проблему. - Camel Case является противоположностью английского, русского и многих других языков: в обычных языках предложение начинается с большой буквы, а все остальные слова пишутся строчными, в случае с camel case же все происходит наоборот. Это настоящий взрыв мозга
- Подчеркивание сложнее набирать. Даже при наличии intellisense, во многих случаях необходимо набирать символ нижнего подчеркивания.
- Camel Case непоследователен, потому что при использовании констант (которые пишутся целиком заглавными буквами) нам приходится использовать нижнее подчеркивание. С другой стороны, стандарт именования с использованием нижнего подчеркивания может быть полным, если вы решите использовать в названиях классов (структур, интерфейсов) нижнее подчеркивание в качестве разделителя
От переводчика: статью старался переводить максимально близко к оригиналу.
От себя добавлю, что в своих проектах предпочитаю использовать Camel Case, только в качестве первого слова использую сокращенный тип переменной (bProductActive, iProductsCount, sUserName), таким образом несколько решается проблема «взрыва мозга» — все слова предложения начинаются с заглавной буквы.
Кроме того, с коллегами очень много споров было на тему аббревиатур при использовании верблюжьей нотации: как писать правильнее GenerateHTMLFromText или GenerateHtmlFromText, в итоге остановились на втором варианте, но чувство нерешенной проблемы все равно немного грызет.
Ну и насчет того, что JavaScript это младшая сестра Java автор немного нагнал, все-таки это совершенно разные языки, общее у них только название и стандарты оформления кода.
- naming conventions
- camelcase
- underscore
Camel, Pascal, Snake Case и другие стили написания
Разбираемся в зоопарке стилей написания составных слов в JS — зачем столько и для чего они нужны.
Заставьте 10 человек нарисовать одну и ту же картинку и вы получите десять совершенно разных изображений — и чем сложнее исходник, тем больше будет отличий между репликами. То же самое справедливо и для кода. Там, где заканчиваются строгие правила языка и начинается творчество разработчика, код становится похож на рукописный текст — он имеет свой стиль, структуру, почерк. У кого-то почерк четкий и понятный, а у кого-то сложно даже просто разобрать написанное. Чтобы один разработчик понял другого, существует масса гласных и негласных правил. Этой же цели служат и стили написания.
Функция у стилей написания всего одна — уложить в одну неделимую строку сложное, составленное из нескольких слов, название переменной, метода, свойства и тому подобное. Потому что в JavaScript, как и во многих других языках программирования, нельзя просто взять и написать:
const user login count = 5;function get user login count() <>;
Пробел является зарезервированным символом, поэтому парсер языка будет воспринимать user, login и count как отдельные сущности, в результате чего вы получите SyntaxError.
Но чем заменить пробел, чтобы код стал рабочим, а человеку, читающему потом ваш код, не захотелось рыдать? Разберем несколько популярных решений, а главное — увидим, что их выбор иногда не просто дело вкуса: зачастую применяются сразу несколько стилей, но каждый из них нужен в определенном месте.
Camel case (camelCase)
«Верблюжий регистр» — по аналогии с горбатым красавцем каждое следующее слово в цепочке начинается с заглавной буквы.
const userLoginCount = 5;function getUserLoginCount() <>;
Этот стиль, пожалуй, можно назвать самым популярным в JS. Он подходит для именования переменных и методов. Его можно назвать наиболее консистентным, так как он используется и для именования стандартных методов — setTimeout, toValue, toLocaleDateString.
Pascal case (PascalCase)
Очень схож с camelCase, но первое слово в строке так же пишется с заглавной буквы. Настолько схож, что часто его относят к разновидности camelCase — якобы есть традиционный camelCase как lowerCamelCase и его частный случай PascalCase как UpperCamelCase. По крайней мере, в этом нас убеждает русскоязычная википедия. Но если перейти на англоязычную версию и покопаться в источниках, то можно найти небольшую заметку 2004 года в блоге Microsoft от Брэда Абрамса — “History around Pascal Casing and Camel Casing”, в которой говорится что термин PascalCase абсолютно логично проистекает из языка Pascal, стандартные методы которого именуются с заглавной буквы (Abs, Random, Round). В JS PascalCase используется для именования типов и классов:
class ExampleCustomComponent <>;
Опять же, такой стиль применяется и в именовании стандартных классов JavaScript — RegExp, ResizeObserver.
Snake case (snake_case)
«Змеиный регистр» — заменяет пробелы на символ подчеркивания. В JS он отлично подходит для именования полей в базах данных, или для именования статичных данных, хранящихся в JSON.
Во-первых, по сравнению с camelCase и PascalCase глаз быстрее “парсит” такую строку. Представьте себе json-словарь, к примеру, c перечнем цветов в стиле PascalCase:
"DarkOliveGreen": "#556B2F", "MediumVioletRed": "#C71585", "LightGoldenrodYellow": "#FAFAD2">
Сложно прочитать, правда? А если таких строк сотня?
А теперь тот же словарь в стиле snake_case:
"dark_olive_green": "#556B2F", "medium_violet_red": "#C71585", "light_goldenrod_yellow": "#FAFAD2">
На мой взгляд, в большом массиве однотипных строк snake_case выглядит однозначно читабельнее.
Во-вторых, в этом случае snake_case позволяет сразу отличить данные, которые нельзя мутировать (перезаписывать).
В-третьих, в отличии от kebab-case, который мы рассмотрим ниже, snake_case всё также дружит с парсером языка и вы можете легко использовать его:
const currentColor = colors.light_goldenrod_yellow;
Screaming snake case (SCREAMING_SNAKE_CASE)
Его ещё иногда называют UPPER_CASE_SNAKE_CASE. Этот стиль стоит особняком. Думаю, все согласятся, что писать таким образом весь код категорически не рекомендуется. Он используется только для акцентирования внимания. До появления в JS настоящих констант, он был особенно актуален для их именования. Таким образом можно было выделить переменную, которая ни в коем случае не должна быть изменена. Теперь же достаточно объявить её с помощью const и в случае попытки перезаписать её вы получите TypeError. Но такой стиль именования по-прежнему используют для лучшей читабельности кода:
const SECOND = 1000;const MINUTE = 60 * SECOND;const HOUR = 60 * MINUTE;
Kebab case (kebab-case)
Его также называют spear-case, и он является стандартом в Lisp. Он может с легкостью использоваться в языках, которые не требуют пробелов между операторами и выражениями. Но, к сожалению, JS к таковым не относится. К примеру, чтобы обратиться к свойству объекта с подобным ключом, придется обернуть его в кавычки:
const userData = 'user-login-count': 5>;console.log(userData['user-login-count']);
Но почему тогда мы всё равно встречаем его в JS?
Их всех перечисленных стилей kebab-case является наиболее читабельным для обычного человека, не разработчика. Поэтому он используется там, где его может увидеть пользователь. Например, в URL-адресах (www.blog.com/cool-article-1) или в названиях скачиваемых файлов (cool-article-1.pdf).
Нельзя назвать какой-либо из стилей предпочтительным — каждый уместен при правильном использовании. Как правило, на проекте используется несколько стилей для разных мест и это только повышает читабельность кода. Одно из качеств хорошего разработчика — это умение легко переходить с одного стиля на другой и подстраиваться под то, что используется в конкретном проекте. Если вы повсеместно использовали camelCase, а в новой команде от вас просят snake_case, то для вас не должно составить труда писать именно так.
Удачи вам в разработке и спасибо за внимание!
P. S. Все мы люди 🙂 А значит, нам свойственно ошибаться.
Увидели опечатку или ошибку — выделите текст, кликните в всплывающем меню иконку сообщения с замочком и напишите о ней.
Я буду вам очень признательна.