update data types

2025-03-04 16:47:30 +03:00
parent cb53cdf7e0
commit e60ec041ae
10 changed files with 863 additions and 1 deletions
--- a/docs/javascript/03-data-types/01-primitive-methods.md
+++ b/docs/javascript/03-data-types/01-primitive-methods.md
@@ -8,10 +8,21 @@ sidebar_position: 1
 #### Примитив

 - Это – значение «примитивного» типа.
- Есть 7 примитивных типов: string, number, boolean, symbol, null, undefined и bigint.
+- Есть 7 примитивных типов: **`string`**, **`number`**, **`boolean`**, **`symbol`**, **`null`**, **`undefined`** и **`bigint`**.

 #### Объект

 - Может хранить множество значений как свойства.
 - Объявляется при помощи фигурных скобок \{\}, например: \{name: "Рома", age: 30\}. В JavaScript есть и другие виды объектов: например, функции тоже являются объектами.

+
+
+## Примитив как объект
+1. Примитивы остаются примитивами. Одно значение, как и хотелось.
+2. Язык позволяет осуществлять доступ к методам и свойствам строк, чисел, булевых значений и символов.
+3. Чтобы это работало, при таком доступе создаётся специальный «объект-обёртка», который предоставляет нужную функциональность, а после удаляется.
+
+Каждый примитив имеет свой собственный «объект-обёртку», которые называются: **`String`**, **`Number`**, **`Boolean`**, **`Symbol`** и **`BigInt`**. Таким образом, они имеют разный набор методов.
+
+💥 ***null/undefined не имеют методов*** \
+Попытка доступа к свойствам такого значения возвратит ошибку:
--- a/docs/javascript/03-data-types/02-numbers.md
+++ b/docs/javascript/03-data-types/02-numbers.md
@@ -0,0 +1,123 @@
+---
+sidebar_position: 2
+---
+
+# Числа
+В современном JavaScript существует два типа чисел:
+1. Обычные числа в JavaScript хранятся в 64-битном формате IEEE-754, который также называют «числа с плавающей точкой двойной точности» (double precision floating point numbers).
+2. BigInt числа дают возможность работать с целыми числами произвольной длины. Они нужны достаточно редко и используются в случаях, когда необходимо работать со значениями более чем (253-1) или менее чем -(253-1).
+
+### Способы записи числа
+
+```js
+let billion = 1000000000;
+let billion = 1_000_000_000
+let billion = 1e9;
+```
+```js
+let mcs = 0.000001;
+let ms = 1e-6; // шесть нулей слева от 1
+let a = 0b11111111; // двоичная (бинарная) форма записи числа 255
+let b = 0o377; // восьмеричная форма записи числа 255
+```
+### toString(base)
+**base** может варьироваться от 2 до 36 (по умолчанию 10).
+```js
+alert( (255).toString(16) );  // ff
+alert( (255).toString(2) );   // 11111111
+alert( 123456..toString(36) ); // 2n9c
+```
+Две точки в 123456..toString(36) это не опечатка. Если нам надо вызвать метод непосредственно на числе, как toString в примере выше, то нам надо поставить две точки .. после числа.
+
+### Округление
+- **Math.floor** \
+    Округление в меньшую сторону: 3.1 становится 3, а -1.1 — -2.
+- **Math.ceil** \
+    Округление в большую сторону: 3.1 становится 4, а -1.1 — -1.
+- **Math.round** \
+    Округление до ближайшего целого: 3.1 становится 3, 3.6 — 4, а -1.1 — -1.
+- **Math.trunc** (не поддерживается в Internet Explorer) \
+    Производит удаление дробной части без округления: 3.1 становится 3, а -1.1 — -1.
+- Метод **toFixed(n)** \
+    округляет число до n знаков после запятой и возвращает строковое представление результата.\
+    ``` alert( (12.34).toFixed(1) ); // "12.3" ```
+
+### Неточные вычисления
+Внутри JavaScript число представлено в виде 64-битного формата IEEE-754. Для хранения числа используется 64 бита: 52 из них используется для хранения цифр, 11 для хранения положения десятичной точки и один бит отведён на хранение знака.
+
+```js
+alert( 1e500 ); // Infinity
+```
+Наиболее часто встречающаяся ошибка при работе с числами в JavaScript – это потеря точности.
+```js
+alert( 0.1 + 0.2 ); // 0.30000000000000004
+```
+И когда мы суммируем 2 числа, их «неточности» тоже суммируются. Наиболее надёжный способ — это округлить результат используя метод toFixed(n):
+```js
+alert( +(0.1 + 0.2).toFixed(2) ); // 0.3
+```
+
+### Проверка: isFinite и isNaN
+- Infinity (и -Infinity) — особенное численное значение, которое ведёт себя в точности как математическая бесконечность ∞.
+- NaN представляет ошибку.
+
+**isNaN(value)** преобразует значение в число и проверяет является ли оно NaN:
+```js
+alert( isNaN(NaN) ); // true
+alert( isNaN("str") ); // true
+alert( NaN === NaN ); // false
+```
+
+**isFinite(value)** преобразует аргумент в число и возвращает true, если оно является обычным числом, т.е. не NaN/Infinity/-Infinity
+Иногда isFinite используется для проверки, содержится ли в строке число:
+```js
+alert( isFinite("15") ); // true
+alert( isFinite("str") ); // false, потому что специальное значение: NaN
+alert( isFinite(Infinity) ); // false, потому что специальное значение: Infinity
+
+// вернёт true всегда, кроме ситуаций, когда аргумент - Infinity/-Infinity или не число
+alert( isFinite(num) );
+```
+Методы **Number.isNaN** и **Number.isFinite** – это более «строгие» версии функций isNaN и isFinite. Они не преобразуют аргумент в число, а наоборот – первым делом проверяют, является ли аргумент числом (принадлежит ли он к типу number).
+Number.isNaN(value) возвращает true только в том случае, если аргумент принадлежит к типу number и является NaN. Во всех остальных случаях возвращает false.
+```js
+alert( Number.isNaN(NaN) ); // true
+alert( Number.isNaN("str" / 2) ); // true
+
+// Обратите внимание на разный результат:
+alert( Number.isNaN("str") ); // false, так как "str" является строкой, а не числом
+alert( isNaN("str") ); // true, так как isNaN сначала преобразует строку "str" в число и в результате преобразования получает NaN
+```
+Number.isFinite(value) возвращает true только в том случае, если аргумент принадлежит к типу number и не является NaN/Infinity/-Infinity. Во всех остальных случаях возвращает false.
+```js
+alert( Number.isFinite(123) ); // true
+alert( Number.isFinite(Infinity) ); // false
+alert( Number.isFinite(2 / 0) ); // false
+
+// Обратите внимание на разный результат:
+alert( Number.isFinite("123") ); // false, так как "123" является строкой, а не числом
+alert( isFinite("123") ); // true, так как isFinite сначала преобразует строку "123" в число 123
+```
+Не стоит считать Number.isNaN и Number.isFinite более «корректными» версиями функций isNaN и isFinite. Это дополняющие друг-друга инструменты для разных задач.
+
+💥 **Сравнение Object.is**
+Существует специальный метод Object.is, который сравнивает значения примерно как ===, но более надёжен в двух особых ситуациях:
+
+Работает с NaN: Object.is(NaN, NaN) === true, здесь он хорош.
+Значения 0 и -0 разные: Object.is(0, -0) === false, это редко используется, но технически эти значения разные.
+Во всех других случаях Object.is(a, b) идентичен a === b.
+
+Этот способ сравнения часто используется в спецификации JavaScript. Когда внутреннему алгоритму необходимо сравнить 2 значения на предмет точного совпадения, он использует Object.is
+
+### parseInt и parseFloat
+Для явного преобразования к числу можно использовать + или Number(). Если строка не является в точности числом, то результат будет NaN, пробелы в начале строки и в конце игнорируются.
+Функция parseInt() имеет необязательный второй параметр. Он определяет систему счисления,
+```js
+alert( parseInt('100px') ); // 100
+alert( parseFloat('12.5em') ); // 12.5
+alert( +"100px" ); // NaN
+alert( parseInt('a123') ); // NaN
+```
+
+### Другие математические функции
+В JavaScript встроен объект **Math**, который содержит различные математические функции и константы.
--- a/docs/javascript/03-data-types/03-strings.md
+++ b/docs/javascript/03-data-types/03-strings.md
@@ -0,0 +1,95 @@
+---
+sidebar_position: 3
+---
+
+# Строки
+
+В JavaScript любые текстовые данные являются строками.
+Внутренний формат для строк — всегда UTF-16, вне зависимости от кодировки страницы.
+
+### Кавычки
+
+```js
+let single = 'single-quoted';
+let double = "double-quoted";
+let backticks = `backticks`;
+```
+
+### Спецсимволы
+
+| Символ        | Описание                                                                                                                                                                                          |
+|---------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| \n            | Перевод строки                                                                                                                                                                                    |
+| \r            | В текстовых файлах Windows для перевода строки используется комбинация символов \r\n, а на других ОС это просто \n. Это так по историческим причинам, ПО под Windows обычно понимает и просто \n. |
+| \\', \\", \\` | Кавычки                                                                                                                                                                                           |
+| \\\           | Обратный слеш                                                                                                                                                                                     |
+| \t            | Знак табуляции                                                                                                                                                                                    |
+| \b, \f, \v    | Backspace, Form Feed и Vertical Tab — оставлены для обратной совместимости, сейчас не используются.                                                                                               |
+
+### Длина строки
+💥 **length** — это числовое свойство, а не функция, добавлять скобки не нужно.
+
+### Доступ к символам
+```js
+let str = `Hello`;
+
+// получаем первый символ
+alert( str[0] ); // H
+alert( str.at(0) ); // H
+
+// получаем последний символ
+alert( str[str.length - 1] ); // o
+alert( str.at(-1) ); // o
+```
+Также можно перебрать строку посимвольно, используя for..of:
+
+### Строки неизменяемы
+Можно создать новую строку и записать её в ту же самую переменную вместо старой.
+
+### Поиск подстроки
+**str.indexOf** - Он ищет подстроку substr в строке str, начиная с позиции pos, и возвращает позицию, на которой располагается совпадение, либо -1 при отсутствии совпадений.
+```js
+let str = 'Widget with id';
+
+alert( str.indexOf('Widget') ); // 0, потому что подстрока 'Widget' найдена в начале
+alert( str.indexOf('widget') ); // -1, совпадений нет, поиск чувствителен к регистру
+
+alert( str.indexOf("id") ); // 1, подстрока "id" найдена на позиции 1 (..idget with id)
+```
+💥 str.lastIndexOf(substr, position) - ищет с конца строки к её началу
+
+**includes** - если нам необходимо проверить, есть ли совпадение, но позиция не нужна.
+```js
+alert( "Widget with id".includes("Widget") ); // true
+alert( "Hello".includes("Bye") ); // false
+```
+**startsWith, endsWith** - начинается ли, заканчивается ли строка определённой строкой
+```js
+alert( "Widget".startsWith("Wid") ); // true, "Wid" — начало "Widget"
+alert( "Widget".endsWith("get") ); // true, "get" — окончание "Widget"
+```
+
+### Получение подстроки
+В JavaScript есть 3 метода для получения подстроки: **substring**, **substr** и **slice**
+Из двух других вариантов, slice более гибок, он поддерживает отрицательные аргументы, и его короче писать. Так что, в принципе, можно запомнить только его.
+```js
+str.slice(start [, end]) // возвращает часть строки от start до (не включая) end.
+str.substring(start [, end]) // возвращает часть строки между start и end (не включая) end.
+str.substr(start [, length]) // - возвращает часть строки от start длины length.
+```
+
+### Сравнение строк
+строки сравниваются посимвольно в алфавитном порядке.
+1. Строчные буквы больше заглавных **'a' > 'Z'**
+2. Буквы, имеющие диакритические знаки, идут «не по порядку» **'Österreich' > 'Zealand'**
+
+#### Правильное сравнение
+«Правильный» алгоритм сравнения строк сложнее, чем может показаться, так как разные языки используют разные алфавиты.
+К счастью, все современные браузеры (для IE10− нужна дополнительная библиотека Intl.JS) поддерживают стандарт ECMA 402, обеспечивающий правильное сравнение строк на разных языках с учётом их правил.
+
+Для этого есть соответствующий метод.
+
+Вызов str.localeCompare(str2) возвращает число, которое показывает, какая строка больше в соответствии с правилами языка:
+- Отрицательное число, если str меньше str2.
+- Положительное число, если str больше str2.
+- 0, если строки равны.
--- a/docs/javascript/03-data-types/04-arrays.md
+++ b/docs/javascript/03-data-types/04-arrays.md
@@ -0,0 +1,78 @@
+---
+sidebar_position: 4
+---
+
+# Массивы
+Особая структура данных, которая называется массив(Array) - это упорядоченная коллекция данных.
+```js
+let arr = new Array();
+let arr = [];
+```
+
+### Получение последних элементов при помощи «at»
+```js
+let fruits = ["Apple", "Orange", "Plum"];
+// то же самое, что и fruits[fruits.length-1]
+alert( fruits.at(-1) ); // Plum
+```
+Другими словами, arr.at(i):
+- это ровно то же самое, что и arr[i], если i >= 0.
+- для отрицательных значений i, он отступает от конца массива.
+
+### Методы pop/push, shift/unshift
+- **`push`** - Добавляет элемент в конец массива
+- **`pop`** - Удаляет последний элемент из массива и возвращает его
+- **`shift`** - Удаляет из массива первый элемент и возвращает его
+- **`unshift`** - Добавляет элемент в начало массива
+
+Методы **`push`** и **`unshift`** могут добавлять сразу несколько элементов
+
+Методы **`push`**/**`pop`** выполняются быстро, а методы **`shift`**/**`unshift`** – медленно.
+
+Чтобы пройтись по элементам массива:
+- **for (let i=0\; i\<arr.length\; i++)** – работает быстрее всего, совместим со старыми браузерами.
+- **for (let item of arr)** – современный синтаксис только для значений элементов (к индексам нет доступа).
+- **for (let i in arr)** – никогда не используйте для массивов!
+
+💥 Не следует использовать цикл **for..in** для массивов.
+1. Цикл **for..in** выполняет перебор всех свойств объекта, а не только цифровых.
+2. Цикл **for..in** оптимизирован под произвольные объекты, не массивы, и поэтому в 10-100 раз медленнее.
+
+Ещё один интересный факт о свойстве **length** – его можно перезаписать.\
+Cамый простой способ очистить массив – это arr.length = 0;
+```js
+let arr = [1, 2, 3, 4, 5];
+
+arr.length = 2; // укорачиваем до двух элементов
+alert( arr ); // [1, 2]
+
+arr.length = 5; // возвращаем length как было
+alert( arr[3] ); // undefined: значения не восстановились
+```
+
+### new Array()
+```js
+let arr = new Array("Яблоко", "Груша", "и тд");
+```
+Если new Array вызывается с одним аргументом, который представляет собой число, он создаёт массив без элементов, но с заданной длиной.
+
+### Многомерные массивы
+Массивы могут содержать элементы, которые тоже являются массивами. Это можно использовать для создания многомерных массивов, например, для хранения матриц
+```js
+let matrix = [
+  [1, 2, 3],
+  [4, 5, 6],
+  [7, 8, 9]
+];
+
+alert( matrix[1][1] ); // 5, центральный элемент
+```
+
+### Не сравнивайте массивы при помощи ==
+В JavaScript, в отличие от некоторых других языков программирования, массивы не следует сравнивать при помощи оператора ==.
+
+У этого оператора нет специального подхода к массивам, он работает с ними, как и с любыми другими объектами.
+Итак, если мы всё же сравниваем массивы с помощью ==, то они никогда не будут одинаковыми, если только мы не сравним две переменные, которые ссылаются на один и тот же массив
+Вместо этого сравните их по элементам в цикле или используя методы итерации.
+
+
--- a/docs/javascript/03-data-types/05-array-methods.md
+++ b/docs/javascript/03-data-types/05-array-methods.md
@@ -0,0 +1,167 @@
+---
+sidebar_position: 5
+---
+
+# Методы массивов
+
+### Добавление/удаление элементов
+
+- **arr.push(...items)** – добавляет элементы в конец,
+- **arr.pop()** – извлекает элемент из конца,
+- **arr.shift()** – извлекает элемент из начала,
+- **arr.unshift(...items)** – добавляет элементы в начало.
+
+### splice
+
+Это универсальный «швейцарский нож» для работы с массивами. Умеет всё: добавлять, удалять и заменять элементы.
+Синтаксис:
+
+```js
+arr.splice(start[, deleteCount, elem1, ..., elemN
+])
+```
+
+Он изменяет arr начиная с индекса start: удаляет deleteCount элементов и затем вставляет elem1, ..., elemN на их место.
+Возвращает массив из удалённых элементов.
+💥 Отрицательные индексы разрешены
+
+### slice
+
+Возвращает новый массив, в который копирует все элементы с индекса start до end (не включая end). start и end могут быть
+отрицательными, в этом случае отсчёт позиции будет вестись с конца массива.
+
+```js
+arr.slice([start], [end])
+```
+
+Это похоже на строковый метод str.slice, но вместо подстрок возвращает подмассивы.
+
+### concat
+
+Метод arr.concat создаёт новый массив, в который копирует данные из других массивов и дополнительные значения.
+
+```js
+let arr = [1, 2];
+// создать массив из: arr и [3,4]
+alert(arr.concat([3, 4])); // 1,2,3,4
+```
+
+### Перебор: forEach
+
+Метод arr.forEach позволяет запускать функцию для каждого элемента массива.
+
+```js
+arr.forEach(function (item, index, array) {
+  // ... делать что-то с item
+});
+```
+
+## Поиск в массиве
+
+### indexOf/lastIndexOf и includes
+
+- arr.indexOf(item, from) ищет item начиная с индекса from и возвращает номер индекса, на котором был найден искомый
+  элемент, в противном случае -1.
+- arr.includes(item, from) ищет item начиная с индекса from и возвращает true, если поиск успешен.
+
+💥 Метод includes правильно обрабатывает NaN, в отличие от indexOf
+
+### find и findIndex/findLastIndex
+
+Функция вызывается по очереди для каждого элемента массива:
+
+- **item** – очередной элемент.
+- **index** – его индекс.
+- **array** – сам массив.
+  Если функция возвращает **true**, поиск прерывается и возвращается **item**. Если ничего не найдено, возвращается
+  `undefined`.
+
+```js
+let result = arr.find(function (item, index, array) {
+  // если true - возвращается текущий элемент и перебор прерывается
+  // если все итерации оказались ложными, возвращается undefined
+});
+```
+
+У метода **arr.findIndex** такой же синтаксис, но он возвращает индекс, на котором был найден элемент, а не сам элемент.
+Значение **-1** возвращается, если ничего не найдено.
+Метод **arr.findLastIndex** похож на **findIndex**, но ищет справа налево, наподобие **lastIndexOf**.
+
+### filter
+
+Если найденных элементов может быть много, можно использовать arr.filter(fn).
+Синтаксис схож с find, но filter возвращает массив из всех подходящих элементов:
+
+```js
+let results = arr.filter(function (item, index, array) {
+  // если `true` -- элемент добавляется к results и перебор продолжается
+  // возвращается пустой массив в случае, если ничего не найдено
+});
+```
+
+## Преобразование массива
+
+### map
+
+Он вызывает функцию для каждого элемента массива и возвращает массив результатов выполнения этой функции.
+
+```js
+let result = arr.map(function (item, index, array) {
+  // возвращается новое значение вместо элемента
+});
+```
+
+### sort(fn)
+
+Вызов arr.sort() сортирует массив на месте, меняя в нём порядок элементов.
+Он также возвращает отсортированный массив, но обычно возвращаемое значение игнорируется, так как изменяется сам arr.
+
+***По умолчанию элементы сортируются как строки.***
+Чтобы использовать наш собственный порядок сортировки, нам нужно предоставить функцию в качестве аргумента arr.sort()
+
+```js
+function compare(a, b) {
+  if (a > b) return 1; // если первое значение больше второго
+  if (a == b) return 0; // если равны
+  if (a < b) return -1; // если первое значение меньше второго
+}
+```
+💥 ***Функция сравнения может вернуть любое число***
+Лучше использовать стрелочные функции
+```js
+arr.sort( (a, b) => a - b );
+```
+Используйте localeCompare для строк
+
+### reverse
+Метод arr.reverse меняет порядок элементов в arr на обратный и возвращает новый массив.
+
+### split и join
+**str.split(delim)** - разбивает строку на массив по заданному разделителю delim.
+**arr.join(glue)** - создаёт строку из элементов arr, вставляя glue между ними.
+
+### reduce/reduceRight
+Функция применяется по очереди ко всем элементам массива и «переносит» свой результат на следующий вызов.
+Аргументы:
+- **accumulator** – результат предыдущего вызова этой функции, равен initial при первом вызове (если передан initial),
+- **item** – очередной элемент массива,
+- **index** – его позиция,
+- **array** – сам массив.
+
+```js
+let arr = [1, 2, 3, 4, 5];
+let result = arr.reduce((sum, current) => sum + current, 0);
+alert( result ); // 15
+```
+### Array.isArray
+Массивы не образуют отдельный тип данных, так как основаны на объектах, поэтому typeof не может отличить простой объект от массива.
+
+### Большинство методов поддерживают «thisArg»
+Все методы за исключением sort(fn)
+Значение параметра thisArg становится this для func.
+
+### Другие функции
+- arr.some(fn)/arr.every(fn) проверяет массив.
+- arr.fill(value, start, end) – заполняет массив повторяющимися value, начиная с индекса start до end.
+- arr.copyWithin(target, start, end) – копирует свои элементы, начиная с позиции start и заканчивая end, в себя, на позицию target (перезаписывая существующие).
+- arr.flat(depth)/arr.flatMap(fn) создаёт новый плоский массив из многомерного массива.
--- a/docs/javascript/03-data-types/06-map-set.md
+++ b/docs/javascript/03-data-types/06-map-set.md
@@ -0,0 +1,97 @@
+---
+sidebar_position: 6
+---
+
+# Map и Set
+Отличия от обычного объекта **`Object`**:
+- Что угодно может быть ключом, в том числе и объекты.
+- Есть дополнительные методы, свойство **`size`**.
+
+**`Set`** – коллекция уникальных значений, так называемое «множество».
+
+## Map
+**`Map`** – это коллекция ключ/значение, как и **`Object`**. Но основное отличие в том, что **`Map`** позволяет использовать ключи любого типа.
+
+Методы и свойства:
+
+- **new Map()** – создаёт коллекцию.
+- **map.set(key, value)** – записывает по ключу key значение value.
+- **map.get(key)** – возвращает значение по ключу или undefined, если ключ key отсутствует.
+- **map.has(key)** – возвращает true, если ключ key присутствует в коллекции, иначе false.
+- **map.delete(key)** – удаляет элемент (пару «ключ/значение») по ключу key.
+- **map.clear()** – очищает коллекцию от всех элементов.
+- **map.size** – возвращает текущее количество элементов.
+
+💥 map[key] это не совсем правильный способ использования **`Map`** \
+Поэтому нам следует использовать методы map: set, get и так далее.\
+**Map может использовать объекты в качестве ключей.**
+
+
+💥 Как объект **`Map`** сравнивает ключи \
+Чтобы сравнивать ключи, объект **Map** использует алгоритм **SameValueZero**. Это почти такое же сравнение, что и ===, с той лишь разницей, что **NaN** считается равным **NaN**. Так что **NaN** также может использоваться в качестве ключа.
+
+### Перебор Map
+Для перебора коллекции Map есть 3 метода:
+- map.keys() – возвращает итерируемый объект по ключам,
+- map.values() – возвращает итерируемый объект по значениям,
+- map.entries() – возвращает итерируемый объект по парам вида [ключ, значение], этот вариант используется по умолчанию в for..of.
+
+💥 Используется порядок вставки
+В отличие от обычных объектов **`Object`**, в **`Map`** перебор происходит в том же порядке, в каком происходило добавление элементов.
+Map имеет встроенный метод **`forEach`**, схожий со встроенным методом массивов **`Array`**
+
+### Object.entries: Map из Object
+При создании Map мы можем указать массив (или другой итерируемый объект) с парами ключ-значение для инициализации
+```js
+// массив пар [ключ, значение]
+let map = new Map([
+  ['1',  'str1'],
+  [1,    'num1'],
+  [true, 'bool1']
+]);
+
+alert( map.get('1') ); // str1
+```
+
+Если у нас уже есть обычный объект, и мы хотели бы создать Map из него, то поможет встроенный метод Object.entries(obj), который получает объект и возвращает массив пар ключ-значение для него, как раз в этом формате.
+```js
+let obj = {
+  name: "John",
+  age: 30
+};
+
+let map = new Map(Object.entries(obj));
+
+alert( map.get('name') ); // John
+```
+
+### Object.fromEntries: Object из Map
+Мы можем использовать **`Object.fromEntries`**, чтобы получить обычный объект из **`Map`**.
+```js
+let map = new Map();
+map.set('banana', 1);
+map.set('orange', 2);
+map.set('meat', 4);
+
+let obj = Object.fromEntries(map.entries()); // создаём обычный объект (*)
+
+alert(obj.orange); // готово! obj = { banana: 1, orange: 2, meat: 4 }
+```
+
+## Set
+Объект Set – это особый вид коллекции: «множество» значений (без ключей), где каждое значение может появляться только один раз.
+Его основные методы это:
+- **`new Set(iterable)`** – создаёт **`Set`**, и если в качестве аргумента был предоставлен итерируемый объект (обычно это массив), то копирует его значения в новый **`Set`**.
+- **`set.add(value)`** – добавляет значение (если оно уже есть, то ничего не делает), возвращает тот же объект set.
+- **`set.delete(value)`** – удаляет значение, возвращает **`true`**, если **`value`** было в множестве на момент вызова, иначе **`false`**.
+- **`set.has(value)`** – возвращает **`true`**, если значение присутствует в множестве, иначе **`false`**.
+- **`set.clear()`** – удаляет все имеющиеся значения.
+- **`set.size`** – возвращает количество элементов в множестве.
+
+### Перебор объекта Set
+Мы можем перебрать содержимое объекта set как с помощью метода for..of, так и используя forEach:
+**`Set`** имеет те же встроенные методы, что и **`Map`**:
+- **`set.values()`** – возвращает перебираемый объект для значений,
+- **`set.keys()`** – то же самое, что и **`set.values()`**, присутствует для обратной совместимости с **`Map`**,
+- **`set.entries()`** – возвращает перебираемый объект для пар вида [значение, значение], присутствует для обратной совместимости с **`Map`**.
+- 
--- a/docs/javascript/03-data-types/07-weakMap-weakSet.md
+++ b/docs/javascript/03-data-types/07-weakMap-weakSet.md
@@ -0,0 +1,63 @@
+---
+sidebar_position: 7
+---
+
+**`WeakMap`** – это **`Map`**-подобная коллекция, позволяющая использовать в качестве ключей только объекты, и автоматически удаляющая их вместе с соответствующими значениями, как только они становятся недостижимыми иными путями.
+
+**`WeakSet`** – это **`Set`**-подобная коллекция, которая хранит только объекты и удаляет их, как только они становятся недостижимыми иными путями.
+
+Обе этих структуры данных не поддерживают методы и свойства, работающие со всем содержимым сразу или возвращающие информацию о размере коллекции. Возможны только операции на отдельном элементе коллекции.
+
+**`WeakMap`** и **`WeakSet`** используются как вспомогательные структуры данных в дополнение к «основному» месту хранения объекта. Если объект удаляется из основного хранилища и нигде не используется, кроме как в качестве ключа в **`WeakMap`** или в **`WeakSet`**, то он будет удалён автоматически.
+
+## WeakMap
+Первое его отличие от Map в том, что ключи в WeakMap должны быть объектами, а не примитивными значениями
+
+Теперь, если мы используем объект в качестве ключа и если больше нет ссылок на этот объект, то он будет удалён из памяти (и из объекта WeakMap) автоматически.
+
+WeakMap не поддерживает перебор и методы keys(), values(), entries(), так что нет способа взять все ключи или значения из неё.
+
+В WeakMap присутствуют только следующие методы:
+- weakMap.get(key)
+- weakMap.set(key, value)
+- weakMap.delete(key)
+- weakMap.has(key)
+
+К чему такие ограничения? Из-за особенностей технической реализации. Если объект станет недостижим (как объект john в примере выше), то он будет автоматически удалён сборщиком мусора. Но нет информации, в какой момент произойдёт эта очистка.
+Решение о том, когда делать сборку мусора, принимает движок JavaScript. Он может посчитать необходимым как удалить объект прямо сейчас, так и отложить эту операцию, чтобы удалить большее количество объектов за раз позже. Так что технически количество элементов в коллекции WeakMap неизвестно. Движок может произвести очистку сразу или потом, или сделать это частично. По этой причине методы для доступа ко всем сразу ключам/значениям недоступны.
+
+В основном, WeakMap используется в качестве дополнительного хранилища данных.
+
+Если мы работаем с объектом, который «принадлежит» другому коду, может быть даже сторонней библиотеке, и хотим сохранить у себя какие-то данные для него, которые должны существовать лишь пока существует этот объект, то WeakMap – как раз то, что нужно.
+
+Мы кладём эти данные в WeakMap, используя объект как ключ, и когда сборщик мусора удалит объекты из памяти, ассоциированные с ними данные тоже автоматически исчезнут.
+
+## WeakSet
+Коллекция WeakSet ведёт себя похоже:
+- Она аналогична Set, но мы можем добавлять в WeakSet только объекты (не примитивные значения).
+- Объект присутствует в множестве только до тех пор, пока доступен где-то ещё.
+- Как и Set, она поддерживает add, has и delete, но не size, keys() и не является перебираемой.
+
+Будучи «слабой» версией оригинальной структуры данных, она тоже служит в качестве дополнительного хранилища. Но не для произвольных данных, а скорее для значений типа «да/нет». Присутствие во множестве WeakSet может что-то сказать нам об объекте.
+```js
+let visitedSet = new WeakSet();
+
+let john = { name: "John" };
+let pete = { name: "Pete" };
+let mary = { name: "Mary" };
+
+visitedSet.add(john); // John заходил к нам
+visitedSet.add(pete); // потом Pete
+visitedSet.add(john); // John снова
+
+// visitedSet сейчас содержит двух пользователей
+
+// проверим, заходил ли John?
+alert(visitedSet.has(john)); // true
+
+// проверим, заходила ли Mary?
+alert(visitedSet.has(mary)); // false
+
+john = null;
+// структура данных visitedSet будет очищена автоматически (объект john будет удалён из visitedSet)
+```
--- a/docs/javascript/03-data-types/08-objects-methods.md
+++ b/docs/javascript/03-data-types/08-objects-methods.md
@@ -0,0 +1,38 @@
+---
+sidebar_position: 8
+---
+
+# keys, values, entries
+.keys(), .values(), .entries(). Универсальные методы, и существует общее соглашение использовать их для структур данных. Если бы мы делали собственную структуру данных, нам также следовало бы их реализовать.
+Методы поддерживаются для структур:
+- Map
+- Set
+- Array
+
+### Object.keys, values, entries
+Для простых объектов доступны следующие методы:
+- **`Object.keys(obj)`** – возвращает массив ключей.
+- **`Object.values(obj)`** – возвращает массив значений.
+- **`Object.entries(obj)`** – возвращает массив пар [ключ, значение].
+
+Объекты являются основой всех сложных структур в JavaScript. У нас может быть объект `data`, который реализует свой собственный метод data.values(). И мы всё ещё можем применять к нему стандартный метод `Object.values(data)`.
+```js
+let user = {
+  name: "John",
+  age: 30
+};
+```
+- `Object.keys(user) = ["name", "age"]`
+- `Object.values(user) = ["John", 30]`
+- `Object.entries(user) = [ ["name","John"], ["age",30] ]`
+
+💥 ***Object.keys/values/entries игнорируют символьные свойства***\
+Так же, как и цикл for..in, эти методы игнорируют свойства, использующие Symbol(...) в качестве ключей.
+
+### Трансформации объекта
+У объектов нет множества методов, которые есть в массивах, например map, filter и других.
+
+Если мы хотели бы их применить, то можно использовать Object.entries с последующим вызовом Object.fromEntries:
+1. Вызов **`Object.entries(obj)`** возвращает массив пар ключ/значение для obj.
+2. На нём вызываем методы массива, например, **`map`**.
+3. Используем `Object.fromEntries(array)` на результате, чтобы преобразовать его обратно в объект.
--- a/docs/javascript/03-data-types/09-destr-assignment.md
+++ b/docs/javascript/03-data-types/09-destr-assignment.md
@@ -0,0 +1,119 @@
+---
+sidebar_position: 9
+---
+
+# Деструктурирующее присваивание
+Деструктуризация позволяет разбивать объект или массив на переменные при присвоении.
+
+Полный синтаксис для объекта:
+```js
+let {prop : varName = defaultValue, ...rest} = object
+```
+Полный синтаксис для массива:
+```js
+let [item1 = defaultValue, item2, ...rest] = array
+```
+Можно извлекать данные из вложенных объектов и массивов, для этого левая сторона должна иметь ту же структуру, что и правая.
+
+### Деструктуризация массива
+```js
+let arr = ["Ilya", "Kantor"]; // у нас есть массив с именем и фамилией
+let [firstName, surname] = arr; // деструктурирующее присваивание
+```
+💥 «Деструктуризация» не означает «разрушение».
+
+#### Работает с любым перебираемым объектом с правой стороны
+```js
+let [a, b, c] = "abc";
+let [one, two, three] = new Set([1, 2, 3]);
+```
+#### Присваивайте чему угодно с левой стороны
+```js
+let user = {};
+[user.name, user.surname] = "Ilya Kantor".split(' ');
+alert(user.name, user.surname); // Ilya Kantor
+```
+#### Цикл с .entries()
+```js
+let user = {
+  name: "John",
+  age: 30
+};
+
+for (let [key, value] of Object.entries(user)) { // цикл по ключам и значениям
+  alert(`${key}:${value}`); // name:John, затем age:30
+}
+```
+#### Трюк обмена переменных
+```js
+let guest = "Jane";
+let admin = "Pete";
+
+[guest, admin] = [admin, guest];// Давайте поменяем местами значения: сделаем guest = "Pete", а admin = "Jane"
+alert(`${guest} ${admin}`); // Pete Jane (успешно заменено!)
+```
+
+### Остаточные параметры «…»
+```js
+let [name1, name2, ...rest] = ["Julius", "Caesar", "Consul", "of the Roman Republic"];
+// rest это массив элементов, начиная с 3-го
+alert(rest[0]); // Consul
+alert(rest[1]); // of the Roman Republic
+alert(rest.length); // 2
+```
+
+### Значения по умолчанию
+Если мы хотим, чтобы значение «по умолчанию» заменило отсутствующее, мы можем указать его с помощью =
+```js
+// значения по умолчанию
+let [name = "Guest", surname = "Anonymous"] = ["Julius"];
+
+alert(name);    // Julius (из массива)
+alert(surname); // Anonymous (значение по умолчанию)
+```
+Значения по умолчанию могут быть гораздо более сложными выражениями или даже функциями. Они выполняются, только если значения отсутствуют.
+
+### Деструктуризация объекта
+Деструктурирующее присваивание также работает с объектами.
+```js
+let options = {
+  title: "Menu",
+  width: 100,
+  height: 200
+};
+
+// { sourceProperty: targetVariable }
+let {width: w, height: h, title} = options;
+
+// width -> w
+// height -> h
+// title -> title
+
+alert(title);  // Menu
+alert(w);      // 100
+alert(h);      // 200
+```
+
+### Остаток объекта «…»
+```js
+let options = {
+  title: "Menu",
+  height: 200,
+  width: 100
+};
+
+// title = свойство с именем title
+// rest = объект с остальными свойствами
+let {title, ...rest} = options;
+
+// сейчас title="Menu", rest={height: 200, width: 100}
+alert(rest.height);  // 200
+alert(rest.width);   // 100
+```
+
+### Умные параметры функций
+```js
+function showMenu(title = "Untitled", width = 200, height = 100, items = []) {
+  // ...
+}
+```
--- a/docs/javascript/03-data-types/10-date-time.md
+++ b/docs/javascript/03-data-types/10-date-time.md
@@ -0,0 +1,71 @@
+---
+sidebar_position: 10
+---
+
+# Дата и время
+
+- Дата и время в JavaScript представлены объектом `Date`. Нельзя создать «только дату» или «только время»: объекты `Date` всегда содержат и то, и другое.
+- Счёт месяцев начинается с нуля (да, январь – это нулевой месяц).
+- Дни недели в `getDay()` также отсчитываются с нуля, что соответствует воскресенью.
+- Объект `Date` самостоятельно корректируется при введении значений, выходящих за рамки допустимых. Это полезно для сложения/вычитания дней/месяцев/недель.
+- Даты можно вычитать, и разность возвращается в миллисекундах. Так происходит, потому что при преобразовании в число объект `Date` становится таймстампом.
+- Используйте `Date.now()` для быстрого получения текущего времени в формате таймстампа.
+
+### Создание
+- **`new Date()`** Без аргументов – создать объект Date с текущими датой и временем
+- **`new Date(milliseconds)`**  Создать объект Date с временем, равным количеству миллисекунд (тысячная доля секунды), прошедших с 1 января 1970 года UTC+0.
+- **`new Date(datestring)`**  Если аргумент всего один, и это строка, то из неё «прочитывается» дата.
+- **`new Date(year, month, date, hours, minutes, seconds, ms)`** Создать объект Date с заданными компонентами в местном часовом поясе. Обязательны только первые два аргумента.
+
+### Получение компонентов даты
+- getFullYear() - Получить год (4 цифры)
+- getMonth() - Получить месяц, от 0 до 11.
+- getDate() - Получить день месяца, от 1 до 31, что несколько противоречит названию метода.
+- getHours(), getMinutes(), getSeconds(), getMilliseconds() - Получить, соответственно, часы, минуты, секунды или миллисекунды.
+- getDay() Получить определённый день недели
+- getTime() Для заданной даты возвращает таймстамп – количество миллисекунд, прошедших с 1 января 1970 года UTC+0.
+- getTimezoneOffset() Возвращает разницу в минутах между UTC и местным часовым поясом:
+
+***Все вышеперечисленные методы возвращают значения в соответствии с местным часовым поясом.***
+
+### Установка компонентов даты
+- setFullYear(year, [month], [date])
+- setMonth(month, [date])
+- setDate(date)
+- setHours(hour, [min], [sec], [ms])
+- setMinutes(min, [sec], [ms])
+- setSeconds(sec, [ms])
+- setMilliseconds(ms)
+- setTime(milliseconds) (устанавливает дату в виде целого количества миллисекунд, прошедших с 01.01.1970 UTC)
+
+У всех этих методов, кроме setTime(), есть UTC-вариант, например: setUTCHours().
+
+### Автоисправление даты
+Автоисправление – это очень полезная особенность объектов Date. Можно устанавливать компоненты даты вне обычного диапазона значений, а объект сам себя исправит.
+```js
+let date = new Date(2013, 0, 32); // 32 Jan 2013 ?!?
+alert(date); // ...1st Feb 2013!
+```
+
+### Преобразование к числу, разность дат
+
+Если объект Date преобразовать в число, то получим таймстамп по аналогии с date.getTime()
+Важный побочный эффект: даты можно вычитать, в результате получаем разность в миллисекундах.
+
+### Date.now()
+Существует особый метод Date.now(), возвращающий текущую метку времени.
+
+Семантически он эквивалентен new Date().getTime(), однако метод не создаёт промежуточный объект Date. Так что этот способ работает быстрее и не нагружает сборщик мусора.
+
+### Разбор строки с датой
+Метод Date.parse(str) считывает дату из строки.
+
+Формат строки должен быть следующим: YYYY-MM-DDTHH:mm:ss.sssZ, где:
+- YYYY-MM-DD – это дата: год-месяц-день.
+- Символ "T" используется в качестве разделителя.
+- HH:mm:ss.sss – время: часы, минуты, секунды и миллисекунды.
+- Необязательная часть 'Z' обозначает часовой пояс в формате +-hh:mm. Если указать просто букву Z, то получим UTC+0.
+
+Возможны и более короткие варианты, например, YYYY-MM-DD или YYYY-MM, или даже YYYY.
+
+Вызов Date.parse(str) обрабатывает строку в заданном формате и возвращает таймстамп (количество миллисекунд с 1 января 1970 года UTC+0). Если формат неправильный, возвращается NaN.