Лекция 6. JavaScript и программирование браузера

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

Лекция 6 JavaScript

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

Пять лекций страница выглядела

🧱HTMLструктура: что есть на странице
🎨CSSвид: как это выглядит
⚙️JavaScriptповедение: что происходит, когда с ней что-то делают

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

1995

Язык за десять дней

Брендан Эйх пишет первую версию для браузера Netscape: простой язык, чтобы «оживлять» страницы.

Название «JavaScript» — маркетинг: Java тогда была на пике моды. Общего у них — четыре буквы.

Стандарт называется ECMAScript, версии выходят каждый год.

Java и JavaScript

🚗Carмашина
🧶Carpetковёр

Java относится к JavaScript, как car к carpet. Общие четыре буквы — и больше ничего.

Где живёт JavaScript

в браузере

единственный язык, который браузер понимает сам. Сегодня — здесь

вне браузера

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

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

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

список дел

Часть 1 · 36 минут JS для тех, кто знает
другой язык

Только отличия

Что вы уже знаете

Переменные, условия, циклы, функции, списки и словари — всё это в JS есть и выглядит почти как в C++ или Java.

Поэтому дальше — не учебник, а список отличий: где JS ведёт себя не так, как Python и C++, и на чём ломаются в первую неделю.

Как устроен JavaScript

⚙️Движокпревращает текст программы в машинный код
🌐Окружениебраузер или Node даёт document, таймеры, сеть
1️⃣Один потокв каждый момент выполняется что-то одно
🧹Сборщик мусорапамять освобождается сама

Четыре вещи, которые объясняют почти всё странное в поведении JS.

Движок

движокгде работает
V8Chrome, Edge, Яндекс Браузер, Node.js
SpiderMonkeyFirefox
JavaScriptCoreSafari

Сначала код просто выполняется строка за строкой. Если функция вызывается часто, движок на лету компилирует её в машинный код — JIT, just-in-time. Поэтому современный JS быстрый, хотя компилятора, как у C++, у вас нет.

Язык и окружение — разные вещи

язык (ECMAScript)

переменные, функции, массивы, объекты, 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. Примитивы копируются. А освобождать память не нужно: объект удалит сборщик мусора, когда на него не останется ни одной ссылки.

Характер языка одним слайдом

Переменные: let и const

const 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 запрещён. Но в чужом коде и старых ответах на форумах он повсюду — узнавать надо.

Типы

number220, 0.5
string'кофе'
booleantrue, false
undefinedзначения нет
null«пусто» явно
bigint10n, огромные целые
symbolуникальный ключ
objectвсё остальное: объекты, массивы, функции

В ЛР понадобятся первые пять и 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. Внутри скобок — любое выражение.

Python на '5' + 2 падает.
JavaScript — молча что-то возвращает.

Приведение типов

'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: разные типы

Правило курса: всегда === и !==. Почему — на следующих слайдах.

Как работает ==

  1. типы одинаковые — сравнивает как ===
  2. null и undefined равны только друг другу
  3. строка и число — строка превращается в число
  4. true / false — сначала в 1 / 0
  5. объект и примитив — объект превращается в примитив

Это упрощение: в стандарте алгоритм занимает полторы страницы.

Сюрпризы ==

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 []: не выполнится: пустой список ложный.

Выполнится

«Есть дела» напечатается. В JS пустой массив — истинное значение.

Ложных значений всего шесть: false, 0, '', null, undefined, NaN. Всё остальное истинно — включая '0', [] и {}.

if (tasks.length === 0) { … }   // так проверяют пустой массив

Игра: JS или WAT?

Десять выражений. Нужно угадать, что ответит консоль. Ответ каждый раз проверяется настоящим JavaScript прямо в браузере.

Название — из знаменитого доклада Гэри Бернхардта 2012 года, где зал хохочет над выражениями вроде [] + {}.

Gary Bernhardt, «Wat», CodeMash 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 возвращает выражение. Здесь выражение — объект.

undefined

Фигурные скобки после стрелки — это тело функции, а не объект. Внутри — метка text: и строка, которая ничего не делает. return нет — значит, undefined.

Чтобы вернуть объект, его берут в круглые скобки:

const make = () => ({ text: 'Купить кофе' });

Функция — это значение Как число или строка

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

function greet() {
    console.log('Привет!');
}

const f = greet;          // без скобок: сама функция
setTimeout(greet, 1000);  // «вызови через секунду»

Мы не вызываем greet, а отдаём её: «вызови сам, когда придёт время». На этом построены все события — часть 3.

map и filter

const 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, и все массивы на него ссылаются.

Цепочка прототипов

tasksсвои элементы и length
→
Array.prototypepush, map, filter
→
Object.prototypetoString, hasOwnProperty
→
nullконец

Когда вы пишете 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 пишут на функциях.

2018

SmooshGate

Новый метод массива хотели назвать flatten. Но старая библиотека MooTools когда-то дописала свой flatten в Array.prototype, и тысячи сайтов сломались бы.

В шутку предложили smoosh. В итоге метод назвали flat. Мораль: не трогайте чужие прототипы.

developer.chrome.com/blog/smooshgate

Часть 2 · 20 минут DOM

Страница как дерево объектов

Дерево из лекции 1

<body>
  <h1>Список дел</h1>
  <ul class="todo__list">
    <li>Начать ЛР 3</li>
    <li>Купить кофе</li>
  </ul>
</body>
body
├── h1
│   └── "Список дел"
└── ul.todo__list
    ├── li
    │   └── "Начать ЛР 3"
    └── li
        └── "Купить кофе"

Браузер читает HTML и строит дерево. Каждый узел — объект.

DOM

Document Object Model — это дерево, доступное из JavaScript. Каждый тег — объект с полями и методами.

Важно: 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-лаборатория

Слева страница со списком дел, справа — её дерево DOM, внизу — строка для JavaScript. Код выполняется прямо в странице, а дерево перерисовывается само.

Начнём с поиска: найденное подсвечивается и на странице, и в дереве.

Поменять текст

const title = document.querySelector('h1');
title.textContent = 'Мои дела';

textContent — текст внутри элемента. Читать и записывать. Всё, что в него записано, показывается как текст, даже если там угловые скобки.

innerHTML

list.innerHTML = '<li>Начать ЛР 3</li><li>Купить кофе</li>';

Записывает строку как разметку: браузер разберёт её и построит элементы. Удобно — и опасно.

Что, если в строке — ввод пользователя?

const name = input.value;   // пользователь ввёл что угодно
title.innerHTML = 'Привет, ' + name;

Пользователь вводит не имя, а <img src=x onerror="…">. Браузер строит картинку, она не грузится — и выполняется код из атрибута.

XSS

Cross-site scripting — чужой код, выполненный на вашей странице. Он может прочитать всё, что видит пользователь, и сделать всё, что может он.

Одна из самых частых уязвимостей в вебе. В DOM-лаборатории — заготовки «innerHTML и XSS» и «textContent безопасен»: одна и та же строка, два результата.

Правило ЛР 3: ввод пользователя — только в textContent.

Стили из JS

можно, но не нужно

item.style.color = '#9aa2ab';
item.style.textDecoration =
    'line-through';

правильно

item.classList.add(
    'todo__item--done'
);

Как выглядит «выполненное дело» — дело CSS. JS только говорит, в каком оно состоянии. Захотели зачёркивать иначе — правите один CSS-файл, а не ищете строки по всему JS.

classList

item.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() — убрать.

DOM в быту Консоль работает на любом сайте — не только на вашем

Видео быстрее, чем разрешает плеер

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 на их сайте, — загляните в консоль любимых сервисов.

На главной странице этого курса консоль тоже кое-что говорит.

Данные → страница

tasksмассив объектов
→
render()создаёт элементы
→
<ul>на странице

Не правим страницу вручную по кусочку. Храним правду в данных, а одна функция по ним рисует страницу заново.

список дел

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

Часть 3 · 22 минуты События

Код, который ждёт

Программа, которая ждёт

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

Большую часть времени не выполняется ничего. Когда пользователь кликает или печатает, браузер сам вызывает наши функции. Те самые функции-значения из части 1.

addEventListener

const 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()"> — код внутри HTML
👉
addEventListener — поведение в JS-файле

Та же идея, что и с классами вместо стилей: HTML — структура, JS — поведение, каждый в своём файле. В ЛР 3 — только addEventListener.

Что лежит в event

полечто это
type'click', 'input', 'submit'…
targetгде событие возникло — самый глубокий элемент
currentTargetна ком висит этот обработчик
key, codeклавиша: символ и физическая кнопка
clientX, clientYкоординаты мыши в окне
shiftKey, ctrlKey…зажаты ли модификаторы
isTrustedtrue — сделал человек, false — код

Суть объекта события

Событие — это отчёт о том, что случилось: что, где, когда и с какими подробностями. Браузер создаёт один такой объект на одно событие и передаёт его по очереди всем обработчикам на пути. У клика в нём больше восьмидесяти полей — попробуйте console.log(event).

Поэтому target у всех обработчиков одинаковый, а currentTarget меняется: событие одно, а слушают его на разных уровнях. И поэтому stopPropagation в одном обработчике останавливает его для всех следующих.

key или code

document.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, вызывая обработчики каждого предка. Клик по кнопке — это ещё и клик по всем, кто её содержит.

stopPropagation

removeButton.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();
});

Почему это лучше

closest поднимается от элемента вверх и ищет ближайшего предка по селектору — самого себя тоже проверяет.

список дел

Часть 4 · 8 минут Финал и ЛР 3

Список дел целиком

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

Это не картинка: можно добавить дело, отметить, удалить.

список дел

Весь код, 1/3: 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);
  });
}

Весь код, 2/3: клик и удаление

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.

Весь код, 3/3: форма

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()
+ события, которые меняют данные Всё остальное во фронтенде — способы делать это удобнее

Что здесь неудобно

Ровно это React берёт на себя. В лекции 8 этот же список будет написан на React — и станет видно, что осталось от сорока строк.

ЛР 3 «JavaScript»

Научить вашу страницу из ЛР 1–2 вести себя. Подключить script.js с defer и сделать четыре вещи:

  1. список из данных: массив объектов → элементы через createElement
  2. два типа событий и больше, через addEventListener
  3. форма с проверкой: без перезагрузки, ошибка — на странице
  4. состояние классом: classList.toggle, имя по БЭМ

ЛР 3: правила и дополнительная часть

нельзя

  • библиотеки и фреймворки
  • ввод пользователя в innerHTML
  • var и ==
  • alert для ошибок
  • ошибки в консоли

на повышенную оценку

  • фильтр или поиск по списку
  • делегирование событий
  • сохранение в localStorage
  • счётчик или итог

На защите — объяснить любую строку своего script.js.

Что почитать

learn.javascript.ruлучший учебник по JS на русском
MDNсправочник по каждому методу DOM
Докаdoka.guide/js — по-русски и коротко
QR-код со ссылкой на учебник learn.javascript.ru learn.javascript.ru части 1 и 2

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

Сегодня написали интерфейс руками. Дальше — как это делают в реальных проектах.

Вопросы?

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