Лекция 7. Современный JavaScript и введение в React

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

Лекция 7 Современный JS
и React

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

В прошлый раз

📦Данныемассив tasks
🖼render()по данным рисует страницу
👆Событияменяют данные и вызывают render()

Список дел в сорок строк — и три неудобства: render() перерисовывает всё, его легко забыть вызвать, разметка собирается десятком createElement.

Так выглядит код на React

import { TodoItem } from './TodoItem.js';

export function TodoList({ tasks, filter = 'all' }) {
  const visible = tasks.filter(t => filter === 'all' || !t.done);
  return (
    <ul className="todo__list">
      {visible.map(t => <TodoItem key={t.id} {...t} />)}
    </ul>
  );
}

Знакомого из лекции 6 здесь немного. И это ещё не React — почти всё здесь обычный современный JavaScript.

Что здесь из сегодняшней лекции

в кодечто эточасть
import, exportмодули2
{ tasks, filter = 'all' }деструктуризация2
t => …, filter, mapфункции, методы массивов1, 2
{...t}spread2
<ul> внутри JSJSX3

Через час каждая строка будет читаться без усилия.

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

И весь путь — на том же списке дел.

список дел → React

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

🎒1. Замыканиесчётчик id спрятан в функции
🧊2. Без мутацийновые массивы вместо push
📁3. Модулитри файла вместо одного
⚛️4. КомпонентыTodoList и TodoItem на React

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

список дел → React

Часть 1 · 22 минуты Функции всерьёз

Области видимости, замыкания, чистые функции

Функция — значение

const double = (n) => n * 2;      // лежит в переменной

[1, 2, 3].map(double);              // передаётся в функцию

function makeGreeter(greeting) {
  return (name) => greeting + ', ' + name;   // возвращается
}
const hello = makeGreeter('Привет');
hello('Аня');                       // 'Привет, Аня'

Это было в лекции 6. Сегодня — что из этого следует.

Функции высшего порядка

Функция, которая принимает или возвращает другую функцию. Вы ими уже пользовались:

addEventListenerвызови потом, при клике
setTimeoutвызови через секунду
map, filterвызови для каждого элемента
makeGreeterвозвращает функцию

В Python то же самое: sorted(key=…) и декораторы.

Области видимости

🌍Глобальнаявидна всем скриптам страницы
📁Модульодин файл type="module" — в части 2
⚙️Функциявсё, что объявлено внутри неё
{ }Блокlet и const внутри фигурных скобок

Область видимости — часть кода, где переменная доступна по имени.

Изнутри видно наружу

глобальная
const shop = 'Кофейня';
функция order
const price = 220;
блок if
let discount = 20; // видит price и shop
discount; // ReferenceError: снаружи блока её нет

Поиск имени идёт изнутри наружу: блок → функция → глобальная. Наоборот — никогда.

Затенение

const name = 'Кофейня';

function greet() {
  const name = 'Аня';     // своя name закрывает внешнюю
  return 'Привет, ' + name;
}

greet();   // 'Привет, Аня'
name;      // 'Кофейня' — внешняя не изменилась

Поиск останавливается на первом найденном имени. Работает, но читается плохо — линтеры об этом предупреждают.

Что вернёт cafe()?

const drink = 'чай';

function order() {
  return drink;
}

function cafe() {
  const drink = 'кофе';
  return order();
}

'чай'

order ищет drink там, где её написали, а не там, откуда вызвали. Рядом с order есть только глобальная drink.

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

Так же в Python, C++ и Java.

Важно, где функция
написана, а не где вызвана Из этого правила и получаются замыкания

Замыкание

function makeCounter() {
  let count = 0;
  return () => {
    count = count + 1;
    return count;
  };
}

const counter = makeCounter();
counter();   // 1
counter();   // 2

makeCounter давно закончилась, а count жива и растёт.

Как это возможно

Замыкание — функция вместе с переменными того места, где она родилась.

Стрелка внутри makeCounter видит count — по правилу с прошлого слайда. Пока стрелка жива, она держит ссылку на count, и сборщик мусора её не трогает.

Удобная картинка: функция уходит наружу с рюкзаком 🎒, а в рюкзаке — переменные, которые она видела при рождении.

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

const a = makeCounter();
const b = makeCounter();

a();
a();
console.log(b());

Один count на двоих или у каждого свой?

1

Каждый вызов makeCounter создаёт новую переменную count. У a свой рюкзак, у b — свой.

Если вынести let count = 0 из функции наружу, рюкзаки опустеют — и счётчики начнут мешать друг другу. Это видно в демо.

В Python замыкания тоже есть

Python

def make_counter():
    count = 0
    def inc():
        nonlocal count
        count += 1
        return count
    return inc

JavaScript

function makeCounter() {
  let count = 0;
  return () => {
    count = count + 1;
    return count;
  };
}

В JS не нужен nonlocal: присваивание не создаёт новую переменную, если нет let или const.

Зачем 1: спрятать состояние

function makeId() {
  let last = 0;
  return () => ++last;
}

const nextId = makeId();
tasks.push({ id: nextId(), text: 'Начать ЛР 4', done: false });

До last не добраться снаружи — ни случайно, ни нарочно. Как private в Java, только без классов.

У дел появились id — пригодятся в React.

список дел → React

Зачем 2: обработчик помнит своё

for (const button of document.querySelectorAll('.drink')) {
  const name = button.dataset.name;

  button.addEventListener('click', () => {
    console.log('Заказ: ' + name);
  });
}

Цикл давно закончился, а каждый обработчик помнит свою name. Каждая итерация — новый блок и новая переменная.

Зачем 3: загадка var из лекции 6

var

for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i));
}
// 3 3 3

let

for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i));
}
// 0 1 2

С var переменная одна на весь цикл, и три стрелки замкнули одну и ту же i. let создаёт новую i на каждом шаге.

Зачем 4: React

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

  const handleClick = () => setCount(count + 1);

  return <button onClick={handleClick}>{count}</button>;
}

handleClick — замыкание: помнит count того вызова Counter, в котором родилась.

Подробно — в лекции 10: хуки React держатся на замыканиях.

Рекурсия

function countNodes(element) {
  let n = 1;
  for (const child of element.children) {
    n = n + countNodes(child);   // вызывает саму себя
  }
  return n;
}

countNodes(document.body);   // сколько элементов на странице

DOM — рекурсивное дерево: у детей свои дети.

🥚 На главной странице курса есть пасхалка recursion

Рекурсии нужен выход

function forever() {
  return forever();
}
forever();
// RangeError: Maximum call stack size exceeded

Каждый вызов занимает место в стеке. У countNodes выход есть: у листьев дерева нет детей, и цикл не выполняется ни разу.

Чтобы понять рекурсию, нужно сначала понять рекурсию.

Чистые функции

чистая

function countLeft(tasks) {
  return tasks
    .filter(t => !t.done)
    .length;
}

с побочным эффектом

function countLeft(tasks) {
  tasks.sort(byDate);
  title.textContent = tasks.length;
  return tasks
    .filter(t => !t.done)
    .length;
}

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

Часть 1 одним слайдом

📨Функция — значениееё передают, возвращают и хранят
📍Лексическая областьважно, где написано, а не где вызвано
🎒Замыканиефункция помнит переменные места рождения

И чистые функции — запомните это слово до части 3.

список дел → React

Часть 2 · 28 минут Современный синтаксис

Деструктуризация, spread, методы массивов, модули

2015

ES2015: язык стал другим

Самое большое обновление в истории JS: let и const, стрелки, шаблонные строки, классы, модули, деструктуризация, spread, промисы.

Его ещё называют ES6. Дальше — по версии в год.

1997 · ES11999 · ES32009 · ES52015 · ES62016…2025

Деструктуризация объекта

было

const name = coffee.name;
const price = coffee.price;

стало

const { name, price } = coffee;

Слева — шаблон, справа — объект. Каждое имя в фигурных скобках получает поле с тем же именем.

Поля, которого нет, — undefined, без ошибки.

Другое имя и значение по умолчанию

const coffee = { name: 'Латте', price: 0 };

const { name: title, size = 'M', price = 200 } = coffee;

title;   // 'Латте' — поле name под именем title
size;    // 'M'     — поля нет, взято значение по умолчанию
price;   // 0       — поле есть, по умолчанию не нужно

Значение по умолчанию срабатывает только для undefined. Ноль, пустая строка и null — настоящие значения.

Деструктуризация массива

const drinks = ['Капучино', 'Латте', 'Раф'];

const [first, second] = drinks;      // по позиции, а не по имени
const [, , third] = drinks;          // пропустить ненужные

let a = 1;
let b = 2;
[a, b] = [b, a];                     // обмен без временной переменной

То же, что распаковка в Python: first, second, *_ = drinks. В React так возвращает значения useState.

Деструктуризация параметров

было

function TodoItem(props) {
  const text = props.text;
  const done = props.done;
  …
}

стало

function TodoItem({ text, done }) {
  …
}

Функция получает один объект и сразу раскладывает его по переменным. Именно так компонент React получает свои данные.

Значения по умолчанию у параметров

function greet(name = 'гость') {
  return 'Привет, ' + name;
}
greet();          // 'Привет, гость'
greet('Аня');     // 'Привет, Аня'

function TodoList({ tasks, filter = 'all' }) { … }

Как в Python, но без ловушки с изменяемым значением по умолчанию: выражение вычисляется заново при каждом вызове.

Spread: разложить массив

const hot = ['Капучино', 'Латте'];
const cold = ['Лимонад'];

const copy = [...hot];                    // новый массив
const menu = [...hot, ...cold, 'Чай'];    // склеить и добавить
Math.max(...[220, 180, 250]);             // 250 — массив в аргументы

Три точки перед массивом — «вынуть все элементы и положить сюда по одному».

Spread: разложить объект

const task = { id: 2, text: 'Начать ЛР 4', done: false };

const copy = { ...task };                  // новый объект
const doneTask = { ...task, done: true };  // копия с одним изменением

Поля записываются слева направо, побеждает последнее. Поэтому изменения пишут после ...task.

{ done: true, ...task } — ошибка: done из task перезапишет true.

Rest: собрать остаток

function total(first, ...rest) {   // все остальные аргументы — массивом
  return rest.length;
}
total(1, 2, 3);    // 2

const { id, ...data } = task;      // id отдельно, остальное — объектом
const [head, ...tail] = drinks;

В Python это *args и head, *tail = drinks.

... — две роли Справа от = и в вызове — spread, раскладывает.
Слева от = и в параметрах — rest, собирает.

Изменится ли task?

const task = { text: 'ЛР 4', tags: ['react'] };
const copy = { ...task };

copy.text = 'ЛР 5';
copy.tags.push('срочно');

task.text;   // ?
task.tags;   // ?

Копия неглубокая

task.text — 'ЛР 4', не изменился. task.tags — ['react', 'срочно']: изменился.

Spread копирует только верхний уровень. В поле tags у копии лежит ссылка на тот же массив — объекты передаются по ссылке, как в лекции 6.

Полная копия — structuredClone(task). Нужна редко.

Изменить или заменить

мутация

tasks.push(newTask);
tasks[1].done = true;

тот же массив, тот же объект

новое значение

tasks = [...tasks, newTask];
tasks = tasks.map(t =>
  t.id === 2 ? { ...t, done: true } : t
);

новый массив, старый не тронут

Почему это важно для React

const before = tasks;
tasks.push(newTask);
before === tasks;    // true — «ничего не изменилось»

const after = [...tasks, newTask];
before === after;    // false — «есть изменения, перерисую»

Объекты сравниваются по ссылке — это было в лекции 6. React замечает изменения именно так: новая ссылка — новые данные. Мутацию он не увидит.

Добавить дело в React

🙅
tasks.push(task)
👉
[...tasks, task]

Первое работает в лекции 6 и тихо ломается в React.

Шпаргалка: изменения без мутаций

что сделатькак
добавить[...tasks, task]
удалитьtasks.filter(t => t.id !== id)
изменить одноtasks.map(t => t.id === id ? { ...t, done: !t.done } : t)
поменять поле объекта{ ...task, text: 'Новое' }

Ни одна строка не трогает старый массив — все возвращают новый.

список дел → React

?. — если есть

document.querySelector('.todo')?.classList.add('ready');

user?.address?.city;      // undefined, если чего-то нет по пути
callback?.();             // вызвать, если функцию передали

querySelector возвращает null, если ничего не нашёл, — первая ошибка ЛР 3. ?. останавливается на null и undefined и возвращает undefined вместо исключения.

?? — значение по умолчанию

const count = 0;

count || 10;    // 10 — || заменяет любое ложное, и ноль тоже
count ?? 10;    // 0  — ?? заменяет только null и undefined

const title = settings.title ?? 'Список дел';

Для чисел и строк, где 0 и '' — нормальные значения, нужен ??.

Методы массивов

методчто делаетвозвращает
mapпревращает каждый элементмассив той же длины
filterоставляет подходящиемассив покороче
reduceсворачивает в одно значениечто угодно
findищет первый подходящийэлемент или undefined
some, everyхоть один? все?true или false

Исходный массив не меняется ни одним из них.

map: каждый во что-то

const prices = [180, 220, 250];

prices.map(p => p * 2);              // [360, 440, 500]
prices.map(p => p + ' ₽');           // ['180 ₽', '220 ₽', '250 ₽']
tasks.map(t => t.text);              // ['Прочитать лекцию 7', 'Начать ЛР 4']

Функция вызывается для каждого элемента, её результаты собираются в новый массив. Как списковое включение [p * 2 for p in prices] в Python.

filter: только подходящие

prices.filter(p => p >= 200);         // [220, 250]
tasks.filter(t => !t.done);           // невыполненные дела
tasks.filter(t => t.id !== 2);        // все, кроме дела 2

Функция отвечает «оставить?» — true или false. Последняя строка — удаление без мутации со шпаргалки.

reduce: всё в одно

prices.reduce((sum, p) => sum + p, 0);     // 650

//  sum = 0
//  sum = 0 + 180   = 180
//  sum = 180 + 220 = 400
//  sum = 400 + 250 = 650

Первый аргумент — накопленное значение, второй — очередной элемент. Что функция вернёт, станет накопленным на следующем шаге. Последний аргумент reduce — с чего начать.

Цепочка

const total = orders
  .filter(o => o.paid)
  .map(o => o.price)
  .reduce((sum, p) => sum + p, 0);

Читается как описание: «оплаченные заказы → их цены → сумма». Каждый метод возвращает массив, поэтому следующий можно вызвать прямо на нём.

find, some, every

tasks.find(t => t.id === 2);       // { id: 2, text: 'Начать ЛР 4', … }
tasks.some(t => !t.done);          // true — есть хоть одно невыполненное
tasks.every(t => t.done);          // false — не все выполнены

Все три останавливаются, как только ответ ясен: find — на первом найденном, some — на первом true.

Что вернёт?

['1', '2', '3'].map(parseInt)

parseInt('1') — это 1. Казалось бы, ответ очевиден.

[1, NaN, NaN]

map передаёт функции три аргумента: элемент, индекс и сам массив. А parseInt вторым аргументом принимает систему счисления.
parseInt('1', 0)   // 1   — 0 значит «по умолчанию»
parseInt('2', 1)   // NaN — системы счисления 1 нет
parseInt('3', 2)   // NaN — в двоичной нет цифры 3

Правильно — .map(Number) или .map(s => parseInt(s, 10)).

Осторожно: sort мутирует

const prices = [250, 180, 220];

const sorted = prices.sort((a, b) => a - b);
prices;              // [180, 220, 250] — исходный тоже отсортирован
sorted === prices;   // true — это один и тот же массив

const fresh = prices.toSorted((a, b) => a - b);   // ES2023: новый массив

Мутируют ещё reverse, splice, push. У первых двух есть безопасные пары: toReversed, toSpliced.

Игра «Что выведет?»

Десять коротких фрагментов: области видимости, замыкания, деструктуризация, spread и методы массивов. Ответ проверяет настоящий JavaScript прямо в браузере.

Засчитывается только первая попытка. Прогресс сохраняется — можно доиграть дома.

Модули: зачем

<script src="tasks.js" defer></script>
<script src="render.js" defer></script>
<script src="main.js" defer></script>

export и import

tasks.js

export const tasks = [];

export function addTask(text) {
  …
}

main.js

import { tasks, addTask }
  from './tasks.js';

addTask('Начать ЛР 4');

У каждого модуля своя область видимости. Наружу видно только то, что помечено export. Зависимости записаны в самом файле.

Именованный и default

// именованный: сколько угодно на файл
export function TodoItem() { … }
import { TodoItem } from './TodoItem.js';   // имя то же

// default: один на файл
export default function App() { … }
import App from './App.js';                 // имя любое

В React-проектах встречаются оба.

Подключить модуль

<script type="module" src="main.js"></script>

Ловушка: открыть файл двойным кликом

Access to script at 'file:///…/main.js' from origin 'null'
has been blocked by CORS policy

С адреса file:// браузер модули не загружает. Нужен локальный сервер — хватит любого:

Список дел в трёх файлах

файлчто внутриexport
tasks.jsданные и изменения без мутацийgetTasks, addTask, toggleTask
render.jsрисует список по массивуrender
main.jsсобытия: форма и кликиничего

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

список дел → React

Импорт без ./

import { tasks } from './tasks.js';     // свой файл: путь с расширением
import { useState } from 'react';       // пакет из npm: просто имя

Вторая строка в браузере сама по себе не заработает: имя пакета превращает в путь к файлу сборщик. Он же склеивает модули перед публикацией.

npm и сборщик Vite — лекция 8.

Часть 2 одним слайдом

const { a, b } = objдеструктуризация — и в параметрах функций
{ ...task, done: true }копия с изменением, без мутации
filter → map → reduceописать, что нужно, а не как
import / exportу каждого файла своя область

Теперь код с начала лекции читается целиком — кроме разметки внутри JS.

список дел → React

Часть 3 · 30 минут Введение в React

Декларативный подход, JSX, компоненты, props

Одно дело — четыре места

function toggleTask(id) {
  const task = tasks.find(t => t.id === id);
  task.done = !task.done;
  itemById(id).classList.toggle('done');
  counter.textContent = tasks.filter(t => !t.done).length;
  badge.hidden = tasks.every(t => t.done);
  emptyMessage.hidden = tasks.length > 0;
}

Чем больше интерфейс, тем больше мест, которые нужно не забыть обновить. Забыли одно — страница показывает неправду.

Два способа объяснить дорогу

императивно

«Прямо двести метров, на светофоре налево, после аптеки направо, второй дом»

декларативно

«Невский проспект, 28»

Императивно — описать шаги. Декларативно — описать результат, а шаги пусть придумает тот, кто везёт.

То же в коде

шаги: лекция 6

const li = document.createElement('li');
li.className = 'todo__item';
li.textContent = task.text;
list.append(li);

результат: React

<li className="todo__item">{task.text}</li>

Справа нет ни одного «создай», «добавь», «вставь» — только как должно выглядеть.

Вы уже писали декларативно

🧱HTMLчто есть на странице, а не как это рисовать
🎨CSSdisplay: grid — без расчёта координат
🗄SQLSELECT … WHERE — без циклов по таблице

React приносит этот подход в JavaScript.

UI = f(данные) Интерфейс — функция от данных. Данные поменялись — вызвали функцию ещё раз.

2013

React

Джордан Уок пишет его в Facebook для ленты новостей, в 2013 году библиотеку открывают для всех. JSX на первой презентации встречают в штыки: «смешали HTML и JavaScript».

Сегодня React — самая популярная библиотека для интерфейсов, на нём написаны Facebook, Instagram, Netflix, Discord.

Тем временем во фронтенде

0 дней без нового
JavaScript-фреймворка

Новые появляются постоянно. Но идея «UI = f(данные)» теперь почти у всех, и после React остальные учатся за неделю. Лекция 14.

dayssincelastjavascriptframework.com

Библиотека, а не фреймворк

React делает одно: превращает данные в интерфейс и держит их в согласии. Всё остальное — отдельные библиотеки на выбор:

адреса страницReact Router — лекция 12
данные с сервераTanStack Query — лекция 13
всё сразуфреймворк Next.js — лекция 15

Как React обновляет страницу

данныеизменились
→
компонентвызывается заново
→
сравнениес прошлым описанием
→
DOMтолько отличия

Компонент каждый раз описывает интерфейс целиком, как наш render(). Но в DOM React вносит только то, что поменялось.

Описание — это просто объекты

const element = <li className="todo__item">Начать ЛР 4</li>;

console.log(element);
// { type: 'li',
//   props: { className: 'todo__item', children: 'Начать ЛР 4' },
//   … }

Не элемент DOM, а лёгкий объект «что должно быть». Создать тысячу таких — дёшево, сравнить два дерева — быстро. Дерево таких объектов называют виртуальным DOM.

SPA: одна страница

обычный сайт

каждая ссылка — новый HTML с сервера, страница загружается заново

single-page application

один HTML, дальше JS сам меняет содержимое и адрес в строке

Gmail, Figma, ВКонтакте: переходы мгновенные, состояние не теряется. React чаще всего используют именно так.

У SPA есть цена

Как это лечат рендерингом на сервере — лекции 14 и 15.

JSX — это не HTML Это JavaScript, который выглядит как HTML

Во что превращается JSX

пишем

<li className="todo__item">
  {task.text}
</li>

получает браузер

React.createElement(
  'li',
  { className: 'todo__item' },
  task.text
)

Браузер JSX не понимает. Перед запуском его переводит в обычные вызовы функций Babel или сборщик. Поэтому внутри JSX работают все правила JavaScript.

Правило 1: один корень

ошибка

return (
  <h1>Список дел</h1>
  <ul>…</ul>
);

так можно

return (
  <>
    <h1>Список дел</h1>
    <ul>…</ul>
  </>
);

Функция возвращает одно значение — значит, и один вызов createElement. Пустой тег <> — фрагмент: обёртка, которой не будет в DOM.

Правило 2: имена из JavaScript

HTMLJSXпочему
class="…"className="…"class — слово языка
for="…"htmlFor="…"for — тоже
tabindex, onclicktabIndex, onClickcamelCase, как свойства DOM
style="color: red"style={{ color: 'red' }}объект, а не строка

Двойные фигурные скобки — не особый синтаксис: внешние значат «здесь JS», внутренние — литерал объекта.

Правило 3: строгость и выражения

<p>{left === 0 ? 'Всё сделано' : 'Осталось: ' + left}</p>

Класс в JSX

🙅
<li class="todo__item">
👉
<li className="todo__item">

Самая частая ошибка первой недели. React подскажет в консоли: «Invalid DOM property class. Did you mean className?»

Что не так в этом JSX?

return (
  <label for="task">Новое дело</label>
  <input id="task" class="todo__input">
  {if (error) { <p>Пустое дело не добавить</p> }}
);

Ошибок здесь больше двух.

Пять ошибок

  1. три корня — нужна обёртка <>…</>
  2. for → htmlFor
  3. class → className
  4. <input> не закрыт → <input />
  5. if в фигурных скобках → {error && <p>…</p>}

&& вернёт правую часть, только если левая истинна. Подробно про условия в JSX — лекция 10.

JSX защищает от XSS

const name = '<img src=x onerror="…">';

<p>Привет, {name}</p>    // на странице — текст «<img src=x …»

Всё, что попадает в { }, вставляется как текст — как textContent из лекции 6. Ошибка с innerHTML в React просто не случается.

Вставить сырой HTML можно, но свойство нарочно называется dangerouslySetInnerHTML.

Компонент — функция

function Header() {
  return (
    <header className="todo__header">
      <h1>Список дел</h1>
    </header>
  );
}

<Header />     // используем как тег

Компонент — обычная функция, которая возвращает JSX. Свой тег, из которого собирается интерфейс, как дом из кирпичей.

Имя — с большой буквы

<header />

строчная буква — HTML-тег <header>, наш компонент не вызовется

<Header />

заглавная — компонент: React вызовет функцию Header

По первой букве Babel решает, что написать: строку 'header' или переменную Header.

Компоненты из компонентов

function TodoApp() {
  return (
    <main className="todo">
      <Header />
      <TodoForm />
      <TodoList />
    </main>
  );
}

Большой интерфейс — дерево маленьких компонентов. Каждый можно понять, проверить и переиспользовать отдельно.

Дерево компонентов

Расширение React DevTools показывает это дерево на любом сайте на React.

Props — аргументы компонента

<TodoItem text="Начать ЛР 4" done={false} />

function TodoItem(props) {
  props;   // { text: 'Начать ЛР 4', done: false }
}

Атрибуты тега превращаются в один объект — props — и приходят первым аргументом.

Props и деструктуризация

function TodoItem({ text, done = false }) {
  return (
    <li className={done ? 'done' : ''}>
      {text}
    </li>
  );
}

Вот где пригодилась часть 2: props раскладываются прямо в параметрах, там же — значения по умолчанию.

Строка или выражение

<TodoItem
  text="Начать ЛР 4"      // строка — в кавычках
  done={false}            // всё остальное — в фигурных скобках
  priority={2}
  tags={['react', 'лр']}
/>

done="false" — частая ошибка: это строка, а непустая строка истинна. Дело окажется выполненным.

Props только для чтения

function TodoItem(props) {
  props.done = true;           // при разработке — TypeError
  props.text.toUpperCase();    // можно: новая строка, props не тронуты
  …
}

Компонент не меняет то, что ему передали. При одинаковых props он возвращает одинаковый JSX и ничего снаружи не трогает.

Компонент — чистая функция
от props То самое слово из части 1

children

function Card({ title, children }) {
  return (
    <section className="card">
      <h2>{title}</h2>
      {children}
    </section>
  );
}

<Card title="Сегодня"><TodoList /></Card>

Всё, что внутри тега, приходит в особом props children. Так делают обёртки: карточки, модальные окна, раскладки.

В props можно передать функцию

<TodoItem
  text="Начать ЛР 4"
  onToggle={() => toggleTask(2)}
/>

function TodoItem({ text, onToggle }) {
  return <li onClick={onToggle}>{text}</li>;
}

Данные текут вниз через props, а сигнал «по мне кликнули» — вверх через функцию. Это лекция 10.

Списки: map в JSX

function TodoList({ tasks }) {
  return (
    <ul className="todo__list">
      {tasks.map(task => (
        <TodoItem key={task.id} text={task.text} done={task.done} />
      ))}
    </ul>
  );
}

Ни цикла, ни append: массив данных превращается в массив элементов, и React вставляет его в <ul>.

Зачем key

После изменения React сравнивает старый список с новым. По key он понимает, какой пункт какой: этот удалили, этот переставили, этот новый.

Вот зачем дела получили id из makeId().

Список дел на React, 1/2

function TodoItem({ text, done }) {
  const mod = done ? ' todo__item--done' : '';
  return (
    <li className={'todo__item' + mod}>
      <span className="todo__check" />
      <span className="todo__text">{text}</span>
    </li>
  );
}

function TodoList({ tasks }) {
  return (
    <ul className="todo__list">
      {tasks.map(t => <TodoItem key={t.id} {...t} />)}
    </ul>
  );
}
список дел → React

Список дел на React, 2/2

function TodoApp({ tasks }) {
  const left = tasks.filter(t => !t.done).length;
  return (
    <div className="todo">
      <p className="todo__head">
        Осталось: {left} из {tasks.length}
      </p>
      <TodoList tasks={tasks} />
    </div>
  );
}

const app = document.querySelector('#app');
ReactDOM.createRoot(app).render(<TodoApp tasks={tasks} />);
список дел → React

Список дел на React: работает

Настоящий React прямо на слайде. Попробуйте кликнуть по делу.

список дел → React

Клик ничего не делает

И это честно: компонент — чистая функция от props. Он нарисовал то, что ему передали, и всё. Помнить «это дело отметили» ему негде.

Нужно состояние — данные, которые живут внутри компонента и при изменении сами вызывают перерисовку. Это useState, главная тема лекции 10.

Что изменилось с лекции 6

лекция 6React
разметкаcreateElement и appendJSX — как выглядит
перерисовкавсё через innerHTML = ''только отличия
XSSследить самимэкранирует сам
вызвать render()не забыть после каждого изменениялекция 10

Последняя строка — то, ради чего React нужен больше всего. Ей нужен useState.

Где попробовать

🧪JSX-лабораторияиз этой лекции: JSX → JS → результат
📖ru.react.devв учебнике песочница прямо на странице
🛠React DevToolsрасширение: дерево компонентов и props

Настоящий проект с npm create vite — в лекции 8.

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

И что дальше

Компонент — функция:
props на входе, описание интерфейса на выходе React сам приводит страницу к этому описанию

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

🎒Функциилексическая область видимости, замыкания, чистые функции
🧊Синтаксисдеструктуризация, spread, map и filter вместо мутаций, модули
⚛️ReactUI = f(данные), JSX, компоненты, props, key

Первые две карточки нужны в React каждый день. Без них код на React не читается.

Что почитать

ru.react.dev/learnофициальный учебник React, переведён на русский
learn.javascript.ruглавы «Замыкание» и «Модули»
Докаdoka.guide/js — деструктуризация, spread
QR-код со ссылкой на учебник ru.react.dev/learn ru.react.dev/learn первый раздел — до лекции 10

Лекция 8. TypeScript и инструменты

Список дел получит типы и переедет в настоящий проект. Клик заработает в лекции 10.

Вопросы?

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