Лекция 9. Асинхронный JavaScript и Web API

Веб-программирование

Лекция 9 Асинхронный
JavaScript

Веб-программирование · лекция 9 из 16

В прошлый раз

🏷TypeScriptтипы проверяются до запуска и исчезают после
⚡Viteнастоящий проект: src/ → dist/
📋Список делtype Task, компоненты в .tsx

Проект настоящий. А данные — нет.

Где живут задачи

const tasks: Task[] = [
  { id: 1, text: 'Прочитать про Event Loop', done: true },
  { id: 2, text: 'Переписать загрузку на async/await', done: false },
];

Массив в коде. Добавили задачу, обновили страницу — её нет. Открыли список с телефона — там свой.

Данные должны жить на сервере. А сервер отвечает не сразу.

Сколько ждать ответа

откуда запроспорядок задержки
сервер на своём компьютереоколо 1 мс
хороший Wi-Fi, сервер в том же городедесятки миллисекунд
мобильная сетьот 50 до 200 мс
метро, лифт, перегруженный серверсекунды — или никогда

За 100 мс процессор выполнит сотни миллионов операций. Стоять и ждать — расточительно.

Сегодня за 90 минут

Каждую тему — на реальной задаче: чистый JS, библиотека, React.

список дел ← сервер

Список дел переезжает на сервер

⏳1. Промисданные приходят не сразу
🔁2. awaitи try / catch
🌐3. fetchнастоящий HTTP-запрос
🛡4. zodпроверка ответа
🚦5. Состояниязагрузка, ошибка, список

Плашка в правом нижнем углу покажет, на каком шаге мы сейчас.

список дел ← сервер

Часть 1 · 24 минуты Как JavaScript ждёт

Один поток, очереди и Event Loop

Задача: кнопка «Загрузить»

C#, консольное приложение

var tasks = client.GetTasks();
// поток стоит и ждёт ответа
Show(tasks);

Если бы так было в браузере

const tasks = getTasksSync();
// страница стоит и ждёт ответа
show(tasks);

В консоли это нормально. В браузере — нет: пока ждём, страница не прокручивается, кнопки не нажимаются, анимации стоят.

Проверим прямо сейчас

0,0 с

Часы и точку двигает JavaScript — 60 раз в секунду.

Первая кнопка занимает поток целиком: замрут и часы, и слайды. Вторая делает ту же работу кусками по 15 мс, и между кусками браузер успевает рисовать.

Поток один И ваш код, и отрисовка, и клики — по очереди

Ждать потоком нельзя

Java, C#, C++

Ждёт поток. Пока он стоит, работают другие. Цена — синхронизация: lock, synchronized, mutex.

JavaScript в браузере

Поток один, и занять его ожиданием — значит заморозить страницу. Зато блокировок нет вообще.

Значит, ждать должен кто-то другой.

Ждёт браузер

JS«сходи за задачами,
потом позови вот эту функцию»
→
браузерсеть, таймеры,
клики — в своих потоках
→
JSфункцию вызвали,
когда ответ пришёл
Колбэк (callback) — функция, которую вы отдаёте, чтобы её вызвали потом: по клику, по таймеру, по приходу ответа.

Колбэки вы уже писали

button.addEventListener('click', () => {
  addTask(input.value);
});

Лекция 6. Функцию вызывает не ваш код, а браузер — когда кликнут. Регистрация обработчика занимает микросекунды, и код идёт дальше.

Колбэк по таймеру: реальные задачи

// подсказка «Сохранено» исчезает через 2 секунды
showToast('Сохранено');
setTimeout(() => hideToast(), 2000);

// «Отменить отправку» в почте: письмо уходит через 5 секунд
const timer = setTimeout(() => sendMail(draft), 5000);
undoButton.onclick = () => clearTimeout(timer);

setTimeout не ждёт: ставит таймер и сразу возвращает его номер.

Event Loop Цикл, который раздаёт потоку работу

Из чего он состоит

Стек вызововкод, который выполняется прямо сейчас. Пока он не пуст — всё остальное ждёт
Браузер (Web API)таймеры, сеть, события: ждут вне JS
↻ Event Loop
берёт работу,
когда стек пуст
Микрозадачиколбэки промисов, продолжения после await
Задачиколбэки таймеров, клики, ответы сети

Правило

  1. Доделать текущий код до конца — стек пуст
  2. Выполнить все микрозадачи — даже те, что добавились по ходу
  3. Взять одну задачу из очереди
  4. Если пора — перерисовать страницу
  5. Повторить

Ничего не прерывает код посередине. Колбэк начнётся, только когда стек пуст.

Что выведется раньше?

setTimeout(() => console.log('таймер'), 0);
console.log('следующая строка');

Сначала «следующая строка»

setTimeout(…, 0) — не «сейчас», а «как только стек опустеет». Колбэк ждёт в очереди задач, пока не доделается текущий код.

Таймер обещает «не раньше чем через N мс», а не «ровно через». Если поток занят, колбэк подождёт.

Две очереди

очередьчто туда попадаеткогда выполняется
Микрозадачиthen, catch, finally, продолжение после await, queueMicrotaskсразу после текущего кода — все
ЗадачиsetTimeout, setInterval, клики, клавиши, ответы сетипо одной, между ними — микрозадачи и отрисовка

Промисы — «срочное»: они обгоняют любой таймер, даже на 0 мс.

Event Loop не делает JS многопоточным

Пока выполняется долгий код, очередь стоит. Клик пользователя ждёт, отрисовка ждёт. Ровно это и было с кнопкой «цикл на 3 секунды».

Посмотрим по шагам, что происходит с кликом.

Что делать с тяжёлыми вычислениями

✂️Дробитькусками по несколько миллисекунд через setTimeout — как вторая кнопка
👷Web Workerотдельный поток со своим JS, без доступа к DOM. Общение — сообщениями
🖥Сервертяжёлое — туда, где есть ядра и время

Для загрузки данных ничего из этого не нужно: ждёт браузер, а не JS.

Реальная задача на колбэках

Найти пользователя → его последний заказ → статус доставки. Каждый шаг — запрос к серверу, каждый может упасть.

getUser(id, (err, user) => {
  if (err) return showError(err);
  getOrders(user.id, (err, orders) => {
    if (err) return showError(err);
    getDelivery(orders[0].id, (err, delivery) => {
      if (err) return showError(err);
      render(user, orders, delivery);
    });
  });
});
🥋хадукен

Почему это называют адом колбэков

Ошибки на каждом уровнезабыли одну проверку — ошибка потерялась
Код уезжает вправокаждый следующий шаг — ещё один уровень вложенности
Не распараллелитькак запустить два запроса и дождаться обоих?
Нет результатафункция ничего не возвращает — только зовёт колбэк

Нужен объект, который можно вернуть: «результат будет потом». Это часть 2.

Игра: что выведется первым?

Двенадцать фрагментов. Кликните строки консоли в правильном порядке — после ответа визуализатор покажет, почему так.

Сейчас — первые раунды. Остальные, с await, — после части 2. Целиком игра — дома: прогресс сохраняется.

Часть 2 · 26 минут Promise и async/await

Как вернуть результат, которого ещё нет

Promise — объект
«результат будет потом» Его можно вернуть, сохранить, передать дальше

Три состояния

⏳pendingожидание: запрос ещё идёт
✅fulfilledвыполнен: есть значение
❌rejectedотклонён: есть ошибка

Состояние меняется один раз: выполненный промис не станет отклонённым, и наоборот.

Промис — это обещание, а не гарантия: его могут и отклонить.

Это вы уже видели

языктип «результат будет потом»
JavaScript / TypeScriptPromise<Task[]>
C#Task<List<TodoTask>>
JavaCompletableFuture<List<Task>>
C++std::future<std::vector<Task>>

Разница одна: в JS нельзя «заблокироваться» и ждать — ни .Result, ни .get(). Только подписаться.

Та же задача — цепочкой

getUser(id)
  .then(user => getOrders(user.id))
  .then(orders => getDelivery(orders[0].id))
  .then(delivery => render(delivery))
  .catch(err => showError(err));

Плоско вместо пирамиды. then возвращает новый промис, поэтому цепочка продолжается. Одна обработка ошибок на все шаги: упадёт любой — сработает catch.

finally — в любом случае

showSpinner();
getTasks()
  .then(tasks => render(tasks))
  .catch(err => showError(err))
  .finally(() => hideSpinner());

Спиннер нужно убрать и при успехе, и при ошибке. Забыть об этом — классический баг «вечной загрузки».

Создать промис самому — редко

// пауза: пригодится для повторов и таймаутов
const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

// старое API на колбэках → промис
function loadImage(src) {
  return new Promise((resolve, reject) => {
    const img = new Image();
    img.onload = () => resolve(img);
    img.onerror = () => reject(new Error('Не загрузилась: ' + src));
    img.src = src;
  });
}

Обычно промисы возвращают готовые функции: fetch, res.json(), библиотеки.

Шаг 1: задачи приходят не сразу

function getTasks(): Promise<Task[]> {
  // пока сервера нет — изображаем задержку сети
  return sleep(500).then(() => [
    { id: 1, text: 'Прочитать про Event Loop', done: true },
    { id: 2, text: 'Переписать загрузку', done: false },
  ]);
}

Тип говорит честно: не Task[], а Promise<Task[]>. Компилятор не даст обратиться к .length, пока не дождались.

список дел ← сервер

Что выведет консоль?

const tasks = getTasks();
console.log(tasks);

Promise {<pending>}

Не массив: задачи ещё в пути. В переменной — обещание, и прочитать из него значение синхронно нельзя никак.

Значение достают через then — или через await.

async / await Асинхронный код, который читается сверху вниз

Та же задача — с await

async function showDelivery(id) {
  try {
    const user = await getUser(id);
    const orders = await getOrders(user.id);
    const delivery = await getDelivery(orders[0].id);
    render(delivery);
  } catch (err) {
    showError(err);
  }
}

Похоже на синхронный код, но поток не стоит. Ошибки — обычным try / catch.

Два правила

📦async всегда возвращает промисreturn 5 внутри — снаружи Promise<number>. throw внутри — отклонённый промис
⏸await приостанавливает функцию, а не потокостаток функции становится микрозадачей. Страница живёт дальше
2012

Идея пришла из C#

async / await появились в C# 5 в 2012 году. В JavaScript — в стандарте ES2017, через пять лет, почти без изменений.

Отсюда и сходство: async Task<T> в C# и async (): Promise<T> в TypeScript работают одинаково.

Ошибки

async function load() {
  throw new Error('сеть');
}

load();                 // Uncaught (in promise) Error: сеть
await load();           // ошибка прилетит сюда — оберните в try
load().catch(showError); // или так

Отклонённый промис, у которого никто не ловит ошибку, — это Uncaught (in promise) в консоли и молчание для пользователя.

Шаг 2: загрузка с try / catch / finally

async function loadTasks() {
  showSpinner();
  try {
    const tasks = await getTasks();
    renderTasks(tasks);
  } catch (err) {
    showError('Не удалось загрузить задачи');
  } finally {
    hideSpinner();
  }
}

Скелет любой загрузки. Дальше меняется только то, что внутри try.

список дел ← сервер

Страница профиля

async function loadProfile() {
  const user = await getUser();     // 300 мс
  const orders = await getOrders(); // 300 мс
  const notes = await getNotes();   // 300 мс
  render(user, orders, notes);
}

Три независимых запроса, каждый по 300 мс. Сколько будет ждать страница?

900 мс

Каждый await ждёт, пока закончится предыдущий. Второй запрос даже не начинается, пока не пришёл первый.
getUser getOrders getNotes

Запустить все сразу, дождаться всех

const [user, orders, notes] = await Promise.all([
  getUser(),
  getOrders(),
  getNotes(),
]);
getUser getOrders getNotes 300 мс — по самому медленному, а не сумма

Независимые запросы

🙅
три await подряд — 900 мс
👉
Promise.all — 300 мс

Четыре комбинатора

комбинаторчего ждётреальная задача
Promise.allвсех; падает на первой ошибкепрофиль из трёх частей
Promise.allSettledвсех; не падает никогдадашборд: упавший виджет не ломает остальные
Promise.raceпервого закончившеготаймаут: запрос против таймера
Promise.anyпервого успешногофайл с трёх зеркал

Таймаут через race

const timeout = (ms) => sleep(ms).then(() => {
  throw new Error('Сервер не ответил за ' + ms + ' мс');
});

const tasks = await Promise.race([getTasks(), timeout(5000)]);

Кто первый — тот и результат. Но запрос при этом не отменяется: промис нельзя остановить снаружи.

Для fetch есть готовое и честное решение — AbortSignal.timeout(5000). В части 3.

Игра: all, allSettled, race, any

Три промиса — когда каждый закончится и чем. Что вернёт комбинатор и через сколько?

Ответ считается настоящими промисами в браузере. После ответа рисуется таймлайн.

Три ловушки async

tasks.forEach(async t => await save(t));   // forEach не ждёт
console.log('Всё сохранено');              // — врёт

const res = fetch('/api/tasks');           // забыли await:
res.json();                                // у промиса нет json

button.onclick = async () => {             // ошибку здесь
  await save();                            // никто не поймает
};

Все три — и ещё семь — в игре «Найди баг» в конце части 3.

Вернёмся к игре

Теперь — раунды с async и await. Подсказка: await превращает остаток функции в микрозадачу.

Часть 3 · 30 минут fetch и HTTP API

Список дел начинает жить на сервере

HTTP за минуту

Запрос

POST /api/tasks HTTP/1.1
Host: todo.example.ru
Content-Type: application/json

{"text": "Купить молоко"}

Ответ

HTTP/1.1 201 Created
Content-Type: application/json

{"id": 4, "text": "Купить молоко",
 "done": false}

Лекция 1: метод, адрес, заголовки, тело. В ответе — статус, заголовки, тело.

JSON — не объект JS

const task = { id: 1, due: new Date(), save() {}, note: undefined };

const text = JSON.stringify(task);
// '{"id":1,"due":"2026-11-06T09:00:00.000Z"}'

const back = JSON.parse(text);
back.due.getDay();   // TypeError: дата стала строкой

Ключи в двойных кавычках, функций и undefined нет, даты — строки. По сети ходит текст, а не объекты.

HTTP API для списка дел

запросчто делаетответ
GET /api/tasksвсе задачи200 и массив
POST /api/tasksсоздать задачу201 и задача с id
PATCH /api/tasks/42изменить поля задачи 42200 и задача
DELETE /api/tasks/42удалить задачу 42204, пустое тело

Такое API пишут на ASP.NET, Spring или Express. Сегодня мы по другую сторону.

fetch HTTP-запрос из браузера одной функцией

Загрузить задачи

const res = await fetch('/api/tasks');
const tasks = await res.json();

Почему два await? Сначала приходят статус и заголовки — это res. Тело может быть большим и идёт следом — res.json() ждёт его и разбирает JSON.

Задачи 42 на сервере нет. Куда попадём?

try {
  const res = await fetch('/api/tasks/42'); // 404
  console.log('try', res.status);
} catch (err) {
  console.log('catch', err);
}

В try: «try 404»

fetch отклоняет промис, только если ответа нет вообще: нет сети, сервер недоступен. 404 и 500 — это ответы. Запрос удался, просто новости плохие.

Тем временем fetch

🔥🐶☕🔥
Сервер ответил 500 Internal Server Error. Промис выполнен. Всё нормально. Проверить статус — ваша работа

Проверяйте res.ok

async function loadTasks() {
  const res = await fetch('/api/tasks');
  if (!res.ok) {
    throw new Error('HTTP ' + res.status);
  }
  return res.json();
}

res.ok — true для статусов 200–299. Теперь 404 и 500 тоже попадут в catch.

Статусы, которые встретятся

200 201 204успех; создано; успех без тела
400клиент прислал не то: невалидная форма
401 / 403«кто вы?» / «знаю, но нельзя»
404 409 429нет такого; конфликт данных; слишком много запросов
500 / 503сервер сломался / сервер временно недоступен

Первая цифра — класс: 2 — успех, 4 — ошибка клиента, 5 — ошибка сервера.

🥚 Есть и статус 418. Введите его на главной странице курса

Игра: угадай статус

Двенадцать ситуаций — от неверного пароля до сервера на обслуживании. Какой код вернёт API?

Шаг 3: создать задачу

async function addTask(text: string): Promise<Task> {
  const res = await fetch('/api/tasks', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ text, done: false }),
  });
  if (!res.ok) throw new Error('HTTP ' + res.status);
  return res.json();
}

Объект в body сам в JSON не превратится — нужен JSON.stringify.

список дел ← сервер

Три вида ошибок

📵Нет ответанет сети, сервер недоступен. fetch отклоняет промис → catch
🚫Ответ с ошибкой404, 500. Промис выполнен, res.ok === false — проверяем сами
🧩Не те данные200, но вместо text пришёл title. Не заметит никто — до пользователя

Данные с сервера
компилятор не видит Типы стёрлись при сборке — лекция 8

as — обещание без проверки

const data = await res.json();   // any
const tasks = data as Task[];    // «поверь мне»

tasks[0].text.toUpperCase();
// бэкенд переименовал поле в title —
// TypeError, уже у пользователя

TypeScript проверяет код, но не сеть. Ответ сервера нужно проверить в рантайме.

Шаг 4: схема на zod

import { z } from 'zod';

const TaskSchema = z.object({
  id: z.number(),
  text: z.string(),
  done: z.boolean(),
});
type Task = z.infer<typeof TaskSchema>;   // тип — из схемы

const tasks = z.array(TaskSchema).parse(await res.json());
// не тот ответ — понятная ошибка здесь, а не undefined в интерфейсе
список дел ← сервер

Одно описание — две проверки

🏷До запускаz.infer даёт тип Task — компилятор проверяет код
🛡Во время работыparse проверяет каждый ответ — ловит бэкенд, который изменился

Тип и проверка не разъедутся: их нельзя поменять по отдельности. Похожие библиотеки — Valibot, ArkType.

Библиотеки над fetch

fetch

const res = await fetch('/api/tasks', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify(task),
});
if (!res.ok) throw new Error(res.status);
const created = await res.json();

axios

const { data: created } =
  await axios.post('/api/tasks', task);

Сам сериализует тело, сам бросает ошибку на 4xx и 5xx, сам разбирает JSON.

Чем ещё axios удобен в проекте

const api = axios.create({ baseURL: '/api', timeout: 5000 });

// перехватчик: токен — в каждый запрос, без повторов в коде
api.interceptors.request.use(config => {
  config.headers.Authorization = 'Bearer ' + getToken();
  return config;
});

const { data } = await api.get('/tasks');

ky — то же, но тоньше и поверх fetch. Выбор — дело вкуса команды.

Отмена: AbortController

const controller = new AbortController();
fetch('/api/tasks', { signal: controller.signal });

controller.abort();   // запрос отменён, промис отклонён с AbortError

// таймаут одной строкой
await fetch('/api/tasks', { signal: AbortSignal.timeout(5000) });

Когда нужно: пользователь ушёл со страницы, закрыл окно или ввёл новый запрос, пока старый ещё в пути.

Реальная задача: подсказки в поиске

Каждая буква — запрос. Сервер отвечает за разное время: ответ на «Мо» может прийти позже, чем на «Москва», и перетереть его.

Справа в демо — водопад запросов, как во вкладке Network в DevTools.

Поток один, а гонка есть

В Java и C# гонка — это два потока и общая переменная. В JS поток один, но порядок ответов всё равно не гарантирован.

Игнорировать старыеномер запроса; запросы всё равно идут
AbortControllerотменить старый запрос перед новым
debounceотправлять, когда человек перестал печатать

Шаг 5: четыре состояния

Загрузкаспиннер или скелетон
ОшибкаНе удалось загрузить задачиПовторить
ПустоЗадач пока нет. Добавьте первую
Данные
  • Event Loop
  • async/await
  • zod

Про «загрузку» и «ошибку» чаще всего забывают — а пользователь в метро видит именно их.

🥚 На главной странице курса есть команда spinner

список дел ← сервер

Одна загрузка — четыре вида

Чистый JS, axios + zod, React и Svelte. Справа — фейковый сервер: задержка и исход. Посмотрим, что делает каждая версия, когда сеть пропала или пришло не то.

Как это будет в React

function TodoApp() {
  const [tasks, setTasks] = useState<Task[] | null>(null);
  const [error, setError] = useState<Error | null>(null);

  useEffect(() => {
    let ignore = false;
    loadTasks().then(
      data => { if (!ignore) setTasks(data); },
      err => { if (!ignore) setError(err); },
    );
    return () => { ignore = true; };   // ответ устарел — не показываем
  }, []);

  if (error) return <ErrorBox error={error} />;
  if (!tasks) return <Spinner />;
  return <TodoList tasks={tasks} />;
}

useState и useEffect — лекция 10.

Как это будет в Svelte

<script>
  import { loadTasks } from './api';
  let promise = $state(loadTasks());
</script>

{#await promise}
  <Spinner />
{:then tasks}
  <TodoList {tasks} />
{:catch error}
  <ErrorBox {error} onRetry={() => (promise = loadTasks())} />
{/await}

Три состояния — встроенный синтаксис. Сравнение фреймворков — лекция 14.

Как это пишут в продакшене

import { useQuery } from '@tanstack/react-query';

function TodoApp() {
  const { data, error, isPending, refetch } = useQuery({
    queryKey: ['tasks'],
    queryFn: loadTasks,
  });
  // загрузка, ошибка, кэш, повтор, отмена устаревших — уже внутри
}

TanStack Query — библиотека для серверного состояния. Подробно — лекция 13.

Игра: найди баг

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

После ответа — исправленный код. Большинство раундов можно запустить: сломанная и исправленная версии идут против фейкового сервера.

CORS: запрос к чужому API

Access to fetch at 'https://api.example.ru/tasks' from origin
'http://localhost:5173' has been blocked by CORS policy

Браузер не отдаёт странице ответ с чужого домена, если сервер явно не разрешил это заголовком Access-Control-Allow-Origin.

Чинится на сервере, а не во фронтенде. В разработке помогает прокси в vite.config.ts.

Что ещё бывает

XMLHttpRequestпредок fetch. С него в 2005 году началось слово AJAX
WebSocket, SSEсервер сам присылает новое: чаты, котировки, уведомления
GraphQLклиент сам описывает, какие поля ему нужны

Для списка дел и большинства сайтов хватает обычного HTTP API и fetch.

Часть 4 · 6 минут Итоги

И что дальше

JavaScript не ждёт —
он просит позвать его, когда готово.
Промис — это «позовут»,
await — удобный способ дождаться

Что взять из лекции

↻Event Loopпоток один; сначала текущий код, потом все микрозадачи, потом задача
⏳async / awaittry / catch / finally; независимое — через Promise.all
🌐fetchпроверять res.ok, ответ — через zod, старые запросы — отменять

И у каждой загрузки четыре состояния: загрузка, ошибка, пусто, данные.

Что почитать и посмотреть

learn.javascript.ruразделы «Промисы, async/await» и «Сетевые запросы»
Филип Робертс«What the heck is the event loop anyway?» — JSConf EU 2014
Джейк Арчибальд«In The Loop» — JSConf.Asia 2018: задачи, микрозадачи и отрисовка
QR-код со ссылкой на раздел «Промисы, async/await» на learn.javascript.ru Промисы, async/await learn.javascript.ru

Четыре игры — пройдите дома

Что выведется первым?12 раундов про Event Loop с пошаговым разбором
all, allSettled, race, any10 раундов с таймлайном
Угадай статус12 ситуаций — 12 кодов HTTP
Найди баг10 реальных багов, которые можно запустить

Все — на сайте курса, на слайдах этой лекции. Прогресс сохраняется в браузере.

Лекция 10. React: состояние и взаимодействие

Список дел станет интерактивным — и загрузит задачи сам.

Вопросы?

Слайды, демо и игры — в репозитории курса