add typescript

docs/javascript/01-base/.gitkeep

@@ -0,0 +1 @@
+empty

docs/javascript/01-base/01-strict.md

@@ -0,0 +1,13 @@
+---
+sidebar_position: 1
+---
+
+# Строгий режим — "use strict"
+
+Появился с 2009 года в редакции ECMAScript 5 (ES5).
+Чтобы устаревший код работал, как и раньше, по умолчанию подобные изменения не применяются. Поэтому нам нужно явно их активировать с помощью специальной директивы: "use strict".
+
+Нет никакого способа отменить use strict
+Use strict по умолчанию выключен в консоли браузера
+
+Современный JavaScript поддерживает «классы» и «модули» — продвинутые структуры языка (и мы, конечно, до них доберёмся), которые автоматически включают строгий режим. 

docs/javascript/01-base/02-variables.md

@@ -0,0 +1,49 @@
+---
+sidebar_position: 2
+---
+
+# Переменные
+
+**Переменная** – это «именованное хранилище» для данных.
+
+Можно объявить при помощи:
+
+- **let**
+- **const** (константа, т.е. изменению не подлежит)
+- **var** (устаревший способ, подробности позже)
+
+```js
+let message;
+ 
+message = 'Hello'; // сохранить строку 'Hello' в переменной с именем message
+
+let user = 'John', age = 25, message = 'Hello';
+ 
+let user = 'John', 
+age = 25, 
+message = 'Hello';
+```
+
+Имя переменной может включать:
+- Буквы и цифры, однако цифра не может быть первым символом.
+- Символы $ и _ используются наряду с буквами.
+- Иероглифы и символы нелатинского алфавита также допустимы, но обычно не используются.
+
+Переменные типизируются динамически. В них могут храниться любые значения.
+
+Всего существует 8 типов данных:
+
+- **number** для целых и вещественных чисел,
+- **bigint** для работы с целыми числами произвольной длины,
+- **string** для строк,
+- **boolean** для логических значений истинности или ложности: true/false,
+- **null** – тип с единственным значением null, т.е. «пустое значение» или «значение не существует»,
+- **undefined** – тип с единственным значением undefined, т.е. «значение не задано»,
+- **object** и **symbol** – сложные структуры данных и уникальные идентификаторы; их мы ещё не изучили.
+
+Оператор `typeof` возвращает тип значения переменной, с двумя исключениями:
+
+```js
+typeof null == "object" // ошибка в языке
+typeof function(){} == "function" // именно для функций
+```

docs/javascript/01-base/03-type-conversion.md

@@ -0,0 +1,55 @@
+---
+sidebar_position: 3
+---
+
+# Преобразование типов
+
+## Строковое преобразование
+```js
+String(value)
+```
+```js
+alert(typeof value); // string
+```
+
+## Численное преобразование
+```js
+Number(str)
+```
+```js
+let num = Number(str); // становится числом 123
+```
+| Значение                | Преобразуется в…                                                                                                                                                                                                                |
+|-------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| undefined               | NaN                                                                                                                                                                                                                             |
+| null                    | 0                                                                                                                                                                                                                               |
+| true / false            | 1 / 0                                                                                                                                                                                                                           |
+| string                  | Пробельные символы (пробелы, знаки табуляции \t, знаки новой строки \n и т. п.) по краям обрезаются. Далее, если остаётся пустая строка, то получаем 0, иначе из непустой строки «считывается» число. При ошибке результат NaN. |
+
+```js
+alert( Number("   123   ") ); // 123 
+alert( Number("123z") );      // NaN (ошибка чтения числа на месте символа "z")
+alert( Number(true) );        // 1
+alert( Number(false) );       // 0
+```
+## Логическое преобразование
+```js
+Boolean(value)
+```
+Происходит в логических операциях, но также может быть выполнено явно с помощью функции Boolean(value).
+
+Правило преобразования:
+- Значения, которые интуитивно «пустые», вроде 0, пустой строки, null, undefined и NaN, становятся false.
+- Все остальные значения становятся true.
+
+| Значение                    | Становится… |
+|-----------------------------|-------------|
+| 0, null, undefined, NaN, "" | false       |
+| любое другое значение       | true        |
+
+```js
+alert( Boolean(1) ); // true 
+alert( Boolean(0) ); // false 
+alert( Boolean("Привет!") ); // true 
+alert( Boolean("") ); // false
+```

docs/javascript/01-base/04-operators.md

@@ -0,0 +1,39 @@
+---
+sidebar_position: 4
+---
+
+# Базовые операторы, математика
+
+Термины: «унарный», «бинарный», «операнд»
+- Операнд – то, к чему применяется оператор. Например, в умножении 5 * 2 есть два операнда: левый операнд равен 5, а правый операнд равен 2. Иногда их называют «аргументами» вместо «операндов». (5 * 2)
+- Унарным называется оператор, который применяется к одному операнду. Например, оператор унарный минус "-" меняет знак числа на противоположный: (-x)
+- Бинарным называется оператор, который применяется к двум операндам. Тот же минус существует и в бинарной форме: (y - x)
+
+## Поддерживаются следующие математические операторы:
+- Сложение +,
+- Вычитание -,
+- Умножение *,
+- Деление /,
+- Взятие остатка от деления %,
+- Возведение в степень **.
+
+## Инкремент/декремент
+- Инкремент counter++ увеличивает переменную на 1
+- Декремент counter-- уменьшает переменную на 1
+
+## Побитовые операторы
+- AND(и)  ( & )
+- OR(или) ( | )
+- XOR(побитовое исключающее или) ( ^ )
+- NOT(не) ( ~ )
+- LEFT SHIFT(левый сдвиг)  ( ≺≺ )
+- RIGHT SHIFT(правый сдвиг) ( ≻≻ )
+- ZERO-FILL RIGHT SHIFT(правый сдвиг с заполнением нулями) ( ≻≻≻ ) 
+  
+## Оператор «запятая»
+Оператор «запятая» предоставляет нам возможность вычислять несколько выражений, разделяя их запятой ,. Каждое выражение выполняется, но возвращается результат только последнего.
+```js
+let a = (1 + 2, 3 + 4);
+alert( a ); // 7 (результат вычисления 3 + 4)
+```
+❗ ***Запятая имеет очень низкий приоритет***

docs/javascript/01-base/05-compare-ops.md

@@ -0,0 +1,43 @@
+---
+sidebar_position: 5
+---
+
+# Операторы сравнения
+***Результат сравнения имеет логический тип***
+- Больше/меньше: a \> b, a \< b.
+- Больше/меньше или равно: a \>= b, a \<= b.
+- Равно: a == b. Обратите внимание, для сравнения используется двойной знак равенства ==. Один знак равенства a = b означал бы присваивание.
+- Не равно. В математике обозначается символом ≠, но в JavaScript записывается как a != b.
+
+## Сравнение строк
+Чтобы определить, что одна строка больше другой, JavaScript использует «алфавитный» или «лексикографический» порядок.\
+Другими словами, строки сравниваются посимвольно.
+
+❗ ***Используется кодировка Unicode, а не настоящий алфавит***
+
+Алгоритм сравнения двух строк довольно прост:
+- Сначала сравниваются первые символы строк.
+- Если первый символ первой строки больше (меньше), чем первый символ второй, то первая строка больше (меньше) второй. Сравнение завершено.
+- Если первые символы равны, то таким же образом сравниваются уже вторые символы строк.
+- Сравнение продолжается, пока не закончится одна из строк.
+- Если обе строки заканчиваются одновременно, то они равны. Иначе, большей считается более длинная строка.
+
+## Сравнение разных типов
+Использование обычного сравнения `==` может вызывать проблемы.
+Это происходит из-за того, что операнды разных типов преобразуются оператором `==` к числу. В итоге, и пустая строка, и false становятся нулём.
+
+**Оператор строгого равенства `===` проверяет равенство без приведения типов.**
+
+## Сравнение с null и undefined
+
+Поведение `null` и `undefined` при сравнении с другими значениями — особое:
+
+При строгом равенстве **===** \
+Эти значения различны, так как различны их типы.
+
+При нестрогом равенстве **==** \
+Эти значения равны друг другу и не равны никаким другим значениям. Это специальное правило языка.
+
+При использовании математических операторов и других операторов сравнения \< \> \<= \>=
+Значения null/undefined преобразуются к числам: `null` становится 0, а `undefined` – NaN.
+

docs/javascript/01-base/06-conditions-logic.md

@@ -0,0 +1,179 @@
+---
+sidebar_position: 6
+---
+
+# Условия и логические операторы
+
+## Условное ветвление: if, '?'
+
+Инструкция if(...) вычисляет условие в скобках и, если результат true, то выполняет блок кода.
+
+***Несколько условий: «else if»***
+
+## Конструкция "switch"
+```js
+let a = 2 + 2;
+ 
+switch (a) { 
+  case 3: 
+    alert( 'Маловато' ); 
+    break;
+  case 4:
+    alert( 'В точку!' ); 
+    break; 
+  case 5:
+    alert( 'Перебор' );
+    break;
+  default: 
+    alert( "Нет таких значений" ); 
+}
+```
+## Условный оператор „?“ (тернарный)
+```js
+let result = условие ? значение1 : значение2;
+```
+## Логические операторы
+
+В JavaScript есть семь логических операторов:
+
+- || (ИЛИ)
+- ||= (Оператор логического присваивания ИЛИ)
+- && (И)
+- &&= (Оператор логического присваивания И)
+- ! (НЕ)
+- ?? (Оператор нулевого слияния)
+- ??= (Оператор нулевого присваивания)
+
+### || (ИЛИ)
+```js
+( true || true ); // true 
+( false || true ); // true 
+( true || false ); // true 
+( false || false ); // false
+```
+### ИЛИ "||" находит первое истинное значение
+```js
+( 1 || 0 ); // 1 (1 - истинное значение) 
+( true || 'какая-то строка' ); // true 
+( null || 1 ); // 1 (первое истинное значение) 
+( null || 0 || 1 ); // 1 (первое истинное значение) 
+( undefined || null || 0 ); // 0 (поскольку все ложно, возвращается последнее значение)
+```
+
+### ||= (Логическое присваивание ИЛИ)
+```js
+a ||= b;
+```
+Оператор `||=` принимает два операнда и выполняет следующие действия:
+
+- Вычисляет операнды слева направо.
+- Конвертирует ***a*** в логическое значение.
+- Если ***a*** ложно, присваивает ***a*** значение ***b***.
+
+### && (И)
+```js
+( true && true ); // true 
+( false && true ); // false 
+( true && false ); // false 
+( false && false ); // false
+```
+#### И «&&» находит первое ложное значение
+```js
+result = value1 && value2 && value3;
+```
+Оператор `&&` выполняет следующие действия:
+
+- Вычисляет операнды слева направо.
+- Каждый операнд преобразует в логическое значение. Если результат **false**, останавливается и возвращает исходное
+  значение этого операнда.
+- Если все операнды были истинными, возвращается последний.
+
+Другими словами, **И** возвращает первое ложное значение. Или последнее, если ничего не найдено.
+
+Вышеуказанные правила схожи с поведением **ИЛИ**. Разница в том, что **И** возвращает первое ложное значение, а **ИЛИ**
+первое истинное.
+
+❗ ***Приоритет оператора && больше, чем у ||*** \
+Приоритет оператора **И &&** больше, чем **ИЛИ ||**, так что он выполняется раньше.
+
+Таким образом, код **a && b || c && d** по существу такой же,  
+как если бы выражения **&&** были в круглых скобках: **(a && b) || (c && d)**
+
+❗ ***Не заменяйте if на || или &&*** \
+Несмотря на то, что вариант с && кажется более коротким, if более нагляден и, как правило, более читабелен.
+
+### &&= (Логическое присваивание И)
+```js
+a &&= b;
+```
+Принцип действия **&&=** практически такой же, как и у оператора логического присваивания **ИЛИ ||=**. \
+Единственное отличие заключается в том, что **&&=** присвоит **a** значение **b** только в том случае, если **a**
+истинно.
+
+### ! (НЕ)
+
+```js
+result = !value;
+```
+
+Оператор принимает один аргумент и выполняет следующие действия:
+
+1. Сначала приводит аргумент к логическому типу **true/false**.
+2. Затем возвращает противоположное значение.
+
+❗ Приоритет **НЕ !** является наивысшим из всех логических операторов, поэтому он всегда выполняется первым, перед **&&
+** или **||**.
+
+### Оператор нулевого слияния (??)
+
+Результат выражения **a ?? b** будет следующим:
+
+- если **a** определено, то **a**,
+- если **a** не определено, то **b**.
+
+Иначе говоря, оператор **??** возвращает первый аргумент, если он не **null/undefined**, иначе второй.
+
+#### Сравнение с ||
+
+Важное различие между ними заключается в том, что:
+
+- || возвращает первое истинное значение.
+- ?? возвращает первое определённое значение.
+
+Приоритет оператора ?? такой же, как и у ||. Они оба равны 3 в таблице на MDN.
+
+#### Использование ?? вместе с && или ||
+
+По соображениям безопасности JavaScript запрещает использование оператора **??** вместе с **&&** и **||**, если
+приоритет явно не указан при помощи круглых скобок.
+```js
+let x = 1 && 2 ?? 3; // Синтаксическая ошибка
+```
+
+Используйте скобки, чтобы обойти это ограничение:
+```js
+let x = (1 && 2) ?? 3; // Работает без ошибок
+```
+### Оператор нулевого присваивания (??=)
+
+Предположим, нам необходимо проверить, равна ли переменная null или undefined, и если это так — присвоить этой
+переменной какое-либо другое значение.
+```js
+let userAge = null;
+
+if (userAge === null || userAge === undefined) {
+  userAge = 18;
+}
+```
+
+Выглядит громоздко, правда? Существует оператор, более подходящий для подобных задач.
+```js
+x ??= y
+```
+
+Оператор **??=** присвоит **x** значение **y** только в том случае, если **x** не определено (null/undefined).
+```js
+let userAge = null;
+userAge ??= 18;
+alert(userAge) // 18
+```

docs/javascript/01-base/07-cycles.md

@@ -0,0 +1,40 @@
+---
+sidebar_position: 7
+---
+
+# Циклы while и for
+
+⚡ ***Циклы for…of и for…in***
+- **for…in** для перебора свойств объекта.
+- **for…of** для перебора массивов и перебираемых объектов.
+
+## Цикл «while»
+```js
+while (condition) {
+    // код
+    // также называемый "телом цикла" 
+}
+```
+## Цикл «do…while»
+```js
+do {
+    // тело цикла
+} while (condition);
+```
+## Цикл «for»
+```js
+for (let i = 0; i < 3; i++) { 
+    alert(i); 
+}
+// выведет 0, затем 1, затем 2
+```
+
+## Прерывание цикла: «break»
+Вообще, сочетание «бесконечный цикл + break» – отличная штука для тех ситуаций, когда условие, по которому нужно прерваться, находится не в начале или конце цикла, а посередине или даже в нескольких местах его тела.
+
+## Переход к следующей итерации: continue
+❗ Нельзя использовать break/continue справа от оператора „?“ \
+Обратите внимание, что эти синтаксические конструкции не являются выражениями и не могут быть использованы с тернарным оператором ?. В частности, использование таких директив, как **break/continue**, вызовет ошибку.
+```js
+(i > 5) ? alert(i) : continue; // continue здесь приведёт к ошибке
+```

docs/javascript/01-base/08-garbage-collector.md

@@ -0,0 +1,53 @@
+---
+sidebar_position: 8
+---
+
+
+# Сборка мусора
+
+Управление памятью в JavaScript выполняется автоматически и незаметно. Мы создаём примитивы, объекты, функции… Всё это занимает память.
+
+### Достижимость
+Основной концепцией управления памятью в JavaScript является принцип достижимости.
+
+Если упростить, то «достижимые» значения – это те, которые доступны или используются. Они гарантированно находятся в памяти.
+
+1. Существует базовое множество достижимых значений, которые не могут быть удалены.
+
+    Например:
+
+   - Выполняемая в данный момент функция, её локальные переменные и параметры.
+   - Другие функции в текущей цепочке вложенных вызовов, их локальные переменные и параметры.
+   - Глобальные переменные.
+   - (некоторые другие внутренние значения)
+        Эти значения мы будем называть корнями.
+
+2. Любое другое значение считается достижимым, если оно доступно из корня по ссылке или по цепочке ссылок.
+
+    Например, если в глобальной переменной есть объект, и он имеет свойство, в котором хранится ссылка на другой объект, то этот объект считается достижимым. И те, на которые он ссылается, тоже достижимы.
+
+### Внутренние алгоритмы
+Основной алгоритм сборки мусора называется «алгоритм пометок» (от англ. «mark-and-sweep»).
+
+Согласно этому алгоритму, сборщик мусора регулярно выполняет следующие шаги:
+
+- Сборщик мусора «помечает» (запоминает) все корневые объекты.
+- Затем он идёт по ним и «помечает» все ссылки из них.
+- Затем он идёт по отмеченным объектам и отмечает их ссылки. Все посещённые объекты запоминаются, чтобы в будущем не посещать один и тот же объект дважды.
+- …И так далее, пока не будут посещены все достижимые (из корней) ссылки.
+- Все непомеченные объекты удаляются.
+
+Движки JavaScript применяют множество оптимизаций, чтобы она работала быстрее и не задерживала выполнение кода.
+
+Вот некоторые из оптимизаций:
+
+- **Сборка по поколениям (Generational collection)** – объекты делятся на два набора: «новые» и «старые». В типичном коде многие объекты имеют короткую жизнь: они появляются, выполняют свою работу и быстро умирают, так что имеет смысл отслеживать новые объекты и, если это так, быстро очищать от них память. Те, которые выживают достаточно долго, становятся «старыми» и проверяются реже.
+- **Инкрементальная сборка (Incremental collection)** – если объектов много, и мы пытаемся обойти и пометить весь набор объектов сразу, это может занять некоторое время и привести к видимым задержкам в выполнении скрипта. Так что движок делит всё множество объектов на части, и далее очищает их одну за другой. Получается несколько небольших сборок мусора вместо одной всеобщей. Это требует дополнительного учёта для отслеживания изменений между частями, но зато получается много крошечных задержек вместо одной большой.
+- **Сборка в свободное время (Idle-time collection)** – чтобы уменьшить возможное влияние на производительность, сборщик мусора старается работать только во время простоя процессора.
+
+Существуют и другие способы оптимизации и разновидности алгоритмов сборки мусора, потому что разные движки реализуют разные хитрости и методы.
+
+### Главное, что нужно знать:
+- Сборка мусора выполняется автоматически. Мы не можем ускорить или предотвратить её.
+- Объекты сохраняются в памяти, пока они достижимы.
+- Если на объект есть ссылка – вовсе не факт, что он является достижимым (из корня): набор взаимосвязанных объектов может стать недоступен в целом.

docs/javascript/01-base/_category_.json

@@ -0,0 +1,7 @@
+{
+  "label": "Введение",
+  "position": 1,
+  "link": {
+    "type": "generated-index"
+  }
+}