Значения, типы и операторы

Перевод с английского языка на русский язык.

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

Бит — это любая двоичная величина, обычно описываемая как ноль или единица. Внутри компьютера они могут принимать различные формы, такие как высокий или низкий уровень заряда, сильный или слабый сигнал, светлые или тёмные точки на поверхности компакт-диска. Любой фрагмент дискретной информации можно упростить до последовательности нулей и единиц, тем самым представив его в виде бита.

Например, мы можем использовать биты для представления числа 13. Принцип такой же, как и у десятичных чисел, но вместо 10 различных цифр у нас есть только 2, и каждая цифра имеет вес, который увеличивается вдвое справа налево. Ниже приведены биты, составляющие число 13, а также их веса:

Таким образом, это двоичное число 00001101, или 8 + 4 + 1 = 13.

Значения

Представьте себе море битов — океан из них. В типичном современном компьютере с энергозависимой памятью (оперативной памятью) имеется более 300 миллиардов битов. Энергонезависимая память (жёсткий диск или эквивалентное устройство) часто содержит ещё несколько порядков величины.

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

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

Эта глава познакомит вас с основными элементами программ JavaScript, включая простые типы значений и операторы значений.

Числа

Числа (тип Number) — это числовые значения. В JavaScript они записываются следующим образом:

13

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

JavaScript использует фиксированное количество битов (64 бита) для хранения одного числового значения. Вы можете создать множество шаблонов с помощью 64 бит, что означает, что количество различных чисел ограничено. Для N десятичных цифр можно представить 10^N различных чисел. Аналогично, с 64 двоичными цифрами вы можете представить 2^64 различных чисел, примерно 18 квинтиллионов (18 с последующими 18 нулями). Это очень много.

Раньше компьютерная память была небольшой, и люди предпочитали использовать группы из 8 или 16 битов для представления своих чисел. Такие маленькие числа легко переполняются, и в итоге полученное число не помещается в заданное количество битов. Сегодня даже карманный компьютер имеет достаточно памяти, чтобы вы могли свободно использовать 64-битные блоки, и вам придётся беспокоиться о переполнении только при работе с астрономическими числами.

Однако не все числа меньше 18 квадриллионов могут быть представлены в числовых значениях JavaScript. Эти биты также хранят знак числа. Более серьёзная проблема заключается в том, что необходимо также представлять нецелые числа. Для этого некоторые биты используются для указания положения десятичной точки. Можно хранить фактическое максимальное целое число больше 9 миллиардов (15 нулей) — всё ещё довольно много.

Десятичные дроби представляются с использованием десятичной точки.

9.81

Для очень больших или очень маленьких чисел вы также можете использовать экспоненциальную запись, вводя e (для обозначения показателя степени) после числа и показателя степени:

2.998e8

Это равно 2.998 * 10^8 = 299,800,000.

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

Арифметика

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

100 + 4 * 11

Мы называем символы + и * операторами. Первый символ обозначает сложение, второй — умножение. Поместив оператор между двумя значениями, этот оператор будет использовать два соседних значения для создания нового значения.

Но что означает этот пример? «Сложить 4 и 100 и умножить результат на 11» или «умножить 4 на 100 перед сложением»? Как вы, возможно, догадались, умножение выполняется первым. Но, как и в математике, вы можете изменить порядок, заключив сложение в круглые скобки:

(100 + 4) * 11

- — оператор вычитания, / — деления.

Если операторы появляются вместе и нет скобок, их порядок определяется приоритетом операторов. В этом примере оператор умножения имеет более высокий приоритет, чем оператор сложения. Операторы / и * имеют одинаковый приоритет, а операторы + и - также имеют одинаковый приоритет. Когда несколько операторов с одинаковым приоритетом находятся рядом, операция выполняется слева направо, например, (1 - 2 + 1).

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

Есть ещё один арифметический оператор, который вы, возможно, не сразу узнаете. Оператор % используется для нахождения остатка от деления. X % Y — это остаток от деления X на Y. Например, 314 % 100 даёт 14, а 144 % 12 даёт 0. Приоритет оператора остатка такой же, как у операторов умножения и деления. Вы также часто будете видеть этот оператор, называемый оператором модуля.

Специальные числа

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

Первые два — Infinity и -Infinity, представляющие положительную и отрицательную бесконечность. «Бесконечность минус один» по-прежнему остаётся «бесконечностью». Однако не стоит слишком доверять вычислениям, основанным на бесконечности, поскольку они нелогичны с математической точки зрения и быстро приводят к следующему специальному числу: NaN.

NaN представляет «не число», хотя и является значением числового типа. Например, когда вы пытаетесь вычислить 0/0 (ноль, делённый на ноль), Infinity - Infinity или любую другую числовую операцию, которая не приводит к осмысленному результату, вы получите этот результат. ### Текст на русском языке:

В JavaScript определено более 16 степеней различных символов. Однако, в Unicode определено больше символов — примерно вдвое больше. Поэтому некоторые символы, например, многие эмодзи, занимают в строках JavaScript два «символьных места». Мы вернёмся к этому в пятой главе.

Мы не можем использовать операторы деления, умножения или вычитания со строками, но оператор сложения + можно использовать. В этом случае оператор не обозначает сложение, а является операцией соединения: он объединяет две строки вместе. Следующая инструкция может создать строку "concatenate":

"con" + "cat" + "e" + "nate"

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

`half of 100 is ${100 / 2}`

Когда вы пишете что-то в шаблоне литерала $ {}, оно вычисляется и преобразуется в строку, которая помещается в это место. Этот пример создаёт "half of 100 is 50".

Унарный оператор

Не все операторы представлены символами, некоторые из них выражены словами. Например, оператор typeof возвращает строковое значение, содержащее тип заданного значения.

console.log(typeof 4.5)
// → number
console.log(typeof "x")
// → string

Мы будем использовать console.log в примерах кода для отображения результатов оценки. Подробнее об этом будет рассказано в следующей главе. Большинство операторов, которые мы видели, используют два значения для выполнения операции, тогда как typeof принимает только одно значение. Операторы, использующие два значения, называются бинарными операторами, а те, которые используют одно значение — унарными. Оператор знака минус может использоваться как унарный или как бинарный.

console.log(- (10 - 2))
// → -8

Булевы значения

Имея значение, которое может различать два варианта, часто бывает полезно, например «да» и «нет» или «вкл.» и «выкл.». Для этого JavaScript имеет логический (Boolean) тип, который имеет два значения: true и false, которые записываются именно этими словами.

Сравнение

Один из способов создания булевого значения выглядит следующим образом:

console.log(3 > 2)
// → true
console.log(3 < 2)
// → false

Символы > и < обозначают «больше» и «меньше». Эти два символа являются бинарным оператором, возвращающим результат, являющийся булевым значением, указывающим, является ли операция истинной. Мы можем сравнить строки аналогичным образом.

console.log("Aardvark" < "Zoroaster")
// → true

Порядок сортировки строк примерно соответствует словарному порядку, но не совсем так, как вы ожидаете увидеть в словаре: заглавные буквы всегда «меньше», чем строчные, поэтому "Z"<"A", а небуквенные символы (например, ! или -) также включены в сортировку. При сравнении строк JavaScript проходит по символам слева направо, сравнивая каждый символ по очереди. Другие подобные операторы включают >= («больше или равно»), <= («меньше или равно»), == («равно») и != («не равно»).

console.log("Apple" == "Orange")
// → false

В JavaScript только одно значение не равно самому себе — это NaN (Not a Number, не число).

console.log(NaN == NaN)
// → false

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

Логические операторы

Есть несколько операторов, которые можно применять к булевым значениям. JavaScript поддерживает три логических оператора: && («и»), || («или») и ! («не»). Эти операторы можно использовать для вывода логических значений. Оператор && обозначает логическое «и». Это бинарный оператор, результатом которого является истина только тогда, когда оба его значения равны true.

console.log(true && false)
// → false
console.log(true && true)
// → true

Оператор || обозначает логическое «или». Когда любое из двух значений равно true, результатом будет истина.

console.log(false || true)
// → true
console.log(false || false)
// → false

Восклицательный знак (!) обозначает логическое отрицание, это унарный оператор, используемый для изменения значения на противоположное, например, !true даёт false, а !false даёт true. При смешивании логических операторов с другими операторами иногда бывает трудно определить, когда нужно использовать круглые скобки. На самом деле, пока вы знакомы с операторами, представленными до сих пор, эта проблема становится менее сложной. Приоритет || самый низкий, затем идёт &&, за ним следуют операторы сравнения (>, == и т. д.), а затем остальные операторы. Основываясь на этих приоритетах, мы обычно стараемся избегать использования скобок, если это возможно, например:

1 + 1 == 2 && 10 * 10 > 50

Теперь давайте обсудим последний логический оператор, который не является ни унарным, ни бинарным, а тернарным (работает с тремя значениями одновременно). Этот оператор состоит из вопросительного знака и двоеточия, вот так:

console.log(true ? 1 : 2);
// → 1
console.log(false ? 1 : 2);
// → 2

Он называется условным оператором (или иногда просто тернарным оператором, потому что это единственный такой оператор в языке). Значение слева от вопроса «выбирает» одно из двух других значений. Если оно истинно, оно выбирает среднее значение, а если оно ложно, то выбирается правое значение.

Пустые значения

Существует два специальных значения, записанных как null и undefined, которые используются для представления бессмысленных значений. Они сами по себе являются значениями, но они не содержат никакой информации. В языке JavaScript существует множество операций, которые приводят к бессмысленным значениям (мы увидим примеры позже), эти операции дают результат undefined просто потому, что каждая операция должна давать значение. Разница между undefined и null является случайной особенностью дизайна JavaScript, и в большинстве случаев она не важна. Когда вам действительно приходится обращать внимание на эти значения, я предлагаю рассматривать их как почти взаимозаменяемые.

Автоматическое преобразование типов

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

console.log(8 * null)
// → 0
console.log("5" - 1)
// → 4
console.log("5" + 1)
// → 51
console.log("five" * 2)
// → NaN
console.log(false == 0)
// → true

Когда оператор применяется к значению неправильного типа, JavaScript тихо преобразует это значение в требуемый тип и использует набор правил, которые обычно не являются желаемыми или ожидаемыми. Это называется преобразованием типов. Первое выражение преобразует null в 0, второе выражение преобразует "5" в 5 (из строки в число). Однако в третьем выражении + пытается выполнить конкатенацию строк перед добавлением числа, поэтому 1 преобразуется в "1" (из числа в строку). Когда что-то, что не может быть явно сопоставлено с числом, такое как "five" или undefined, преобразуется в число, вы получите значение NaN. NaN дальнейшие арифметические операции приведут к NaN, поэтому, если вы обнаружите, что получаете его неожиданно, вам следует искать неожиданное преобразование типов. Когда значения одного типа сравниваются с помощью ==, результат сравнения легко предсказать: кроме NaN, если два значения совпадают, возвращается true. Но если типы различаются, JavaScript использует сложный и непонятный набор правил для определения результата. В большинстве случаев JavaScript просто преобразует одно из значений в тип другого значения. Но если с обеих сторон есть null или undefined, то результат будет true только тогда, когда обе стороны равны null или undefined.

console.log(null == undefined);
// → true
console.log(null == 0);
// → false

Такое поведение обычно полезно. Когда вы хотите проверить, имеет ли значение истинное значение, отличное от null или undefined, вы можете сравнить его с null с помощью == (или !=). Но что, если вы хотите проверить что-то на строгое «ложное» значение? Строка и число преобразуются в логическое значение по правилам, согласно которым 0, NaN и пустая строка ("") считаются ложными, а все остальные значения считаются истинными. Таким образом, такие выражения, как '0 == false' и "" == false, также верны. Когда вы не хотите, чтобы происходило автоматическое преобразование типов, есть ещё два дополнительных оператора: === и !==. Первый проверяет, строго ли равно значение другому значению, второй проверяет, не строго ли оно равно. Поэтому "" === false неверно, как и ожидалось. Я рекомендую использовать трёхсимвольные операторы сравнения, чтобы избежать случайного преобразования типов и не попасть в ловушку. Но если сравниваемые значения имеют одинаковый тип, использование более коротких операторов также допустимо.

Особенности логических операторов короткого замыкания

Логические операторы && и || обрабатывают значения разных типов особым образом. Они преобразуют значение слева в логическое, чтобы решить, что делать, но в зависимости от оператора и результата преобразования они возвращают исходное значение слева или справа. Например, когда значение слева можно преобразовать в true, оператор || вернёт его, иначе он вернёт значение справа. Когда значение является булевым, это имеет ожидаемый эффект, и аналогичные операции выполняются для других типов значений.

console.log(null || "user")
// → user
console.log("Agnes" || "user")
// → Agnes

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

Работа оператора && похожа на работу оператора ||, но не идентична ей. Когда значение слева можно преобразовать в false, оператор && возвращает левое значение, в противном случае он возвращает правое значение.

Ещё одна важная особенность этих двух операторов заключается в том, что они вычисляют правую часть только при необходимости. В случае true || X результатом всегда будет true, независимо от того, что такое X, даже если это фрагмент программы, выполняющий какие-то вредоносные действия, и X никогда не будет вычислен. То же самое верно и для false && X: оно всегда равно false и игнорирует X. Это называется коротким замыканием.

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

Краткое содержание этой главы

В этой главе мы представили четыре типа значений в JavaScript: числовые, строковые, булевы и неопределённые.

Вы можете создавать их, вводя имена значений (true, null) или значения (13, "abc"). Вы также можете объединять и преобразовывать значения с помощью операторов. В этой главе были представлены арифметические бинарные операторы (+, -, $*$, / и $%$), оператор конкатенации строк (+), операторы сравнения (==$, $!=$$, $===$$, $!==$$, <$$, $>$$, $<=$$ и $>=$$), логические операторы (&&$ и $||$) и некоторые унарные операторы ($-$ для обозначения отрицательных чисел, $!$ для логического отрицания и $typeof$ для запроса типа значения).

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