Сообщения kdcore

kdcore

Сайты, обслуживаемые nginx, содержатся в блоке сервера, который обычно хранится в отдельных файлах, отличных от основного конфигурационного файла nginx (который редактируется крайне редко).

Лучший способ установить новые конфигурационные файлы nginx — добавить новые файлы в /etc/nginx/sites-available (например, /etc/nginx/sites-available/example.org). Затем необходимо связать эти файлы из sites-available с sites-enabled.

Ниже показана типичная последовательность команд при создании новой конфигурации nginx:

cd /etc/nginx/sites-available
sudo nano forum.example.com # конфигурация введена в файл и сохранена
cd ../sites-enabled
sudo ln -s ../sites-available/example.com

Ниже приведен пример конфигурации проектов, работающего на портах. Обязательно замените example.com на URL-адрес вашего сайта (без https://).

server {
    listen 80;

    server_name example.com;

    location / {
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header Host $http_host;
        proxy_set_header X-NginX-Proxy true;

        # Прописываем необходимый порт вашегоприложения
        proxy_pass http://127.0.0.1:8888; 
        proxy_redirect off;

        # Socket.IO Support если требуется, если нет то можно не использовать
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

После внесения изменений в конфигурации nginx необходимо перезагрузить службу, чтобы изменения вступили в силу:

sudo systemctl reload nginx

kdcore

1. Function Declaration (Объявление функции)

Синтаксис:

function имяФункции(параметры) {
  // тело функции
}

Пример:

function sayHello(name) {
  return `Привет, ${name}!`;
}

console.log(sayHello("Анна")); // Привет, Анна!

Особенности:

Объявляется с помощью ключевого слова function.
Поднимается (hoisted) — можно вызывать до её объявления в коде.
Имеет своё имя (может быть использовано для рекурсии).
Создаётся в глобальной области видимости или в области видимости функции, где объявлена.

Пример hoisting:

console.log(greet("Мария")); // Работает! Вывод: Здравствуй, Мария!

function greet(name) {
  return `Здравствуй, ${name}!`;
}

2. Function Expression (Функциональное выражение)

Синтаксис:

const имяПеременной = function(параметры) {
  // тело функции
};

Пример:

const sayGoodbye = function(name) {
  return `Пока, ${name}!`;
};

console.log(sayGoodbye("Иван")); // Пока, Иван!

Особенности:

Функция присваивается переменной.
Не поднимается полностью — переменная поднимается, но не значение (функция).
Можно быть анонимной или именованной.
Часто используется как callback или для передачи функций как аргументов.

Пример с именованной функцией (редко, но возможно):

const factorial = function fact(n) {
  return n <= 1 ? 1 : n * fact(n - 1);
};

Важно:

console.log(add(2, 3)); // Ошибка! Cannot access 'add' before initialization

const add = function(a, b) {
  return a + b;
};

️ const и let не поднимаются (или поднимаются, но в "temporal dead zone"), поэтому вызов до объявления — ошибка.

3. Arrow Function (Стрелочная функция)

Синтаксис:

const имя = (параметры) => {
  // тело функции
};

Примеры:

// Однострочная (неявный return)
const multiply = (a, b) => a * b;

// Многострочная (явный return нужен)
const divide = (a, b) => {
  if (b === 0) return "Ошибка: деление на ноль";
  return a / b;
};

// Без параметров
const greet = () => "Привет, мир!";

// Один параметр — скобки можно опустить
const square = x => x * x;

Особенности:

Нет собственного this, arguments, super, new.target.
Не поднимается (как и function expression).
Не имеет имени (анонимная), но может быть присвоена переменной.
Лексическое this — берёт this из внешнего контекста.
Не может использоваться как конструктор (new вызовет ошибку).
Не имеет arguments — используйте ...args.

Различия: Сравнение

Характеристика	Function Declaration	Function Expression	Arrow Function
Синтаксис	`function name() {}`	`const f = function() {}`	`const f = () => {}`
Hoisting	Да (вся функция)	Нет (только переменная)	Нет
`this`	Собственное (зависит от вызова)	Собственное	Лексическое (взято извне)
`arguments`	Есть	Есть	Нет (используйте `...args`)
Можно использовать `new`	Да	Да	Нет (ошибка)
Имя функции	Да	Может быть (но редко)	Нет (анонимная)
Подходит для методов объекта	Да	Да	Осторожно (из-за `this`)

Пример с `this` — ключевое отличие

const user = {
  name: "Алексей",
  regularFunction: function() {
    console.log("Привет, я " + this.name);
  },
  arrowFunction: () => {
    console.log("Привет, я " + this.name); // this — не user!
  }
};

user.regularFunction(); // Привет, я Алексей
user.arrowFunction();   // Привет, я undefined (в браузере может быть window.name)

Почему? У стрелочной функции this берётся из внешнего контекста, а не из объекта user.

Когда что использовать?

Тип функции	Когда использовать
Function Declaration	Когда нужна hoisting, простая именованная функция
Function Expression	Когда функция — значение (callback, замыкание)
Arrow Function	Для коротких функций, в `map/filter`, когда нужен лексический `this`

Примеры в реальных сценариях

1. Arrow Function в `map`

const numbers = [1, 2, 3];
const doubled = numbers.map(n => n * 2); // [2, 4, 6]

2. Function Expression как callback

button.addEventListener('click', function() {
  console.log('Кнопка нажата');
});

3. Function Declaration — удобно для чтения

function validateEmail(email) {
  return email.includes("@");
}

Вывод

Function Declaration — классика, поднимается, удобна для простых функций.
Function Expression — гибкая, не поднимается, хороша для динамических функций.
Arrow Function — короткая, лексическое this, идеальна для колбэков и однострочных операций.

Выбирайте в зависимости от контекста: нужно ли this, нужна ли hoisting, где используется функция.

kdcore

Изучить TypeScript можно на freecodecamp

А также можно прочитать книгу профессиональный TypeScript:

kdcore

В CSS можно подключить один файл стилей к другому с помощью специальной директивы @import. Это удобно, если вы хотите разделить стили на несколько файлов для удобства организации проекта.

Используйте директиву @import в самом начале файла CSS, чтобы "подтянуть" другой файл. Синтаксис следующий:

@import url("путь_к_файлу.css");

Обязательно пишите эту запись в начале файла до всех остальных CSS правил.
Путь к файлу может быть относительным или абсолютным.

Предположим, у вас есть два файла:

base.css — содержит базовые стили
style.css — основной файл, куда вы подключите base.css

Содержимое style.css:

@import url("base.css");

/* Далее идут остальные стили */
body {
  background-color: #f0f0f0;
}

h1 {
  color: blue;
}

В таком случае стили из base.css автоматически применятся в том же документе, где подключён style.css.

Для чего вообще это необходимо?

Позволяет разделять стили по тематике или компонентам.
Упрощает поддержку крупных проектов.
Можно подключать общие стили в нескольких местах без дублирования кода.

На заметку:

Директива @import замедляет загрузку, так как браузер сначала загружает первый файл, а затем все импортированные.
Лучше использовать @import для небольших и редко изменяемых файлов.
Для большого проекта рекомендовано использовать сборщики и препроцессоры, которые оптимизируют подключение.

kdcore

Функция замыкания (closure) в JavaScript — это одна из ключевых концепций языка, которая позволяет функции запоминать и получать доступ к переменным из внешней области видимости, даже после того, как внешняя функция завершила своё выполнение.

Простыми словами: Замыкание — это функция внутри другой функции, которая "запоминает" окружение, в котором была создана, и может использовать переменные из этого окружения.

В JavaScript действует лексическое окружение — функция "знает", где она была определена, и имеет доступ к переменным из родительской области видимости.

Пример замыкания:

function outerFunction(x) {
    return function innerFunction(y) {
        return x + y;
    };
}

const add5 = outerFunction(5);  // x = 5 запоминается
console.log(add5(3));           // 8 → innerFunction всё ещё "помнит" x = 5

Что происходит:

outerFunction(5) вызывается, x = 5.
Возвращается innerFunction, которая использует x.
Даже после завершения outerFunction, innerFunction всё ещё имеет доступ к x.
Это и есть замыкание — innerFunction "замкнула" в себе переменную x.

Ещё один пример — счётчик:

function createCounter() {
    let count = 0;
    return function() {
        count++;
        console.log(count);
    };
}

const counter = createCounter();
counter(); // 1
counter(); // 2
counter(); // 3

Переменная count находится внутри createCounter, но возвращаемая функция может к ней обращаться.
Каждый вызов увеличивает count, и значение сохраняется между вызовами, потому что замыкание "удерживает" переменную.

Важные особенности замыканий:

Замыкания позволяют инкапсулировать данные (как приватные переменные).
Они используются для создания фабрик функций, модулей, обработчиков событий и т.д.
Замыкания могут привести к утечкам памяти, если держат ссылки на большие объекты, которые больше не нужны.

Где используются замыкания?

В модульном паттерне (приватные переменные и методы).
При работе с колбэками и асинхронным кодом (например, в setTimeout).
В функциях высшего порядка (map, filter, reduce).
При создании декораторов и каррирования.

Замыкание — это функция, которая "запоминает" своё лексическое окружение, даже когда вызывается вне его.

kdcore

Что такое скомпилированный язык?

Скомпилированный язык — это язык программирования, в котором исходный код сначала преобразуется (компилируется) в машинный код (или ближайший к нему, например, байт-код) до выполнения программы.

Как это работает:

Ты пишешь программу на языке (например, C, C++, Rust).
Запускаешь компилятор (например, gcc для C).
Компилятор преобразует весь исходный код в исполняемый файл (например, .exe на Windows).
Этот исполняемый файл можно запускать напрямую на компьютере, без исходного кода.

Пример:

// hello.c
#include <stdio.h>
int main() {
    printf("Привет, мир!\n");
    return 0;
}

→ Компилируется в hello.exe → Запускается напрямую.

Преимущества:

Высокая скорость выполнения (машинный код).
Лучшая оптимизация.
Исходный код не нужен для запуска.

Недостатки:

Нужно перекомпилировать при изменениях.
Зависимость от платформы (например, отдельная сборка под Windows, Linux, macOS).

Что такое интерпретируемый язык?

Интерпретируемый язык — это язык, в котором исходный код выполняется построчно (или по блокам) специальной программой — интерпретатором, без предварительной компиляции в машинный код.

Как это работает:

Ты пишешь код (например, на Python).
Запускаешь его через интерпретатор (например, python script.py).
Интерпретатор читает и выполняет код построчно, "на лету".

Пример:

# hello.py
print("Привет, мир!")

→ Запускается командой: python hello.py → Интерпретатор выполняет код.

Преимущества:

Быстрая разработка и тестирование (не нужно компилировать).
Кроссплатформенность (если есть интерпретатор, код работает везде).
Гибкость (динамическая типизация, метапрограммирование и т.д.).

Недостатки:

Медленнее выполнение (интерпретатор "переводит" код во время запуска).
Нужен интерпретатор на целевой машине.

Современные реалии: гибридный подход

На самом деле, граница между интерпретацией и компиляцией не всегда чёткая.

Например:

Python сначала компилируется в байт-код (.pyc), который потом интерпретируется виртуальной машиной (CPython).
Java компилируется в байт-код (.class), который выполняется на JVM (Java Virtual Machine) — это тоже своего рода интерпретация.
JavaScript в браузерах сначала интерпретируется, а потом JIT-компилятор (Just-In-Time) может скомпилировать "горячие" участки кода в машинный код для ускорения.

Основные различия в таблице:

Характеристика	Скомпилированный язык	Интерпретируемый язык
Когда преобразуется код?	До выполнения (на этапе компиляции)	Во время выполнения (по ходу)
Скорость выполнения	Высокая	Ниже (обычно)
Зависимость от ПО	Нет (если нет зависимостей)	Нужен интерпретатор
Переносимость	Низкая (пересборка под платформу)	Высокая (если есть интерпретатор)
Отладка и разработка	Медленнее	Быстрее
Примеры	C, C++, Rust, Go	Python, JavaScript, Ruby, PHP

kdcore

BigInt — это специальный числовой тип в JavaScript, который позволяет работать с очень большими целыми числами, больше, чем Number.MAX_SAFE_INTEGER.

Почему нужен `BigInt`?

Обычные числа (number) в JavaScript — это 64-битные дроби по стандарту IEEE-754.
Они точны только до:

Number.MAX_SAFE_INTEGER // 9007199254740991 (≈9 квадриллионов)

Если число больше — оно может потерять точность:

console.log(9007199254740992 + 1); // 9007199254740992 ❌ (не изменилось!)

Вот тут и пригодится BigInt.

Как создать `BigInt`?

Добавь n в конце числа:

let big = 1234567890123456789012345n;

Или через функцию BigInt():

let big = BigInt("1234567890123456789012345");

Как привести `number` в `BigInt`?

Используй функцию BigInt():

let num = 42;
let big = BigInt(num); // 42n

️ Нельзя приводить дробные числа:

BigInt(3.14); // Ошибка! Дроби не поддерживаются

Как привести `BigInt` обратно в `number`?

Используй Number():

let big = 100n;
let num = Number(big); // 100

️ Осторожно! Если BigInt слишком большой — потеряешь точность:

let big = 9007199254740992n;
let num = Number(big); // 9007199254740992 — может выглядеть нормально,
                       // но уже за пределами безопасной зоны

Преобразование в number — рискованно, если число огромное.

Ограничения и особенности `BigInt`

Особенность	Что нужно знать
Только целые числа	Дробные не поддерживаются: `1.5n` → ошибка
Не работает с `Math`	`Math.sqrt()`, `Math.random()` и др. — не работают с `BigInt`
Нельзя смешивать с `number` в операциях	`10 + 5n` → ошибка!
Сравнения (`<`, `>`, `===`) работают	`5n < 10` → `true`, `5n === 5` → `false`
`typeof` возвращает `"bigint"`	`typeof 5n` → `"bigint"`

Примеры работы:

let a = 10n;
let b = 20n;

console.log(a + b); // 30n
console.log(b - a); // 10n
console.log(a * 3n); // 30n
console.log(a < 15); // true

// ❌ Ошибка:
// console.log(a + 5); // нельзя складывать bigint и number

Сначала приведи к одному типу (но аккуратно!):

console.log(a + BigInt(5)); // 15n ✅
console.log(Number(a) + 5); // 15 ✅ (но может быть потеря точности)

Когда использовать BigInt?

При работе с очень большими числами: криптография, ID, научные расчёты
Когда важна абсолютная точность для целых чисел
В библиотеках, где числа выходят за пределы MAX_SAFE_INTEGER

Итог:

Что	Как
Создать `BigInt`	`123n` или `BigInt(123)`
`number` → `BigInt`	`BigInt(num)` (только целые!)
`BigInt` → `number`	`Number(big)` — с риском потери точности
Операции	Только с другими `BigInt`
Ограничения	Нет дробей, нет `Math`, нельзя смешивать с `number`

BigInt — мощный инструмент, но используй его только когда действительно нужно.
Для обычных задач — хватит обычных чисел (number).

kdcore

JSON (JavaScript Object Notation) — это текстовый формат для хранения и передачи данных.
Он выглядит похоже на объект в JavaScript, но является строкой, которую можно легко отправить по сети или сохранить.

Пример JSON:

'{"name": "Анна", "age": 28, "city": "Москва"}'

Это не объект, а строка в специальном формате.

Зачем нужен JSON?

Когда данные нужно:

отправить с клиента на сервер,
получить от сервера,
сохранить в файле,

— их преобразуют в JSON (в строку), потому что по сети нельзя передавать объекты напрямую.

Два главных метода: `JSON.stringify` и `JSON.parse`

1. JSON.stringify(объект) → превращает объект/массив в JSON-строку

let user = { name: "Анна", age: 28 };

let json = JSON.stringify(user);
console.log(json); // '{"name":"Анна","age":28}'

Используется, когда нужно отправить данные (например, на сервер).

Особенности stringify:

Поддерживает объекты, массивы, числа, строки, null, true/false
Игнорирует функции, undefined, символы (Symbol)
Можно красиво форматировать:

JSON.stringify(user, null, 2);
// красиво отформатированная строка:
// {
//   "name": "Анна",
//   "age": 28
// }

2. JSON.parse(строка) → превращает JSON-строку обратно в объект/массив

let json = '{"name":"Анна","age":28}';

let user = JSON.parse(json);
console.log(user.name); // "Анна"

Используется, когда получаешь данные (например, с сервера).

Особенности parse:

Строка должна быть в правильном JSON-формате
Кавычки — только двойные (")
Никаких функций или одинарных кавычек

Так нельзя:

JSON.parse("{'name': 'Анна'}"); // Ошибка: одинарные кавычки
JSON.parse('{"name": undefined}'); // Ошибка: undefined в JSON запрещён

Пример: отправка и получение данных

// 1. Отправляем данные на сервер
let data = { title: "Книга", price: 1000 };
let json = JSON.stringify(data);
// отправляем json как строку через fetch или WebSocket

// 2. Получаем строку с сервера
let response = '{"title":"Книга","price":1000}';
let obj = JSON.parse(response);
console.log(obj.title); // "Книга"

Круг в одном примере:

let original = { name: "Петя", isStudent: true };

// В строку
let str = JSON.stringify(original);

// Обратно в объект
let copy = JSON.parse(str);

console.log(copy.name); // "Петя"

Это часто используют для глубокого копирования объекта.

Итог

Метод	Что делает	Когда использовать
`JSON.stringify(obj)`	Объект → JSON-строка	Чтобы отправить или сохранить данные
`JSON.parse(str)`	JSON-строка → объект	Чтобы прочитать или получить данные

Правила JSON:

Только двойные кавычки: " (не ')
Нет undefined, function, Symbol
Поддерживает: объекты, массивы, строки, числа, null, true/false

JSON — универсальный формат. Он используется не только в JavaScript, но и в Python, Java, PHP и других языках.
Поэтому он идеален для обмена данными между разными системами.

kdcore

В JavaScript всё (почти) — объект, и у каждого объекта может быть прототип — другой объект, из которого он наследует свойства и методы.

Представь: если у объекта нет нужного метода — он смотрит в свой прототип. Если и там нет — идёт дальше по цепочке. Это называется цепочкой прототипов.

1. Встроенные прототипы объектов

У встроенных конструкторов (вроде Object, Array, Function) есть прототипы, где хранятся общие методы.

Например:

`Array.prototype`

Все массивы наследуют методы от Array.prototype:

let arr = [1, 2, 3];
arr.push(4); // метод push взят из Array.prototype

То есть:

arr.__proto__ === Array.prototype // true

Аналогично:

Object.prototype — база для всех объектов
String.prototype — содержит toUpperCase(), slice() и др.
Number.prototype, Function.prototype и т.д.

Эти прототипы позволяют всем объектам одного типа использовать одни и те же методы.

2. Прототипы объектов-обёрток для примитивов

Тут становится интереснее.

Примитивы — это не объекты:
string, number, boolean, null, undefined, symbol, bigint

Но... почему у строки есть методы вроде .toUpperCase()?

"hello".toUpperCase(); // "HELLO"

Строка — примитив, а метод вызывается как у объекта. Как?

Магия: объекты-обёртки

Когда вы вызываете метод на примитиве, JavaScript временно оборачивает его в объект.

Пример со строкой:

"hello".toUpperCase();

JS делает нечто вроде:

new String("hello").toUpperCase();

→ Создаётся временный объект-обёртка,
→ вызывается метод из String.prototype,
→ результат возвращается,
→ объект удаляется.

Такие обёртки есть для:

String — для строк
Number — для чисел
Boolean — для булевых значений

Пример:

let str = "hi";
console.log(str.length); // 2

// str — примитив, но JS делает: new String(str).length

Но если попробовать добавить свойство к примитиву — оно не сохранится:

str.test = "привет";
console.log(str.test); // undefined — потому что обёртка уничтожена

Разница между примитивом и объектом:

let str1 = "hello";           // примитив
let str2 = new String("hello"); // объект-обёртка

typeof str1; // "string"
typeof str2; // "object"

str1 == str2; // true (сравнение по значению)
str1 === str2; // false (разные типы)

Всегда используй примитивы. Объекты-обёртки — это внутренний механизм, а не инструмент для кода.

Итог:

Что	Объяснение
Встроенные прототипы	`Array.prototype`, `String.prototype` и др. — хранят методы, которые используют все объекты этого типа
Цепочка прототипов	Объект ищет метод сначала у себя, потом в `__proto__`, потом выше — до `Object.prototype`
Обёртки для примитивов	`new String`, `new Number`, `new Boolean` — временные объекты, которые позволяют вызывать методы на строках, числах и булевых значениях
Но!	Примитивы — не объекты. Обёртки создаются автоматически и исчезают после использования

Прототипы — основа наследования в JS.
Методы у строк и чисел работают благодаря временным объектам-обёрткам.
Не создавай new String() или new Number() вручную — это плохая практика.

kdcore

Иногда нужно разделить строку на части и получить массив. Например, превратить "яблоко, банан, апельсин" в список, с которым удобно работать.

Для этого в JavaScript есть главный метод — split().

`split()` — превращает строку в массив

Синтаксис:

строка.split(разделитель)

Указываешь, по чему разделять строку — и получаешь массив.

Пример 1: строка с запятыми

let str = "яблоко, банан, апельсин";
let arr = str.split(", ");
console.log(arr); // ['яблоко', 'банан', 'апельсин']

Разделитель — ", " (запятая и пробел).

Пример 2: по пробелам

let str = "кошка собака птица";
let arr = str.split(" ");
console.log(arr); // ['кошка', 'собака', 'птица']

Пример 3: по символам (каждая буква — отдельный элемент)

let str = "привет";
let arr = str.split("");
console.log(arr); // ['п', 'р', 'и', 'в', 'е', 'т']

Пустая строка "" как разделитель — разобьёт по каждому символу.

Пример 4: только первые N частей

Можно указать, сколько элементов взять:

let str = "a,b,c,d,e";
let arr = str.split(",", 3);
console.log(arr); // ['a', 'b', 'c'] — только первые 3

Важно:

Если разделитель не найден — вернёт массив с одной строкой.

"hello".split("x") // ['hello']

Пустая строка → пустой массив:

"".split(",") // [''] — почти пустой, но с одним элементом

Обратная операция: массив в строку — `join()`

let arr = ['a', 'b', 'c'];
let str = arr.join(", "); // "a, b, c"

Когда это полезно?

Обработка текста (например, хэштеги: "#js #html #css".split(" "))
Парсинг данных из строки (CSV, логи)
Работа с URL или пользовательским вводом

Чтобы превратить строку в массив, используй метод split(разделитель):

split(", ") — по запятым
split(" ") — по словам
split("") — по символам

Это один из самых частых и полезных приёмов в JavaScript.

kdcore

Массив — это специальный тип данных в JavaScript, который позволяет хранить несколько значений в одной переменной. Представь его как упорядоченный список.

Пример:

let fruits = ['яблоко', 'банан', 'апельсин'];

Каждый элемент имеет индекс — порядковый номер, начинающийся с 0:

fruits[0] → 'яблоко'
fruits[1] → 'банан'
fruits[2] → 'апельсин'

Теперь разберём ключевые методы для работы с массивами.

`push()` — добавить элемент в конец

fruits.push('груша');
// fruits = ['яблоко', 'банан', 'апельсин', 'груша']

`pop()` — удалить последний элемент

fruits.pop();
// удаляет 'груша', возвращает её
// fruits = ['яблоко', 'банан', 'апельсин']

`unshift()` — добавить элемент в начало

fruits.unshift('манго');
// fruits = ['манго', 'яблоко', 'банан', 'апельсин']

`shift()` — удалить первый элемент

fruits.shift();
// удаляет 'манго', возвращает её
// fruits = ['яблоко', 'банан', 'апельсин']

`join()` — превратить массив в строку

let text = fruits.join(', ');
// 'яблоко, банан, апельсин'

Можно указать любой разделитель: ' - ', '; ', '' и т.д.

`sort()` — отсортировать элементы по алфавиту (по умолчанию)

fruits.sort();
// ['апельсин', 'банан', 'яблоко'] — по алфавиту

️ Для чисел нужно передавать функцию сравнения:

let numbers = [10, 2, 5];
numbers.sort((a, b) => a - b);
// [2, 5, 10] — по возрастанию

`concat()` — объединить массивы

let more = ['груша', 'вишня'];
let allFruits = fruits.concat(more);
// ['яблоко', 'банан', 'апельсин', 'груша', 'вишня']

Метод не меняет исходные массивы, а возвращает новый.

🧠 Важно знать:

push, pop, unshift, shift, sort — меняют исходный массив (мутируют).
join, concat — не меняют, а возвращают новое значение.
sort() по умолчанию работает как строки — будь осторожен с числами!

Пример: цепочка действий

let colors = ['зелёный', 'красный'];

colors.push('синий');        // ['зелёный', 'красный', 'синий']
colors.shift();              // ['красный', 'синий']
let result = colors.join(' | '); // 'красный | синий'

Метод	Что делает	Меняет массив?
`push`	добавляет в конец	да
`pop`	удаляет с конца	да
`unshift`	добавляет в начало	да
`shift`	удаляет с начала	да
`join`	в строку с разделителем	нет
`sort`	сортирует	да
`concat`	объединяет массивы	нет

Массивы — одна из самых полезных структур в JavaScript. Знание этих методов позволяет легко добавлять, удалять, сортировать и объединять данные.

kdcore

Объект Date используется, чтобы хранить и получать дату и время: год, месяц, день, часы, минуты и т.д.

Как создать дату:

new Date(); // сейчас
new Date(2025, 0, 1); // 1 января 2025 года

️ ВАЖНО: При создании даты месяцы считаются с нуля.

Месяцы: с какого числа начинаются?

С 0.

0 — январь
1 — февраль
2 — март
...
11 — декабрь

То есть январь — это 0, а не 1.
Поэтому 1 февраля: new Date(2025, 1, 1)

Если напишешь new Date(2025, 12, 1) — это будет январь 2026, потому что 12 — это уже "месяц после декабря", и JS перейдёт на следующий год.

День недели: с какого числа?

Тоже с 0, но:

0 — воскресенье
1 — понедельник
2 — вторник
3 — среда
4 — четверг
5 — пятница
6 — суббота

Значит, первый день недели — воскресенье, если смотреть по методу getDay().

Пример:

let date = new Date(2025, 0, 1); // 1 января 2025
console.log(date.getMonth()); // 0 → январь
console.log(date.getDay());   // 3 → среда (потому что 1 января 2025 — это среда)

Как получить правильный номер месяца (1–12)?
Просто добавь +1:

let month = date.getMonth() + 1; // 0 + 1 = 1 → январь

Как сделать, чтобы день недели был от 1 (понедельник) до 7 (воскресенье)?

let day = date.getDay(); // 0 = вс, 1 = пн, ..., 6 = сб
let dayNumber = day === 0 ? 7 : day; // теперь: 1 = пн, ..., 7 = вс

Так будет привычнее для нас (в Европе принято, что неделя начинается с понедельника).

Полезные методы:

getFullYear() — год (например, 2025)
getMonth() — месяц от 0 до 11
getDate() — число месяца (1–31)
getDay() — день недели от 0 (вс) до 6 (сб)
getHours(), getMinutes(), getSeconds() — время

Чтобы не ошибаться:

Запомни: месяцы — с 0
При выводе — всегда добавляй +1 к месяцу
Или используй удобное отображение:

date.toLocaleDateString('ru-RU'); // "01.01.2025"

Месяцы в JavaScript — от 0 до 11
Дни недели — от 0 (воскресенье) до 6 (суббота)
Первый день недели по умолчанию — воскресенье

Это неудобно, но так устроено. Главное — помнить и аккуратно работать с датами.

kdcore

Объект — это способ хранить данные как "ключ-значение", как коробка с ярлыками.

Представь шкаф:

У каждой полки (свойства) есть название (ключ)
И на ней что-то лежит (значение)

let user = {
  name: "Анна",
  age: 30,
  isStudent: false
};

Здесь user — это объект.
Он содержит данные о пользователе.

Что такое ключ и значение?

Ключ — это имя свойства: "name", "age", "isStudent"
Значение — то, что хранится под этим именем: "Анна", 30, false

То есть значение объекта — это все то, что хранится в его свойствах.

Что может быть значением в объекте?

Любой тип данных:

let product = {
  title: "Телефон",           // строка
  price: 1000,                // число
  inStock: true,              // булево
  tags: ["электроника", "новинка"], // массив
  owner: { name: "Иван" },    // другой объект
  sayHello: function() {      // функция
    console.log("Привет!");
  }
};

То есть значением может быть:

строка, число, булево
null, undefined
массив
другой объект
функция (тогда это метод объекта)

Главное:

Объект — это коллекция данных в формате ключ: значение.
Значение объекта — это то, что находится по каждому ключу. Это может быть что угодно: число, строка, функция, другой объект и т.д.

Как получить значение?

user.name        → "Анна"
user["age"]      → 30
product.sayHello() → выполнит функцию

kdcore

В JavaScript часто нужно преобразовывать значения из одного типа в другой — например, строку в число или булево значение. Вот как это делается между boolean, string и number.

1. К числу (number)

Нужно, например, когда пользователь ввёл "10" в инпут, а ты хочешь посчитать: 10 + 5.

Используй: Number() или унарный +

Number("5")     → 5
Number("3.14")  → 3.14
Number("hello") → NaN (не число, ошибка)
Number(true)    → 1
Number(false)   → 0
Number("")      → 0

// Короткая запись:
+"42" → 42

Подходит для строк с числами. Если строка не похожа на число — будет NaN.

2. К строке (string)

Нужно, когда хочешь вывести число или булево значение как текст.

Используй: String() или добавить пустую строку: + ""

String(42)     → "42"
String(true)   → "true"
String(false)  → "false"
String(null)   → "null"
String(undefined) → "undefined"

// Или проще:
42 + ""        → "42"
true + ""      → "true"

Просто превращает что угодно в текст.

3. К булеву (boolean)

Нужно, чтобы проверить, "есть ли значение?" — например, в if.

Используй: Boolean() или двойное отрицание: !!

Boolean(1)     → true
Boolean(0)     → false
Boolean("hi")  → true   (непустая строка — true)
Boolean("")    → false
Boolean(null)  → false
Boolean(undefined) → false
Boolean([])    → true   (массив — это объект, даже пустой)
Boolean({})    → true

// Часто пишут короче:
!!"hi"         → true
!!""           → false

В JS только 6 вещей всегда становятся false:
false, 0, "", null, undefined, NaN
Всё остальное — true.

Простые правила:

В число → +str или Number(str)
В строку → value + "" или String(value)
В логическое → !!value или Boolean(value)

Живой пример:

// Строка в число
let age = +"25";        // 25 (число)

// Число в строку
let text = 100 + "";    // "100"

// Проверить, заполнено ли поле
if (!!userName) { ... } // true, если имя есть

kdcore

В JavaScript есть 7 основных типов данных (все они — примитивы, кроме одного). Вот краткое и понятное объяснение каждого:

Примитивные типы (6 шт):

string — строки
Текст в кавычках:
```
"Hello", 'world', `template ${expr}`
```
number — числа (целые и дробные)
В JavaScript нет отдельного типа для целых или дробных:
```
42, 3.14, -10, Infinity, NaN
```
boolean — логический тип
Только два значения:
```
true, false
```
undefined — значение не присвоено
Автоматически у переменных без значения:
```
let x;
console.log(x); // undefined
```
null — «ничего» (намеренно пустое значение)
```
let user = null; // явно указываем, что пусто
```
️ typeof null даёт "object" — это ошибка JS с древних времён.
symbol — уникальный идентификатор
Используется для уникальных ключей объектов:
```
const id = Symbol('id');
```

Объектный тип (1 шт):

object — для хранения коллекций и сложных данных
```
{ name: "Alex", age: 25 }
[1, 2, 3]
function() { }
new Date()
```
→ Включает обычные объекты, массивы, функции, даты и т.д.

Отличие от примитивов: объекты передаются по ссылке, а не по значению.

Примитивы vs Объекты:

Примитивы — неизменяемы (immutable), хранят одно значение.
Объекты — изменяемы (mutable), могут содержать много данных.

Как проверить тип?
Используй оператор typeof:

typeof "text"   // "string"
typeof 42       // "number"
typeof true     // "boolean"
typeof undefined // "undefined"
typeof null     // "object" 😱 (ошибка JS!)
typeof Symbol() // "symbol"
typeof {}       // "object"
typeof []       // "object"
typeof function(){} // "function"

️ typeof для массивов и null возвращает "object" — будь внимателен!

В JavaScript 7 типов:

Примитивы: string, number, boolean, undefined, null, symbol
И один не-примитив: object (включая массивы и функции)

Знание типов помогает избегать ошибок и правильно работать с данными.

kdcore

Два основных метода регулярного выражения в JavaScript — это test() и exec(). Оба используются для поиска совпадений, но возвращают разные данные.

test(regexp) — проверяет, есть ли совпадение

Что делает:
Проверяет, находит ли регулярное выражение совпадение в строке.
Возвращает true или false.

const regex = /hello/;
regex.test('hello world'); // true
regex.test('goodbye');     // false

Используется для условий и валидации.
Быстр и прост.

️ Важно: Если у регулярки флаг g и вызывается test() несколько раз, она запоминает позицию (lastIndex), и последующие вызовы идут с этой позиции — будьте осторожны!

exec(regexp) — ищет совпадение и возвращает детали

Что делает:
Ищет первое совпадение и возвращает массив с результатом (или null, если не найдено).

const regex = /(\d+)/;
const result = regex.exec('Year 2025');
console.log(result);
// ['2025', '2025', index: 5, input: 'Year 2025']

Возвращает:

result[0] — всё совпадение ("2025")
result[1] — первая захваченная группа ("2025")
index — позиция совпадения (5)
input — исходная строка

Полезно, когда нужно не просто проверить, а получить данные совпадения.

При флаге g, exec() можно вызывать несколько раз — каждый раз будет искать следующее совпадение (благодаря свойству lastIndex).

const regex = /\w+/g;
let match;
while (match = regex.exec('hi there world')) {
  console.log(match[0]); // 'hi', 'there', 'world'
}

Разница между test() и exec():

Метод	Возвращает	Что проверяет	Полезен для
`test()`	`true`/`false`	Есть ли совпадение	Проверок, валидации
`exec()`	Массив / `null`	Совпадение + детали	Извлечения данных

Итог:

Используй test() — чтобы проверить, подходит ли строка под шаблон.
Используй exec() — чтобы найти и получить совпадение (особенно с группами и при поиске всех совпадений в цикле).

kdcore

Метод matchAll() используется для поиска всех совпадений регулярного выражения в строке. Он возвращает специальный объект-итератор, который содержит информацию о каждом найденном совпадении, включая:

сам найденный текст,
его позицию в строке,
дополнительные группы (если они есть в регулярке).

Особенности:

Работает только с флагом g – иначе будет ошибка.
Возвращает итератор (не массив!), но его можно преобразовать в массив через Array.from() или [...result].
Каждое совпадение – это массив с подробной информацией (как в exec()).

Пример:

const str = 'JavaScript';
const regexp = /a/g; // ищем все буквы 'a' (с флагом g)
const matches = str.matchAll(regexp);

// Преобразуем итератор в массив и выводим
console.log([...matches]);

Вывод:

[
  ['a', index: 1, input: 'JavaScript', groups: undefined],
  ['a', index: 3, input: 'JavaScript', groups: undefined]
]

В строке JavaScript буква a встречается дважды:

Первая a на позиции 1 (индексация с 0: J=0, a=1, v=2, a=3, ...).
Вторая a на позиции 3.

Зачем это нужно?

Если нужно не просто найти совпадения, но и их позиции – matchAll() удобнее, чем match() (который без флага g дает только первое совпадение, а с флагом g – только текст без деталей).
Полезно при работе с группами в регулярках, например:

const text = 'Иван: 30, Пётр: 25';
const regexp = /(\w+): (\d+)/g;
const matches = [...text.matchAll(regexp)];

// matches[0] = ['Иван: 30', 'Иван', '30', ...]
// matches[1] = ['Пётр: 25', 'Пётр', '25', ...]

Регулярное выражение должно иметь флаг g, иначе будет ошибка TypeError.
Результат – итератор, поэтому для повторного использования лучше преобразовать его в массив.

Если нужно просто проверить наличие или получить первое совпадение – можно использовать match() или exec().

Коротко: matchAll() – это мощный способ найти все совпадения регулярки в строке с полной информацией о каждом.

kdcore

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

Вот как и где они применяются:

`match(regexp)`

Ищет все совпадения с регулярным выражением в строке.

'Hello123'.match(/\d+/); // ['123']

→ Возвращает массив совпадений или null.

`matchAll(regexp)`

Возвращает итератор всех совпадений (с группами), если стоит флаг g.

'JavaScript'.matchAll(/a/g); // итератор с позициями 'a'

→ Удобно для цикла for...of.

`split(regexp)`

Разделяет строку по шаблону (а не только по символу).

'a1b2c3'.split(/\d/); // ['a', 'b', 'c']

→ Регулярное выражение как разделитель.

`search(regexp)`

Ищет позицию первого совпадения с регулярным выражением.

'abc123'.search(/\d/); // 3 — индекс первой цифры

→ Возвращает индекс или -1, если не найдено.

`replace(regexp, replacement)`

Заменяет первое (или все, если с флагом g) совпадение.

'hello123'.replace(/\d+/g, 'X'); // 'helloX'

→ Может заменить на строку или результат функции.

`test(regexp)` — (метод регекса, но часто используется с строками)

Проверяет, есть ли совпадение. Возвращает true / false.

/\d/.test('abc123'); // true

→ Удобно для проверки форматов (например, email).

Зачем это нужно?
Регулярные выражения позволяют:

искать по сложным шаблонам (например, email, номер телефона),
обрабатывать текст гибко,
писать меньше кода для парсинга строк.

Регулярные выражения — мощные "шаблоны поиска", которые можно передавать в строковые методы, чтобы находить, разделять, заменять или проверять текст не по буквам, а по правилам.

kdcore

Динамические импорты (import() как функция) нужны, чтобы загружать модули по требованию, а не сразу при запуске приложения.

Зачем они на практике:

Оптимизация производительности
Загружай код только тогда, когда он нужен.
→ Страница грузится быстрее, потому что не тянет всё сразу.

Пример:
```
if (userClickedHelp) {
  const helpModule = await import('./help.js');
  helpModule.showHelp();
}
```
Ленивая загрузка (lazy loading)
Особенно полезно в больших приложениях (например, React, Vue, Angular).
→ Код отдельных страниц или компонентов загружается только при переходе на них.
Условный импорт
Загружать разные модули в зависимости от условий (браузер, язык, права пользователя и т.д.).

Пример:
```
let api;
if (isMobile) {
  api = await import('./api-mobile.js');
} else {
  api = await import('./api-desktop.js');
}
```
Работа с динамическими путями
Импортировать модуль с путём, который определяется во время выполнения.
```
const moduleName = getUserTheme() + '.js';
const theme = await import(`./themes/${moduleName}`);
```

️ Отличие от статического `import`:

import ... from '...' — статический, должен быть наверху файла, загружается сразу.
import(...) — динамический, можно вызвать где угодно и когда угодно (возвращает Promise).

Итог:
Динамические импорты нужны, чтобы делать приложения быстрее и легче, загружая код по мере необходимости.

kdcore

Регулярное выражение (регекс) — это шаблон для поиска и обработки строк. Оно состоит из двух частей:

Шаблон (pattern) — последовательность символов, описывающая, что искать.
Например: \d+ — ищет одну или более цифр.
Флаги (flags) — необязательные модификаторы, которые меняют поведение поиска.
Распространённые флаги:
- i — игнорирует регистр (a совпадает с A)
- g — ищет все совпадения (а не только первое)
- m — многострочный режим (влияет на ^ и $)

Способы записи:

1. Литерал (в слешах):

/dog/i        // шаблон: "dog", флаг: i (игнорировать регистр)
/\d+/g        // шаблон: одна или более цифр, флаг: g (все совпадения)

2. Через конструктор:

new RegExp('\\d+', 'g') // то же, что /\d+/g

Пример:

const text = "I love Dogs. DoGS are great!";
const regex = /dog/gi; // шаблон: dog, флаги: g (все) и i (регистронезависимо)
console.log(text.match(regex)); // ['Dogs', 'DoGS', 'dog']

Итог:
Регулярное выражение = шаблон + (опционально) флаги — мощный инструмент для работы со строками.

kdcore