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

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

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

React · Vue · Svelte — веб-программирование, лекция 10 из 16

В прошлый раз

⏳async / awaitJS не ждёт — просит позвать, когда будет готово
🌐fetchзадачи приходят с сервера: res.ok, отмена, гонки
🔄Три состояниязагрузка, ошибка, данные

А клик по делу по-прежнему ничего не делает.

Интерфейс должен отвечать Для этого ему нужно состояние

Сегодня — три фреймворка сразу

ReactMeta, 2013. Самый популярный
VueЭван Ю, 2014. Сделан одним человеком
SvelteРич Харрис, 2016. Компилятор вместо библиотеки

Лабы и проект можно писать на любом. А Angular покажем там, где влезет четвёртой колонкой.

Один вопрос — пятнадцать лет

Данные изменились — что перерисовать? Каждое поколение фреймворков отвечает по-своему.

2010AngularJSпосле каждого события сравнить всё подряд
2013Reactперерисовать всё в памяти и сравнить
2014Vueследить за чтением и записью полей
2016Angular 2, SvelteZone.js ловит события; компилятор знает всё заранее
2023–24все на сигналахобновить ровно то, что читало значение
Грязная проверка (dirty checking) — после каждого события фреймворк сравнивает все привязанные значения с прошлыми.

Как в жизни. Охранник после каждого звонка в дверь обходит все комнаты и сверяет, всё ли на месте.

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

// после каждого клика, таймера, ответа
do {
  dirty = false;
  for (const w of watchers) { // ВСЕ
    const now = w.get();
    if (now !== w.last) {
      w.last = now;
      w.update(now);
      dirty = true;
    }
  }
} while (dirty); // пока не успокоится

Десять кругов — и хватит

🤯 сюрприз кода

Если значения меняются на каждом круге проверки, AngularJS не крутится вечно. После десятого круга он сдаётся с ошибкой:

10 $digest() iterations reached. Aborting!

Её видел почти каждый, кто писал на AngularJS. Чаще всего виновата функция в шаблоне, которая каждый раз возвращает новый массив.

docs.angularjs.org/error/$rootScope/infdig
Виртуальный DOM — описание страницы обычными объектами JS. После изменения строится новое описание, сравнивается со старым, в DOM уходит только разница.

Как в жизни. «Найди десять отличий»: две картинки, старая и новая. Перерисовать нужно только отличия.

Создать объект — дёшево, тронуть DOM — дорого.

// <li className="done">Молоко</li>
// — это просто объект:
{
  type: 'li',
  props: {
    className: 'done', // было ''
    children: 'Молоко',
  },
}
// разница одна → li.className = 'done'
Реактивный объект — данные в обёртке, которая замечает чтение и запись. Кто прочитал поле — подписался. Записали — обновляем только подписчиков.

Как в жизни. Рассылка: письмо о новой серии получают только те, кто смотрел сериал.

Vue 2 делал это геттерами и сеттерами, Vue 3 — через Proxy.

// Vue 2, упрощённо
Object.defineProperty(task, 'done', {
  get() {
    subs.add(currentRender); // читатель
    return done;
  },
  set(v) {
    done = v;
    subs.forEach(r => r()); // обновись
  },
});
Zone.js подменяет setTimeout, addEventListener, fetch и промисы. После любого из них говорит Angular: «что-то могло измениться» — и тот проверяет дерево компонентов.

Как в жизни. Датчик движения: сработал — свет включается во всём доме, а не в одной комнате.

Что именно поменялось, Zone.js не знает.

// суть, упрощённо
const original = window.setTimeout;

window.setTimeout = (fn, ms) =>
  original(() => {
    fn();
    appRef.tick(); // проверить всё
  }, ms);

// то же — для кликов, fetch, Promise…
Компилятор делает работу заранее, при сборке: читает шаблон и пишет JS, который уже знает, какой узел зависит от какой переменной.

Как в жизни. Книга, переведённая заранее, против синхронного переводчика, который слушает каждое слово.

Svelte 5 компилирует уже в сигналы.

// вы написали:
count += 1;

// Svelte 3 выдал (упрощённо):
$$invalidate('count', count += 1);

// и при обновлении экрана:
if (changed.count) {
  set_data(text, count);
}

Сигнал — как ячейка Excel

Сигнал — значение плюс список тех, кто его читал. Чтение подписывает, запись оповещает подписчиков. Ничего не сравнивается целиком.
ABCD
1ценакол-восуммазаметка
25 → 73=A2*B215 → 21«купить»

Меняете A2 — пересчитывается только C2, он её читал. D2 никто не трогает. Ячейка — сигнал, формула — вычисляемое значение.

Сигнал в коде

let current = null; // кто читает сейчас

function signal(value) {
  const subs = new Set();
  return {
    get() {
      if (current) subs.add(current);
      return value;
    },
    set(v) {
      value = v;
      subs.forEach(fn => fn());
    },
  };
}
function effect(fn) {
  current = fn; fn(); current = null;
}

const count = signal(0);

effect(() => {
  label.textContent = count.get();
}); // прочитал → подписался

count.set(5); // label сам стал 5

Это вся идея. Версия на 30 строк с computed — в демо чуть позже.

Что проверяется после клика

AngularJSвсе привязки страницы — по кругу, пока не успокоится
Angular + Zone.jsвсё дерево компонентов после любого события
Reactизменившийся компонент и все его дети
Сигналытолько то, что читало значение

Чем точнее, тем меньше работы на клик. React идёт своим путём — компилятором (часть 3).

Семь принципов на сегодня

Синтаксис разный. Задачи и проблемы — одни и те же.

Список дел оживает — в пять шагов

  1. клик отмечает дело
  2. удаление и «Дел нет»
  3. форма с проверкой и фильтр
  4. «Осталось N» — вычисляется
  5. загрузка с сервера и отмена при уходе
список дел оживает

Часть 1 · 20 минут Интерфейс = функция от состояния

И как фреймворк узнаёт, что состояние изменилось

Как было в лекции 6

item.addEventListener('click', () => {
  item.classList.toggle('done');                 // 1. вид дела
  const left = list.querySelectorAll('li:not(.done)').length;
  counter.textContent = 'Осталось: ' + left;     // 2. счётчик
  empty.hidden = list.children.length > 0;       // 3. «Дел нет»
  saveToServer(...);                             // 4. и данные
});

Каждое действие — четыре ручные правки. Забыли одну — интерфейс врёт.

Типичный баг ручного DOM

🐞«Осталось: 3»а список пуст: удаление забыло обновить счётчик
🐞Дело зачёркнутоа в данных done: false: DOM и массив разошлись

Две правды — в DOM и в данных — рано или поздно разъедутся.

UI = f(state) Описываем, как выглядит интерфейс при данных. Как перейти — забота фреймворка

Декларативно — как SQL

Императивно: как

for (const t of tasks)
  if (!t.done)
    ul.append(makeLi(t));

Декларативно: что

<li v-for="t in active">
  {{ t.text }}
</li>

В SQL пишете SELECT … WHERE, а не цикл по страницам диска. Здесь так же.

Что такое состояние

Данные, которые меняются со временем и влияют на вид.

данныесостояние?почему
список делдаменяется, от него зависит экран
текст в поле вводадаменяется на каждой букве
«Осталось N»нетвычисляется из списка
props от родителянетчужое состояние, только читаем

Одно состояние — четыре записи

React
const [tasks,
  setTasks] =
  useState(init);
Vue
const tasks =
  ref(init);
Svelte
let tasks =
  $state(init);
Angular
tasks =
  signal(init);

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

Шаг 1. Клик отмечает дело

React
function toggle(id: number) {
  setTasks(tasks.map(t =>
    t.id === id
    ? { ...t, done: !t.done }
    : t));
}
Vue
function toggle(t: Task) {
  t.done = !t.done;
}
Svelte
function toggle(t: Task) {
  t.done = !t.done;
}

React — новый массив. Vue и Svelte — просто меняем поле. Почему так — через минуту.

список дел оживает

Как фреймворк узнаёт,
что данные изменились? Три разных ответа — и один результат на экране

React: вы ему сообщаете

Это виртуальный DOM из демо rerender лекции 7. За изменениями React не следит вообще.

Vue: следит сам — через Proxy

const tasks = new Proxy(data, {
  get(target, key) {
    track(key);            // запомнить, кто читает
    return target[key];
  },
  set(target, key, value) {
    target[key] = value;
    trigger(key);          // перерисовать тех, кто читал
    return true;
  },
});

Упрощённо, но идея та: ref и reactive — обёртки, которые видят чтение и запись.

Svelte: всё решает компилятор

Вы пишете

<script>
  let count = $state(0);
</script>

<button onclick={() => count++}>
  {count}
</button>

Компилятор отдаёт (суть)

let count = $.state(0);
// …
$.template_effect(() =>
  $.set_text(text, $.get(count))
);

Знает ещё при сборке, какой текстовый узел зависит от count. «Фреймворк, который исчезает».

Angular: от Zone.js к сигналам

🕸Zone.js (2016–…)перехватывает все клики, таймеры и запросы — и после каждого проверяет всё дерево компонентов
📡signal() (с Angular 16)count = signal(0), count.set(…) — точечные обновления, как во Vue и Svelte

Это паттерн Observer

C#

class Task : INotifyPropertyChanged {
  bool done;
  public bool Done {
    set { done = value;
      PropertyChanged?.Invoke(…); }
  }
}

Фреймворки

  • сигнал = субъект
  • эффект и шаблон = наблюдатели
  • подписка — автоматически, при чтении

Все пришли к одному

🕷Vueref()
🕷Svelte 5$state()
🕷Angular 16signal()
🕷SolidcreateSignal()

Knockout (2010) → Solid сделал слово модным → Preact, Angular, Svelte 5 → предложение добавить сигналы в сам JavaScript (TC39).

github.com/tc39/proposal-signals

Кто придумал Svelte

📜 история

Svelte придумал Рич Харрис из команды интерактивной графики The Guardian (позже — графический редактор The New York Times). Для инфографики важен каждый килобайт.

Там же он начал сборщик Rollup — на нём выросла сборка Vite (с Vite 8 — его наследник Rolldown).

svelte.dev/blog — «Frameworks without the framework», 2016

Кто придумал Vue

📜 история

Vue сделал Эван Ю после работы в Google Creative Lab с AngularJS: «взять то, что мне нравилось в Angular, и сделать что-то по-настоящему лёгкое».

За Vue не стоит корпорация — проект живёт на спонсорских деньгах. Он же автор Vite из лекции 8.

Интервью Эвана Ю, «Between the Wires», 2016

Как встретили React

📜 история

React открыли на JSConf US в мае 2013 года — и разметку внутри JavaScript встретили в штыки: «смешали всё, что десять лет учились разделять».

Через полгода Пит Хант выступил с докладом «React: Rethinking Best Practices» — ответом критикам. Сейчас JSX понимают Vue, Solid и Preact.

Pete Hunt, «React: Rethinking Best Practices», JSConf EU 2013

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

const [count, setCount] = useState(0);

function add() {
  setCount(count + 1);
  console.log(count);
}

0 — состояние это снимок

setCount не меняет переменную — он заказывает новый рендер, в котором count будет 1. В этом вызове функции count — константа, равная 0.

Как кадр фильма: в каждом рендере свои значения.

На сколько вырастет счётчик?

function addThree() {
  setCount(count + 1);
  setCount(count + 1);
  setCount(count + 1);
}

На 1

🤯 сюрприз

Три раза подряд «поставь 0 + 1». Чтобы опираться на предыдущее значение, передают функцию:

setCount(c => c + 1) — React применит три обновления по очереди.

React: не мутировать, а заменять

Ничего не произойдёт

tasks.push(task);
setTasks(tasks);

Новый массив

setTasks([...tasks, task]);

React сравнивает старое и новое через Object.is: тот же массив — «не изменилось». Как record и with в C#.

А во Vue и Svelte — можно

React
setTasks([...tasks, t]);
Vue
tasks.value.push(t);
Svelte 5
tasks.push(t);

Vue и Svelte видят запись в массив через Proxy. Проблема общая — заметить изменение. Решения разные.

Так было не всегда

🤯 сюрприз

Vue 2 не замечал arr[i] = x и новые поля объекта — нужен был Vue.set. Svelte 3–4 не замечал arr.push(x) — писали arr = arr.

Обе ловушки исчезли с переходом на Proxy: Vue 3 (2020) и Svelte 5 (2024).

v2.vuejs.org/v2/guide/reactivity · v4.svelte.dev/tutorial

Часть 2 · 20 минут События, условия, списки

Одни задачи — четыре синтаксиса

Один и тот же клик

React
<button
  onClick={add}>
Vue
<button
  @click="add">
Svelte
<button
  onclick={add}>
Angular
<button
  (click)="add()">

Общее: обработчик — это функция, которую фреймворк вызовет при клике.

В шаблонах Vue и Angular выражение add() фреймворк сам заворачивает в функцию. В JSX и Svelte — нет: там {add()} вызовется сразу.

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

{tasks.map(t => (
  <li key={t}>
    {t} <button onClick={remove(t)}>×</button>
  </li>
))}

Никто ничего не нажимал.

Все дела исчезнут сразу

onClick={remove(t)} вызывает remove прямо во время рендера. Каждый рендер удаляет дела — пока не кончатся. Нужна функция: onClick={() => remove(t)}.

Проверено запуском в игре «Что на экране?», раунд 9. TypeScript поймал бы это ещё до запуска.

Мелочи событий

задачаReact и SvelteVue
не отправлять формуe.preventDefault()@submit.prevent
не всплывать к родителюe.stopPropagation()@click.stop
только по Enterif (e.key === 'Enter')@keyup.enter

Всплытие и делегирование — из лекции 6, никуда не делись.

onChange, который не change

🤯 сюрприз

В DOM событие change у поля срабатывает, когда фокус ушёл. В React onChange срабатывает на каждую букву — как input.

Так решили ещё в 2013 году. Поменять уже нельзя: сломается весь код на React.

react.dev — <input>

Где живут обработчики

📜 история

До React 17 все обработчики висели на document — делегирование из лекции 6. Две версии React на одной странице мешали друг другу.

С React 17 (2020) — на корневом элементе приложения.

React blog, «React v17.0», 2020

Условия

React
{tasks.length > 0
  ? <List />
  : <Empty />}
Vue
<List v-if="ok" />
<Empty v-else />
Svelte
{#if ok}
  <List />
{:else}
  <Empty />
{/if}
Angular 17
@if (ok) {
  <List />
} @else {
  <Empty />
}

React — обычный JavaScript в фигурных скобках. Остальные — специальный синтаксис шаблона.

Что будет на экране, если дел нет?

<h3>Мои дела</h3>
{tasks.length && <TaskList tasks={tasks} />}

Цифра 0 под заголовком

🤯 сюрприз

0 && … — это 0. false и null React не рисует, а число рисует.

Слева от && — только настоящее условие: tasks.length > 0 && …

react.dev — Conditional Rendering

Angular стал похож на Svelte

Angular до 17

<p *ngIf="ok; else empty">
  …
</p>

Angular 17 (2023)

@if (ok) {
  <p>…</p>
} @else { … }

Блоки в фигурных скобках — как {#if} в Svelte. Фреймворки подсматривают друг у друга.

angular.dev — Control flow

Убрать или спрятать?

🗑Убрать из DOMv-if, {#if}, @if, && в React. Компонент исчезает со своим состоянием
🙈Спрятать через CSSv-show во Vue, hidden или стиль в остальных. Узел остаётся, состояние тоже

Вопрос для любого фреймворка: часто переключается — прячем, редко — убираем.

Списки

React
{tasks.map(t =>
  <li key={t.id}>
    {t.text}
  </li>
)}
Vue
<li
  v-for="t in tasks"
  :key="t.id">
  {{ t.text }}
</li>
Svelte
{#each tasks
  as t (t.id)}
  <li>{t.text}</li>
{/each}
Angular 17
@for (t of tasks;
  track t.id) {
  <li>{{ t.text }}</li>
}

Ключ есть везде. В Angular 17 без track код даже не скомпилируется.

Ключ — паспорт элемента По нему фреймворк понимает, какое дело куда переехало

Что брать ключом

🪪id из данныхне меняется, пока живёт дело
🔢индекстолько если список никогда не меняется и в строках нет полей ввода
🎲Math.random()новый ключ на каждом рендере — весь список пересоздаётся

Шаг 2. Удаление и «Дел нет»

React
setTasks(tasks.filter(
  t => t.id !== id));

{tasks.length === 0 &&
  <p>Дел нет</p>}
Vue
<button
  @click.stop=
    "remove(t.id)">

<p v-if="!tasks.length">
Svelte
tasks = tasks.filter(
  t => t.id !== id);

{#if !tasks.length}
  <p>Дел нет</p>
{/if}
список дел оживает

Компоненты: данные вниз, события вверх

React
function TaskItem(
  { task, onToggle }: Props
) {
  … onClick={() =>
    onToggle(task.id)}
}
Vue
defineProps<{
  task: Task }>();
const emit = defineEmits<{
  toggle: [number] }>();
… @click="emit(
  'toggle', task.id)"
Svelte
let { task, ontoggle }:
  Props = $props();

… onclick={() =>
  ontoggle(task.id)}

Ребёнок не меняет чужое состояние — он просит родителя. Подробно — лекция 11.

Данные — вниз
События — вверх Одинаково в React, Vue, Svelte и Angular

Часть 3 · 14 минут Формы и вычисляемые значения

Что связать, что хранить, а что считать

Поле ввода — тоже состояние

React
<input
  value={text}
  onChange={e =>
    setText(
      e.target.value)}
/>
Vue
<input
  v-model="text"
/>
Svelte
<input
  bind:value={text}
/>
Angular
<input
  [(ngModel)]="text"
/>

Vue, Svelte, Angular — двусторонняя привязка. React — привязка руками: поле показывает состояние, событие его меняет.

Двусторонняя привязка — старая знакомая

WPF, C#

<TextBox Text="{Binding Title,
  Mode=TwoWay}" />

JavaFX

field.textProperty()
  .bindBidirectional(title);

Поле меняет переменную, переменная меняет поле. v-model — та же идея для веба.

v-model — это value + событие Просто короче

Что прячется за v-model

Пишем

<input v-model="text" />

Vue разворачивает в

<input
  :value="text"
  @input="text =
    $event.target.value"
/>

Ровно то, что в React пишут руками. Магии нет — есть сокращение.

Поле, в которое нельзя писать

🤯 сюрприз

В React <input value={query} /> без onChange — «замороженное» поле: печатаешь, а текст не появляется.

Поле показывает состояние, а состояние никто не меняет. В консоли — предупреждение.

react.dev — <input>

Шаг 3. Форма с проверкой

React
const blank =
  text.trim() === '';

<button
  disabled={blank}>
Vue
const blank = computed(
  () => text.value
    .trim() === '');

<button :disabled="blank">
Svelte
let blank = $derived(
  text.trim() === '');

<button
  disabled={blank}>

Пустое поле — кнопка неактивна. Одни пробелы — ещё и ошибка под полем.

список дел оживает

«Задача добавлена»

После отправки формы пользователю нужен ответ: поле очистилось, дело появилось в списке. Иногда — всплывающее уведомление на пару секунд.

Уведомление — тоже состояние: показать, подождать, убрать.

🥚 Введите toast в строку на главной странице курса

Вычисляемые значения

React
const left =
  tasks.filter(
    t => !t.done
  ).length;
Vue
const left =
  computed(() =>
    tasks.value.filter(
      t => !t.done
    ).length);
Svelte
let left =
  $derived(
    tasks.filter(
      t => !t.done
    ).length);
Angular
left = computed(
  () => this.tasks()
    .filter(
      t => !t.done
    ).length);

В React — просто выражение: функция компонента и так выполняется заново.

Не храните то, что можно вычислить Два источника правды рано или поздно разъедутся

«Осталось N»

🙅
useState для left + эффект, который его синхронизирует
👉
просто посчитать в рендере: const left = …
список дел оживает

React догоняет

📜 история

Vue и Svelte с самого начала знают, какие компоненты зависят от изменения, и не трогают остальные. В React для этого годами расставляли useMemo и memo руками.

В октябре 2025 вышел React Compiler 1.0 (в разработке — «React Forget»): мемоизацию расставляет компилятор.

react.dev/blog — React Compiler v1.0

Часть 4 · 18 минут Эффекты и жизненный цикл

Что открыл — то и закрой

Жизнь компонента

появилсязагрузить данные, подписаться, запустить таймер
→
обновилсяданные изменились — перезапросить
→
исчезотменить запрос, отписаться, остановить таймер

Как IDisposable и using в C#: ресурс, который открыли, нужно освободить.

Эффект с уборкой

React
useEffect(() => {
  const off = start();
  return () => off();
}, []);
Vue
let off;
onMounted(() =>
  off = start());
onUnmounted(() =>
  off());
Svelte
$effect(() => {
  const off = start();
  return () => off();
});

Angular: effect(onCleanup => …) или ngOnInit + ngOnDestroy.

Когда запускается

React useEffectVue watchEffectSvelte $effect
первый запускпосле рендерасразу, до рендерапосле рендера
от чего зависитвы пишете [deps]собирает самсобирает сам
перед повтором и при уходеcleanuponCleanupcleanup

Зависимости Vue и Svelte собирают сами: кто что прочитал. Нужен DOM во Vue — onMounted.

Что будет, если забыть []?

useEffect(() => {
  loadTasks().then(data => setTasks(data));
});

Бесконечные запросы

Без массива зависимостей эффект запускается после каждого рендера. Ответ пришёл → setTasks → рендер → эффект → новый запрос → … Вкладка Network заполняется за секунды.

[] — «только при появлении». [id] — «при появлении и когда сменился id».

Шаг 5. Загрузка при появлении

React
useEffect(() => {
  const c =
    new AbortController();
  loadTasks(c.signal)
    .then(setTasks);
  return () => c.abort();
}, []);
Vue
const c =
  new AbortController();
onMounted(async () =>
  tasks.value =
    await loadTasks(
      c.signal));
onUnmounted(() =>
  c.abort());
Svelte
onMount(() => {
  const c =
    new AbortController();
  loadTasks(c.signal)
    .then(t => tasks = t);
  return () => c.abort();
});

fetch из лекции 9 + состояние. Плюс загрузка и ошибка — в демо.

список дел оживает

Пока грузится

⏳Спиннер«что-то происходит» — просто и честно
🦴Скелетонсерые заглушки на месте будущего списка — страница не прыгает, когда данные пришли

В каждом фреймворке это просто ещё одна ветка условия: status === 'loading'.

🥚 Введите skeleton в строку на главной странице курса

Гонка ответов возвращается

Ушли со страницы или сменили фильтр — старый ответ приходит в исчезнувший компонент или перетирает новый. Как в лекции 9.

🚫ОтменитьAbortController в cleanup
🙈Игнорироватьфлаг ignore = true в cleanup, ответ выбросить

Во всех трёх фреймворках это делает cleanup.

Эффект запустился дважды?

🤯 сюрприз

В режиме разработки React StrictMode запускает каждый эффект так: эффект → cleanup → эффект. В Network — два запроса.

Это проверка, что cleanup написан. В production — один раз.

react.dev — <StrictMode>

Это не баг, это StrictMode GET /api/tasks (canceled) · GET /api/tasks

Вам может быть не нужен эффект

🌐Эффектсинхронизация с внешним миром: сеть, таймеры, подписки, чужой DOM
🧮Не эффектвычисление из состояния — считайте в рендере или computed
👆Не эффектреакция на клик — это обработчик события
react.dev — You Might Not Need an Effect

Великий раскол

📜 история

Октябрь 2014, конференция ng-Europe: Google объявляет, что Angular 2 пишется с нуля — и пути миграции с AngularJS пока нет. Сообщество взорвалось.

Многие ушли — в том числе в React и Vue. AngularJS официально закончился 31 декабря 2021 года.

blog.angular.dev — AngularJS LTS

Лицензия, которая чуть не сломала React

📜 история

Лето 2017: Apache Foundation запрещает в своих проектах лицензию React «BSD + патенты». В сентябре WordPress объявляет, что уходит с React.

Через неделю Facebook переводит React на MIT. WordPress остаётся.

engineering.fb.com — Relicensing React, 2017

Откуда взялись хуки

📜 история

До 2019 года состояние в React жило в классах: this.setState, componentDidMount, componentWillUnmount — привычно для Java и C#.

Хуки показали на React Conf в октябре 2018-го. Vue 3 прямо называет их источником вдохновения для Composition API.

vuejs.org — Composition API FAQ

Финал · 9 минут Розеттский камень

Одна таблица — четыре фреймворка

Синтаксис учится за вечер Принципы — одни и те же везде

Что решает любой фреймворк

Где живёт состояниеи кто имеет право его менять
Как заметить изменениеперезапуск, Proxy, компилятор, сигналы
Какой элемент куда делсяключи в списках
Как связать поле с даннымидвусторонняя привязка или руками
Что хранить, что считатьвычисляемое не хранят
Как убрать за собойcleanup: отмена, отписка
🧡 мнение лектора · на оценку не влияет

Все фреймворки равны.Но Svelte — равнее

Лабы — на чём угодно, баллы те же. Дальше — совершенно банальные сравнения с React.

🧡 банальность № 1

Счётчик

React

const [count, setCount] = useState(0);

<button onClick={() => setCount(count + 1)}>
  {count}
</button>

Svelte

let count = $state(0);

<button onclick={() => count++}>
  {count}
</button>

count++. Просто count++. Как в C++, Java и C#.

🧡 банальности № 2–4

Ещё три мелочи

ReactSvelte
добавить делоsetTasks([...tasks, task])tasks.push(task)
поле вводаvalue={text}
onChange={e => setText(e.target.value)}
bind:value={text}
эффектuseEffect(…, [left, total])
забыли total — баг
$effect(…)
зависимости найдёт сам
🧡 банальность № 5 · размер

Один и тот же счётчик

React 1967,7 КБ
Svelte 510,0 КБ

JavaScript после npm run build (Vite 8, gzip). В 6,7 раза меньше.

до кнопки на «телефоне»2,0 с
0,55 с

Chromium: процессор в 6 раз медленнее, сеть Fast 3G, без кэша. Медиана из 9 загрузок.

🧡 а теперь скорость

Я ждал разгрома. Замерил

таблица, мсReactSvelte
создать 1 000 строк5,86,9
обновить каждую 10-ю2,22,3
создать 10 000 строк157170
очистить 10 000 строк1110,6

Ничья. React даже чуть быстрее — глазом не заметить.

Production-сборки Vite 8, Chromium, время до готовой вёрстки, медиана из 15 прогонов.

🧡 и строки кода

Наш список дел, шаг 5

React108 строк
Svelte94 строки
Vue86 строк

Svelte короче React на 13%. А Vue — ещё короче. Неловко вышло.

Те же файлы, что в демо «Список дел», без пустых строк.

🧡 вывод лектора

За что я на самом деле люблю Svelte

Стили не протекают<style> p {…} </style>действуют только в этом компоненте — без CSS-модулей
Анимации из коробки<li transition:fade>появление, исчезновение, перестановка — без библиотек
Загрузка в шаблоне{#await p}…{:then t}спиннер, данные и ошибка из лекции 9 — тремя блоками
Общее состояниеcart.svelte.ts$state в обычном файле — импорт вместо Context и Redux
Нет правил хуков$derived(a * b)ни массивов зависимостей, ни useMemo, ни useCallback
Компилятор — зануда⚠ <img> без altподсказывает про доступность ещё до запуска

Любовь — не бенчмарк. Выбирайте сами: принципы везде те же.

Что почитать

QR-код со ссылкой на шпаргалку «Розеттский камень» Розеттский камень шпаргалка для печати

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

Что на экране?12 сюрпризов состояния — каждый можно запустить
Чей это код?10 фрагментов: React, Vue, Svelte, Angular, Solid, Lit

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

Лекция 11. Композиция и общее состояние

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

Вопросы?

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