Веб-программирование
Веб-программирование · лекция 6 из 16
Сегодня страница начнёт думать: реагировать на клики, проверять формы, менять саму себя.
Брендан Эйх пишет первую версию для браузера Netscape: простой язык, чтобы «оживлять» страницы.
Название «JavaScript» — маркетинг: Java тогда была на пике моды. Общего у них — четыре буквы.
Стандарт называется ECMAScript, версии выходят каждый год.
Java относится к JavaScript, как car к carpet. Общие четыре буквы — и больше ничего.
единственный язык, который браузер понимает сам. Сегодня — здесь
Node.js: серверы, сборщики, инструменты. Лекция 10
Язык один и тот же. Разное — то, что вокруг: в браузере есть
страница и document, на сервере — файлы и сеть.
<head>
<script src="script.js" defer></script>
</head>
Без defer браузер выполнит скрипт, как только до него
дочитает, — когда остальной разметки ещё нет, и скрипт не найдёт
элементы, которые ищет.
defer — «скачай сейчас, выполни, когда дочитаешь страницу».
Как браузер читает страницу — лекция 1.
console.log('Hello, world');
Вывод — в консоль: DevTools, вкладка Console. Там же можно писать JS прямо в работающую страницу — удобнее любой песочницы.
F12 или Cmd+Option+J. Держите её открытой всю ЛР 3: все ошибки — там.
🥚 На главной странице курса есть пасхалка hello world
И весь путь — на одном примере: списке дел.
Только отличия
Переменные, условия, циклы, функции, списки и словари — всё это в JS есть и выглядит почти как в C++ или Java.
Поэтому дальше — не учебник, а список отличий: где JS ведёт себя не так, как Python и C++, и на чём ломаются в первую неделю.
document, таймеры, сетьЧетыре вещи, которые объясняют почти всё странное в поведении JS.
| движок | где работает |
|---|---|
| V8 | Chrome, Edge, Яндекс Браузер, Node.js |
| SpiderMonkey | Firefox |
| JavaScriptCore | Safari |
Сначала код просто выполняется строка за строкой. Если функция вызывается часто, движок на лету компилирует её в машинный код — JIT, just-in-time. Поэтому современный JS быстрый, хотя компилятора, как у C++, у вас нет.
переменные, функции, массивы, объекты, if и циклы
document, console, setTimeout, fetch, localStorage
document — не часть языка. Его даёт браузер. В
Node.js никакого document нет, зато есть файлы и сеть.
Поэтому на MDN рядом с методом пишут «Web API».
JavaScript в странице выполняет одну задачу за раз. Пока крутится ваш
цикл на миллиард итераций, браузер не может ни нажать кнопку, ни
прокрутить страницу, — это то самое демо jank-lab из
лекции 4.
А ждать — таймеров, кликов, ответа сервера — JS умеет, не стоя на месте: браузер кладёт «вызови потом» в очередь, и функции выполняются по одной, когда поток свободен. Это event loop — подробно в лекции 9.
const a = { text: 'Начать ЛР 3' };
const b = a; // не копия, а вторая ссылка
b.text = 'Сдать ЛР 3';
a.text // 'Сдать ЛР 3'
Объекты и массивы передаются по ссылке — как в Python и Java. Примитивы копируются. А освобождать память не нужно: объект удалит сборщик мусора, когда на него не останется ни одной ссылки.
documentlet и constconst price = 220; // переприсвоить нельзя
let count = 0; // можно
count = count + 1;
По умолчанию — const. let — только когда
значение правда меняется. Так по коду сразу видно, что меняется, а что
нет.
const list = [];
list.push('Купить кофе');
const — «нельзя менять». А мы меняем массив.
const запрещает переприсвоить
переменную, а не менять то, что в ней лежит.
list.push('Ещё дело'); // можно: тот же массив
list = []; // TypeError: Assignment
// to constant variable
Как final в Java: ссылка неизменна, объект — нет.
var: видна во всей функцииif (true) {
var a = 1;
let b = 2;
}
console.log(a); // 1 — var «вытекла» из блока
console.log(b); // ReferenceError: b is not defined
До 2015 года var был единственным способом объявить
переменную. Его область видимости — вся функция, а не блок в
фигурных скобках, как у let, const и
переменных в C++ и Java.
var: подъёмconsole.log(x); // undefined — не ошибка!
var x = 5;
console.log(y); // ReferenceError: Cannot access 'y'
let y = 5; // before initialization
Объявления var движок поднимает в начало функции,
а присваивание оставляет на месте. Переменная существует до своей
строки и равна undefined. С let до строки
объявления — «мёртвая зона» и честная ошибка.
for (var i = 0; i < 3; i++) {
setTimeout(() =>
console.log(i));
}
// 3, 3, 3
for (let i = 0; i < 3; i++) {
setTimeout(() =>
console.log(i));
}
// 0, 1, 2
С var переменная одна на весь цикл: к моменту, когда
сработают таймеры, она уже равна 3. let создаёт новую
i на каждый шаг.
var на верхнем уровнеvar name = 123;
typeof name // 'string' ?!
Глобальная var становится свойством window.
А window.name у браузера уже есть, и он всегда строка —
ваше число молча превратилось в '123'.
Итог: в новом коде var не нужен, в ЛР 3
запрещён. Но в чужом коде и старых ответах на форумах он повсюду —
узнавать надо.
220, 0.5'кофе'true, false10n, огромные целые
В ЛР понадобятся первые пять и object.
typeof 42 // 'number'
typeof 4.2 // 'number'
0.1 + 0.2 // 0.30000000000000004
Нет отдельных int и float: number
— это всегда double. Ошибка округления та же, что в любом
языке, но здесь от неё не уйти в целый тип.
🥚 На главной странице курса: 0.1 + 0.2
let x = 5; // число
x = 'пять'; // теперь строка — и это законно
typeof x // 'string'
Как в Python, а не как в C++ и Java. Компилятора, который поймает ошибку типов до запуска, нет — ошибка случится при работе.
Именно это исправляет TypeScript — лекция 10.
undefinedзначение не задавали: переменная без значения, нет такого поля, функция ничего не вернула
null«пусто» задали явно: элемента не нашлось, ничего не выбрано
querySelector возвращает null, если элемента
нет. Это первая ошибка в ЛР 3: «Cannot read properties of null».
const left = 2;
const text = `Осталось дел: ${left}`;
Обратные кавычки и ${…} — это f-строки из Python. Внутри
скобок — любое выражение.
'5' + 2 падает.'5' + 2 // '52'
'5' - 2 // 3
Плюс со строкой склеивает: число превращается в строку. Минус склеивать не умеет и превращает строку в число.
Самая частая ошибка в формах: значение из <input> —
всегда строка. input.value + 1 даст '51', а
не 6. Нужен Number(input.value).
'5' + 2 → '52'
Да здравствует Санкт-Петербург
'5' * '2' // 10
'5' + - '2' // '5-2'
[] == ![] // true: равен своему отрицанию
('b' + 'a' + +'a' + 'a') // 'baNaNa'
Последняя строка: +'a' пытается сделать из буквы число и
получает NaN. Остальное склеивается. Вывод тот же, что из
всего блока: не смешивайте типы и сравнивайте через
===.
🥚 Все эти выражения — варианты пасхалки 0.1 + 0.2 на главной
== и ==='10' == 10 → true: приводит типы'10' === 10 → false: разные типы
Правило курса: всегда === и !==.
Почему — на следующих слайдах.
=====null и undefined равны только друг другуtrue / false — сначала в 1 / 0Это упрощение: в стандарте алгоритм занимает полторы страницы.
==0 == '' // true
0 == '0' // true
'' == '0' // false — а ведь оба равны нулю
false == '0' // true
false == 'false' // false
null == 0 // false
[1, 2] == '1,2' // true
Первые три строки — главное: == даже не
транзитивно. Из a == b и a == c не
следует b == c. Математика плачет.
true == 2
2 — истинное значение, if (2) выполнится.
Значит, true == 2?
false== не проверяет истинность. По правилу 4
true сначала становится 1, а
1 == 2 — ложь.
«Истинное» в if и «равное true» в
== — разные вещи. Ещё одна причина писать
=== и не сравнивать с true вообще:
if (task.done), а не if (task.done == true).
=== тоже со странностямиNaN === NaN // false: не равен ничему
+0 === -0 // true: хотя числа разные
Object.is(NaN, NaN) // true
Object.is(0, -0) // false
Обе странности — из стандарта чисел с плавающей точкой, а не из JS.
Object.is — «точно то же самое значение». Нужен редко;
проверять NaN удобнее через Number.isNaN(x).
[] === [] // false
({ a: 1 }) === ({ a: 1 }) // false
const a = [];
const b = a;
a === b // true: один массив
И ==, и === для объектов проверяют не
содержимое, а тот же ли это объект. Два одинаковых массива —
два разных объекта. Это ещё вернётся в React: там именно так
проверяют, изменилось ли состояние.
const tasks = [];
if (tasks) {
console.log('Есть дела');
}
В Python if []: не выполнится: пустой список ложный.
Ложных значений всего шесть:
false, 0, '', null,
undefined, NaN. Всё остальное истинно —
включая '0', [] и {}.
if (tasks.length === 0) { … } // так проверяют пустой массив
Десять выражений. Нужно угадать, что ответит консоль. Ответ каждый раз проверяется настоящим JavaScript прямо в браузере.
Название — из знаменитого доклада Гэри Бернхардта 2012 года, где зал
хохочет над выражениями вроде [] + {}.
if (left === 0) { … } else { … }
const label = left === 0 ? 'Всё сделано' : 'Есть дела';
// как в C++
for (let i = 0; i < tasks.length; i++) { … }
// как for x in tasks в Python
for (const task of tasks) { … }
Ловушка: есть ещё for…in, и он идёт по ключам, а не
по значениям. Для массивов — только for…of.
const tasks = ['Лекция', 'ЛР'];
tasks.length // 2
tasks[0] // 'Лекция'
tasks.push('Кофе');
tasks.includes('ЛР') // true
const task = {
text: 'Начать ЛР 3',
done: false,
};
task.text
task['done'] = true;
Литералы [] и {} — как list и dict в Python.
Поле объекта читается через точку.
const tasks = [
{ text: 'Прочитать лекцию 6', done: true },
{ text: 'Начать ЛР 3', done: false },
{ text: 'Купить кофе', done: false },
];
Массив объектов — форма, в которой живёт почти любой интерфейс: список товаров, сообщений, дел. Сначала — данные, а не разметка.
function countLeft(tasks) {
let left = 0;
for (const task of tasks) {
if (!task.done) left++;
}
return left;
}
const double = (x) => x * 2; // стрелочная функция
Два способа записать функцию. Стрелочная — короче, для маленьких функций.
function и () => {}function | () => {} | |
|---|---|---|
| короткая запись | нет | x => x * 2, без return |
| вызов до объявления | можно (подъём) | нельзя: это const |
свой this | есть, зависит от вызова | нет, берёт снаружи |
arguments | есть | нет |
new | можно | TypeError |
render(); // работает
function render() { … }
render(); // ReferenceError
const render = () => { … };
Объявление function поднимается целиком, вместе с телом.
Поэтому главные функции можно писать внизу файла, а вызывать вверху.
Стрелочная функция — это значение в переменной: до строки объявления
её нет.
const make = () => { text: 'Купить кофе' };
make();
Стрелочная функция без return возвращает выражение. Здесь
выражение — объект.
undefinedtext: и строка, которая ничего не делает.
return нет — значит, undefined.
Чтобы вернуть объект, его берут в круглые скобки:
const make = () => ({ text: 'Купить кофе' });
function greet() {
console.log('Привет!');
}
const f = greet; // без скобок: сама функция
setTimeout(greet, 1000); // «вызови через секунду»
Мы не вызываем greet, а отдаём её: «вызови сам,
когда придёт время». На этом построены все события — часть 3.
map и filterconst left = tasks.filter((task) => !task.done);
const texts = tasks.map((task) => task.text);
Методы массива, которые принимают функцию. filter —
оставить подходящие, map — превратить каждый элемент.
Сегодня — чтобы узнавать. Всерьёз — в лекции 7: без них не пишут на React.
push?const tasks = [];
tasks.push('Купить кофе'); // мы ведь не писали push
tasks.push === Array.prototype.push // true
Object.getPrototypeOf(tasks) === Array.prototype // true
Методов внутри самого массива нет. Они лежат в одном общем объекте —
прототипе Array.prototype, и все массивы на него
ссылаются.
lengthpush, map, filtertoString, hasOwnProperty
Когда вы пишете tasks.map, движок ищет map в
самом массиве, не находит — идёт в прототип, потом в прототип
прототипа. Нашёл — вызывает. Дошёл до null —
undefined.
class — тоже прототипыclass Task {
constructor(text) { this.text = text; this.done = false; }
toggle() { this.done = !this.done; }
}
const t = new Task('Начать ЛР 3');
typeof Task // 'function'
t.toggle === Task.prototype.toggle // true
Синтаксис как в Java, внутри — та же цепочка прототипов. В курсе классы почти не понадобятся: React пишут на функциях.
Новый метод массива хотели назвать flatten. Но старая
библиотека MooTools когда-то дописала свой flatten в
Array.prototype, и тысячи сайтов сломались бы.
В шутку предложили smoosh. В итоге метод назвали
flat. Мораль: не трогайте чужие
прототипы.
Страница как дерево объектов
<body>
<h1>Список дел</h1>
<ul class="todo__list">
<li>Начать ЛР 3</li>
<li>Купить кофе</li>
</ul>
</body>
body
├── h1
│ └── "Список дел"
└── ul.todo__list
├── li
│ └── "Начать ЛР 3"
└── li
└── "Купить кофе"
Браузер читает HTML и строит дерево. Каждый узел — объект.
Важно: DOM — это не HTML-файл. Поменяли DOM — страница на экране поменялась сразу, а файл на диске остался прежним. Обновили страницу — и всё как было.
const title = document.querySelector('h1');
const list = document.querySelector('.todo__list');
const first = document.querySelector('.todo__list li');
document — корень дерева. querySelector
принимает CSS-селектор и возвращает первый подходящий элемент.
Всё, что знаем о селекторах из лекции 2, работает здесь.
Не нашлось — вернёт null.
const items = document.querySelectorAll('.todo__item');
items.length // 3
for (const item of items) {
console.log(item.textContent);
}
Коллекция всех подходящих элементов. Перебирается
for…of. Ничего не нашлось — пустая коллекция, не
null.
getElementById — старый способ, встретится в чужом коде.
Слева страница со списком дел, справа — её дерево DOM, внизу — строка для JavaScript. Код выполняется прямо в странице, а дерево перерисовывается само.
Начнём с поиска: найденное подсвечивается и на странице, и в дереве.
const title = document.querySelector('h1');
title.textContent = 'Мои дела';
textContent — текст внутри элемента. Читать и записывать.
Всё, что в него записано, показывается как текст, даже если там
угловые скобки.
innerHTMLlist.innerHTML = '<li>Начать ЛР 3</li><li>Купить кофе</li>';
Записывает строку как разметку: браузер разберёт её и построит элементы. Удобно — и опасно.
const name = input.value; // пользователь ввёл что угодно
title.innerHTML = 'Привет, ' + name;
Пользователь вводит не имя, а
<img src=x onerror="…">. Браузер строит картинку,
она не грузится — и выполняется код из атрибута.
Одна из самых частых уязвимостей в вебе. В DOM-лаборатории — заготовки «innerHTML и XSS» и «textContent безопасен»: одна и та же строка, два результата.
Правило ЛР 3: ввод пользователя — только в
textContent.
item.style.color = '#9aa2ab';
item.style.textDecoration =
'line-through';
item.classList.add(
'todo__item--done'
);
Как выглядит «выполненное дело» — дело CSS. JS только говорит, в каком оно состоянии. Захотели зачёркивать иначе — правите один CSS-файл, а не ищете строки по всему JS.
classListitem.classList.add('todo__item--done');
item.classList.remove('todo__item--done');
item.classList.toggle('todo__item--done'); // есть — снять
item.classList.contains('todo__item--done'); // true / false
todo__item--done — это модификатор БЭМ из лекции 5.
Методология из CSS здесь становится интерфейсом между CSS и JS.
data-*<li class="todo__item" data-id="7">Начать ЛР 3</li>
item.dataset.id // '7' — строка!
link.getAttribute('href')
input.value // то, что ввели в поле
data-* — свои атрибуты для своих данных: чтобы по элементу
понять, какому объекту в массиве он соответствует.
const li = document.createElement('li');
li.className = 'todo__item';
li.textContent = 'Купить кофе';
list.append(li); // теперь он на странице
Созданный элемент живёт в памяти и на странице не виден, пока его не
вставили в дерево. append — в конец, prepend
— в начало, remove() — убрать.
document.querySelector('video').playbackRate = 3;
Плеер даёт максимум 2×, а у элемента <video> есть
свойство, которому всё равно. Работает почти на любом сайте с
видео.
Записи этой лекции рекомендуется смотреть не быстрее 2,5×.
document.designMode = 'on';
Вся страница становится текстовым редактором: кликаете в любой текст и печатаете. Удобно, чтобы примерить заголовок на макете или посмотреть, как вёрстка переживёт длинное слово.
И да, так делаются «скриншоты» с зарплатой в миллион. Меняется DOM в вашем браузере, а не сайт — вспомните слайд «DOM — это не файл».
| команда | что делает |
|---|---|
$0 | элемент, выделенный во вкладке Elements |
$('.todo__item') | как querySelector |
$$('.todo__item') | как querySelectorAll, но сразу массив |
copy(…) | положить значение в буфер обмена |
console.table(tasks) | массив объектов — таблицей |
Работают только в консоли DevTools, в коде страницы их нет.
copy($$('a').map((a) => a.href).join('\n'));
Одна строка: найти все ссылки, взять адреса, склеить по строке на каждую и положить в буфер. Список литературы курса, все картинки альбома, все задачи в трекере — так же.
$$('img').length // сколько картинок
$$('*').length // сколько вообще элементов
console.log('%cМы ищем фронтендеров',
'font-size: 40px; color: #4b86c2');
%c включает CSS прямо в выводе консоли. Так крупные
компании размещают вакансии для тех, кто открыл DevTools на их сайте,
— загляните в консоль любимых сервисов.
На главной странице этого курса консоль тоже кое-что говорит.
Не правим страницу вручную по кусочку. Храним правду в данных, а одна функция по ним рисует страницу заново.
render()const list = document.querySelector('.todo__list');
function render() {
list.innerHTML = ''; // ввода пользователя тут нет
tasks.forEach((task, i) => {
const li = document.createElement('li');
li.className = 'todo__item';
li.dataset.index = i; // номер в массиве
li.textContent = task.text;
if (task.done) li.classList.add('todo__item--done');
list.append(li);
});
}
render();
Список на странице построен из массива. В HTML-файле — только пустой
<ul>.
render() снова
На этом держится вся часть 3
Код, который ждёт
Программа в консоли выполняется сверху вниз и заканчивается. Скрипт страницы выполняется сверху вниз — и остаётся: страница открыта, а он ждёт.
Большую часть времени не выполняется ничего. Когда пользователь кликает или печатает, браузер сам вызывает наши функции. Те самые функции-значения из части 1.
addEventListenerconst button = document.querySelector('.todo__add');
function handleClick() {
console.log('Клик!');
}
button.addEventListener('click', handleClick);
«Когда по этой кнопке кликнут — вызови handleClick». Тип
события, функция-обработчик. Обработчиков на одном элементе может быть
сколько угодно.
button.addEventListener('click', handleClick());
Отличие от прошлого слайда — пара скобок. Страница только открылась, по кнопке никто не кликал.
undefined. Сами клики потом не делают ничего.
Самая частая ошибка в ЛР 3. Обработчик передают без скобок: отдаём функцию, а не результат её вызова.
button.addEventListener('click', () => {
console.log('Клик!');
});
Так пишут чаще всего: функция создаётся прямо в вызове и нигде больше не нужна.
onclick в разметке?<button onclick="handleClick()"> — код внутри HTMLaddEventListener — поведение в JS-файле
Та же идея, что и с классами вместо стилей: HTML — структура, JS —
поведение, каждый в своём файле. В ЛР 3 — только
addEventListener.
event| поле | что это |
|---|---|
type | 'click', 'input', 'submit'… |
target | где событие возникло — самый глубокий элемент |
currentTarget | на ком висит этот обработчик |
key, code | клавиша: символ и физическая кнопка |
clientX, clientY | координаты мыши в окне |
shiftKey, ctrlKey… | зажаты ли модификаторы |
isTrusted | true — сделал человек, false — код |
Событие — это отчёт о том, что случилось: что, где, когда и с
какими подробностями. Браузер создаёт один такой объект на
одно событие и передаёт его по очереди всем обработчикам на пути. У
клика в нём больше восьмидесяти полей — попробуйте
console.log(event).
Поэтому target у всех обработчиков одинаковый, а
currentTarget меняется: событие одно, а слушают его на
разных уровнях. И поэтому stopPropagation в одном
обработчике останавливает его для всех следующих.
key или codedocument.addEventListener('keydown', (event) => {
event.key // 'ф' или 'a' — зависит от раскладки
event.code // 'KeyA' — всегда: это кнопка
});
Для ввода текста — key. Для горячих клавиш —
code, иначе в русской раскладке они не сработают. Клавиша
F в этих слайдах включает полноэкранный режим через
event.code === 'KeyF' — именно поэтому.
this в обработчикеbtn.addEventListener('click',
function () {
this; // кнопка
});
btn.addEventListener('click',
() => {
this; // НЕ кнопка:
}); // this снаружи
У обычной функции this — элемент, на котором висит
обработчик. У стрелочной своего this нет. Чтобы не
помнить разницу, используйте event.currentTarget: он
работает с обеими.
// какие обработчики висят на элементе
getEventListeners($0)
// печатать в консоль каждый клик
monitorEvents(window, 'click')
unmonitorEvents(window)
Ещё два помощника консоли DevTools. Первый отвечает на вопрос «почему кнопка не реагирует», второй — «какие события вообще происходят». Пригодятся на защите ЛР 3.
| событие | когда |
|---|---|
click | клик мышью, тап, Enter на кнопке |
input | каждое изменение в поле ввода |
change | значение поменяли и ушли из поля |
submit | отправка формы |
keydown | нажатие клавиши |
DOMContentLoaded | разметка прочитана — если нет defer |
for (const li of list.querySelectorAll('.todo__item')) {
li.addEventListener('click', () => {
const task = tasks[li.dataset.index];
task.done = !task.done; // меняем данные…
render(); // …и перерисовываем
});
}
Обработчик не трогает класс напрямую. Он меняет данные и
просит render() нарисовать их заново.
render() каждый раз создаёт новые <li>.
Обработчики висели на старых — и пропали вместе с ними.
Значит, после каждой перерисовки их надо навешивать заново. Неудобно и легко забыть. К решению придём через десять минут — сначала разберёмся, куда вообще идёт событие после клика.
<form class="todo__form">
<input class="todo__input" placeholder="Новое дело">
<button class="todo__add">Добавить</button>
</form>
form.addEventListener('submit', (event) => {
event.preventDefault();
…
});
Слушаем не клик по кнопке, а submit формы: он срабатывает
и по кнопке, и по Enter в поле.
preventDefault
У формы есть поведение по умолчанию из лекции 1: отправить данные на
адрес из action и перезагрузить страницу. Вместе с
перезагрузкой исчезнет и массив tasks.
event.preventDefault() — «не делай того, что делаешь
обычно». Ссылка не перейдёт, форма не отправится. Дальше всё решает наш
код.
form.addEventListener('submit', (event) => {
event.preventDefault();
const text = input.value.trim();
if (text === '') {
form.classList.add('todo__form--error');
return;
}
form.classList.remove('todo__form--error');
tasks.push({ text: text, done: false });
input.value = '';
render();
});
required?
Из лекции 1: <input required> — браузер сам не даст
отправить пустое поле. Это хорошо, и его стоит ставить.
Но строку из пробелов он пропустит, а своих правил — «не длиннее ста символов», «такого дела ещё нет» — не знает. Для них нужен JS.
И ещё одно: проверка в браузере — для удобства пользователя. Сервер всё равно проверяет всё сам, ему нельзя верить на слово.
ul.addEventListener('click', () => console.log('ul'));
li.addEventListener('click', () => console.log('li'));
btn.addEventListener('click', () => console.log('btn'));
Кнопка btn лежит внутри li, li — внутри
ul. Кликнули по кнопке. Что напечатается и в каком порядке?
btn, потом li, потом ul.
Все три.
Событие возникает на самом глубоком элементе и поднимается
по дереву до document, вызывая обработчики каждого
предка. Клик по кнопке — это ещё и клик по всем, кто её содержит.
stopPropagationremoveButton.addEventListener('click', (event) => {
event.stopPropagation(); // дальше вверх не пойдёт
…
});
Иногда нужно: клик по крестику не должен заодно отмечать дело. Но это инструмент на крайний случай — чаще проблему решает правильное место для обработчика.
Раз событие всё равно всплывает до ul, не нужно вешать
обработчик на каждый li. Хватит одного на родителе:
list.addEventListener('click', (event) => {
const li = event.target.closest('.todo__item');
if (!li) return; // мимо пунктов
const task = tasks[li.dataset.index];
task.done = !task.done;
render();
});
render() пересоздаёт <li> — и ничего не ломается: обработчик висит на ul, который не пересоздаётся
closest поднимается от элемента вверх и ищет ближайшего
предка по селектору — самого себя тоже проверяет.
Список дел целиком
Пустое дело не добавить
Это не картинка: можно добавить дело, отметить, удалить.
render()function render() {
list.innerHTML = '';
tasks.forEach((task, i) => {
const li = document.createElement('li');
li.className = 'todo__item';
li.classList.toggle('todo__item--done', task.done);
li.dataset.index = i;
const text = document.createElement('span');
text.className = 'todo__text';
text.textContent = task.text;
const remove = document.createElement('button');
remove.className = 'todo__remove';
remove.textContent = '✕';
li.append(text, remove);
list.append(li);
});
}
list.addEventListener('click', (event) => {
const li = event.target.closest('.todo__item');
if (!li) return;
const i = Number(li.dataset.index);
if (event.target.closest('.todo__remove')) {
tasks.splice(i, 1);
} else {
tasks[i].done = !tasks[i].done;
}
render();
});
Один обработчик на весь список — делегирование. Крестик и сам пункт
различаются через closest.
form.addEventListener('submit', (event) => {
event.preventDefault();
const text = input.value.trim();
if (text === '') {
form.classList.add('todo__form--error');
return;
}
form.classList.remove('todo__form--error');
tasks.push({ text: text, done: false });
input.value = '';
render();
});
Плюс массив, три querySelector и первый вызов
render() — около сорока строк.
tasks — единственный источник правдыrender()Обработчики никогда не правят страницу сами. Только данные.
render()render() перерисовывает всё, даже если поменялась одна галочкаrender() после измененияcreateElementРовно это React берёт на себя. В лекции 8 этот же список будет написан на React — и станет видно, что осталось от сорока строк.
Научить вашу страницу из ЛР 1–2 вести себя. Подключить
script.js с defer и сделать четыре вещи:
createElementaddEventListenerclassList.toggle, имя по БЭМinnerHTMLvar и ==alert для ошибокlocalStorage
На защите — объяснить любую строку своего script.js.
map и filter всерьёзСегодня написали интерфейс руками. Дальше — как это делают в реальных проектах.
Слайды, демо и игра — в репозитории курса