
## Rest(ful) API

REST API — это архитектурный стиль взаимодействия между клиентом и сервером.  
Он использует стандартные HTTP-методы для работы с ресурсами:

- **GET** — получить данные (например, список пользователей).
- **POST** — создать новый ресурс.
- **PUT** — полностью заменить существующий ресурс новым.
- **PATCH** — частично обновить ресурс.
- **DELETE** — удалить ресурс.

### Разница между PUT и PATCH
Напр. хотим отредактировать User:
```json
{
  "id": 1,
  "name": "Alice",
  "email": "alice@example.com",
  "age": 25
}
```
Если редактировать через PUT - даже если нужно изменить только name, всё равно нужно отправить объект со всеми полями.
Если редактировать через PATCH - можно отправить объект содержащий только name.

## CDN

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

## DNS

DNS преобразует удобочитаемые доменные имена в IP-адреса.
Пример: openai.com → 104.18.12.123

## Безопасность

### CORS (Cross-Origin Resource Sharing) <div id="CORS" />

- это политика безопасности браузера, которая ограничивает запросы на другой домен.
- если сервер не разрешает домен клиента в заголовках, браузер заблокирует ответ.
- напр. с локалхоста при разработке фронта, ты отправляешь запрос и браузер заблокирует доступ к ответу, если бэк не добавил в хэдеры "Access-Control-Allow-Origin": http://localhost:3000
- (либо юзать reverse-proxy, это дев-сервер (Next/CRA/Vite), ты шлёшь на него запросы(на его локалхост), а он делает запрос на реальный урл и даёт браузеру ответ от лица локалхоста

### Preflight-запрос:
- Для небезопасных методов (например, POST с `Content-Type: application/json`) браузер сначала отправляет OPTIONS-запрос, чтобы проверить, разрешает ли сервер такой доступ.
- Preflight отправляется, если запрос не попадает под “simple requests”.
#### Simple request — это:
- метод: GET, POST, HEAD;
- Content-Type: application/x-www-form-urlencoded, multipart/form-data или text/plain;
- без кастомных заголовков (например, Authorization, X-My-Header).

### CSRF (XSRF) (Cross-Site Request Forgery) <div id="CSRF" />
Атака: злоумышленник заставляет браузер отправить запрос на доверенный сайт с твоими **cookie**.  
Пример:
- во вкладке 1 ты залогинен в `bank.com`
- во вкладке 2 открываешь `evil.com`
- там скрытая форма отправляет запрос на `bank.com`
- браузер сам прикладывает cookie  → сервер думает, что это сделал ты.

**Защита:**

1. **SameSite для cookie**
    - флаг `SameSite=Lax` или `Strict` говорит браузеру: *не отправляй cookie, если запрос пришёл с другого сайта*.
    - значит, при переходе с `evil.com` cookie `bank.com` не прикрепятся.

2. **CSRF-токены**
    - сервер генерирует случайный токен и вставляет его в форму или выдаёт в API.
    - клиент при каждом запросе должен его отправлять.
    - злоумышленник не знает токен → его запрос отклоняется.

3. **Проверка заголовков**
    - сервер смотрит `Origin` или `Referer`.
    - если запрос пришёл не с `bank.com`, он блокируется.


### XSS (Cross-Site Scripting) <div id="XSS" />
- внедрение вредоносных скриптов в сайт через инпуты, параметры урла
**Защита**
1. Экранирование HTML (React делает автоматически, если не выключить через prop `dangerouslySetInnerHTML`)
   - замена спецсимволов напр. `<` `>` в кодировку `&lt` `&gt`
2. HttpOnly cookie
   - Флаг HttpOnly делает cookie недоступными для JavaScript
   - Напр. (Express) 
   ```javascript
   app.post('/login', (req, res) => {
     // допустим, пользователь успешно авторизовался
     res.cookie('session', 'abc123', {
       httpOnly: true,   // ❗ JS на фронте не сможет прочитать
       secure: true,     // только через HTTPS
       sameSite: 'Lax',  // базовая защита от CSRF
       maxAge: 1000 * 60 * 60 // 1 час
     });
     res.send('Logged in');
   });
   ```
3. CSP (Content Security Policy) <div id="content-security-policy"/>
   - это HTTP-заголовок, который говорит браузеру:
     "какие скрипты, стили, картинки и другие ресурсы можно загружать и выполнять на этом сайте"
   - выставляется на File Static Server-е (напр. Nginx), в Next.js - в next.config.js


### HTTP(S)
- HTTP — это протокол, по которому браузер и сервер обмениваются данными.
- HTTPS — это тот же HTTP, но «поверх» него включается TLS-шифрование.

**Что это даёт:**
- Никто не может подглядеть, какие данные отправляются (например, пароль).
- Никто не может подменить ответы сервера незаметно.
- Браузер проверяет, что сайт настоящий (через сертификат).

### MITM - Атака «человек посередине» <div id="MITM"/>
Злоумышленник встраивается между браузером и сервером, читает или подменяет данные.
Часто встречается в открытых Wi-Fi или при HTTP (или при `ws://`).

**Защита**
1. Редирект с HTTP на HTTPS (настраивается в Nginx)
2. Для Websocket использование `wss://`
3. [CSP](#content-security-policy)
4. HSTS (HTTP Strict Transport Security)
- это еще один заголовок (наравне с CSP)
- тоже выставляется на File Static Server-е (напр. Nginx), в Next.js - в next.config.js

## После ввода URL в адресную строку

1. Браузер через DNS получает IP-адрес домена.
2. Если HTTPS → TLS-рукопожатие (договариваются о шифровании, проверяется сертификат).
3. Запрос к серверу → приходит HTML.
4. Загружаются CSS, JS, картинки.
5. Строятся DOM и CSSOM → layout → paint.
6. JS делает страницу интерактивной (гидратация).


Сеть

## Порождающие паттерны
### Одиночка
Следит за тем, чтобы в приложении существовал только один экземпляр объекта. Достаточно хранить общий экземпляр в области модуля и возвращать его через функцию.
```typescript
class Database {
  static #_instance: Database;
  
  private constructor() {
    // делаем конструктор приватным, чтобы запретить вызов через new 
  }
  
  //делаем логику в статическом методе, а не в конструкторе, чтобы не вводить в заблуждение,
  //что создание нового инстанса new Database() может возвращать старый объект
  static getInstance() {
    if (!Database.#_instance) {
      Database.#_instance = new Database();
    }
    return Database.#_instance
  }
}
```
Еще проще в случае с ES-модулями - просто экспортировать готовый инстанс из модуля.
В данном примере:
```typescript
export default Database.getInstance();
```

### Фабрика
Помогает создавать объекты, не раскрывая детали их устройства. Функция-фабрика сама решает, какой объект вернуть.
```ts
function createNotifier(type: "email" | "sms") {
  if (type === "email") {
    return {
      send: (message) => console.log(`Письмо: ${message}`),
    };
  }

  return {
    send: (message) => console.log(`SMS: ${message}`),
  };
}

const notifier = createNotifier("sms");
notifier.send("Order is ready");
```
## Структурные паттерны
### Декоратор
Добавляет объекту новое поведение, не изменяя его исходный код. Мы оборачиваем функцию и расширяем ее возможности.
```ts
function withLog<T extends (...args: unknown[]) => unknown>(fn: T): T {
  return ((...args: unknown[]) => {
    console.log("Вызов с аргументами:", args);
    const result = fn(...args);
    console.log("Результат:", result);
    return result;
  }) as T;
}

const multiply = (a: number, b: number) => a * b;
const multiplyWithLog = withLog(multiply);

multiplyWithLog(2, 3);
// Вызов с аргументами: [2, 3]
// Результат: 6
```
В React декоратор часто реализуют через HOC (Higher-Order Component), который принимает компонент и возвращает новый с добавленным поведением.
```tsx
type WithLoaderProps = { isLoading: boolean };

function withLoader<P>(Component: React.ComponentType<P>) {
  return function WithLoader(props: P & WithLoaderProps) {
    if (props.isLoading) {
      return <div>Загрузка...</div>;
    }

    const { isLoading, ...restProps } = props;
    return <Component {...(restProps as P)} />;
  };
}

function UsersList({ users }: { users: string[] }) {
  return (
    <ul>
      {users.map((user) => (
        <li key={user}>{user}</li>
      ))}
    </ul>
  );
}

const UsersListWithLoader = withLoader(UsersList);

// <UsersListWithLoader users={["Аня", "Петр"]} isLoading={false} />
```
## Поведенческие паттерны
### Наблюдатель
Описывает зависимость "один ко многим": когда источник события изменяется, все подписчики получают уведомление.
```ts
type Listener = () => void;

const listeners: Listener[] = [];

export function subscribe(listener: Listener) {
  listeners.push(listener);
}

export function notify() {
  listeners.forEach((listener) => listener());
}

subscribe(() => console.log("Пользователь получил уведомление"));
subscribe(() => console.log("Логгер записал событие"));

notify();
// Пользователь получил уведомление
// Логгер записал событие
```
### Стратегия
Определяет семейство алгоритмов, инкапсулирует каждый из них и позволяет взаимозаменять. Мы можем выбирать стратегию в зависимости от ситуации.
```ts
type PriceStrategy = (value: number) => string;

const short: PriceStrategy = (value) => `$${value}`;
const detailed: PriceStrategy = (value) => `${value.toFixed(2)} USD`;

function formatPrice(value: number, strategy: PriceStrategy) {
  return strategy(value);
}

const products = [199, 49.9, 12];
const strategy = detailed;

products.map((price) => console.log(formatPrice(price, strategy)));
// 199.00 USD
// 49.90 USD
// 12.00 USD
```


Паттерны проектирования


## Концепции

1. Абстракция
2. Инкапсуляция
3. Наследование
4. Полиморфизм

### Абстракция

Абстракция позволяет нам сосредоточиться на том, **что** делает объект, а не на том, **как** он это делает.

#### В TypeScript реализованы **абстрактные классы** ключевым словом `abstract`. <div id="abstract-class"/>

От абстрактного класса нельзя создать экземпляр.
Пример из Revuud: абстрактный класс — User, конкретные классы — Talent и Admin.

Цель — не дублировать код

[ссылка на пример с абстрактным классом](#abstract-class-example)

### Инкапсуляция

Это разделение интерфейсов на внутренний и внешний — приватные и публичные свойства/методы.

Цель — ограничить внешних пользователей от изменений внутреннего интерфейса, чтобы ничего не сломали внутри извне.

Есть конвенция называть приватные свойства начиная с `_`.
На уровне языка реализуется символом `#`:

```js
class Person {
    #_privateField: 'value'
    #_privateMethod () {}
}
new Person()._privateField// undefined
```

### Наследование

Наследование классов – это способ расширения одного класса другим классом.

Цель — не дублировать код и экономить память, расширять уже существующий функционал.

### Полиморфизм

Это способность вызывать один и тот же метод для разных объектов, и при этом каждый объект реагирует по-своему.
Чтобы это произошло, полиморфизм использует наследование.

### Пример, демонстрирующий все 4 концепции <div id="abstract-class-example"/>

```typescript
abstract class User {
  abstract firstName: string;
  abstract lastName: string;
  abstract sendInvite(): void; //! 1. принцип абстракции (нет реализации, только объявление)

  get fullName() {
    // неабстрактный метод с логикой
    return this.firstName + this.lastName; // в отличие от интерфейса здесь можно писать логику
  }
}

new User(); // Ошибка, нельзя создать экземпляр абстрактного класса

class Admin extends User {
  //! 3. принцип наследования (расширяем конкретный класс от абстрактного)
  firstName;
  lastName;

  constructor(firstName: string, lastName: string) {
    super();
    this.firstName = firstName;
    this.lastName = lastName;
  }

  get fullName() {
    //! 4. принцип полиморфизма (переопределяем геттер родителя, чтобы он работал по-другому)
    return this.firstName + " last name is NDA for admins";
  }
  sendInvite() {
    //! 4. принцип полиморфизма (реализуем абстрактный метод по-разному в 2 дочерних классах)
    const author = this.fullName;
    alert({ type: "admin", author }); //фиктивная функция отправки
  }
}

class Talent extends User {
  //! 3. принцип наследования (расширяем конкретный класс от абстрактного)
  firstName;
  lastName;

  #age: number; //2. инкапсуляция (приватное поле)

  constructor(firstName: string, lastName: string, age: number) {
    super();
    this.firstName = firstName;
    this.lastName = lastName;

    this.#age = age;
  }
  sendInvite() {
    //! 4. принцип полиморфизма (реализуем абстрактный метод по-разному в 2 дочерних классах
    const author = super.fullName; //! 3. наследование, вызываем геттер родительского класса
    alert({ type: "talent", author }); //фиктивная функция отправки
  }
}

const john = new Talent("John", "Smith", 30);
//! 2. инкапсуляция (приватное поле недоступно вне класса Talent)
john.#age; // SyntaxError
```


Объектно-ориентированное программирование и OOP в JavaScript


# Electron.js

## Процессы

Electron делится на 2 процесса: основной (main) и рендерер (renderer).

1. **Main** имеет доступ к Node API и модулям Electron.
2. **Renderer** — это браузерный процесс, который делится на:
   1. фронтенд-фреймворк;
   2. скрипт preload.ts.

![main-process-and-frontend-processes](electron-processes.png)


Electron.js


## Common

### Complex types of data

#### Map - ассоциативный массив / словарь

> Это объект, где ключом может помимо строки быть любой тип данных

Пример оптимизации Мапом

```js
// было
const getAssets = async () => [
  //pseudo-GET req
  { symbol: "APPL", price: 100 },
  { symbol: "GOOG", price: 50 },
  { symbol: "MSFT", price: 25 },
];
const resp = await getAssets();
// iterates every time in Biseness Logic Layer
resp.find((asset) => asset.symbol === "MSFT");
// стало
const transformAssetsArrayToMap = async () => {
  const respArray = await getAssets();
  const respMap = new Map();
  // iterates 1 time in Data Acess Layer
  respArray.forEach((asset) => {
    const { symbol, ...rest } = asset;
    respMap.set(symbol, { ...rest });
  });
  return respMap;
};
const resp = await transformAssetsArrayToMap();
// instant in BLL
resp.get("MSFT");
```

#### Set - массив, только с уникальными значениями

Можно отфильтровать дубликаты с массива
`const uniqArr = [...new Set(arr)];`

#### WeakMap - словарь со слабыми ссылками

Нужен для того, чтобы помочь **garbage collector** удалить неиспользуемые объекты
т.к. в Map они хранятся даже когда все ссылки в коде на них были перезаписаны

> Ключом могут быть только объекты.
> Не поддерживает методы, которыми можно взять все ключи сразу _(keys(), values(), entries()
> т.к. мы не знаем в какой момент происходит удаление объектов сборщиком мусора)_

Напр. Map

```js
let john = { name: "John" };

let map = new Map();
map.set(john, "...");

john = null; // overwrite the reference

// объект john сохранён внутри объекта `Map`
// и будет занимать место в памяти, хотя уже не используется в коде,
// и доступен только через map.keys()
```

Same code with WeakMap:

```js
let john = { name: "John" };

let weakMap = new WeakMap();
weakMap.set(john, "...");

john = null; // перезаписываем ссылку на объект

// объект john !будет удалён из памяти сборщиком!
```

[memoization example with WeakMap](#weakmap-cache)

#### WeakSet

Тоже самое, только Set-подобная структура

> тоже ключи только объекты и тоже удаляет из памяти
> неиспользуемые в иных местах объекты

### Hoisting - поднятие

При поднятии (hoisting) декларации `var` переменных поднимаются и инициализируются значением `undefined`, а объявления функций поднимаются вместе со своей реализацией

**do hoist**:

1. `function declaration(){}`
2. `var`

**don't hoist**:

1. `let functionExpression = () => {}`
2. `let functionExpression = function (){}`
3. `let/const`

It's correct code;

```js
a = 1;
var a; // compilator will hoist this line upper
```

### Boxing/Unboxing

Вызывая `.length` у строки, движок js **оборачивает** примитив `"str"` в `new String("str")`  
и у этого объекта вызывает поле `.length`,
после чего **удаляет** объект, чтобы мы не могли присвоить ему своих полей.

## Objects

### Object creating:

```javascript
//inherite user object as prototype
const admin = Object.create(user);
let admin = { __proto__: user };
let admin = new Object({ __proto__: user });
```

### Object copying:

#### Reference copying

```js
let admin = user;
({}) === {}; // false, objects are never equal, only references
```

#### Shallow copying

1. Object.assign

```js
let user = {
  name: "John",
  age: 30,
};
let anotherObject = { role: "admin" };

let shallowClone = Object.assign({}, user, anotherObject);
```

2. Spread operator

```js
let shallowClone = { ...user, ...anotherObject };
```

#### Deep copying

1. JSON.parse(JSON.stringify(originalObj))

```js
const originalObj = { a: 1, b: { c: 2 } };
const clone = JSON.parse(JSON.stringify(originalObj));
```

> - <div style="color:red;font-size:25px;">!!!</div> JSON format doesn't support methods, so you can't copy methods in such way.
> - It's also expensive in computational costs
>
> 2. Recursive copying implementation
> 3. `lodash.deepClone`
> 4. `window.structuredClone` (modern browsers only)
>
> - <div style="color:red;font-size:25px;">!!!</div> structuredClone can't copy methods

## Functions

### Замыкание closure

Когда функция запоминает своё лексическое окружение в скрытом свойстве `[[Environment]]`

Напр. дочерняя функция запомнит параметр родительской функции

<div id="closure"></div>

```js
const maxLengthCreator = (maxLength) => {
  return (value) => {
    return value.length > maxLength
      ? `Max length is ${maxLength} symbols`
      : undefined;
  };
};
const max10 = maxLengthCreator(10); //max10 функция замкнула значение maxLength == 10
max10("This is string more than 10 letters");
```

### Псевдомассив `arguments`

- даже если мы объявили функцию без аргументов, мы всё равно можем передать в неё параметры,
  они попадут в специальный псевдомассив(нет методов массива) и к ним можно будет обратиться по индексам –

- В `use strict` arguments ведет себя по другому, с пересваиванием параметров
- У стрелочных нету псевдомассива arguments

### Современная замена - …rest оператор

`function(first, second, …restArgs){}` – остальные аргументы сложаться в настоящий массив

![spread, rest, destructuring operators](3-dots-syntax.png)

## Asynchrony

### Event loop

#### Ответ на заучить:

1. Компилятор в колл стеке выполняет синхронный код
   - И регистрирует асинхронные задачи в одной из очередей
   - И попутно при необходимости выполняя web API (**!!! Напр.** 10 сек таймера или обработчик события будет висеть и его ждать)
2. Колл стек свободен - Далее выполняются асинхронные задачи
   - начиная с очереди микрозадач, выполняются ВСЕ **микрозадачи** в очереди
     - начиная с **самой старой**
   - ТУТ РЕРЕНДЕР
3. Колл стек и очередь микро свободна - Далее выполняется ОДНА самая старая макрозадача
   - после этого цикл повторяется

#### Theory:

1. **Call Stack** - Это синхронный код.

   - **стэк, стопка** - выполняются **сначала новые**

2. **Callback (Microtask) queue** - После освобождения стека в очереди выполняются микрозадачи

   - микрозадачи могут возвращать другие микрозадачи, создавая **очередь** микрозадач - chain of `.then` & `.catch`)
   - **очередь** - выполняются **сначала старые**
   - помимо промисов есть `queueMicrotask`(Web) & `process.nextTick`(Node)

3. **Macro(task) queue** - После освобождения стека и очереди микрозадач, event loop проверяет наличие макрозадач.
   Самая старая макрозадача помещается в стек, выполняется и затем выполняются **все** новые микрозадачи, добавленные в очередь. Далее выполняется следующая макрозадача и т.д.
   - Это Web APIs (fetch, setTimeout, слушатели событий).

![event-loop.png](event-loop.png)

#### Common cases:

Regular: `Sync code > Async code (micro - high prio) > Browser API code (macro - low prio)`

Macro in Micro (SetTimeout in Promise): `sync code > setTimeout > .then`

```javascript
const promise = new Promise((resolve, reject) => {
  console.log(1);
  setTimeout(() => {
    console.log("timerStart");
    resolve("success");
    console.log("timerEnd");
  }, 0);
  console.log(2);
});

promise.then((res) => {
  console.log(res);
});
```

Micro in Macro (Promise in SetTimeout): `sync code > micro > macro`

```javascript
const timer1 = setTimeout(() => {
  console.log("timer1");
  const promise1 = Promise.resolve().then(() => {
    console.log("promise1");
  });
}, 0);

const timer2 = setTimeout(() => {
  console.log("timer2");
}, 0);
```

#### Example:

<https://www.jsv9000.app>

```javascript
function logA() {
  console.log("A");
}
function logB() {
  console.log("B");
}
function logC() {
  console.log("C");
}
function logD() {
  console.log("D");
}
function logE() {
  console.log("E");
}

function timeoutWithPromise() {
  Promise.resolve().then(logE);
}

setTimeout(timeoutWithPromise, 0); // 5
logA(); // 1
setTimeout(logB, 5000); // 6
Promise.resolve().then(logC).then(logA); // 3 - 4
logD(); // 2
```

**Step 1.** **Evaluate Script**

<div style='background-color: yellow'>Synchronously execute the script as though it were a function body. Run until the Call Stack is empty.</div>

1. logA > console.log(A) // call stack
2. logB // task queue
3. logC // microtask queue
4. logD > console.log(D) // call stack

**Step 2. Run all Microtasks**

<div style='background-color: yellow'>Select the oldest Microtask from the Microtask Queue. Run it until the Call Stack is empty. Repeat until the Microtask Queue is empty.</div>

5. logC// from micro to call stack > > console.log(C) // call stack
6. logA // microtask queue (.then chain)
7. logA// from micro to call stack > > console.log(A) // call stack

**Step 3. Rerender**

<div style='background-color: yellow'>Rerender the UI (This step only applies to browsers, not NodeJS).</div>

**Step 4. Run a Task**

<div style='background-color: yellow'>Select the oldest Task from the Task Queue. Run it until the Call Stack is empty.</div>

8. timeoutWithPromise // call stack

**Step 2. Run all Microtasks**

9. log E // microtask queue
10. log E // from micro to call stack >> > console.log(E) // call stack
11. log F // microtask queue
    12 log F // from micro to call stack >> console.log(F) // call stack

**Step 3. Rerender**

**Step 4. Run a Task**

13. logB > console.log(B) // call stack

### Promise

**Создание** - конструктор new Promise с аргументом в виде cb, в которую передаются аргументами передаются функции resolve & reject.

```javascript
const myPromise = new Promise((resolve, reject) => {});
```

**Cостояние** - pending | fulfilled | rejected. Хранится в скрытом свойстве экземпляра `[[PromiseState]]`

**Подписка** - у экземпляра есть функции then, catch, finally для подписки на изменения состояния промиса

**Результат** - хранится в скрытом свойстве экземпляра `[[PromiseResult]]`. Передаётся в функции подписки:

`.then(data => { })`

`.catch(error => { })`

#### Статические методы:

**all**:

- возвращает другой promise, который зарезолвится когда ЗАРЕЗОЛВЯТСЯ ВСЕ промисы из его массива.
- если хотя бы один из [] rejected, то promise из all тоже rejected
- .then all сидит массив результатов всех промисов

**race**:

- отработает, когда первый promise из массива выполнится

**allSettled**:

- возвращает promise, который зарезолвится, когда все промисы из его массива уйдут из состояния pending (попадем в then, даже если некоторые зареджектятся)

#### Chains:

каждый then и catch возвращают новый промис. Catch как и then может вернуть fulfilled или rejected промис. 

`.then(data => Promise.reject() ).then().then()` - 2 и 3 промисы не будут испольнены

`.then(data => Promise.resolve() ).catch().then()` - catch не будет исполнен

`.then(data => Promise.reject() ).catch().then()` - все функции-подписчики будут исполнены

## Browser Javascript

### Terms

`removeEventListener("click", название функции)` -- нам нужно назвать функцию внутри, если мы хотим удалить

`event.target` - элемент, на котором событие возникло изначально

`event.currentTarget` - элемент, на котором обработчик события был назначен

**Фазы события: Погружение -- Цель - Всплытие**

### Всплытие (bubbling)

Когда кликаем на button внутри div, событие сработает сначала в button потом в div потом в body

Остановить можно `event.stopPropagation` в `addEventListener`

`event.stopImmediatePropagation` останавливает всплытие даже на соседние элементы (в одном родителе)

### Погружение (immersion)

```js
element.addEventListener(
  "click",
  (e) => {
    e.preventDefault();
  },
  { capture: true },
);
```

3-ий аргумент опциональный(либо просто true). Полезно, **если нужно выполнить событие сначала на родительском элементе**

### Делегирование событий(event delegation):

**Пример:**
допустим у нас 800к комментов и на каждый придется вешать свой обработчик события для лайка/дизлайка.

Вместо этого используется прием делегирования -
вешаем обработчик на родителя элементов и с помощью `if (event.target.tagName)` указываем где именно должен произойти клик, таким образом мы сэкономили кучу памяти.

## FP - Functional Programming

### КАРРИРОВАНИЕ (carrying)

[Example from closure](#closure):

```js
maxLengthCreator(10)("This is string from some input");
```

Это трансформация функций таким образом, чтобы они принимали аргументы не как `fun(a, b, c)`, а как `fun(a)(b)(c)`.

```js
const sum = (n) => (b) => b + n;
sum(1)(2); // 3
```

> sum is a HOF (High order function)
>
> similar conception exists in React - HOC (High order component)

## Popular tasks

### Мемоизация (кэширование)

```javascript
const add = (a, b) => a + b;

// HOF-мемоизатор
function memoize(func) {
  const cache = {};
  return function (...args) {
    // Формируем уникальный ключ для комбинации аргументов
    let keyForThisCall = JSON.stringify(args);
    if (cache[keyForThisCall]) {
      // Если результат уже в памяти
      return cache[keyForThisCall]; // возвращаем его
    } else {
      const result = func(args[0], args[1]); // Иначе считаем
      cache[keyForThisCall] = result; // и сохраняем в память
      return result;
    }
  };
}

const memoizedAdd = memoize(add);

console.log(memoizedAdd(2, 3)); // Складываем 2 и 3, результат 5
console.log(memoizedAdd(2, 3)); // Берем из памяти 2,3, результат 5
```

### Advanced, мемоизация с WeakMap/WeakSet <div id="weakmap-cache"/>

```js
const difficultCalculationsWithObject = (obj) => {
  return { ...obj };
};
// HOF-мемоизатор
function memoize(func) {
  const cache = new WeakMap();
  return function (...args) {
    // Уникальным ключом будет ссылка на объект переданный в аргументах
    const keyForThisCall = args[0];
    if (cache.has(keyForThisCall)) {
      const cachedResult = cache.get(keyForThisCall); // Если результат уже в памяти
      return cachedResult; // возвращаем его
    } else {
      let result = func(keyForThisCall); // Иначе считаем
      cache.set(keyForThisCall, result); // и сохраняем в память
      return result;
    }
  };
}

const memoizedFunc = memoize(difficultCalculationsWithObject);

let obj1 = { a: 1, b: 2 };

console.log(memoizedFunc(obj1)); // calculates 1st call
console.log(memoizedFunc(obj1)); // takes from cache 2nd
obj1 = {}; // overwrite the reference
// позже { a: 1, b: 2 } будет удалён из WeakMap cache и из памяти
```


JavaScript


## Type vs Interface

**Type** может быть примитивом, union или tuple (кортеж). Нельзя изменить после создания.

```typescript
// primitive
type Name = string;

// union
type PartialPoint = PartialPointX | PartialPointY;

// tuple
type Data = [number, string];
```

**Interface** описывает только объект, и **повторные объявления объединяются** ([declaration merging](#declaration-merging))

### Extension & Intersection

#### Intersection

```typescript
type Shape = { color: string };
type Circle = Shape & { role: string };
```

#### Extension

То же самое, только синтаксис ближе к ООП.

```typescript
interface Shape {
  color: string;
}
interface Circle extends Shape {
  radius: number;
}
```

### Implements

В `implements` можно вставить как type, так и interface.

```typescript
interface Point {
  x: number;
  y: number;
}
class SomePoint implements Point {
  x = 1;
  y = 2;
}

// same
type Point2 = {
  x: number;
  y: number;
};

class SomePoint2 implements Point2 {
  x = 1;
  y = 2;
}
```

### Declaration merging <div id="declaration-merging"/>

> Повторные объявления интерфейса объединяются.

В отличие от **type**, он не может быть изменён после создания.

```typescript
// Эти две декларации становятся:
// interface Point { x: number; y: number; }
interface Point {
  x: number;
}
interface Point {
  y: number;
}

const point: Point = { x: 1, y: 2 };
```

## Абстрактные классы

Это смесь interface и class: мы задаём абстрактные свойства и методы, которые должны быть реализованы
в классе-наследнике, как и в интерфейсе,

НО в этой конструкции также позволено писать общую для детей логику.
[link to OOP article](OOP#abstract-class)

## Generic type

Это динамическая <тип-переменная>, что-то вроде параметра функции,
которую можно использовать в декларации типов, повышая его реюзабельность.

```typescript
type ListResponse<T> = {
  count: number;
  next: string;
  previous: string;
  results: T[];
};
```

## Type Guards

1. Операторы `typeof` и `instanceof`:

```typescript
function fn(param: number | string | Date) {
  if (typeof param === "string") {
    param.slice();
  } else if (param instanceof Date) {
    param.getTime();
  }
}
```

2. Предикат `is`:
   Помогает TS лучше определять тип значения, которое проверяется функциями наподобие isString, isUser.

```typescript
const isAxiosError = (error: unknown | AxiosError): error is AxiosError => {
  return axios.isAxiosError(error);
};
```

3. Оператор `in`:
   проверяет, существует ли поле в объекте

```typescript
"house" in { name: "test", house: { parts: "roof" } }; // => true
"house" in { name: "test" }; // => false
```

## Utility Types

Это что-то вроде встроенных «функций» для манипулирования типами.
Например: Partial, Pick, Omit, ReturnType, ReadOnly<PropsType> и т.д.


TypeScript


# Базовые понятия

- **Аутентификация** отвечает на вопрос «кто это?» и подтверждает личность пользователя (пароль, токен, WebAuthn).
- **Авторизация** отвечает на вопрос «что разрешено?» — проверяет права уже известного пользователя.
- **Учёт (accounting/auditing)** фиксирует действия пользователя: когда зашёл, что сделал, какие данные изменил.

### Схема входа

1. Клиент отправляет доказательства личности (логин/пароль, OTP, подпись и т. п.).
2. Сервер проверяет их и выдаёт «доказательство входа» (сессия, access token).
3. Клиент прикладывает это доказательство к каждому запросу, пока оно не протухло/не отозвано.

# Ниже — основные способы хранить такое доказательство.

## Сессионная аутентификация

1. `/login` → сервер создаёт запись в хранилище (Redis, БД) с ID сессии и данными пользователя.
2. ← браузер получает cookie с `sessionId`.
3. Клиент отправляет куку на каждый запрос → сервер находит сессию и восстанавливает пользователя.

Плюсы:
- легко отзываться (удалить запись в хранилище) — пригодится при logout со всех устройств.
- можно хранить дополнительные данные (роль, timeouts, CSRF-токены).

Минусы:
- требуется отдельное хранилище (например, таблица в БД или Redis), за которым нужно отдельно следить.
- браузер сам прикладывает куки → уязвимость к [CSRF](/posts/network#CSRF) без доп. мер.

**Обязательные флаги cookie:** `HttpOnly`, `SameSite`, `Secure`. Подробности — в конспекте [Сеть](/posts/network).

## JWT (JSON Web Token)

JWT — компактный, URL-safe токен c тремя частями `header.payload.signature`, подписанный секретом/SSH-ключом. Подписанный payload содержит поля с информацией о сессии: `sub`, `exp`, `role`, `aud` и др.

### Как работает

1. `/api/login` → сервер проверяет пользователя и подписывает JWT c коротким TTL (15–60 мин).
2. Клиент сохраняет токен (обычно в `localStorage` или `HttpOnly` cookie).
3. Все запросы → отправлять токен в заголовке `Authorization: Bearer <jwt>`.
4. Сервер проверяет подпись и срок действия; при успехе восстанавливает контекст пользователя.

Плюсы:
- Stateless — не нужно централизованное хранилище (сервер не хранит сессию).
- Можно работать с несколькими сервисами: любой сервис с секретом проверит токен. (Напр. если есть несколько бэкендов и в случае JWT не нужно иметь коллекцию сессий в БД или отдельный бэкенд централизованный для авторизации)

Минусы:
- Отозвать токен заранее сложно → приходится хранить black list токенов или использовать короткий TTL.
- Размер токена растёт по мере добавления полей в payload → влияет на размер заголовков.
- Хранение в `localStorage` уязвимо к XSS — см. раздел [XSS](/posts/network/#XSS). Поэтому нужно хранить в cookie.

### Refresh tokens и ротация

- Access token делаем короткоживущим, а refresh token — долгоживущим и храним только в `HttpOnly` cookie.
- При `401` клиент обращается к `/refresh` → сервер проверяет refresh token, выдаёт новую пару и, по желанию, ревоукит старый.
- Важно хранить refresh tokens серверно (whitelist) и делать ротацию (меняем и access, и refresh при каждом обновлении).

## OAuth 2.0 и OpenID Connect

Используем, когда нужен вход через сторонний провайдер (Google, GitHub) или доступ к API от имени пользователя.

- **OAuth 2.0** — протокол делегирования доступа.
- **Authorization Code Flow** (с PKCE для SPA) — безопасный способ получить access token через редирект и одноразовый код.
- **Scopes** описывают, что можно делать: `read:user`, `repo`, `openid email`.
- **OpenID Connect** — надстройка над OAuth 2.0, которая даёт id_token (JWT) с данными пользователя. Используем для SSO (Single Sign-on - одна авторизация для разных сайтов, вроде YouTube и Google).

Важно валидировать `redirect_uri`, `state` и `nonce`, хранить client secret на сервере и регулярно вращать ключи.

# Авторизация и контроль доступа

### RBAC (role-based)

Наборы прав привязываем к ролям (`admin`, `editor`, `viewer`).
В БД в коллекции `users` есть поле `role`.
Наиболее простая реализация авторизации, но и наименее гибкая.

### ABAC (attribute-based)

Когда RBAC не хватает и приходится добавлять доп. условия к ролям, напр. ``if (user.role === 'admin' && user.id === comment.authorId)``
Тогда удобно их вынести в централизованную функцию-хелпер. 
```js
// policy.js
export function can(user, action, resource) {
  switch (action) {
    case "addComment":
      return user.role === 'admin';
    case "editComment":
      return user.role === "admin" && user.id === comment.authorId;
    default:
      return false;
  }
}
```

### PBAC / Policy-based

Правила описываем декларативно: напр. в JSON и используем движок (библиотеку напр. Casbin) для интерпретации этих правил на фронте и бэке.

`// policies/post.json`
```json
{
  "version": 1,
  "policies": [
    { "effect": "allow", "role": "editor", "action": "posts.edit", "resource": "post" },
    { "effect": "allow", "role": "author", "action": "posts.edit", "resource": "post", "condition": "resource.authorId == user.id" },
    { "effect": "deny", "role": "*", "action": "posts.delete", "resource": "post" }
  ]
}
```

<b>Политики можно менять без релиза — достаточно обновить файл или конфигурацию.</b>

### Scope-based

Классический подход для OAuth и API.
JWT-токен содержит перечень разрешений (scopes), определяющих, какие действия пользователь может выполнять.
Бэкенд использует эти скоупы, чтобы решать, имеет ли клиент право вызывать конкретный эндпоинт.
Фронтенд может декодировать токен и применять эти же разрешения для управления интерфейсом (например, скрывать недоступные кнопки или страницы).
```json
{
  "sub": "123",
  "exp": 1736342261,
  "scope": "users:read orders:write"
}
```
### Практика

- правила и роли храним в БД/конфигурации, кэшируем и инвалидируем при обновлении;
- frontend отдаём минимальный список разрешений (`['posts.edit']`), UI скрывает недоступные действия;
- backend всегда делает финальную проверку (нельзя доверять только фронту);
- в микросервисах выносим общую библиотеку или отдельный сервис авторизации, чтобы все сервисы проверяли права одинаково.

## Хранение секретов и валидация

- Пароли хешируем (bcrypt/argon2/scrypt), используем соль и параметризацию (work factor).
- При регистрации и смене пароля — rate limiting + капча/механизм задержки.
- Верифицируем email/телефон, чтобы уменьшить количество одноразовых аккаунтов.
- Логируйте попытки входа и храните аудит в неизменяемом хранилище.

## Многофакторная аутентификация (MFA)

Второй фактор — что-то, что у пользователя **есть** (телефон, ключ), **является** (биометрия) или **знает** (PIN).

- **TOTP** (Google Authenticator): сервер хранит секрет, выдаёт QR-код, проверки через `code = totp(secret, timestamp)`.
- **FIDO2/WebAuthn**: криптография с ключом, работает без паролей (passkeys). Часто реализуют через `navigator.credentials`.
- **Backup codes** — одноразовая матрица для восстановления.

На фронте — обязательное UX: предупреждение о невозможности входа без второго фактора и маршруты для восстановления.

## Типовые угрозы и защита

- **CSRF** — защищаемся `SameSite` + CSRF-токены, см. подробности в конспекте [Сеть](/posts/network/#CSRF).
- **XSS** — токены в памяти или `HttpOnly` cookie, проверяем инпуты, см. раздел [XSS](/posts/network/#XSS).
- **MITM и перехват трафика** — используем HTTPS/HSTS и защищённые каналы, подробнее в [Сеть](/posts/network#MITM).
- **Brute-force** <i>(атака, когда спамят логин/пароль пытаясь подобрать)</i> — rate limiting, блокировка IP, reCAPTCHA.
- **Credential stuffing** — мониторим утечки, внедряем защиту на основе аномалий (невозможные путешествия, новые устройства).
- **Session fixation** — регенерация идентификаторов сессии напр. после смены прав (роли).

Если приложение SPA:
- избегаем хранения access token в `localStorage` → лучше `HttpOnly` cookie + `SameSite=strict`.
- при необходимости работать с небезопасными запросами — используем `fetch` с `credentials: 'include'` и настройками CORS (см. [CORS](/posts/network#CORS)).


Аутентификация


# React

## React и чистый JavaScript:

- Код на React более читаем (JSX = JS + HTML в одном файле)
- Компоненты
- JS императивный (буквально даёшь пошаговые инструкции)
- React декларативный (описываешь, что именно хочешь получить)

```javascript
// Императивный подход
const element = document.createElement("p");
element.textContent = "example";
element.className = "styles";
element.addEventListener("click", function () {});
// Декларативный
<p className="styles" onClick={function () {}}>
  example
</p>;
```

## Виртуальный DOM

- Виртуальный DOM представляет собой упрощённые объекты JavaScript по сравнению с настоящим DOM.

## Сверка (Reconciliation)

- Это процесс сравнения старой и новой версий (снимков) виртуального DOM после изменения данных (например, массива, на основе которого отображается список).
- На основе этой сверки React вносит точечные изменения в реальный DOM.
- В итоге пользователь видит обновление только изменённого элемента списка, а не полную перерисовку.

## Базовые хуки

### useState

- Локальное состояние
- Сравнивает предыдущие значения с новыми и при необходимости вызывает повторный рендер тех частей UI, которые от него зависят (в отличие от обычной переменной, которую мы вывели бы в JSX и изменили в обработчике события)
- правильное изменение состояния `setState(prev => prev + 1)`
- `useState(() => compute())` — можно передать функцию в качестве начального значения, чтобы вычислить его один раз, а не при каждом рендере

### useRef

- Можно использовать как useState, но **изменение не вызывает повторный рендер**
- Также может хранить ссылку на DOM-элемент

### useContext

- Нужен для избежания **props drilling**, когда приходится пробрасывать состояние через пропсы каждого уровня, даже там, где оно не нужно
- Подходит для небольшого глобального состояния; для сложных сценариев используют менеджеры состояния (Redux, Zustand, React Query и т.д.)


### useCallback <div id="useCallback"></div>

1. Используется вместе с [React.memo](#React.memo) для функций, передаваемых в дочерний компонент, чтобы между рендерами родителя сохранялась та же ссылка.

### useMemo <div id="useMemo"></div>

Сценарии использования:

1. Аналогично useCallback, в дополнение к [React.memo](#React.memo), но для объектов, массивов и т.д.
2. Когда одно из состояний сложно вычисляется, а мы изменяем другое состояние, при ререндере сложное состояние пересчитывается снова.

```javascript
function formatData() {
  return data.map((item) => {
    // сложные вычисления (форматирование, сортировка, фильтрация)
  });
}
const formattedData = useMemo(formatData, [data]);
```

## Оптимизация

### Атрибут `key`

- Нужен для оптимизации обновления списка элементов, созданного с помощью метода `map`.
- Если мы добавляем новый элемент в начало или середину массива,
  React с `key` сможет корректно сопоставить существующие элементы и обновить **только изменённые**,
  избегая полной перерисовки всех элементов.
- Не рекомендуется использовать индекс массива, если список динамичный (удаление элемента из середины массива, будет рассмотрено Реактом так, будто удалился последний элемент массив, а все остальные элементы после реально удаленного изменились)

### React.lazy

- Нужен, когда не хотим, чтобы компонент попадал в начальный бандл (собранный файл из всех файлов проекта).
- Начальная загрузка будет быстрее (бандл меньше), но пользователь будет ждать, когда компонент подгрузится.
- Такой компонент следует оборачивать в `React.Suspense` и указывать загрузчик в `fallback` (бандл делится на чанки).

### Profiler

- Компонент для измерения времени рендеринга
- Оборачиваем часть дерева в `<Profiler id="name" onRender={callback}>`
- Подробный анализ доступен во вкладке **Profiler** в React DevTools

### Оптимизация повторных рендеров дочерних компонентов

- Без PureComponent / shouldComponentUpdate / React.memo **компоненты перерисовываются каждый раз при ререндере родителя независимо от изменения пропсов.**

```javascript
// UserName будет перерисовываться каждый раз при клике на кнопку
<>
  <button onClick={() => setState((prev) => prev + 1)}>Add</button>
  <UserName name="John Doe" />
</>
```

#### PureComponent

- При наследовании от `PureComponent` сравниваются новые и старые props и state, предотвращая ререндер, если они одинаковые.

#### shouldComponentUpdate(nextProps, nextState)

- Делает то же, но в этом методе жизненного цикла можно реализовать **пользовательскую логику сравнения** props и state.

#### HOC React.memo

- Делает то же для функциональных компонентов и только для props.
- Предотвращает ререндер, когда props не изменились.

```javascript
// не будет перерисовываться при рендере родителя, только при изменении props.name
const UserName = React.memo((props) => {
  return <div>{props.name}</div>;
});
```

- <div id="React.memo" style="color:red;font-size:25px;">!!!</div> React.memo / PureComponent делают **только поверхностную проверку** (примитивы и ссылки).
- Когда в пропс передан не примитивный тип, дополнительно к React.memo
  данные нужно обернуть в [useMemo](#useMemo) / [useCallback](#useCallback).
- Использование этих хуков сохраняет ссылки на функции и объекты между рендерами, предотвращая лишние перерисовки.

```javascript
const user = useMemo(() => ({ name: "John Doe" }), []);
const handleClick = useCallback(() => setState((prev) => prev + 1), []);
return (
  <>
    <UserName user={user} />
    <button onClick={handleClick}>Add</button>
  </>
);
```

## Продвинутые хуки

### useLayoutEffect

- Применяется, когда нужно напрямую изменить стили в DOM-дереве (`ref.current.style.border = "1px solid black"`)
- и хотим, чтобы они применились **до отрисовки — синхронно**, а не после рендера, как в обычном useEffect.

### useImperativeHandle

- Нужен, когда из родительского компонента, например, нужно очистить поля, привязанные к локальному состоянию дочернего.
- Через `forwardRef` в дочернем компоненте раскрываются методы, которые доступны только внутри него, а в родительском их можно вызвать через ссылку.

### useTransition

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

```javascript
const [input, setInput] = useState("");
const [list, setList] = useState([]);
const [isPending, startTransition] = useTransition();

function handleChange(e) {
  setInput(e.target.value); // устанавливаем приоритетное состояние
  startTransition(() => {
    const filteredValue = data.filter((item) => item); // тяжёлые вычисления фильтрации
    setList(filteredValue); // состояние с меньшим приоритетом внутри startTransition
  });
}
```

## Чего нет в React из коробки

- Маршрутизация (React Router, Next.js)
- Глобальное состояние (Redux, MobX, Zustand)
- Data fetching и кеширование (fetch/axios, React Query, SWR)
- Управление формами (React Hook Form, Formik)
- i18n и локализация (react-i18next)

## Техники в React

### Порталы
- Позволяют рендерить дочерний компонент вне иерархии родителя в DOM.
- Используется, например, для модальных окон, тултипов и всплывающих меню.
- Работает через ReactDOM.createPortal(children, container).
```javascript
const portalTargetElement = document.getElementById("portal-root")
return ReactDOM.createPortal(
    <div className="modal">Hello!</div>, portalTargetElement
);
```

### Error Boundary
- Реализуются только на классовых компонентах (componentDidCatch и getDerivedStateFromError).

### Render props
- Используются, когда у нас есть общий компонент (например, TransferList), и мы хотим передать в него кастомный UI.
- Если children уже занят или не подходит, можно передать функцию через проп, например:
```typescript jsx
<TransferList
  renderLabel={(member) => <User {...member} />}
/>
```
### Race condition useEffect
- При работе с асинхронными эффектами (например, fetch) возможна ситуация, когда быстрый второй запрос "перебивает" первый. Это и есть race condition.
- Решение — использовать AbortController для отмены устаревших запросов:
```typescript jsx
function Search() {
  const [query, setQuery] = useState("");
  const [data, setData] = useState(null);

  useEffect(() => {
    const controller = new AbortController();

    (async () => {
      try {
        const res = await fetch(`/api/search?q=${query}`, {
          signal: controller.signal,
        });
        setData(await res.json());
      } catch (e) {
        if (e.name !== "AbortError") console.error(e);
      }
    })();

    return () => controller.abort();
  }, [query]);

  // ...
}
```

# Важные библиотеки, связанные с React

## React-router-dom V6
- Основные компоненты и хуки: <BrowserRouter> <Routes> и <Route> useNavigate, useParams, useLocation
- Поддержка динамических маршрутов (/user/:id).
- В версиях 6.4+ роутер поддерживает загрузку данных через `loader` и отправку через `action`

## Redux

- Redux хранит состояние объектов в едином store
- Чтобы изменить состояние, нужно отправить action; action попадает в reducer, reducer описывает, как изменится state
- Изменения происходят только с помощью **чистой** функции reducer — создаются копии и подменяются
- ACTION — простой объект { type, payload }
- Методы `dispatch(action)`, `getState()`, `subscribe(listener)` принадлежат store (`store.dispatch`)
- mstp выбирает нужную для компонента часть state и отслеживает изменения в выбранных свойствах
- FLOW — dispatch(action) -> reducer(current state, action) -> возвращается новый экземпляр state

## Redux-toolkit

- Не используем ActionCreators
- Используем `ThunkCreator.fulfilled/rejected` для успешных/неуспешных случаев санок
- Настраиваем санки не на диспатч нужного AC, а на возврат данных/rejectedWithValue(error)

## Redux-thunk

- Middleware для Redux, позволяющий диспатчить асинхронные функции (thunks)
- Thunk это частный случай HOF (отложенное вычисление)
- Диспатч может принимать не только объект action, но и функцию (dispatch, getState) => {}.
- Через это можно делать асинхронные запросы (fetch/axios), а результат уже диспатчить как обычный action.

## React-query

- Позволяет кэшировать запросы на уровне клиента.
- Автоматически повторяет запросы при ошибке или восстановлении сети.
- Снимает необходимость вручную писать loading/error/success стейты.

## MobX

- Менеджер состояния на основе `observable` значений
- Компоненты автоматически реагируют на изменения; меньше шаблонного кода по сравнению с Redux
- ООП стиль (observable, классы для сторов, мутабельный стейт)


React.js


## Ключевые особенности Next.js:

### 1. **Предварительный рендеринг страниц на стороне сервера:**

- Эта возможность устраняет состояние **первой загрузки**, рендеря страницы на стороне сервера.
  Компоненты React получают данные из API только после того, как были отрендерены, что предотвращает появление мигающих загрузчиков.
- Предварительный рендеринг улучшает SEO, поскольку поисковые боты видят содержимое страницы.
  Поскольку React строит разметку внутри `<div id="root"/>`, боты не могут прочитать HTML. Поэтому если у вас есть публичные страницы с большим количеством контента, которые нужно находить через поисковики, Next.js незаменим.

### 2. **Маршрутизация на основе файлов (#File-based Routing):**

- В отличие от React, который не имеет встроенного решения для роутинга, Next.js предлагает простую концепцию, напоминающую базовую разработку сайтов на чистом HTML.
- В этом подходе каждый файл `.html` представляет страницу, а имя файла служит её путём.
- Next.js поддерживает вложенные, catch-all и динамические маршруты.
- **К слову:** Роутинг — это изменение содержимого экрана в зависимости от URL без отправки запроса на сервер, что предотвращает стандартное обновление страницы при смене адреса (например, при `window.location.href = "url"`).

### 3. **Full Stack возможности:**

- Next.js позволяет легко добавлять серверный код в проект через специальные функции предварительного рендеринга (например, static/serverSide Props).
- Также можно создавать собственные API с адресами эндпоинтов на основе файлов, где по необходимости можно писать бэкенд-код.
- В результате нет необходимости собирать отдельный проект REST API.


All Posts