JavaScript. Величины, типы и операторы

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

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

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

0 0 0 0 1 1 0 1
128 64 32 16 8 4 2 1

Получается двоичное число 00001101, или 8 + 4 + 1 = 13

Величины

Современный компьютер хранит в ОЗУ (оперативной памяти) более 30 млрд бит информации. Постоянной память на несколько порядков больше.

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

В JS единицы информации - называются величинами.

Значения величин состоят из бит, но играют разные роли.

У каждой величины есть тип, определяющий его роль.

Есть шесть основных типов:

числа; строки; булевые значения; объекты; функции; неопределенные значения.

Чтобы создать величину, нужно задать ей имя.

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

Числа

Величины числовых выражений, это - числа.

Запись числа в JS:

13

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

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

Для n десятичных цифр количество чисел, которые ими можно записать, равно 10 в степени n. А значит (64 бит) можно выразить (2ˆ64) 2 в 64 степени чисел.

Не все числа меньше 2ˆ64 помещаются в число JS. В этих битах хранятся и отрицательные числа - один бит хранит знак числа. Еще нужно иметь возможность хранить дроби, а значит часть бит используется для хранения позиции десятичной точки.

Отсюда вывод, что реальный максимум чисел - около 10ˆ15.

Запись дроби в JS:

9.81

Запись больших и маленьких чисел в JS идет с помощью буквы "e" (exponent), за которой следует степень

2.998e8

Это 2.998 x 10ˆ8 = 299800000

Вычисления с целыми числами (называются - "integer") меньшими, чем 10ˆ15, будут гарантировано точными. Вычисления с дробями - обычно не точными, так же, как и число π (пи) нельзя представить точно.

Арифметика

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

Символы в JS "+", "-", "×", "/" называются операторами:

100 + 4 * 11

Умножение выполняется первым, но как и в математике, это можно изменить при помощи скобок:

(100 + 4) * 1

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

У операторов "×", "/" приоритет одинаковый, и выше, чем "+", "-" При вычислении операторов с равным приоритетом, они вычисляются слева - направо

1 - 2 + 1

Вычисляется как (1-2) + 1

Символ "%" - оператор в JS для получения остатка:
X % Y - остаток от деления X на Y;
314 % 100 - остаток от деления 314 на 100 дает 14;
144 % 12 - остаток от деления 144 на 12 дает 0;

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

Три специальных значения в JS: "Infinity", "-Infinity", "NaN", которые считаются числами, но ведут себя не как обычные числа:
"Infinity", "-Infinity" - положительная и отрицательная бесконечности

Infinity - 1 = Infinity

"NaN" - не число (not a number)

0 / 0, либо Infinity - Infinity - не ведут к точным осмысленным результатам, поэтому в результате получим NaN

Строки

Строки используются для хранения текста.

Запись строк в JS:
"Что посеешь, то из пруда"
'Баба с возу, потехе час'

Можно использовать, как двойные, так и одинарные кавычки

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

Перевод строки тоже нельзя просто так заключить в кавычки - строка должна идти одной строкой

Для заключения специальных символов в JS используется "\" обратный слеш:

символ, идущий за ним, имеет специальное значение и называется "экранирование символов" (escape character)

\n - означает перевод строки;
\t - означает табуляцию

Введу строку: "Между первой и второй \n символ будет небольшой"
Результат:
Между первой и второй
символ будет небольшой

Если нужно включить в строку обратный слеш, его тоже нужно отдельно экранировать:

"Символ новой строки - это \"\ \n"

Строки в JS нельзя делить, умножать, складывать. Однако можно использовать оператор "+", который будет соединять их друг с другом:
"сое" + "ди" + "н" + "ение"

В результате получаем:

"соединение"

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

В JS оператор "typeof" выдает название типа величины к которой применяется:

console.log(typeof 4.5)
// → number

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

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

Операторы в JS
операторы, работающие с двумя величинами - "бинарные"
операторы, работающие с одной величиной - "унарные"

Минус (вычитание) можно использовать и как "бинарный" и как "унарный"

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

Булевские величины

Часто нужна величина, которая показывает одну из двух возможностей - типа "да", "нет" или "вкл", "выкл"

В JS тип "Boolean" имеет два значения "true", "false" - (истина, ложь):

var x = 0;
Boolean(x);
// → false - возвращает "ложь"

Boolean(10 > 9)
// → true - возвращает "истина"

Сравнение

В JS бинарные операторы "<", ">", ">=", "<=", "==", "!=" обозначают "меньше", "больше", "больше или равно", "меньше или равно", "равно", "не равно" Используя их получаем булевскую величину, которая покажет является ли неравенство верным:

console.log(3 > 2);
// → true - возвращает "истина"

console.log(3 < 2);
// → false - вовзвращает "ложь"

Строки можно сравнивать:

console.log("Арбуз" < "Яблоко")
// → true - возвращает "истина"

console.log("Хочется" != "Колется")
// → true - возвращает "истина"

Строки сравниваются по алфавиту: буквы в верхнем регистре всегда "меньше" букв в нижнем регистре. Сравнение основано на стандарте "Unicode".

Данный стандарт присваивает номер любому символу. Во время сравнения строк JS проходит по символами "слева - направо", сравнивая номерные коды этих символов.

В JavaScript есть величина, которая не равна самой себе - "NaN" (не число)

NaN - результат любого бессмысленного вычисления, поэтому он не равен результату другого бессмысленного вычисления:

console.log(NaN == NaN)
// → false - возвращает "ложь"

Есть операции, которые можно совершать с самими булевскими значениями.

Три логических оператора "&&", "||", "!" - обозначает "и", "или", "нет":

Оператор "&&" - логическое "и". Он бинарный, и его результат - "истина", только при условии, что обе величины, к которым он применяется, тоже "истина":

console.log(true && false)
// → false - возвращает "ложь"

console.log(true && true)
// → true - возвращает "истина"

Оператор "||" - логическое "или". Он бинарный, и его результат - "истина", только при условии, что одна из величин, к которым он применяется, тоже "истина":

console.log(false || true)
// → true - возвращает "истина"

console.log(false || false)
// → false - возвращает "ложь"

Оператор "!" - логическое "нет". Он унарный, обращает величину к которой применяется на обратную, где "!false" получается "true", "!true" получается "false":

console.log(!true)
// → false - возвращает "ложь"

console.log(!false)
// → true - возвращает "истина"

Условный оператор. Не унарный и не бинарный - он тройной. Записывается при помощи вопросительного знака и двоеточия. Величина слева от вопросительного знака выбирает одну из величин, разделенных двоеточием. Когда величина слева "true" - выбираем первое значение, когда величина слева "false" - выбираем второе значение:

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

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

По приоритетности у оператора "||" самый низкий приоритет, затем идет "&&", затем операторы сравнения, затем все остальные. Такой порядок выбран для того, чтобы в выражениях использовать скобок по минимуму.

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

Неопределенные значения

Два специальных значения "null", "undefined" для обозначения отсутствия осмысленного значения, но сами по себе никакой информации не несут.

Множество операторов, которые не выдает значения, возвращают "undefined" просто для того, чтобы что-то вернуть.

Разница между "null", "undefined" в JS появилась случайно, и обычно не имеет значения.

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

Приведение типов (coercion) в JS - когда оператор применяется не к тому типу величин, JS самостоятельно преобразовывает величину к нужному типу, используя правила, которые не всегда соответствуют ожиданиям.

В первом выражении "null" превращается в 0:

console.log(8 * null);
// → 0

Во втором выражении строка "5" становится числом 5:

console.log("5" - 1);
// → 4

В третьем выражении "+" выполняет объединение (конкатенацию) строк, и число 1 преобразовывается в строку "1":

console.log("5" + 1);
// → 51

В четвертом выражении что-то неочевидное превращается в номер, "пять" или "undefined", то возвращается NaN. Последующие арифметические операции с NaN опять получают NaN. Если в результате получили такое значение, то стоит поискать, где произошло случайное преобразование типов:

console.log("пять" * 2);
// → NaN

В пятом выражении при сравнении величин одного типа через "==", если величины одинаковые (только если не равны NaN), то должны получить "true". Но когда типы различны, то JS пытается преобразовать тип одной величины в тип другой. Если с любой стороны оператора появляется null или undefined, то результат будет true, только если обе стороны равны null или же обе равны undefined

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

Когда нужно проверить, имеет ли величина реальное значение, вместо null или undefined, то можно сравнить величину с null при помощи операторов "==", "!=":

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

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

В случае, когда нужно сравнить нечто с точной величиной, тогда согласно правилам преобразования типов в булевские значения "0", "NaN", и пустая строка "" - считается false, а все остальные true

0 == false;
"" == false;
NaN == false;

[!note] Можно использовать дополнительные два оператора "===" - проверяет, что две величины идентичны, "!==" - проверяет, что две величины различны, когда не нужно автоматического преобразования типов:

"" === false;
// → false

[!faq] Рекомендую использовать трехсимвольные операторы сравнения для защиты от неожиданных преобразований типов выражений, которые ведут к непредсказуемым последствиям.

Короткое вычисление логических операторов

Логические операторы && - "и", || - "или" с величинами разных типов работают странно. Они преобразовывают величину с левой стороны оператора в булевское, чтобы понять, что делать дальше, и в зависимости от оператора и от результата преобразования, возвращают оригинальное значение с левой или правой части

Оператор || - "или" вернет значение с левой части, когда его можно преобразовать в true, а иначе вернет правую часть:

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

console.log("Karl" || "user");
// → Karl

Оператор && - "и" оператор работает сходным образом, но наоборот. Если величина слева преобразовывается в false, он возвращает эту величину, а иначе величину справа.

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

[!note] Важное свойство короткого вычисления - выражение правой части вычисляется только при необходимости.
true || X - не важно чему равно Х, результат всегда true и X не вычисляется.
false && X - игнорируется Х, результат всегда false

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

Краткий итог

Четыре типа величин:

числа строки булевские неопределенные

Бинарные операторы:

+ - сложение - - вычитание * - умножение / - деление % - остаток от деления

Оператор конкатенации (объединения) строк:

+ - через оператор сложения

Операторы сравнения:

== - равно != - не равно === - равно (для исключения преобразования типов) !== не равно (для исключения преобразования типов) > - больше < - меньше <= - меньше или равно >= - больше или равно

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

&& - и || - или

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

- - для отрицательного значения ! - для логического отрицания typeof - для определения типа величины