add js-base, functions

2025-02-27 15:52:06 +03:00
parent e8fe7c6f0c
commit 698358afaf
33 changed files with 710 additions and 3 deletions
--- a/docs/javascript/base/01-strict.md
+++ b/docs/javascript/base/01-strict.md
@@ -0,0 +1,13 @@
+---
+sidebar_position: 1
+---
+
+# Строгий режим — "use strict"
+
+Появился с 2009 года в редакции ECMAScript 5 (ES5).
+Чтобы устаревший код работал, как и раньше, по умолчанию подобные изменения не применяются. Поэтому нам нужно явно их активировать с помощью специальной директивы: "use strict".
+
+Нет никакого способа отменить use strict
+Use strict по умолчанию выключен в консоли браузера
+
+Современный JavaScript поддерживает «классы» и «модули» — продвинутые структуры языка (и мы, конечно, до них доберёмся), которые автоматически включают строгий режим. 
--- a/docs/javascript/base/02-variables.md
+++ b/docs/javascript/base/02-variables.md
@@ -0,0 +1,49 @@
+---
+sidebar_position: 2
+---
+
+# Переменные
+
+**Переменная** – это «именованное хранилище» для данных.
+
+Можно объявить при помощи:
+
+- let
+- const (константа, т.е. изменению не подлежит)
+- var (устаревший способ, подробности позже)
+
+```
+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 возвращает тип значения переменной, с двумя исключениями:
+
+```
+typeof null == "object" // ошибка в языке
+typeof function(){} == "function" // именно для функций
+```
--- a/docs/javascript/base/03-type-conversion.md
+++ b/docs/javascript/base/03-type-conversion.md
@@ -0,0 +1,49 @@
+---
+sidebar_position: 3
+---
+
+# Преобразование типов
+
+## Строковое преобразование
+**String(value)**
+```
+alert(typeof value); // string
+```
+
+## Численное преобразование
+**Number(str)**
+```
+let num = Number(str); // становится числом 123
+```
+| Значение                | Преобразуется в…                                                                                                                                                                                                                |
+|-------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| undefined               | NaN                                                                                                                                                                                                                             |
+| null                    | 0                                                                                                                                                                                                                               |
+| true / false            | 1 / 0                                                                                                                                                                                                                           |
+| string                  | Пробельные символы (пробелы, знаки табуляции \t, знаки новой строки \n и т. п.) по краям обрезаются. Далее, если остаётся пустая строка, то получаем 0, иначе из непустой строки «считывается» число. При ошибке результат NaN. |
+
+```
+alert( Number("   123   ") ); // 123 
+alert( Number("123z") );      // NaN (ошибка чтения числа на месте символа "z")
+alert( Number(true) );        // 1
+alert( Number(false) );       // 0
+```
+## Логическое преобразование
+**Boolean(value)**\
+Происходит в логических операциях, но также может быть выполнено явно с помощью функции Boolean(value).
+
+Правило преобразования:
+- Значения, которые интуитивно «пустые», вроде 0, пустой строки, null, undefined и NaN, становятся false.
+- Все остальные значения становятся true.
+
+| Значение                    | Становится… |
+|-----------------------------|-------------|
+| 0, null, undefined, NaN, "" | false       |
+| любое другое значение       | true        |
+
+```
+alert( Boolean(1) ); // true 
+alert( Boolean(0) ); // false 
+alert( Boolean("Привет!") ); // true 
+alert( Boolean("") ); // false
+```
--- a/docs/javascript/base/04-operators.md
+++ b/docs/javascript/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(правый сдвиг с заполнением нулями) ( ≻≻≻ ) 
+  
+## Оператор «запятая»
+Оператор «запятая» предоставляет нам возможность вычислять несколько выражений, разделяя их запятой ,. Каждое выражение выполняется, но возвращается результат только последнего.
+```
+let a = (1 + 2, 3 + 4); \
+alert( a ); // 7 (результат вычисления 3 + 4) \
+```
+❗ ***Запятая имеет очень низкий приоритет***
--- a/docs/javascript/base/05-compare-ops.md
+++ b/docs/javascript/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.
+
--- a/docs/javascript/base/06-conditions-logic.md
+++ b/docs/javascript/base/06-conditions-logic.md
@@ -0,0 +1,177 @@
+---
+sidebar_position: 6
+---
+
+# Условия и логические операторы
+
+## Условное ветвление: if, '?'
+
+Инструкция if(...) вычисляет условие в скобках и, если результат true, то выполняет блок кода.
+
+***Несколько условий: «else if»***
+
+## Конструкция "switch"
+```
+let a = 2 + 2;
+ 
+switch (a) { 
+  case 3: 
+    alert( 'Маловато' ); 
+    break;
+  case 4:
+    alert( 'В точку!' ); 
+    break; 
+  case 5:
+    alert( 'Перебор' );
+    break;
+  default: 
+    alert( "Нет таких значений" ); 
+}
+```
+## Условный оператор „?“ (тернарный)
+```
+let result = условие ? значение1 : значение2;
+```
+## Логические операторы
+
+В JavaScript есть семь логических операторов:
+
+- || (ИЛИ)
+- ||= (Оператор логического присваивания ИЛИ)
+- && (И)
+- &&= (Оператор логического присваивания И)
+- ! (НЕ)
+- ?? (Оператор нулевого слияния)
+- ??= (Оператор нулевого присваивания)
+
+### || (ИЛИ)
+```
+( true || true ); // true 
+( false || true ); // true 
+( true || false ); // true 
+( false || false ); // false
+```
+### ИЛИ "||" находит первое истинное значение
+```
+( 1 || 0 ); // 1 (1 - истинное значение) 
+( true || 'какая-то строка' ); // true 
+( null || 1 ); // 1 (первое истинное значение) 
+( null || 0 || 1 ); // 1 (первое истинное значение) 
+( undefined || null || 0 ); // 0 (поскольку все ложно, возвращается последнее значение)
+```
+
+### ||= (Логическое присваивание ИЛИ)
+```
+a ||= b;
+```
+Оператор **||=** принимает два операнда и выполняет следующие действия:
+
+- Вычисляет операнды слева направо.
+- Конвертирует ***a*** в логическое значение.
+- Если ***a*** ложно, присваивает ***a*** значение ***b***.
+
+### && (И)
+```
+( true && true ); // true 
+( false && true ); // false 
+( true && false ); // false 
+( false && false ); // false
+```
+#### И «&&» находит первое ложное значение
+```
+result = value1 && value2 && value3;
+```
+Оператор **&&** выполняет следующие действия:
+
+- Вычисляет операнды слева направо.
+- Каждый операнд преобразует в логическое значение. Если результат **false**, останавливается и возвращает исходное
+  значение этого операнда.
+- Если все операнды были истинными, возвращается последний.
+
+Другими словами, **И** возвращает первое ложное значение. Или последнее, если ничего не найдено.
+
+Вышеуказанные правила схожи с поведением **ИЛИ**. Разница в том, что **И** возвращает первое ложное значение, а **ИЛИ**
+первое истинное.
+
+❗ ***Приоритет оператора && больше, чем у ||*** \
+Приоритет оператора **И &&** больше, чем **ИЛИ ||**, так что он выполняется раньше.
+
+Таким образом, код **a && b || c && d** по существу такой же,  
+как если бы выражения **&&** были в круглых скобках: **(a && b) || (c && d)**
+
+❗ ***Не заменяйте if на || или &&*** \
+Несмотря на то, что вариант с && кажется более коротким, if более нагляден и, как правило, более читабелен.
+
+### &&= (Логическое присваивание И)
+```
+a &&= b;
+```
+Принцип действия **&&=** практически такой же, как и у оператора логического присваивания **ИЛИ ||=**. \
+Единственное отличие заключается в том, что **&&=** присвоит **a** значение **b** только в том случае, если **a**
+истинно.
+
+### ! (НЕ)
+
+```
+result = !value;
+```
+
+Оператор принимает один аргумент и выполняет следующие действия:
+
+1. Сначала приводит аргумент к логическому типу **true/false**.
+2. Затем возвращает противоположное значение.
+
+❗ Приоритет **НЕ !** является наивысшим из всех логических операторов, поэтому он всегда выполняется первым, перед **&&
+** или **||**.
+
+### Оператор нулевого слияния (??)
+
+Результат выражения **a ?? b** будет следующим:
+
+- если **a** определено, то **a**,
+- если **a** не определено, то **b**.
+
+Иначе говоря, оператор **??** возвращает первый аргумент, если он не **null/undefined**, иначе второй.
+
+#### Сравнение с ||
+
+Важное различие между ними заключается в том, что:
+
+- || возвращает первое истинное значение.
+- ?? возвращает первое определённое значение.
+
+Приоритет оператора ?? такой же, как и у ||. Они оба равны 3 в таблице на MDN.
+
+#### Использование ?? вместе с && или ||
+
+По соображениям безопасности JavaScript запрещает использование оператора **??** вместе с **&&** и **||**, если
+приоритет явно не указан при помощи круглых скобок.
+```
+let x = 1 && 2 ?? 3; // Синтаксическая ошибка
+```
+
+Используйте скобки, чтобы обойти это ограничение:
+```
+let x = (1 && 2) ?? 3; // Работает без ошибок
+```
+### Оператор нулевого присваивания (??=)
+
+Предположим, нам необходимо проверить, равна ли переменная null или undefined, и если это так — присвоить этой
+переменной какое-либо другое значение.
+```
+let userAge = null;
+
+if (userAge === null || userAge === undefined) {
+  userAge = 18;
+}
+```
+
+Выглядит громоздко, правда? Существует оператор, более подходящий для подобных задач.
+```x ??= y```
+
+Оператор **??=** присвоит **x** значение **y** только в том случае, если **x** не определено (null/undefined).
+```
+let userAge = null;
+userAge ??= 18;
+alert(userAge) // 18
+```
--- a/docs/javascript/base/07-cycles.md
+++ b/docs/javascript/base/07-cycles.md
@@ -0,0 +1,38 @@
+---
+sidebar_position: 7
+---
+
+# Циклы while и for
+
+⚡ ***Циклы for…of и for…in***
+- **for…in** для перебора свойств объекта.
+- **for…of** для перебора массивов и перебираемых объектов.
+
+## Цикл «while»
+```
+while (condition) {
+    // код
+    // также называемый "телом цикла" 
+}
+```
+## Цикл «do…while»
+```
+do {
+    // тело цикла
+} while (condition);
+```
+## Цикл «for»
+```
+for (let i = 0; i < 3; i++) { 
+    alert(i); 
+}
+// выведет 0, затем 1, затем 2
+```
+
+## Прерывание цикла: «break»
+Вообще, сочетание «бесконечный цикл + break» – отличная штука для тех ситуаций, когда условие, по которому нужно прерваться, находится не в начале или конце цикла, а посередине или даже в нескольких местах его тела.
+
+## Переход к следующей итерации: continue
+❗ Нельзя использовать break/continue справа от оператора „?“ \
+Обратите внимание, что эти синтаксические конструкции не являются выражениями и не могут быть использованы с тернарным оператором ?. В частности, использование таких директив, как **break/continue**, вызовет ошибку.
+> (i > 5) ? alert(i) : continue; // continue здесь приведёт к ошибке
--- a/docs/javascript/base/_category_.json
+++ b/docs/javascript/base/_category_.json
@@ -0,0 +1,7 @@
+{
+  "label": "Основа",
+  "position": 1,
+  "link": {
+    "type": "generated-index"
+  }
+}