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

схема хранения переменной

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

У переменных, объявленных с var, let или const, есть своя специфика использования, о которой будет рассказываться далее в течение курса. А также у переменных, объявленных через var, есть некоторые неочевидные особенности, незнание которых, может негативно сказываться на разработке и поддержке кода. Поэтому с выходом стандарта ES6, где появились новые ключевые слова let и const, объявление через var используется всё меньше и можно сказать устаревает. Но знать об особенностях и побочных эффектах var переменных очень важно.

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

var myName;
let age;

Вы можете назвать переменную как угодно, но есть ограничения. Как правило, вы должны придерживаться только латинских символов (0-9, a-z, A-Z) и символа подчеркивания.

После объявления переменной, вы можете присвоить ей значение:

myName = "Иван";
age = 30;

Или же вы можете сделать обе эти операции на одной и той же строке:

var myName = "Иван";
let age = 30;

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

const height = 180;

Ключевое слово const создаёт константу — переменную, значение которой не может быть переопределено. Поэтому, попытка объявить константу, не присвоив ей при этом значение (другими словами — без её инициализации), вызовет синтаксическую ошибку:

const height;
> Uncaught SyntaxError: Missing initializer in const declaration

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

myName;
age;
height;

Если вы запросите значение переменной, которую объявили, но не присвоили ей никакого значения, то в ответе вам придёт undefined:

var x;
console.log(x);

> undefined

undefined - это особый тип данных в javascript, который выражает, что “значение не определено” (“не присвоено”).

После установки значения переменной, объявленной через var и let, вы можете изменить его позже:

var myName = "Иван";
myName = "Ваня";

let age = 30;
age = 31;

Значение переменной, которую вы объявили через const, переопределить уже нельзя.

const height = 180;
height = 200;

> Uncaught TypeError: Assignment to constant variable.

Так как это ключевое слово подразумевает объявление константы — переменной, значение которой постоянно, такая попытка переопределить её значение вызовет ошибку TypeError в консоли. В следующих частях курса будет показано, что само значение константы, в действительности, может меняться и это зависит от типа данных, которые в ней хранятся.

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

схема хранения переменных

В отличие от некоторых других языков программирования со статической типизацией, например таких, как C++, C#, Java, в JavaScript вам не требуется как-то явно указывать тип данных для переменных. Потому, что переменная связывается с типом в момент присваивания значения, а не в момент объявления переменной.

let age = 35;
age = "Тридцать пять";

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

В любом случае, переменная age хранит текущее значение, которое меняется по ходу выполнения программы. Это иллюстрирует первичную цель переменных: хранение текущего состояния программы, которое может изменяться по ходу её выполнения.

Если значения переменных var и let могут меняться в ходе выполнения программы, то переменные const - предназначены для хранения постоянных значений. Часто бывает нужно задать определенные значения в программе, которые впоследствии никак не будут меняться в течение её работы, а только использоваться для получения самих данных. То есть, другими словами, необходимо задать константы и для этой цели тоже используются переменные.

До выхода стандарта ES6 в 2015 году, для объявления констант использовалось всё то же ключевое слово var, только имя этой константы записывалось большими буквами, с подчеркиваниями _ между словами, тем самым предупреждая других разработчиков или себя в будущем, что это константа и менять её дальше в коде нельзя, например:

var PI = 3.14;
var radius = 10;
var circle = 2 * PI * radius;

var TAX_RATE = 0.13;
var salary = 1000 * TAX_RATE;

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

const pi = 3.14;
var radius = 10;
var circle = 2 * pi * radius;

const taxRate = 0.13;
var salary = 1000 * taxRate;

Объявление переменных через const предотвращает случайное изменение, где-либо после начальной установки, значения. И как было показано ранее, попытка присвоить новое значение переменным taxRate или pi после их объявления, будет отвергнуто и вызовет ошибку TypeError.

Общие принципы выбора имен переменных

В этом разделе представлены основные принципы именования переменных из книги “Совершенный код” Стива Макконнела.

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

Переменную, представляющую число членов команды, можно было бы назвать numTeamMembers. Переменную, представляющую число мест на стадионе, — numSeatsInStadium. Для хранения максимального числа очков, набранных спортсменами какой-то страны в современной Олимпиаде, можно было бы создать переменную teamPointsMax. Переменную, определяющую текущую процентную ставку, лучше было бы назвать rate или interestRate, а не r или x.

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

Несколько примеров удачных и неудачных имен переменных:

суть переменной адекватное описание неадекватное описание
Сумма, на которую на данный момент выписаны чеки runningTotal, checkTotal written, ct, checks, CHKTTL, x, x1, x2
Скорость поезда velocity, trainVelocity, velocityInMph velt, v, tv, x, x1, x2, train
Текущая дата currentDate, todaysDat cd, current, c, x, x1, x2, date

Имена currentDate и todaysDate — хорошие имена, потому что полно и точно описывают идею «текущей даты». Фактически они составлены из слов с очевидным значением. Программисты иногда упускают из виду обычные слова, которые порой приводят к самому простому решению. Имена cd и c неудачны потому, что слишком коротки и «неописательны». Имя current тоже неудачно: оно не говорит, что именно является «текущим». Имя date кажется хорошим, но в итоге оно оказывается плохим, потому что мы имеем в виду не любую дату, а текущую; само по себе имя date об этом не говорит. Имена x, x1 и x2 заведомо неудачны: x традиционно представляет неизвестное количество чего-либо, и, если вы не хотите, чтобы ваши переменные были неизвестными величинами, подумайте о выборе других имен.

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

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

Запись данных о сотруднике можно было бы назвать inputRec или employeeData. Имя inputRec — компьютерный термин, выражающий идеи ввода данных и записи. Имя employeeData относится к проблемной области, а не к миру компьютеров. В случае битового поля, определяющего статус принтера, имя bitFlag более компьютеризировано, чем printerReady, а в случае приложения бухгалтерского учета calcVal более компьютеризировано, чем sum.

Оптимальная длина имени, наверное, лежит где-то между длинами имен x и maximumNumberOfPointsInModernOlympics. Слишком короткие страдают от недостатка смысла. Проблема с именами вроде x1 и x2 в том, что, даже узнав, что такое x, вы ничего не сможете сказать об отношении между x1 и x2. Слишком длинные имена надоедает печатать, к тому же они могут сделать неясной визуальную структуру программы.

Было обнаружено, что отладка программы требовала меньше всего усилий, если имена переменных состояли в среднем из 10–16 символов. Отладка программ с именами, состоящими в среднем из 8–20 символов, была почти столь же легкой. Это не значит, что следует присваивать всем переменным имена из 9–15 или 10–16 символов. Это значит, что, увидев в своем коде много более коротких имен, вы должны проверить их ясность.

Вопрос адекватности длины имен переменных поясняет следующая таблица:

Слишком длинные имена: Слишком короткие имена: То, что надо:
numberOfPeopleOnTheUsOlympicTeam, numberOfSeatsInTheStadium, maximumNumberOfPointsInModernOlympics n, np, ntm, n, ns, nsisd, m, mp, max, points numTeamMembers, teamMemberCount, numSeatsInStadium, seatCount, teamPointsMax, pointsRecord
Обнаружили ошибку или хотите добавить что-то своё в документацию? Отредактируйте эту страницу на GitHub!

Оставить комментарий