RSS conspectus

css.md

‎‎​

git.md

‎‎​

js.md

Если атрибут src установлен, содержимое тега script будет игнорироваться.

Атрибуты type и language необязательны.

В большинстве случаев точку с запятой можно не ставить, если есть переход на новую строку. JavaScript не вставляет точку с запятой перед квадратными скобками [...].

Современный JavaScript поддерживает «классы» и «модули» — продвинутые структуры языка (и мы, конечно, до них доберёмся), которые автоматически включают строгий режим. Поэтому в них нет нужды добавлять директиву "use strict". Пока очень желательно добавлять "use strict"; в начале ваших скриптов. Позже, когда весь ваш код будет состоять из классов и модулей, директиву можно будет опускать.

Самое интересное – знак доллара '$' и подчёркивание '_' также можно использовать в названиях. Это обычные символы, как и буквы, без какого-либо особого значения.

Регистр имеет значение Переменные с именами apple и AppLE – это две разные переменные.

Нелатинские буквы разрешены, но не рекомендуются

Зарезервированные имена Например: let, class, return и function зарезервированы.

Широко распространена практика использования констант в качестве псевдонимов для трудно запоминаемых значений, которые известны до начала исполнения скрипта.

Дополнительная переменная – это добро, а не зло.

Кроме обычных чисел, существуют так называемые «специальные числовые значения», которые относятся к этому типу данных: Infinity, -Infinity и NaN.

NaN означает вычислительную ошибку. Это результат неправильной или неопределённой математической операции. Значение NaN «прилипчиво». Любая операция с NaN возвращает NaN. Если где-то в математическом выражении есть NaN, то результатом вычислений с его участием будет NaN.

Математические операции в JavaScript «безопасны». Мы можем делать что угодно: делить на ноль, обращаться с нечисловыми строками как с числами и т.д. Скрипт никогда не остановится с фатальной ошибкой (не «умрёт»). В худшем случае мы получим NaN как результат выполнения.

Двойные или одинарные кавычки являются «простыми», между ними нет разницы в JavaScript. Обратные же кавычки имеют расширенную функциональность. Они позволяют нам встраивать выражения в строку, заключая их в ${…}. Выражение внутри ${…} вычисляется, и его результат становится частью строки.

Нет отдельного типа данных для одного символа.

Специальное значение null не относится ни к одному из типов, описанных выше. Оно формирует отдельный тип, который содержит только значение null: let age = null; В JavaScript null не является «ссылкой на несуществующий объект» или «нулевым указателем», как в некоторых других языках. Это просто специальное значение, которое представляет собой «ничего», «пусто» или «значение неизвестно».

Специальное значение undefined также стоит особняком. Оно формирует тип из самого себя так же, как и null. Оно означает, что «значение не было присвоено». Если переменная объявлена, но ей не присвоено никакого значения, то её значением будет undefined. Технически мы можем присвоить значение undefined любой переменной …Но так делать не рекомендуется. Обычно null используется для присвоения переменной «пустого» или «неизвестного» значения, а undefined – для проверок, была ли переменная назначена.

Тип object (объект) – особенный. Все остальные типы называются «примитивными», потому что их значениями могут быть только простые значения (будь то строка, или число, или что-то ещё). В объектах же хранят коллекции данных или более сложные структуры. Тип symbol (символ) используется для создания уникальных идентификаторов в объектах. Мы упоминаем здесь о нём для полноты картины, изучим этот тип после объектов.

typeof undefined // "undefined"
typeof 0 // "number"
typeof 10n // "bigint"
typeof true // "boolean"
typeof "foo" // "string"
typeof Symbol("id") // "symbol"
typeof Math // "object"  это встроенный объект, который предоставляет математические операции и константы.
typeof null // "object"  Это официально признанная ошибка в typeof, ведущая начало с времён создания JavaScript и сохранённая для совместимости. Конечно, null не является объектом. Это специальное значение с отдельным типом.
typeof alert // "function"

Итого В JavaScript есть 8 основных типов. number для любых чисел: целочисленных или чисел с плавающей точкой; целочисленные значения ограничены диапазоном ±(253-1). bigint для целых чисел произвольной длины. string для строк. Строка может содержать ноль или больше символов, нет отдельного символьного типа. boolean для true/false. null для неизвестных значений – отдельный тип, имеющий одно значение null. undefined для неприсвоенных значений – отдельный тип, имеющий одно значение undefined. object для более сложных структур данных. symbol для уникальных идентификаторов. Оператор typeof позволяет нам увидеть, какой тип данных сохранён в переменной. Имеет две формы: typeof x или typeof(x). Возвращает строку с именем типа. Например, "string". Для null возвращается "object" – это ошибка в языке, на самом деле это не объект.

Строковое преобразование происходит, когда требуется представление чего-либо в виде строки.

Численное преобразование происходит в математических функциях и выражениях. Например, когда операция деления / применяется не к числу. Правила численного преобразования: Значение Преобразуется в… undefined NaN null 0 true / false 1 / 0 string Пробельные символы по краям обрезаются. Далее, если остаётся пустая строка, то получаем 0, иначе из непустой строки «считывается» число. При ошибке результат NaN. Учтите, что null и undefined ведут себя по-разному. Так, null становится нулём, тогда как undefined приводится к NaN.

Правило логического преобразования: Значение Становится… 0, null, undefined, NaN, "" false любое другое значение true Заметим, что строчка с нулём "0" — это true.

Большую часть из этих правил легко понять и запомнить. Особые случаи, в которых часто допускаются ошибки: undefined при численном преобразовании становится NaN, не 0. "0" и строки из одних пробелов типа " " при логическом преобразовании всегда true.

Математика Взятие остатка от деления %, Возведение в степень **.

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

alert(2 + 2 + '1' ); // будет "41", а не "221" Здесь операторы работают один за другим. Первый + складывает два числа и возвращает 4, затем следующий + объединяет результат со строкой, производя действие 4 + '1' = 41.

Унарный, то есть применённый к одному значению, плюс + ничего не делает с числами. Но если операнд не число, унарный плюс преобразует его в число.

let apples = "2";
let oranges = "3";
// оба операнда предварительно преобразованы в числа
alert( +apples + +oranges ); // 5

Приоритет Название Обозначение … … … 15 унарный плюс + 15 унарный минус - 14 возведение в степень *_ 13 умножение _ 13 деление / 12 сложение + 12 вычитание - … … … 2 присваивание = … … …

Тот факт, что = является оператором, а не «магической» конструкцией языка, имеет интересные последствия. Благодаря этому присваивание можно использовать как часть более сложного выражения:

let a = 1;
let b = 2;

let c = 3 - (a = b + 1);

alert( a ); // 3
alert( c ); // 0

Присваивание по цепочке

let a, b, c;

a = b = c = 2 + 2;

alert( a ); // 4
alert( b ); // 4
alert( c ); // 4

Такое присваивание работает справа налево.

Сокращённая арифметика с присваиванием

let n = 2;
n *= 3 + 5;
alert( n ); // 16  (сначала выполнится правая часть, выражение идентично n *= 8)

Операторы ++ и -- могут быть расположены не только после, но и до переменной. Когда оператор идёт после переменной — это «постфиксная форма»: counter++. «Префиксная форма» — это когда оператор идёт перед переменной: ++counter. Давайте проясним этот момент. Как мы знаем, все операторы возвращают значение. Операторы инкремента/декремента не исключение. Префиксная форма возвращает новое значение, в то время как постфиксная форма возвращает старое (до увеличения/уменьшения числа). Операторы ++/-- могут также использоваться внутри выражений. Их приоритет выше, чем у большинства других арифметических операций.

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

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

// три операции в одной строке
for (a = 1, b = 3, c = a * b; a < 10; a++) {
 ...
}

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

Операторы сравнения Алгоритм сравнения двух строк довольно прост: Сначала сравниваются первые символы строк. Если первый символ первой строки больше (меньше), чем первый символ второй, то первая строка больше (меньше) второй. Сравнение завершено. Если первые символы равны, то таким же образом сравниваются уже вторые символы строк. Сравнение продолжается, пока не закончится одна из строк. Если обе строки заканчиваются одновременно, то они равны. Иначе, большей считается более длинная строка. Используется кодировка Unicode, а не настоящий алфавит

При сравнении значений разных типов JavaScript приводит каждое из них к числу.

alert( '2' > 1 ); // true, строка '2' становится числом 2
alert( '01' == 1 ); // true, строка '01' становится числом 1

Забавное следствие Возможна следующая ситуация: Два значения равны. Одно из них true как логическое значение, другое – false. Например:

let a = 0;
alert( Boolean(a) ); // false

let b = "0";
alert( Boolean(b) ); // true

alert(a == b); // true!

С точки зрения JavaScript, результат ожидаем. Равенство преобразует значения, используя числовое преобразование, поэтому "0" становится 0. В то время как явное преобразование с помощью Boolean использует другой набор правил.

Строгое сравнение Использование обычного сравнения == может вызывать проблемы. Например, оно не отличает 0 от false: alert( 0 == false ); // true Та же проблема с пустой строкой: alert( '' == false ); // true Это происходит из-за того, что операнды разных типов преобразуются оператором == к числу. В итоге, и пустая строка, и false становятся нулём. Как же тогда отличать 0 от false? Оператор строгого равенства === проверяет равенство без приведения типов. Другими словами, если a и b имеют разные типы, то проверка a === b немедленно возвращает false без попытки их преобразования. Давайте проверим: alert( 0 === false ); // false, так как сравниваются разные типы Ещё есть оператор строгого неравенства !==, аналогичный !=.

Оператор строгого равенства дольше писать, но он делает код более очевидным и оставляет меньше места для ошибок.

Сравнение с null и undefined Поведение null и undefined при сравнении с другими значениями — особое: При строгом равенстве === Эти значения различны, так как различны их типы. alert( null === undefined ); // false При нестрогом равенстве == Эти значения равны друг другу и не равны никаким другим значениям. Это специальное правило языка. alert( null == undefined ); // true При использовании математических операторов и других операторов сравнения < > <= >= Значения null/undefined преобразуются к числам: null становится 0, а undefined – NaN. Посмотрим, какие забавные вещи случаются, когда мы применяем эти правила. И, что более важно, как избежать ошибок при их использовании.

Странный результат сравнения null и 0 Сравним null с нулём:

alert( null > 0 );  // (1) false
alert( null == 0 ); // (2) false
alert( null >= 0 ); // (3) true

Причина в том, что нестрогое равенство и сравнения > < >= <= работают по-разному. Сравнения преобразуют null в число, рассматривая его как 0. Поэтому выражение (3) null >= 0 истинно, а null > 0 ложно. С другой стороны, для нестрогого равенства == значений undefined и null действует особое правило: эти значения ни к чему не приводятся, они равны друг другу и не равны ничему другому. Поэтому (2) null == 0 ложно.

Несравненное значение undefined Значение undefined несравнимо с другими значениями:

alert( undefined > 0 ); // false (1)
alert( undefined < 0 ); // false (2)
alert( undefined == 0 ); // false (3)

Почему же сравнение undefined с нулём всегда ложно? На это есть следующие причины: Сравнения (1) и (2) возвращают false, потому что undefined преобразуется в NaN, а NaN – это специальное числовое значение, которое возвращает false при любых сравнениях. Нестрогое равенство (3) возвращает false, потому что undefined равно только null, undefined и ничему больше.

Как избежать проблем Зачем мы рассмотрели все эти примеры? Должны ли мы постоянно помнить обо всех этих особенностях? Не обязательно. Со временем все они станут вам знакомы, но можно избежать проблем, если следовать надёжным правилам:

• Относитесь очень осторожно к любому сравнению с undefined/null, кроме случаев строгого равенства ===.
• Не используйте сравнения >= > < <= с переменными, которые могут принимать значения null/undefined, разве что вы полностью уверены в том, что делаете. Если переменная может принимать эти значения, то добавьте для них отдельные проверки.

Итого

• Операторы сравнения возвращают значения логического типа.
• Строки сравниваются посимвольно в лексикографическом порядке.
• Значения разных типов при сравнении приводятся к числу. Исключением является сравнение с помощью операторов строгого равенства/неравенства.
• Значения null и undefined равны == друг другу и не равны любому другому значению.
• Будьте осторожны при использовании операторов сравнений вроде > и < с переменными, которые могут принимать значения null/undefined. Хорошей идеей будет сделать отдельную проверку на null/undefined.

Преобразование к логическому типу Инструкция if (…) вычисляет выражение в скобках и преобразует результат к логическому типу. Давайте вспомним правила преобразования типов из главы Преобразование типов: Число 0, пустая строка "", null, undefined и NaN становятся false. Из-за этого их называют «ложными» («falsy») значениями. Остальные значения становятся true, поэтому их называют «правдивыми» («truthy»).