Веб-программирование
Веб-программирование · лекция 9 из 16
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 мс процессор выполнит сотни миллионов операций. Стоять и ждать — расточительно.
Promise и async/await — как дождаться результатаfetch и HTTP API — как получить данные с сервераКаждую тему — на реальной задаче: чистый JS, библиотека, React.
try / catchПлашка в правом нижнем углу покажет, на каком шаге мы сейчас.
Один поток, очереди и Event Loop
var tasks = client.GetTasks();
// поток стоит и ждёт ответа
Show(tasks);
const tasks = getTasksSync();
// страница стоит и ждёт ответа
show(tasks);
В консоли это нормально. В браузере — нет: пока ждём, страница не прокручивается, кнопки не нажимаются, анимации стоят.
Часы и точку двигает JavaScript — 60 раз в секунду.
Первая кнопка занимает поток целиком: замрут и часы, и слайды. Вторая делает ту же работу кусками по 15 мс, и между кусками браузер успевает рисовать.
Ждёт поток. Пока он стоит, работают другие. Цена — синхронизация: lock, synchronized, mutex.
Поток один, и занять его ожиданием — значит заморозить страницу. Зато блокировок нет вообще.
Значит, ждать должен кто-то другой.
button.addEventListener('click', () => {
addTask(input.value);
});
Лекция 6. Функцию вызывает не ваш код, а браузер — когда кликнут. Регистрация обработчика занимает микросекунды, и код идёт дальше.
// подсказка «Сохранено» исчезает через 2 секунды
showToast('Сохранено');
setTimeout(() => hideToast(), 2000);
// «Отменить отправку» в почте: письмо уходит через 5 секунд
const timer = setTimeout(() => sendMail(draft), 5000);
undoButton.onclick = () => clearTimeout(timer);
setTimeout не ждёт: ставит таймер и сразу возвращает его номер.
awaitНичего не прерывает код посередине. Колбэк начнётся, только когда стек пуст.
setTimeout(() => console.log('таймер'), 0);
console.log('следующая строка');
setTimeout(…, 0) — не «сейчас», а «как только стек
опустеет». Колбэк ждёт в очереди задач, пока не доделается текущий код.
Таймер обещает «не раньше чем через N мс», а не «ровно через». Если поток занят, колбэк подождёт.
| очередь | что туда попадает | когда выполняется |
|---|---|---|
| Микрозадачи | then, catch, finally, продолжение после await, queueMicrotask | сразу после текущего кода — все |
| Задачи | setTimeout, setInterval, клики, клавиши, ответы сети | по одной, между ними — микрозадачи и отрисовка |
Промисы — «срочное»: они обгоняют любой таймер, даже на 0 мс.
Пока выполняется долгий код, очередь стоит. Клик пользователя ждёт, отрисовка ждёт. Ровно это и было с кнопкой «цикл на 3 секунды».
Посмотрим по шагам, что происходит с кликом.
setTimeout — как вторая кнопкаДля загрузки данных ничего из этого не нужно: ждёт браузер, а не 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.
Целиком игра — дома: прогресс сохраняется.
Как вернуть результат, которого ещё нет
Состояние меняется один раз: выполненный промис не станет отклонённым, и наоборот.
Промис — это обещание, а не гарантия: его могут и отклонить.
| язык | тип «результат будет потом» |
|---|---|
| JavaScript / TypeScript | Promise<Task[]> |
| C# | Task<List<TodoTask>> |
| Java | CompletableFuture<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(), библиотеки.
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.
awaitasync 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 приостанавливает функцию, а не потокостаток функции становится микрозадачей. Страница живёт дальше
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) в консоли и молчание для пользователя.
try / catch / finallyasync 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 мс. Сколько будет ждать страница?
await ждёт, пока закончится предыдущий. Второй запрос
даже не начинается, пока не пришёл первый.
const [user, orders, notes] = await Promise.all([
getUser(),
getOrders(),
getNotes(),
]);
await подряд — 900 мсPromise.all — 300 мс| комбинатор | чего ждёт | реальная задача |
|---|---|---|
Promise.all | всех; падает на первой ошибке | профиль из трёх частей |
Promise.allSettled | всех; не падает никогда | дашборд: упавший виджет не ломает остальные |
Promise.race | первого закончившего | таймаут: запрос против таймера |
Promise.any | первого успешного | файл с трёх зеркал |
raceconst timeout = (ms) => sleep(ms).then(() => {
throw new Error('Сервер не ответил за ' + ms + ' мс');
});
const tasks = await Promise.race([getTasks(), timeout(5000)]);
Кто первый — тот и результат. Но запрос при этом не отменяется: промис нельзя остановить снаружи.
Для fetch есть готовое и честное решение — AbortSignal.timeout(5000). В части 3.
Три промиса — когда каждый закончится и чем. Что вернёт комбинатор и через сколько?
Ответ считается настоящими промисами в браузере. После ответа рисуется таймлайн.
asynctasks.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 превращает остаток функции в микрозадачу.
Список дел начинает жить на сервере
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: метод, адрес, заголовки, тело. В ответе — статус, заголовки, тело.
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 нет, даты —
строки. По сети ходит текст, а не объекты.
| запрос | что делает | ответ |
|---|---|---|
GET /api/tasks | все задачи | 200 и массив |
POST /api/tasks | создать задачу | 201 и задача с id |
PATCH /api/tasks/42 | изменить поля задачи 42 | 200 и задача |
DELETE /api/tasks/42 | удалить задачу 42 | 204, пустое тело |
Такое API пишут на ASP.NET, Spring или Express. Сегодня мы по другую сторону.
const res = await fetch('/api/tasks');
const tasks = await res.json();
Почему два await? Сначала приходят статус и заголовки —
это res. Тело может быть большим и идёт следом —
res.json() ждёт его и разбирает JSON.
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 — это ответы. Запрос удался,
просто новости плохие.
fetch500 Internal Server Error. Промис выполнен.
Всё нормально.
Проверить статус — ваша работа
res.okasync 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?
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 отклоняет промис → catchres.ok === false — проверяем самиtext пришёл title. Не заметит никто — до пользователяas — обещание без проверкиconst data = await res.json(); // any
const tasks = data as Task[]; // «поверь мне»
tasks[0].text.toUpperCase();
// бэкенд переименовал поле в title —
// TypeError, уже у пользователя
TypeScript проверяет код, но не сеть. Ответ сервера нужно проверить в рантайме.
zodimport { 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.
fetchconst 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();
const { data: created } =
await axios.post('/api/tasks', task);
Сам сериализует тело, сам бросает ошибку на 4xx и 5xx, сам разбирает JSON.
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. Выбор — дело вкуса команды.
AbortControllerconst 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 поток один, но порядок ответов всё равно не гарантирован.
Про «загрузку» и «ошибку» чаще всего забывают — а пользователь в метро видит именно их.
🥚 На главной странице курса есть команда spinner
Чистый JS, axios + zod, React и Svelte. Справа —
фейковый сервер: задержка и исход. Посмотрим, что делает каждая версия,
когда сеть пропала или пришло не то.
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.
<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.
Десять реальных фрагментов: загрузка, сохранение, поиск. В каждом — асинхронная ошибка. Что увидит пользователь?
После ответа — исправленный код. Большинство раундов можно запустить: сломанная и исправленная версии идут против фейкового сервера.
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.
fetch. С него в 2005 году началось слово AJAX
Для списка дел и большинства сайтов хватает обычного HTTP API и fetch.
И что дальше
await — удобный способ дождаться
try / catch / finally; независимое — через Promise.allres.ok, ответ — через zod, старые запросы — отменятьИ у каждой загрузки четыре состояния: загрузка, ошибка, пусто, данные.
Все — на сайте курса, на слайдах этой лекции. Прогресс сохраняется в браузере.
useState — данные, которые меняютсяuseEffect — откуда в React берётся загрузкаСписок дел станет интерактивным — и загрузит задачи сам.
Слайды, демо и игры — в репозитории курса