Веб-программирование
Веб-программирование · лекция 7 из 16
tasksrender()
Список дел в сорок строк — и три неудобства: render()
перерисовывает всё, его легко забыть вызвать, разметка собирается
десятком createElement.
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} | spread | 2 |
<ul> внутри JS | JSX | 3 |
Через час каждая строка будет читаться без усилия.
И весь путь — на том же списке дел.
id спрятан в функцииpushTodoList и TodoItem на ReactПлашка в правом нижнем углу покажет, на каком шаге мы сейчас.
Области видимости, замыкания, чистые функции
const double = (n) => n * 2; // лежит в переменной
[1, 2, 3].map(double); // передаётся в функцию
function makeGreeter(greeting) {
return (name) => greeting + ', ' + name; // возвращается
}
const hello = makeGreeter('Привет');
hello('Аня'); // 'Привет, Аня'
Это было в лекции 6. Сегодня — что из этого следует.
Функция, которая принимает или возвращает другую функцию. Вы ими уже пользовались:
В Python то же самое: sorted(key=…) и декораторы.
type="module" — в части 2let и const внутри фигурных скобокОбласть видимости — часть кода, где переменная доступна по имени.
Поиск имени идёт изнутри наружу: блок → функция → глобальная. Наоборот — никогда.
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 на двоих или у каждого свой?
1makeCounter создаёт новую переменную
count. У a свой рюкзак, у b — свой.
Если вынести let count = 0 из функции наружу, рюкзаки
опустеют — и счётчики начнут мешать друг другу. Это видно в демо.
def make_counter():
count = 0
def inc():
nonlocal count
count += 1
return count
return inc
function makeCounter() {
let count = 0;
return () => {
count = count + 1;
return count;
};
}
В JS не нужен nonlocal: присваивание не создаёт новую
переменную, если нет let или const.
function makeId() {
let last = 0;
return () => ++last;
}
const nextId = makeId();
tasks.push({ id: nextId(), text: 'Начать ЛР 4', done: false });
До last не добраться снаружи — ни случайно, ни нарочно.
Как private в Java, только без классов.
У дел появились id — пригодятся в React.
for (const button of document.querySelectorAll('.drink')) {
const name = button.dataset.name;
button.addEventListener('click', () => {
console.log('Заказ: ' + name);
});
}
Цикл давно закончился, а каждый обработчик помнит свою
name. Каждая итерация — новый блок и новая переменная.
var из лекции 6varfor (var i = 0; i < 3; i++) {
setTimeout(() => console.log(i));
}
// 3 3 3
letfor (let i = 0; i < 3; i++) {
setTimeout(() => console.log(i));
}
// 0 1 2
С var переменная одна на весь цикл, и три стрелки замкнули
одну и ту же i. let создаёт новую
i на каждом шаге.
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;
}
Чистая: одинаковый вход — одинаковый результат, снаружи ничего не трогает. Правая переставляет чужой массив и меняет страницу.
И чистые функции — запомните это слово до части 3.
Деструктуризация, spread, методы массивов, модули
Самое большое обновление в истории JS: let и
const, стрелки, шаблонные строки, классы, модули,
деструктуризация, spread, промисы.
Его ещё называют ES6. Дальше — по версии в год.
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, но без ловушки с изменяемым значением по умолчанию: выражение вычисляется заново при каждом вызове.
const hot = ['Капучино', 'Латте'];
const cold = ['Лимонад'];
const copy = [...hot]; // новый массив
const menu = [...hot, ...cold, 'Чай']; // склеить и добавить
Math.max(...[220, 180, 250]); // 250 — массив в аргументы
Три точки перед массивом — «вынуть все элементы и положить сюда по одному».
const task = { id: 2, text: 'Начать ЛР 4', done: false };
const copy = { ...task }; // новый объект
const doneTask = { ...task, done: true }; // копия с одним изменением
Поля записываются слева направо, побеждает последнее. Поэтому
изменения пишут после ...task.
{ done: true, ...task } — ошибка: done из
task перезапишет true.
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
);
новый массив, старый не тронут
const before = tasks;
tasks.push(newTask);
before === tasks; // true — «ничего не изменилось»
const after = [...tasks, newTask];
before === after; // false — «есть изменения, перерисую»
Объекты сравниваются по ссылке — это было в лекции 6. 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: 'Новое' } |
Ни одна строка не трогает старый массив — все возвращают новый.
?. — если есть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, everytasks.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>
render в разных файлах — одна молча затрёт другуюexport и importexport const tasks = [];
export function addTask(text) {
…
}
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>
defer не нужен — модуль и так ждёт разметкуmain.js подтянет сам через importAccess to script at 'file:///…/main.js' from origin 'null'
has been blocked by CORS policy
С адреса file:// браузер модули не загружает. Нужен
локальный сервер — хватит любого:
python3 -m http.server в папке проекта| файл | что внутри | export |
|---|---|---|
tasks.js | данные и изменения без мутаций | getTasks, addTask, toggleTask |
render.js | рисует список по массиву | render |
main.js | события: форма и клики | ничего |
Каждый файл знает только то, что импортировал. React-проект устроен так же: один компонент — один файл.
./import { tasks } from './tasks.js'; // свой файл: путь с расширением
import { useState } from 'react'; // пакет из npm: просто имя
Вторая строка в браузере сама по себе не заработает: имя пакета превращает в путь к файлу сборщик. Он же склеивает модули перед публикацией.
npm и сборщик Vite — лекция 8.
const { a, b } = objдеструктуризация — и в параметрах функций{ ...task, done: true }копия с изменением, без мутацииfilter → map → reduceописать, что нужно, а не какimport / exportу каждого файла своя областьТеперь код с начала лекции читается целиком — кроме разметки внутри JS.
Декларативный подход, 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»
Императивно — описать шаги. Декларативно — описать результат, а шаги пусть придумает тот, кто везёт.
const li = document.createElement('li');
li.className = 'todo__item';
li.textContent = task.text;
list.append(li);
<li className="todo__item">{task.text}</li>
Справа нет ни одного «создай», «добавь», «вставь» — только как должно выглядеть.
display: grid — без расчёта координатSELECT … WHERE — без циклов по таблицеReact приносит этот подход в JavaScript.
Джордан Уок пишет его в Facebook для ленты новостей, в 2013 году библиотеку открывают для всех. JSX на первой презентации встречают в штыки: «смешали HTML и JavaScript».
Сегодня React — самая популярная библиотека для интерфейсов, на нём написаны Facebook, Instagram, Netflix, Discord.
Новые появляются постоянно. Но идея «UI = f(данные)» теперь почти у всех, и после React остальные учатся за неделю. Лекция 14.
dayssincelastjavascriptframework.comReact делает одно: превращает данные в интерфейс и держит их в согласии. Всё остальное — отдельные библиотеки на выбор:
Компонент каждый раз описывает интерфейс целиком, как наш
render(). Но в DOM React вносит только то, что
поменялось.
const element = <li className="todo__item">Начать ЛР 4</li>;
console.log(element);
// { type: 'li',
// props: { className: 'todo__item', children: 'Начать ЛР 4' },
// … }
Не элемент DOM, а лёгкий объект «что должно быть». Создать тысячу таких — дёшево, сравнить два дерева — быстро. Дерево таких объектов называют виртуальным DOM.
каждая ссылка — новый HTML с сервера, страница загружается заново
один HTML, дальше JS сам меняет содержимое и адрес в строке
Gmail, Figma, ВКонтакте: переходы мгновенные, состояние не теряется. React чаще всего используют именно так.
Как это лечат рендерингом на сервере — лекции 14 и 15.
<li className="todo__item">
{task.text}
</li>
React.createElement(
'li',
{ className: 'todo__item' },
task.text
)
Браузер JSX не понимает. Перед запуском его переводит в обычные вызовы функций Babel или сборщик. Поэтому внутри JSX работают все правила JavaScript.
return (
<h1>Список дел</h1>
<ul>…</ul>
);
return (
<>
<h1>Список дел</h1>
<ul>…</ul>
</>
);
Функция возвращает одно значение — значит, и один вызов
createElement. Пустой тег <> —
фрагмент: обёртка, которой не будет в DOM.
| HTML | JSX | почему |
|---|---|---|
class="…" | className="…" | class — слово языка |
for="…" | htmlFor="…" | for — тоже |
tabindex, onclick | tabIndex, onClick | camelCase, как свойства DOM |
style="color: red" | style={{ color: 'red' }} | объект, а не строка |
Двойные фигурные скобки — не особый синтаксис: внешние значат «здесь JS», внутренние — литерал объекта.
<img />, <br />, <input />{ } — только выражения: то, что можно присвоить переменнойif и for внутри { } нельзя — вместо них ? : и map<p>{left === 0 ? 'Всё сделано' : 'Осталось: ' + left}</p>
<li class="todo__item"><li className="todo__item">
Самая частая ошибка первой недели. React подскажет в консоли:
«Invalid DOM property class. Did you mean
className?»
return (
<label for="task">Новое дело</label>
<input id="task" class="todo__input">
{if (error) { <p>Пустое дело не добавить</p> }}
);
Ошибок здесь больше двух.
<>…</>for → htmlForclass → className<input> не закрыт → <input />if в фигурных скобках → {error && <p>…</p>}
&& вернёт правую часть, только если левая истинна.
Подробно про условия в JSX — лекция 10.
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.
<TodoItem text="Начать ЛР 4" done={false} />
function TodoItem(props) {
props; // { text: 'Начать ЛР 4', done: false }
}
Атрибуты тега превращаются в один объект — 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" — частая ошибка: это строка, а непустая
строка истинна. Дело окажется выполненным.
function TodoItem(props) {
props.done = true; // при разработке — TypeError
props.text.toUpperCase(); // можно: новая строка, props не тронуты
…
}
Компонент не меняет то, что ему передали. При одинаковых props он возвращает одинаковый JSX и ничего снаружи не трогает.
childrenfunction Card({ title, children }) {
return (
<section className="card">
<h2>{title}</h2>
{children}
</section>
);
}
<Card title="Сегодня"><TodoList /></Card>
Всё, что внутри тега, приходит в особом props children.
Так делают обёртки: карточки, модальные окна, раскладки.
<TodoItem
text="Начать ЛР 4"
onToggle={() => toggleTask(2)}
/>
function TodoItem({ text, onToggle }) {
return <li onClick={onToggle}>{text}</li>;
}
Данные текут вниз через props, а сигнал «по мне кликнули» — вверх через функцию. Это лекция 10.
map в JSXfunction 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
Вот зачем дела получили id из makeId().
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>
);
}
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 прямо на слайде. Попробуйте кликнуть по делу.
И это честно: компонент — чистая функция от props. Он нарисовал то, что ему передали, и всё. Помнить «это дело отметили» ему негде.
Нужно состояние — данные, которые живут внутри компонента и при
изменении сами вызывают перерисовку. Это useState,
главная тема лекции 10.
| лекция 6 | React | |
|---|---|---|
| разметка | createElement и append | JSX — как выглядит |
| перерисовка | всё через innerHTML = '' | только отличия |
| XSS | следить самим | экранирует сам |
вызвать render() | не забыть после каждого изменения | лекция 10 |
Последняя строка — то, ради чего React нужен больше всего. Ей нужен
useState.
Настоящий проект с npm create vite — в лекции 8.
И что дальше
map и filter вместо мутаций, модулиkeyПервые две карточки нужны в React каждый день. Без них код на React не читается.
type, interface и genericspackage.jsonСписок дел получит типы и переедет в настоящий проект. Клик заработает в лекции 10.
Слайды, демо и игра — в репозитории курса