update docs, add object

docs/javascript/base/02-variables.md

@@ -12,7 +12,7 @@ sidebar_position: 2
 - const (константа, т.е. изменению не подлежит)
 - var (устаревший способ, подробности позже)
 
-```
+```js
 let message;
  
 message = 'Hello'; // сохранить строку 'Hello' в переменной с именем message
@@ -43,7 +43,7 @@ message = 'Hello';
 
 Оператор typeof возвращает тип значения переменной, с двумя исключениями:
 
-```
+```js
 typeof null == "object" // ошибка в языке
 typeof function(){} == "function" // именно для функций
 ```

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

@@ -5,14 +5,18 @@ sidebar_position: 3
 # Преобразование типов
 
 ## Строковое преобразование
-**String(value)**
+```js
+String(value)
 ```
+```js
 alert(typeof value); // string
 ```
 
 ## Численное преобразование
-**Number(str)**
+```js
+Number(str)
 ```
+```js
 let num = Number(str); // становится числом 123
 ```
 | Значение                | Преобразуется в…                                                                                                                                                                                                                |
@@ -22,14 +26,16 @@ let num = Number(str); // становится числом 123
 | 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
 ```
 ## Логическое преобразование
-**Boolean(value)**\
+```js
+Boolean(value)
+```
 Происходит в логических операциях, но также может быть выполнено явно с помощью функции Boolean(value).
 
 Правило преобразования:
@@ -41,7 +47,7 @@ alert( Number(false) );       // 0
 | 0, null, undefined, NaN, "" | false       |
 | любое другое значение       | true        |
 
-```
+```js
 alert( Boolean(1) ); // true 
 alert( Boolean(0) ); // false 
 alert( Boolean("Привет!") ); // true 

docs/javascript/base/04-operators.md

@@ -32,8 +32,8 @@ sidebar_position: 4
   
 ## Оператор «запятая»
 Оператор «запятая» предоставляет нам возможность вычислять несколько выражений, разделяя их запятой ,. Каждое выражение выполняется, но возвращается результат только последнего.
-```
-let a = (1 + 2, 3 + 4); \
-alert( a ); // 7 (результат вычисления 3 + 4) \
+```js
+let a = (1 + 2, 3 + 4);
+alert( a ); // 7 (результат вычисления 3 + 4)
 ```
 ❗ ***Запятая имеет очень низкий приоритет***

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

@@ -11,7 +11,7 @@ sidebar_position: 6
 ***Несколько условий: «else if»***
 
 ## Конструкция "switch"
-```
+```js
 let a = 2 + 2;
  
 switch (a) { 
@@ -29,7 +29,7 @@ switch (a) {
 }
 ```
 ## Условный оператор „?“ (тернарный)
-```
+```js
 let result = условие ? значение1 : значение2;
 ```
 ## Логические операторы
@@ -45,14 +45,14 @@ let result = условие ? значение1 : значение2;
 - ??= (Оператор нулевого присваивания)
 
 ### || (ИЛИ)
-```
+```js
 ( true || true ); // true 
 ( false || true ); // true 
 ( true || false ); // true 
 ( false || false ); // false
 ```
 ### ИЛИ "||" находит первое истинное значение
-```
+```js
 ( 1 || 0 ); // 1 (1 - истинное значение) 
 ( true || 'какая-то строка' ); // true 
 ( null || 1 ); // 1 (первое истинное значение) 
@@ -61,7 +61,7 @@ let result = условие ? значение1 : значение2;
 ```
 
 ### ||= (Логическое присваивание ИЛИ)
-```
+```js
 a ||= b;
 ```
 Оператор **||=** принимает два операнда и выполняет следующие действия:
@@ -71,14 +71,14 @@ a ||= b;
 - Если ***a*** ложно, присваивает ***a*** значение ***b***.
 
 ### && (И)
-```
+```js
 ( true && true ); // true 
 ( false && true ); // false 
 ( true && false ); // false 
 ( false && false ); // false
 ```
 #### И «&&» находит первое ложное значение
-```
+```js
 result = value1 && value2 && value3;
 ```
 Оператор **&&** выполняет следующие действия:
@@ -103,7 +103,7 @@ result = value1 && value2 && value3;
 Несмотря на то, что вариант с && кажется более коротким, if более нагляден и, как правило, более читабелен.
 
 ### &&= (Логическое присваивание И)
-```
+```js
 a &&= b;
 ```
 Принцип действия **&&=** практически такой же, как и у оператора логического присваивания **ИЛИ ||=**. \
@@ -112,7 +112,7 @@ a &&= b;
 
 ### ! (НЕ)
 
-```
+```js
 result = !value;
 ```
 
@@ -146,19 +146,19 @@ result = !value;
 
 По соображениям безопасности JavaScript запрещает использование оператора **??** вместе с **&&** и **||**, если
 приоритет явно не указан при помощи круглых скобок.
-```
+```js
 let x = 1 && 2 ?? 3; // Синтаксическая ошибка
 ```
 
 Используйте скобки, чтобы обойти это ограничение:
-```
+```js
 let x = (1 && 2) ?? 3; // Работает без ошибок
 ```
 ### Оператор нулевого присваивания (??=)
 
 Предположим, нам необходимо проверить, равна ли переменная null или undefined, и если это так — присвоить этой
 переменной какое-либо другое значение.
-```
+```js
 let userAge = null;
 
 if (userAge === null || userAge === undefined) {
@@ -167,10 +167,12 @@ if (userAge === null || userAge === undefined) {
 ```
 
 Выглядит громоздко, правда? Существует оператор, более подходящий для подобных задач.
-```x ??= y```
+```js
+x ??= y
+```
 
 Оператор **??=** присвоит **x** значение **y** только в том случае, если **x** не определено (null/undefined).
-```
+```js
 let userAge = null;
 userAge ??= 18;
 alert(userAge) // 18

docs/javascript/base/07-cycles.md

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

docs/javascript/base/_category_.json

@@ -1,5 +1,5 @@
 {
-  "label": "Основа",
+  "label": "Введение",
   "position": 1,
   "link": {
     "type": "generated-index"