События dom javascript. Типы событий

Типы событий

На заре развития Всемирной паутины веб-разработчикам приходилось иметь дело лишь с небольшим количеством событий: «load», «click», «mouseover» и другими. Эти довольно старые типы событий хорошо поддерживаются всеми браузерами. По мере развития веб-платформы в нее были включены более мощные прикладные интерфейсы, а количество событий существенно увеличилось. Не существует стандарта, который определял бы полный набор событий, и количество поддерживаемых событий продолжает быстро увеличиваться. Эти новые события определяются в следующих двух источниках:

    Спецификация «DOM Level 3 Events», которая после долгих лет застоя стала активно разрабатываться под эгидой консорциума W3C.

    Множество новых прикладных интерфейсов в спецификации HTML5 (и в связанных с ней дополнительных спецификациях) определяют новые события, используемые, например, для управления историей посещений, механизмом drag-and-drop (перетащил и бросил), обмена сообщениями между документами и проигрывания аудио- и видеороликов.

Обратите внимание, что многие из этих новых типов событий пока еще не получили широкой поддержки и определяются стандартами, которые еще находятся на стадии проектирования. События, которые вам чаще всего придется использовать в своих веб-приложениях, обычно будут относиться к категории давно существующих и поддерживаемых всеми браузерами: это события для работы с мышью, с клавиатурой, с HTML-формами и с объектом Window. Эти события мы и рассмотрим.

События загрузки документа

Большинству веб-приложений совершенно необходимо, чтобы веб-браузер извещал их о моменте, когда закончится загрузка документа и он будет готов для выполнения операций над ним. Этой цели служит событие load в объекте Window. Событие load возбуждается только после того, как документ и все его изображения будут полностью загружены. Однако обычно сценарии можно запускать сразу после синтаксического анализа документа, до того как будут загружены изображения. Можно существенно сократить время запуска веб-приложения, если начинать выполнение сценариев по событиям, отличным от load.

Событие DOMContentLoaded возбуждается, как только документ будет загружен, разобран синтаксическим анализатором, и будут выполнены все отложенные сценарии. К этому моменту изображения и сценарии с атрибутом async могут продолжать загружаться, но сам документ уже будет готов к выполнению операций. Это событие впервые было введено в Firefox и впоследствии заимствовано всеми другими производителями браузеров, включая корпорацию Microsoft, которая добавила поддержку этого события в IE9. Несмотря на приставку DOM в имени, это событие не является частью стандарта модели событий DOM Level 3 Events, но оно стандартизовано спецификацией HTML5.

В ходе загрузки документа изменяется значение свойства document.readyState. Каждое изменение значения этого свойства в IE сопровождается событием readystatechange в объекте Document, благодаря чему в IE это событие можно использовать для определения момента появления состояния complete. Спецификация HTML5 стандартизует событие readystatechange , но предписывает возбуждать его непосредственно перед событием load, поэтому не совсем понятно, в чем заключается преимущество события readystatechange перед load.

В примере ниже определяется функция whenReady(). Функция, передаваемая функции whenReady(), вызывается (как метод объекта Document) сразу, как только документ будет готов к выполнению операций. whenReady() ожидает появления событий DOMContentLoaded и readystatechange и использует событие load только как запасной вариант, на случай если она будет задействована в старых браузерах, не поддерживающих первые два события. Функция whenReady() будет использоваться в некоторых сценариях, следующих далее:

/* Передайте функции whenReady() свою функцию, и она вызовет ее (как метод объекта документа), как только завершится синтаксический анализ документа и он будет готов к выполнению операций. Зарегистрированные функции вызываются при первом же событии DOMContentLoaded, readystatechange или load. Как только документ станет готов и будут вызваны все функции, whenReady() немедленно вызовет все функции, которые были ей переданы. */ var whenReady = (function() { // Эта функция возвращается функцией whenReady() var funcs = ; // Функции, которые должны вызываться по событию var ready = false; // Получит значение true при вызове функции handler // Обработчик событий, который вызывается, как только документ // будет готов к выполнению операций function handler(e) { // Если обработчик уже вызывался, просто вернуть управление if (ready) return; // Если это событие readystatechange и состояние получило значение, // отличное от "complete", значит, документ пока не готов if (e.type==="readystatechange" && document.readyState !== "complete") return; // Вызвать все зарегистрированные функции. // Обратите внимание, что здесь каждый раз проверяется значение // свойства funcs.length, на случай если одна из вызванных функций // зарегистрирует дополнительные функции. for(var i = 0; i

События мыши

С мышью связано довольно много событий. Все они перечислены в таблице ниже. Все события мыши, кроме mouseenter и mouseleave, всплывают. Для событий click, возникающих в ссылках и кнопках отправки форм, предусматриваются действия по умолчанию, которые можно отменить. Теоретически имеется возможность отменить событие contextmenu и предотвратить появление контекстного меню, но некоторые браузеры имеют параметры настройки, которые делают это событие неотменяемым.

События мыши JavaScript Тип Описание
click Высокоуровневое событие, возбуждаемое, когда пользователь нажимает и отпускает кнопку мыши или иным образом активирует элемент.
contextmenu Отменяемое событие, возбуждаемое перед выводом контекстного меню. Текущие браузеры выводят контекстное меню по щелчку правой кнопки мыши, поэтому данное событие можно также использовать как событие click.
dblclick Возбуждается, когда пользователь выполняет двойной щелчок.
mousedown Возбуждается, когда пользователь нажимает кнопку мыши.
mouseup Возбуждается, когда пользователь отпускает кнопку мыши.
mousemove Возбуждается, когда пользователь перемещает указатель мыши.
mouseover Возбуждается, когда указатель мыши помещается над элементом. Свойство relatedTarget (или fromElement в IE) определяет элемент, с которого был перемещен указатель мыши.
mouseout Возбуждается, когда указатель мыши покидает элемент. Свойство relatedTarget (или toElement в IE) определяет элемент, на который был перемещен указатель мыши.
mouseenter Подобно mouseover, но не всплывает. Впервые появилось в IE и было стандартизовано в HTML5, но пока поддерживается не всеми браузерами.
mouseleave Подобно mouseout, но не всплывает. Впервые появилось в IE и было стандартизовано в HTML5, но пока поддерживается не всеми браузерами.

Объект, передаваемый обработчикам событий от мыши, имеет свойства clientX и clientY , определяющие координаты указателя относительно окна. Чтобы преобразовать их в координаты документа, к ним необходимо добавить позиции полос прокрутки окна.

Свойства altKey , ctrlKey , metaKey и shiftKey определяют состояния различных клавиш-модификаторов, которые могли удерживаться в нажатом состоянии в момент события: с их помощью можно отличать простой щелчок от щелчка с нажатой клавишей Shift, например.

Свойство button определяет, какая кнопка мыши удерживалась в нажатом состоянии в момент события. Однако разные браузеры записывают в это свойство разные значения, поэтому его сложно использовать переносимым способом.

Некоторые браузеры возбуждают событие click только в случае щелчка левой кнопкой. Поэтому, если потребуется обрабатывать щелчки другими кнопками, следует использовать события mousedown и mouseup. Событие contextmenu обычно сигнализирует о том, что был выполнен щелчок правой кнопкой, но, как отмечалось выше, в обработчиках этого события не всегда бывает возможным предотвратить появление контекстного меню.

В примере ниже демонстрируется функция drag(), которая при вызове из обработчика события mousedown позволяет пользователю перетаскивать мышью абсолютно позиционированные элементы документа. Функция drag() работает с обеими моделями событий, DOM и IE.

Функция drag() принимает два аргумента. Первый - перетаскиваемый элемент. Это может быть элемент, в котором возникло событие mousedown, и содержащий его элемент (например, можно дать пользователю возможность ухватить мышью элемент, который выглядит как заголовок окна, и перетащить содержащий его элемент, который выглядит как окно). Однако в любом случае это должен быть элемент документа, абсолютно позиционированный с помощью CSS-атрибута position. Второй аргумент - объект события, полученный с событием mousedown:

/* drag() - перетаскивание абсолютно позиционированных HTML-элементов. Эта функция должна вызываться из обработчика события onmousedown. Последующие события mousemove будут вызывать перемещение указанного элемента. Событие mouseup будет завершать перемещение. Эта реализация действует в обеих моделях событий, стандартной и IE. Использует функцию getScrollOffsets(). Аргументы: elementToDrag: элемент, принявший событие mousedown или содержащий его элемент. Этот элемент должен иметь абсолютное позиционирование. Значения его свойств style.left и style.top будут изменяться при перемещении указателя мыши пользователем. event: объект Event, полученный обработчиком события mousedown. */ function drag(elementToDrag, event) { // Преобразовать начальные координаты указателя мыши в координаты документа var scroll = getScrollOffsets(); // Вспомогательная функция, объявленная ниже var startX = event.clientX + scroll.x; var startY = event.clientY + scroll.y; // Первоначальные координаты (относительно начала документа) элемента, который // будет перемещаться. Так как elementToDrag имеет абсолютное позиционирование, // предполагается, что его свойство offsetParent ссылается на тело документа. var origX = elementToDrag.offsetLeft; var origY = elementToDrag.offsetTop; // Найти расстояние между точкой события mousedown и верхним левым углом элемента. // Это расстояние будет учитываться при перемещении указателя мыши. var deltaX = startX - origX; var deltaY = startY - origY; // Зарегистрировать обработчики событий mousemove и mouseup, // которые последуют за событием mousedown. if (document.addEventListener) { // Стандартная модель событий // Зарегистрировать перехватывающие обработчики в документе document.addEventListener("mousemove", moveHandler, true); document.addEventListener("mouseup", upHandler, true); } else if (document.attachEvent) { // Модель событий IE для IE5-8 // В модели событий IE перехват событий осуществляется вызовом // метода setCapture() элемента. elementToDrag.setCapture(); elementToDrag.attachEvent("onmousemove", moveHandler); elementToDrag.attachEvent("onmouseup", upHandler); // Интерпретировать потерю перехвата событий мыши как событие mouseup elementToDrag.attachEvent("onlosecapture", upHandler); } // Это событие обработано и не должно передаваться другим обработчикам if (event.stopPropagation) event.stopPropagation(); // Стандартная модель else event.cancelBubble = true; // IE // Предотвратить выполнение действий, предусмотренных по умолчанию. if (event.preventDefault) event.preventDefault(); // Стандартная модель else event.returnValue = false; // IE /* Этот обработчик перехватывает события mousemove, возникающие в процессе перетаскивания элемента. Он отвечает за перемещение элемента. */ function moveHandler(e) { if (!e) e = window.event; // Модель событий IE // Переместить элемент в позицию указателя мыши с учетом позиций // полос прокрутки и смещений относительно начального щелчка. var scroll = getScrollOffsets(); elementToDrag.style.left = (e.clientX + scroll.x - deltaX) + "px"; elementToDrag.style.top = (e.clientY + scroll.y - deltaY) + "px"; // И прервать дальнейшее распространение события. if (e.stopPropagation) e.stopPropagation(); // Стандартная модель else e.cancelBubble = true; // IE } /* Этот обработчик перехватывает заключительное событие mouseup, которое завершает операцию перетаскивания. */ function upHandler(e) { if (!e) e = window.event; // Модель событий IE // Удалить перехватывающие обработчики событий. if (document.removeEventListener) { // Модель событий DOM document.removeEventListener("mouseup", upHandler, true); document.removeEventListener("mousemove", moveHandler, true); } else if (document.detachEvent) { // Модель событий IE 5+ elementToDrag.detachEvent("onlosecapture", upHandler); elementToDrag.detachEvent("onmouseup", upHandler); elementToDrag.detachEvent("onmousemove", moveHandler); elementToDrag.releaseCapture(); } // И прервать дальнейшее распространение события. if (e.stopPropagation) e.stopPropagation(); // Стандартная модель else e.cancelBubble = true; // IE } } // Возвращает текущие позиции полос прокрутки в виде свойств x и y объекта function getScrollOffsets(w) { // Использовать указанное окно или текущее, // если функция вызвана без аргумента w = w || window; // Следующий способ работает во всех браузерах, кроме IE версии 8 и ниже if (w.pageXOffset != null) return {x: w.pageXOffset, y:w.pageYOffset}; // Для IE (и других браузеров) в стандартном режиме var d = w.document; if (document.compatMode == "CSSICompat") return {x: d.documentElement.scrollLeft, y: d.documentElement.scrollTop}; // Для браузеров в режиме совместимости return { x: d.body.scrollLeft, y: d.body.scrollTop }; }

Следующий фрагмент демонстрирует порядок использования функции drag() в HTML-файле:

Перетащи меня

Это тест. Проверка, проверка, проверка.

Самым важным здесь является атрибут onmousedown во вложенном элементе . Обратите внимание, что в нем используется свойство this.parentNode. Это говорит о том, что перемещаться будет весь контейнерный элемент.

События ввода текста

Браузеры поддерживают три старых события ввода с клавиатуры. События keydown и keyup являются низкоуровневыми событиями и рассматриваются в следующем разделе. Однако событие keypress является высокоуровневым, сообщающим, что был введен печатаемый символ.

Проект спецификации DOM Level 3 Events определяет более обобщенное событие textinput , генерируемое в ответ на ввод текста, независимо от того, каким способом он был введен.

С предлагаемым событием textinput и реализованным в настоящее время событием textInput передается простой объект события, имеющий свойство data, хранящее введенный текст. (Другое предлагаемое спецификацией свойство, inputMethod, должно определять источник ввода, но оно пока не реализовано.) В случае ввода с клавиатуры свойство data обычно будет содержать единственный символ, но при вводе из других источников в нем может содержаться множество символов.

Объект события, передаваемый с событием keypress, имеет более сложную организацию. Событие keypress представляет ввод единственного символа. Этот символ содержится в объекте события в виде числового значения кодового пункта Юникода и, чтобы преобразовать его в строку, необходимо использовать метод String.fromCharCode(). В большинстве браузеров кодовый пункт введенного символа сохраняется в свойстве keyCode объекта события. Однако по историческим причинам в Firefox вместо него используется свойство charCode .

В большинстве браузеров событие keypress возбуждается только при вводе печатаемого символа. Однако в Firefox событие keypress возбуждается также для непечатаемых символов. Чтобы отличить эти два случая (и проигнорировать непечатаемые символы), можно проверить, существует ли свойство charCode объекта события и содержит ли оно значение 0.

События textinput, textInput и keypress можно отменить, чтобы предотвратить ввод символа. То есть эти события можно использовать для фильтрации ввода. Например, можно предотвратить ввод алфавитных символов в поле, предназначенное для ввода числовых данных.

В примере ниже демонстрируется модуль на языке JavaScript, реализующий такого рода фильтрацию. Он отыскивает элементы с дополнительным (нестандартным) атрибутом data-allowed-chars. Регистрирует обработчики событий textinput, textInput и keypress для всех найденных элементов и ограничивает возможность ввода символами регулярного выражения, заданным в атрибуте data-allowed-chars:

/* Фильтрация ввода для элементов Этот модуль отыскивает все элементы в документе, имеющие атрибут "data-allowed-chars". Регистрирует обработчики событий keypress, textinput и textInput для этих элементов, чтобы ограничить набор допустимых для ввода символов, чтобы разрешить вводить только символы, указанные в атрибуте. Если элемент также имеет атрибут "data-messageid", значение этого атрибута интерпретируется как id другого элемента документа. Если пользователь вводит недопустимый символ, элемент с указанным id делается видимым. Если пользователь вводит допустимый символ, элемент с сообщением скрывается. Данный элемент с сообщением предназначается для вывода пояснений, почему ввод пользователя был отвергнут. Его оформление необходимо реализовать с помощью CSS так, чтобы изначально он был невидим. */ whenReady(function () { // Вызовет эту функцию, когда документ будет загружен // Отыскать все элементы var inputelts = document.getElementsByTagName("input"); // Обойти их в цикле for(var i = 0 ; i < inputelts.length; i++) { var elt = inputelts[i]; // Пропустить элементы, не являющиеся текстовыми полями ввода // и не имеющие атрибута data-allowed-chars if (elt.type != "text" || !elt.getAttribute("data-allowed-chars")) continue; // Зарегистрировать наш обработчик события в этом элементе input // keypress старое событие и реализовано во всех браузерах. // textInput поддерживается в Safari и Chrome с 2010 года. // textinput версия проекта стандарта "DOM Level 3 Events". if (elt.addEventListener) { elt.addEventListener("keypress", filter, false); elt.addEventListener("textInput", filter, false); elt.addEventListener("textinput", filter, false); } // textinput не поддерживается версиями IE, в которых не реализован // метод addEventListener() else { elt.attachEvent("onkeypress", filter); } } // Обработчик событий keypress и textInput, фильтрующий ввод пользователя function filter(event) { // Получить объект события и целевой элемент target var e = event || window.event; // Модель стандартная или IE var target = e.target || e.srcElement; // Модель стандартная или IE var text = null; // Введенный текст // Получить введенный символ или текст if (e.type === "textinput" || e.type === "textInput") text = e.data; else { // Это было событие keypress // Введенный печатаемый символ в Firefox сохраняется в свойстве charCode var code = e.charCode || e.keyCode; // Если была нажата какая либо функциональная клавиша, не фильтровать ее if (code < 32 || // Управляющий символ ASCII e.charCode == 0 || // Функциональная клавиша (в Firefox) e.ctrlKey || e.altKey) // Удерживаемая клавиша-модификатор return; // Не фильтровать это событие // Преобразовать код символа в строку var text = String.fromCharCode(code); } // Отыскать необходимую нам информацию в этом элементе input var allowed = target.getAttribute("data-allowed-chars"); // Допустимые символы var messageid = target.getAttribute("data-messageid"); // Сообщение id if (messageid) // Если указано значение id, получить элемент var messageElement = document.getElementById(messageid); // Обойти в цикле символы во введенном тексте for(var i = 0; i < text.length; i++) { var c = text.charAt(i); allowed = new RegExp(allowed, "i"); // Создаем регулярное выражение if (c.search(allowed) == -1) { // Недопустимый символ? // Отобразить элемент с сообщением, если указан if (messageElement) messageElement.style.visibility="visible"; // Отменить действия по умолчанию, чтобы предотвратить вставку текста if (e.preventDefault) e.preventDefault(); if (e.returnValue) e.returnValue = false; return false; } } // Если все символы оказались допустимыми, скрыть элемент // с сообщением, если он был указан if (messageElement) messageElement.style.visibility = "hidden"; } });

Ниже показан образец разметки HTML, использующей этот модуль:

Пожалуйста, заполните форму.

Контактная информация Имя Только буквы
Телефон Только цифры
Email Некорректный email

На рисунке ниже показано использование этой формы. Здесь после ввода имени я вставил цифру, которая была автоматически заблокирована и появилось предупреждающее сообщение:

События keypress и textinput генерируются непосредственно перед фактической вставкой нового текста в элемент документа, обладающий фокусом ввода, благодаря чему обработчики этих событий могут предотвратить вставку текста, отменив событие.

Браузеры также реализуют событие input , которое возбуждается после вставки текста в элемент. Это событие нельзя отменить и соответствующий ему объект события не содержит информации о вставленном тексте - оно просто извещает о том, что текстовое содержимое элемента изменилось. Если, к примеру, потребуется обеспечить ввод только символов в верхнем регистре, можно определить обработчик события input, как показано ниже:

Событие input стандартизовано в спецификации HTML5 и поддерживается всеми современными браузерами, кроме IE. Похожего эффекта в IE можно добиться, обнаруживая изменение значения свойства value текстового элемента ввода с помощью нестандартного события propertychange .

События клавиатуры

События keydown и keyup возбуждаются, когда пользователь нажимает или отпускает клавишу на клавиатуре. Они генерируются для клавиш-модификаторов, функциональных клавиш и алфавитно-цифровых клавиш. Если пользователь удерживает клавишу нажатой настолько долго, что включается режим автоповтора, будет сгенерировано множество событий keydown, прежде чем появится событие keyup.

Объект события, соответствующий этим событиям, имеет свойство keyCode с числовым значением, которое определяет нажатую клавишу. Для клавиш, генерирующих печатаемые символы, в общем случае свойство keyCode содержит кодовый пункт Юникода, соответствующий основному символу, изображенному на клавише. Клавиши с буквами всегда генерируют значения keyCode, соответствующие символам в верхнем регистре, независимо от состояния клавиши Shift, поскольку именно такие символы изображены на клавишах.

Аналогично цифровые клавиши всегда генерируют значения keyCode, соответствующие цифровым символам, изображенным на клавишах, даже если при этом вы удерживали нажатой клавишу Shift, чтобы ввести знак препинания. Для клавиш, не соответствующих печатаемым символам, свойство keyCode будет иметь некоторое другое значение. Эти значения свойства keyCode никогда не были стандартизованы. Однако в разных браузерах они отличаются не настолько сильно, чтобы нельзя было обеспечить переносимость.

Подобно объектам событий мыши, объекты событий клавиатуры имеют свойства altKey , ctrlKey , metaKey и shiftKey , которые получают значение true, если в момент возникновения события удерживалась нажатой соответствующая клавиша-модификатор.

События keydown и keyup, а также свойство keyCode используются уже более десяти лет, но они так и не были стандартизованы. Проект стандарта DOM Level 3 Events стандартизует типы keydown и keyup событий, но не стандартизует свойство keyCode. Вместо этого он определяет новое свойство key, которое должно содержать название клавиши в виде строки. Если клавиша соответствует печатаемому символу, свойство key должно содержать этот печатаемый символ. Для функциональных клавиш свойство key должно содержать такие значения, как F2, Home или Left.

На момент написания этих строк свойство key, определяемое стандартом DOM Level 3 Events, еще не было реализовано ни в одном из браузеров. Однако браузеры на базе механизма Webkit, Safari и Chrome определяют в объектах этих событий свойство keyIdentifier . Для функциональных клавиш, подобно свойству key, свойство keyIdentifier содержит не число, а строку с именем клавиши, таким как Shift или Enter. Для клавиш, соответствующих печатаемым символам, это свойство содержит менее удобное в использовании строковое представление кодового пункта Юникода символа. Например, клавише A соответствует значение U+0041.

В примере ниже определяется класс Keymap, который отображает идентификаторы комбинаций клавиш, такие как PageUp, Alt_Z и ctrl+alt+shift+F5 в функции на языке JavaScript, вызываемые в ответ на нажатия этих комбинаций. Определения привязок клавиш передаются конструктору Keymap() в форме объекта JavaScript, имена свойств которого соответствуют идентификаторам комбинаций клавиш, а значения этих свойств содержат ссылки на функции-обработчики. Добавление и удаление привязок осуществляется с помощью методов bind() и unbind().

Устанавливается объект Keymap в HTML-элемент (обычно в объект Document) с помощью метода install(). При установке объекта Keymap в этом элементе регистрируется обработчик события keydown. Каждый раз, когда нажимается клавиша, обработчик проверяет наличие функции, соответствующей этой комбинации. Если функция существует, она вызывается.

Обработчик события keydown использует свойство key, определяемое стандартом «DOM Level 3 Events», если оно существует. В противном случае он пытается использовать Webkit-свойство keyIdentifier. И как запасной вариант, обработчик использует нестандартное свойство keyCode:

// Функция конструктор function Keymap(bindings) { this.map = {}; // Определить отображение идентификатор->обработчик if (bindings) { // Скопировать в него начальную карту привязок for(name in bindings) this.bind(name, bindings); } } // Связывает указанный идентификатор клавиши с указанной функцией обработчиком Keymap.prototype.bind = function(key, func) { this.map = func; }; // Удаляет привязку для указанного идентификатора клавиши Keymap.prototype.unbind = function(key) { delete this.map; }; // Устанавливает этот объект Keymap в указанный HTML-элемент Keymap.prototype.install = function(element) { var keymap = this; // Определить функции обработчика события function handler(event) { return keymap.dispatch(event, element); } // Установить ее if (element.addEventListener) element.addEventListener("keydown", handler, false); else if (element.attachEvent) element.attachEvent("onkeydown", handler); }; // Этот метод делегирует обработку события клавиатуры, опираясь на привязки Keymap.prototype.dispatch = function(event, element) { // Изначально нет ни имен клавиш-модификаторов, ни имени клавиши var modifiers = ""; var keyname = null; // Сконструировать строки модификаторов в каноническом виде из символов // в нижнем регистре, расположив их в алфавитном порядке. if (event.altKey) modifiers += "alt_"; if (event.ctrlKey) modifiers += "ctrl_"; if (event.metaKey) modifiers += "meta_"; if (event.shiftKey) modifiers += "shift_"; // Имя клавиши легко получить, если реализовано свойство key, // определяемое стандартом DOM Level 3: if (event.key) keyname = event.key; // Для получения имен функциональных клавиш в Safari и Chrome можно // использовать свойство keyIdentifier else if(event.keyIdentifier && event.keyIdentifier.substring(0,2) !== "U+") keyname = event.keyIdentifier; // В противном случае можно использовать свойство keyCode // и отображение код > имя ниже else keyname = Keymap.keyCodeToKeyName; // Если имя клавиши не удалось определить, просто проигнорировать событие // и вернуть управление. if (!keyname) return; // Канонический идентификатор клавиши состоит из имен модификаторов // и имени клавиши в нижнем регистре var keyid = modifiers + keyname.toLowerCase(); // Проверить, имеется ли привязка для данного идентификатора клавиши var handler = this.map; if (handler) { // Если обработчик для данной клавиши, вызвать его // Вызвать функцию обработчик var retval = handler.call(element, event, keyid); // Если обработчик вернул false, отменить действия по умолчанию // и прервать всплытие события if (retval === false) { if (event.stopPropagation) event.stopPropagation(); // модель DOM else event.cancelBubble = true; // модель IE if (event.preventDefault) event.preventDefault(); // DOM else event.returnValue = false; // IE } // Вернуть значение, полученное от обработчика return retval; } }; // Вспомогательная функция преобразования идентификатора клавиши в каноническую форму. // Нам необходимо преобразовать идентификатор "meta" в "ctrl", чтобы превратить // идентификатор Meta-C в "Command-C" на компьютерах Mac и в "Ctrl-C" на всех остальных. Keymap.normalize = function(keyid) { keyid = keyid.toLowerCase(); // В нижний регистр var words = keyid.split(/\s+|[\-+_]/); // Вычленить модификаторы var keyname = words.pop(); // keyname - последнее слово keyname = Keymap.aliases || keyname; // Это псевдоним? words.sort(); // Сортировать модификаторы words.push(keyname); // Поместить обратно нормализованное имя return words.join("_"); // Объединить все вместе } Keymap.aliases = { // Отображение привычных псевдонимов клавиш в их // "официальные" имена, используемые в DOM Level 3, и отображение кодов клавиш // в имена ниже. Имя и значение должны состоять только из символов нижнего регистра "escape":"esc", "return":"enter", "delete":"del", "ctrl":"control", "space":"spacebar", "ins":"insert" }; // Старое свойство keyCode объекта события keydown не стандартизовано // Но следующие значения с успехом могут использоваться в большинстве браузеров и ОС. Keymap.keyCodeToKeyName = { // Клавиши со словами или стрелками на них 8:"Backspace", 9:"Tab", 13:"Enter", 16:"Shift", 17:"Control", 18:"Alt", 19:"Pause", 20:"CapsLock", 27:"Esc", 32:"Spacebar", 33:"PageUp", 34:"PageDown", 35:"End", 36:"Home", 37:"Left", 38:"Up", 39:"Right", 40:"Down", 45:"Insert", 46:"Del", // Цифровые клавиши на основной клавиатуре (не на дополнительной) 48:"0",49:"1",50:"2",51:"3",52:"4",53:"5",54:"6",55:"7",56:"8",57:"9", // Буквенные клавиши. Обратите внимание, что здесь не различаются // символы верхнего и нижнего регистров 65:"A", 66:"B", 67:"C", 68:"D", 69:"E", 70:"F", 71:"G", 72:"H", 73:"I", 74:"J", 75:"K", 76:"L", 77:"M", 78:"N", 79:"O", 80:"P", 81:"Q", 82:"R", 83:"S", 84:"T", 85:"U", 86:"V", 87:"W", 88:"X", 89:"Y", 90:"Z", // Цифровые клавиши на дополнительной клавиатуре и клавиши со знаками препинания. // (Не поддерживаются в Opera.) 96:"0",97:"1",98:"2",99:"3",100:"4",101:"5",102:"6",103:"7",104:"8", 105:"9",106:"Multiply", 107:"Add", 109:"Subtract", 110:"Decimal", 111:"Divide", // Функциональные клавиши 112:"F1", 113:"F2", 114:"F3", 115:"F4", 116:"F5", 117:"F6", 118:"F7", 119:"F8", 120:"F9", 121:"F10", 122:"F11", 123:"F12", 124:"F13", 125:"F14", 126:"F15", 127:"F16", 128:"F17", 129:"F18", 130:"F19", 131:"F20", 132:"F21", 133:"F22", 134:"F23", 135:"F24", // Клавиши со знаками препинания, для ввода которых не требуется // удерживать нажатой клавишу Shift. // Дефис не может использоваться переносимым способом: FF возвращает // тот же код, что и для клавиши Subtract 59:";", 61:"=", 186:";", 187:"=", // Firefox и Opera возвращают 59,61 188:",", 190:".", 191:"/", 192:"`", 219:"[", 220:"\\", 221:"]", 222:""" };

Ниже показан пример использования объекта Keymap:

Window.onload = function() { var keymap = new Keymap; // Создать новый объект Keymap keymap.bind("ctrl+a", // Комбинация Ctrl+A function(event, keyid) { alert("Вы нажали: " + keyid) }); // Еще одна привязка Ctrl + Enter keymap.bind("ctrl+enter", function(event, keyid) { alert("Вы нажали: " + keyid) }); keymap.install(document.body); // Устанавливаем объект Keymap для всего документа };

Последнее обновление: 1.11.2015

Встроенные обработчики

В прошлой теме были рассмотрены встроенные обработчики (inline event handler), которые определяются в коде элемента с помощью атрибутов:

Хотя этот подход прекрасно работает, но он имеет кучу недостатков:

    Код html смешивается с кодом JavaScript, в связи с чем становится труднее разрабатывать, отлаживать и поддерживать приложение

    Обработчики событий можно задать только для уже созданных на веб-странице элементов. Динамически создаваемые элементы в этом случае лишаются возможности обработки событий

    К элементу для одного события может быть прикреплен только один обработчик

    Нельзя удалить обработчик без изменения кода

Свойства обработчиков событий

Проблемы, которые возникают при использовании встроенных обработчиков, были призваны решить свойства обработчиков. Подобно тому, как у html-элементов есть атрибуты для обработчиков, так и в коде javascript у элементов DOM мы можем получить свойства обработчиков, которые соответствуют атрибутам:

function handler(e){ alert(e.type); } document.getElementById("rect").onclick = handler;

В итоге нам достаточно взять свойство onclick и присвоить ему функцию, используемую в качестве обработчика. За счет этого код html отделяется от кода javascript.

Стоит также отметить, что в обработчик события браузер автоматически передает объект Event, хранящий всю информацию о событии. Поэтому также мы можем получить этот объект в функции обработчика в качестве параметра.

Слушатели событий

Несмотря на то, что свойства обработчиков решают ряд проблем, которые связаны с использованием атрибутов, в то же время это также не оптимальный подход. Еще один способ установки обработчиков событий представляет использование слушателей.

Для работы со слушателями событий в JavaScript есть объект EventTarget , который определяет методы addEventListener() (для добавления слушателя) и removeEventListener() для удаления слушателя. И поскольку html-элементы DOM тоже являются объектами EventTarget, то они также имеют эти методы. Фактически слушатели представляют те же функции обработчиков.

Метод addEventListener() принимает два параметра: название события без префикса on и функцию обработчика этого события. Например:

#rect{ width:50px; height:50px; background-color:blue; } var rect = document.getElementById("rect"); rect.addEventListener("click", function (e) { alert(e.type); });

То есть в данном случае опять же обрабатывается событие click. И также можно было бы в качестве второго параметра название функции:

Function handler(e){ alert(e.type); } var rect = document.getElementById("rect"); rect.addEventListener("click", handler);

Удаление слушателя аналогично добавлению:

Rect.removeEventListener("click", handler);

Преимуществом использования слушателей является и то, что мы можем установить для одного события несколько функций:

Var clicks = 0; function handlerOne(e){ alert(e.type); } function handlerTwo(e){ clicks++; var newNode = document.createElement("p"); newNode.textContent = "произошло нажатие " + clicks; document.body.appendChild(newNode); } var rect = document.getElementById("rect"); // прикрепляем первый обработчик rect.addEventListener("click", handlerOne); // прикрепляем второй обработчик rect.addEventListener("click", handlerTwo);

Рассмотрим наиболее стандартные и часто используемые javaScript события:

Обработчик
события

Поддерживающие HTML- элементы и объекты

Описание

Получение элементом фокуса

a, area, button, input,
label, select, textarea

Потеря текущим элементом фокуса. Возникает при
щелчке мышью вне элемента либо нажатии клавиши табуляции

Input, select, textarea

Изменение значений элементов формы. Возникает после потерей элементом фокуса, т.е. после события blur

Практически все

Одинарный щелчок (нажата и отпущена кнопка мыши)

a, area, button, input, label, select, textarea

Практически все

Нажата кнопка мыши в пределах текущего элемента

Практически
все

Курсор мыши выведен за пределы
текущего элемента

Практически все

Курсор мыши наведен на текущий элемент

Практически все

Отпущена кнопка мыши в пределах текущего элемента

Перемещение окна

Изменение размеров окна

Выделение текста в текущем элементе

Отправка данных формы

Попытка закрытия окна браузера и выгрузки документа
Событие onLoad. Свойства высоты и ширины объекта в javaScript

Для выполнения следующего примера нам понадобится новое понятие — событие.

В нашем случае событие — это реакция программы на действие пользователя (щелчок мышью по кнопке, уменьшение мышкой окна браузера, ввод текста с клавиатуры и т.д.). С помощью программы у нас есть возможность отреагировать на любые действия пользователя.

Рассмотрим одно из самых распространенных событий — onload — которое происходит при загрузке документа (когда пользователь своими действиями вызвал загрузку веб-страницы).

Рассмотрим пример использования события javascript onload для изменения ширины и высоты элемента.

Пример: Добавить на страницу изображение и при помощи javascript при наступлении события загрузки страницы сделать ширину изображения соответствующей ширине окна браузера.


✍ Решение:
    function resizeImg() { var myImg= document.getElementById ("img1" ) ; myImg.style .width = document.body .clientWidth ; } ...

    function resizeImg(){ var myImg=document.getElementById("img1"); myImg.style.width=document.body.clientWidth; } ...

В примере основные действия происходят в функции resizeImg() :

  • переменная myImg ассоциирована с тегом img — картинкой, свойство которой width — ширина — меняется в самой функции.
  • Вызов функции происходит по загрузке страницы в событии onload тела документа (тело — body — главный элемент, поэтому загрузка страницы — это событие, относящееся к телу).

    • Задание Js8_4. Разместите в html-коде несколько изображений (тег img). Используя метод измените:
    — размер (свойства width и height) всех изображений страницы
    — размер границы (свойство border) всех изображений.

    Дополните код:

    var allImg=document...; // получаем массив изображений for (var i=0; i < allImg.length; i++){ allImg[i].....; // меняем свойство width ...; // меняем свойство height ...; // меняем border }

    Событие onclick javaScript и три способа обработки событий

    Событие onClick происходит во время одинарного щелчка кнопкой мыши . Обычно для события назначается обработчик , то есть функция, которая сработает, как только событие произошло. Обработать событие, т.е. отреагировать на него посредством скрипта, можно тремя способами. Рассмотрим их:

    Пример: По щелчку на кнопке вывести диалоговое окно с сообщением «Ура!»

  • Через свойство объекта с использованием пользовательской функции:

    • Скрипт:

    В данном примере в html-коде мы видим кнопку. У кнопки присутствует атрибут onclick («по щелчку» ), в значении которого стоит вызов функции с названием message() . Это пользовательская функция, описанная выше в скрипте. В самой функции выводится диалоговое окно, что и задано согласно заданию.

    Скрипт при такой обработке события обычно находится в области head документа


  • Через атрибут тега:

    • Это упрощенный вариант обработки события, он подходит только для небольшого кода, когда необходимо выполнить один-два оператора. Иначе код будет плохочитаемым.
    В качестве атрибута кнопки указывается onclick («по щелчку» ), а в качестве значения пишется скрипт из операторов с указанием на каком языке он написан (javascript:). В нашем случае оператор для вывода модального окна со словом «Ура!»

  • Через регистрацию функции-обработчика в качестве свойства элемента:

    • html-код:

    Скрипт:

    document.myForm .myButton .onclick = message; function message() { alert("Ура!" ) ; }

    document.myForm.myButton.onclick = message; function message() { alert("Ура!"); }

    В html-коде здесь присутствует кнопка с атрибутом id , который необходим для обращения к кнопке через скрипт.

    В скрипте, который обязательно находится ниже дерева элементов (можно перед закрытием тега body), находится обращение к кнопке (document.myForm.myButton), для которой назначается обработчик события onclick со значением ссылки на функцию . Обращение к кнопке может быть организовано через атрибут id (document.getElementById("myButton").onclick = message;)

    Скобки после названия функции message не ставятся. В данном случае это именно ссылка на функцию, иначе, при использовании скобок, функция была бы вызвана, а не назначена в качестве обработчика событий.

    Именно такой способ обработки событий максимально приближен к тому, который происходит, например, в ОС windows.

    Как лучше выводить результаты примеров?

    Важно: При вызове document.write после окончания загрузки страницы (при обработке событий onclick , oninput , …), страница перезапишется, поэтому вызывать этот метод не рекомендуется . Для примеров лучше использовать метод alert() .

  • document.write добавляет html во время построения DOM
  • alert блокируют выполнение JS, пока пользователь не нажмёт OK

    • Рассмотрим все простые способы вывода отладочной информации :

    document.innerHTML += "htmlstr"; // добавляет на страницу

    console.log("str"); // выводит в консоль браузерах


    Задание Js8_5. Выполните задание по инструкции:

  • Создайте веб-страницу и расположите в ней тег img с изображением грустного смайлика.
  • Щелчок на изображении (onclick) вызывает заданный метод (пользовательская функция):

  • В скрипте опишите метод (функция sayHello()), который «спрашивает», как зовут пользователя, а затем приветствует его по имени, и меняет изображение на улыбающийся смайлик (свойство src тега img):
    • function sayHello() { var userName= prompt("Как вас зовут?" ) ; if (userName) { alert(...) ; document.getElementById ("smileImg" ) . ...= ...; } }

    function sayHello() { var userName=prompt("Как вас зовут?"); if(userName){ alert(...); document.getElementById("smileImg"). ...=...; } }

    =>>

    События onMouseOver и onMouseOut

    Событие наступает при наведении (onMouseOver) на объект и при выведении (onMouseOut) за пределы объекта курсора мыши.

    Назначение обработчика событий осуществляется точно таким же образом, как и в случае .

    Поэтому выполним задание:

    Задание Js8_6. По наведению курсора мыши на гиперссылки закрашивать задний фон страницы в разные цвета.

    Дополните код:

    Зеленый
    … seagreen
    … magenta
    … purple
    … navy
    … royalblue

    Задание Js8_7. Создание rollover-изображения

    — Добавьте в код тег img с изображением.
    — Введите обработчики событий onmouseover (по наведению) и onmouseout (при отведении). Сделайте это в виде функций.
    — Присоедините к обработчику событий onmouseover процедуру загрузки в тег img другого изображения.
    — Присоедините к обработчику событий onmouseout процедуру загрузки другого изображения в тег img .

    Несколько обработчиков одного и того же события

    В javascript можно назначать НЕСКОЛЬКО обработчиков одного и того же события. Для этого используются методы:

  • addEventListener — добавление обработчика
  • removeEventListener — удаление обработчика

    • Синтаксис addEventListener :

    У метода три аргумента:

    Element.addEventListener(event, handler[, phase]);

  • event click
  • handler — функция-обработчикgetElementById ("MyElem" ) ; input.addEventListener ("click" , message) ;

    function message() { alert("Ура!"); } var input = document.getElementById("MyElem"); input.addEventListener("click", message);

    Синтаксис removeEventListener :

    Методу следует передать те же аргументы, что были у addEventListener :

    Element.removeEventListener(event, handler[, phase]);

  • event — название события, например, click
  • handler — функция-обработчик
  • phase — необязательный аргумент, «фаза», на которой обработчик должен сработать

    • Пример: В предыдущем задании удалить добавленный обработчик с кнопки, используя метод removeEventListener .

    function message() { alert("Ура!"); } var input = document.getElementById("MyElem"); input.addEventListener("click", message); input.removeEventListener("click", message);

    Всплытие и погружение события

    obj.onevent = function(e) {/*...*/} // где e - объект события // e.target - элемент, на котором произошло событие

    Некоторые программы с применением JavaScript event работают напрямую с вводимыми пользователем данными. Момент возникновения и порядок таких взаимодействий не могут быть предсказаны заранее.

    Обработчики событий

    Реагировать на нажатие клавиши можно, постоянно считывая ее состояние, чтобы поймать момент нажатия клавиши, прежде чем она снова не будет отпущена.

    Именно так обрабатывался ввод данных на примитивных машинах. Более прогрессивным является определение нажатия клавиши и его постановка в очередь. Затем программа может периодически проверять очередь новых событий и реагировать на то, что там находит. В таком случае программа должна не забывать просматривать очередь и делать это часто.

    В период от нажатия клавиши и до обнаружения программой этого события, она фактически не отвечает на запросы. Такой подход называется поллингом (опросом ).

    Большинство программистов стараются избегать его, если это возможно.

    Самым лучшим способом считается реализация системы, которая дает коду возможность реагировать на события, когда они происходят. Браузеры реализуют ее, предоставляя возможность регистрировать функции обработчиков для конкретных JavaScript event :

    Кликните по этому документу, чтобы активировать обработчик.

    addEventListener("click", function() { console.log("You clicked!"); });

    Функция addEventListener регистрируется таким образом, что ее второй аргумент вызывается всякий раз, когда происходит событие, описанное первым аргументом.

    События и узлы DOM

    Каждый обработчик событий браузера регистрируется в контексте. При вызове функции addEventListener она вызывается как метод для всего окна, так как в браузере глобальный диапазон эквивалентен объекту window . Каждый элемент DOM имеет свой собственный метод addEventListener , который позволяет отслеживать события именно в этом элементе:

    Нажмите на меня

    Здесь нет обработчика.

    var button = document.querySelector("button"); button.addEventListener("click", function() { console.log("Button clicked."); });

    В данном примере обработчик подключен к узлу кнопки. JavaScript mouse events приводит в действие обработчик, а клик в остальной части документа — нет.

    Установив для узла атрибут onclick , мы получим тот же результат. Но узел имеет только один атрибут onclick , поэтому можно зарегистрировать для каждого узла только один обработчик. Метод addEventListener позволяет добавлять любое количество обработчиков. Так мы застрахованы от случайной замены обработчика, который уже был зарегистрирован.

    Метод removeEventListener , вызывается с аргументами, аналогичными addEventListener . Он удаляет обработчик:

    Одноразовая кнопка var button = document.querySelector("button"); function once() { console.log("Done."); button.removeEventListener("click", once); } button.addEventListener("click", once);

    Чтобы отменить функцию обработчика, мы задаем для нее имя (например, once ). Так мы передаем ее как в addEventListener , так и в removeEventListener .

    Объекты событий

    Хотя мы не упоминали об этом в приведенных выше примерах, в функции обработчиков JavaScript event передается аргумент: объект события. Он предоставляет дополнительную информацию о событии. Например, если мы хотим знать, какая клавиша мыши была нажата, нужно получить значение свойства объекта события which :

    Кликните по мне любой клавишей мыши var button = document.querySelector("button"); button.addEventListener("mousedown", function(event) { if (event.which == 1) console.log("Left button"); else if (event.which == 2) console.log("Middle button"); else if (event.which == 3) console.log("Right button"); });

    Информация, хранящаяся в объекте, различается зависимости от типа события. Свойство объекта type всегда содержит строку, идентифицирующую событие (например, «click » или «mousedown «).

    Распространение

    Обработчики событий (например, JavaScript touch events ), зарегистрированные для родительских узлов, также будут принимать события, которые происходят в дочерних элементах. Если была нажата кнопка, находящаяся внутри абзаца, обработчики событий абзаца также получат событие click .

    Событие распространяется от узла, в котором оно произошло, в родительский узел и в корень документа. После того, как все обработчики, зарегистрированные в конкретном узле, вступили в действие по очереди, возможность реагировать на событие получают обработчики, зарегистрированные для всего окна.

    В любой момент обработчик события может вызвать для объекта события метод stopPropagation , чтобы предотвратить распространение события дальше. Это может быть полезно, когда у вас есть кнопка внутри другого интерактивного элемента, и вы не хотите, чтобы при нажатии кнопки активировалось поведение, заданное для клика мышью по внешним элементам.

    В следующем примере мы регистрируем обработчики «MouseDown » как для кнопки, так и для абзаца. При клике правой клавишей (JavaScript mouse events ) обработчик вызывает метод stopPropagation , который предотвращает запуск обработчика абзаца. При нажатии на кнопку другой клавишей мыши запускаются оба обработчика:

    Абзац и в нем кнопка.

    var para = document.querySelector("p"); var button = document.querySelector("button"); para.addEventListener("mousedown", function() { console.log("Handler for paragraph."); }); button.addEventListener("mousedown", function(event) { console.log("Handler for button."); if (event.which == 3) event.stopPropagation(); });

    Большинство объектов событий имеют свойство target , которое указывает на узел, в котором они возникли. Вы можете использовать это свойство, чтобы случайно не обрабатывать какое-то событие, которое распространяется вверх из узла.

    Также можно использовать JavaScript event target , чтобы расширить диапазон события определенного типа. Например, если у вас есть узел, содержащий длинный список кнопок, более удобно зарегистрировать один обработчик клика для внешнего узла и использовать свойство target , чтобы отслеживать, была ли нажата кнопка, а не регистрировать экземпляры обработчика для всех кнопок:

    A B C document.body.addEventListener("click", function(event) { if (event.target.nodeName == "BUTTON") console.log("Clicked", event.target.textContent); });

    Действия по умолчанию

    Со многими событиями связаны действия по умолчанию. Если вы нажмете на ссылку, то перейдете к целевому элементу ссылки. Если нажмете стрелку вниз, браузер прокрутит страницу вниз. Если вы кликните правой клавишей мыши, откроется контекстное меню.

    Для большинства типов событий обработчики JavaScript event вызываются до выполнения действий по умолчанию. Если не нужно, чтобы выполнялось поведение по умолчанию, нужно вызвать для объекта события метод preventDefault .

    Его использовать для реализации пользовательских сочетаний клавиш или контекстных меню. Или, чтобы переопределить поведение, которое ожидают пользователи. Ниже приводится ссылка, по которой нельзя перейти:

    MDN var link = document.querySelector("a"); link.addEventListener("click", function(event) { console.log("Nope."); event.preventDefault(); });

    Старайтесь не делать так, если у вас нет на это веских причин.

    В зависимости от браузера некоторые события не могут быть перехвачены. В Google Chrome , например, сочетание клавиш (event keycode JavaScript ) для закрытия текущей вкладки (Ctrl-W или Command-W ) не может быть обработано с помощью JavaScript .

    События клавиш

    Когда пользователь нажимает клавишу на клавиатуре, браузер запускает событие «keydown «. Когда он отпускает клавишу, срабатывает событие «keyup «:

    Эта страница становится фиолетовой, когда вы нажимаете клавишу V.

    addEventListener("keydown", function(event) { if (event.keyCode == 86) document.body.style.background = "violet"; }); addEventListener("keyup", function(event) { if (event.keyCode == 86) document.body.style.background = ""; });

    Также это событие срабатывает, когда пользователь нажимает и удерживает клавишу, или пока клавиша удерживается. Например, если требуется увеличить скорость персонажа в игре, нажав на клавишу со стрелкой, и снова уменьшить ее, отпустив клавишу, то нужно быть осторожным, чтобы не увеличивать скорость каждый раз, пока клавиша нажата.

    В предыдущем примере использовано свойство объекта event keycode JavaScript . С его помощью определяется, какая именно клавиша была нажата или отпущена. Ноне всегда очевидно, как привести числовой код клавиши к фактической клавише.

    Для считывания значений клавиш букв и цифр используется код символа Unicode . Он связан с буквой (в верхнем регистре ) или цифрой, обозначенной на клавише. Метод charCodeAt для строк позволяет получить это значение:

    console.log("Violet".charCodeAt(0)); // → 86 console.log("1".charCodeAt(0)); // → 49

    С другими клавишами связаны менее предсказуемые коды клавиш. Лучший способ определить нужный код, это поэкспериментировать. Зарегистрировать обработчик события нажатия клавиши, который фиксирует коды клавиш, которые он получает, и нажать нужную клавишу.

    Такие клавиши, как Shift , Ctrl , Alt порождают события, как обычные клавиши. Но при отслеживании комбинаций клавиш также можно определить, нажаты ли эти клавиши, по свойствам событий клавиатуры и JavaScript mouse events : shiftKey , ctrlKey , altKey и metaKey :

    Чтобы продолжить, нажмите Ctrl-Space.

    addEventListener("keydown", function(event) { if (event.keyCode == 32 && event.ctrlKey) console.log("Continuing!"); });

    События «keydown » и «keyup » предоставляют информацию о фактическом нажатии клавиш. Но что, если нам нужен сам вводимый текст? Получать текст из кодов клавиш неудобно. Для этого существует событие, «keypress «, которое срабатывает сразу после «keydown «. Оно повторяется вместе с «keydown «, пока клавиша нажата. Но только для клавиш, с помощью которых производится ввод символов.

    Свойство charCode в объекте события содержит код, который может быть интерпретирован, как код символа Unicode . Мы можем использовать функцию String.fromCharCode , чтобы преобразовать этот код в строку из одного символа.

    Установите фокус ввода на этой странице и наберите что-нибудь.

    addEventListener("keypress", function(event) { console.log(String.fromCharCode(event.charCode)); });

    Узел DOM , в котором происходит событие зависит, от того элемента, который находился в фокусе ввода при нажатии клавиши. Обычные узлы не могут находиться в фокусе ввода (если не установить для них атрибут tabindex ), но такие элементы, как ссылки, кнопки и поля формы, могут.

    Если никакой конкретный элемент не выделен фокусом ввода, то в качестве целевого узла для событий клавиши и JavaScript touch events выступает document.body .

    Клики мыши

    Нажатие клавиши мыши также приводит в действие ряд событий. События «mousedown » и «mouseup » похожи на «keydown » и «keyup «. Они запускаются, когда нажата и отпущена клавиша мыши. Данные события возникают в узлах DOM, на которые был наведен указатель мыши, когда возникло событие.

    Для общего узла, к которому относилось как нажатие, так и освобождение клавиши мыши, после события «mouseup » запускается событие «click «. Например, если нажать клавишу мыши на одном пункте, а затем переместить курсор на другой пункт и отпустить кнопку, то событие «click » будет происходить в элементе, который содержит оба эти пункта.

    Если два клика возникли близко друг к другу, также запускается событие «dblclick » (двойной клик ). Оно возникает после второго клика. Чтобы получить точную информацию о месте, где произошло событие мыши, нужно получить значение свойств pageX и pageY , которые содержат координаты события (в пикселях ) относительно левого верхнего угла документа.

    Ниже приведена реализация примитивной программы для рисования. Каждый раз при нажатии мыши в документе (под курсором ) добавляется точка:

    body { height: 200px; background: beige; } .dot { height: 8px; width: 8px; border-radius: 4px; /* закругленные углы */ background: blue; position: absolute; } addEventListener("click", function(event) { var dot = document.createElement("div"); dot.className = "dot"; dot.style.left = (event.pageX - 4) + "px"; dot.style.top = (event.pageY - 4) + "px"; document.body.appendChild(dot); });

    Свойства clientX и clientY подобны pageX и pageY , но они относятся к видимой части документа. Они могут использоваться для сравнения координат мыши с координатами, возвращаемыми функцией getBoundingClientRect .

    Движение мыши

    Каждый раз, когда перемещается курсов мыши, срабатывает событие «mousemove » из набора JavaScript mouse events . Оно может быть использовано для отслеживания положения мыши. Это применяется при реализации возможности перетаскивания элементов мышью.

    В следующем примере программа выводит на экран панель и устанавливает обработчики событий таким образом, что при перетаскивании эта панель становится уже или шире:

    Потяните за край панели, чтобы изменить ее ширину:

    var lastX; // Отслеживает последнюю позицию X мыши var rect = document.querySelector("div"); rect.addEventListener("mousedown", function(event) { if (event.which == 1) { lastX = event.pageX; addEventListener("mousemove", moved); event.preventDefault(); // Предотвращает выделение } }); function buttonPressed(event) { if (event.buttons == null) return event.which != 0; else return event.buttons != 0; } function moved(event) { if (!buttonPressed(event)) { removeEventListener("mousemove", moved); } else { var dist = event.pageX - lastX; var newWidth = Math.max(10, rect.offsetWidth + dist); rect.style.width = newWidth + "px"; lastX = event.pageX; } }

    Обратите внимание, что обработчик «mousemove » зарегистрирован для всего окна. Даже если во время изменения размеров мышь выходит за пределы панели, мы все равно обновляем ширину панели и прекращаем JavaScript touch events , когда клавиша мыши была отпущена.

    Мы должны прекратить изменение размера панели, когда пользователь отпускает клавишу мыши. К сожалению, не все браузеры устанавливают для событий «mousemove » свойство which . Существует стандартное свойство buttons , которое предоставляет аналогичную информацию, но оно также поддерживается не во всех браузерах. К счастью, все основные браузеры поддерживают что-то одно: либо buttons , либо which . Функция buttonPressed в приведенном выше примере сначала пытается использовать свойство buttons , и, если оно не доступно, переходит к which .

    Когда курсор мыши наводится или покидает узел, запускаются события «mouseover » или «mouseout «. Они могут использоваться для создания эффектов при наведении курсора мыши, вывода какой-нибудь подписи или изменения стиля элемента.

    Чтобы создать такой эффект, недостаточно просто начать его отображение при возникновении события «mouseover » и завершить после события «mouseout «. Когда мышь перемещается от узла к одному из его дочерних элементов, для родительского узла происходит событие «mouseout «. Хотя указатель мыши не покинул диапазон распространения узла.

    Что еще хуже, эти JavaScript event распространяются так же, как и другие события. Когда мышь покидает один из дочерних узлов, для которого зарегистрирован обработчик, возникнет событие «mouseout «.

    Чтобы обойти эту проблему, можно использовать свойство объекта события relatedTarget . В случае возникновения события «mouseover » оно указывает, на какой элемент был наведен курсор мыши до этого. А в случае возникновения «mouseout » — к какому элементу перемещается указатель. Мы будем изменять эффект наведения мыши только, когда relatedTarget находится вне нашего целевого узла.

    В этом случае мы изменяем поведение, потому что курсор мыши был наведен на узел из-за его пределов (или наоборот ):

    Наведите курсор мыши на этот абзац.

    var para = document.querySelector("p"); function isInside(node, target) { for (; node != null; node = node.parentNode) if (node == target) return true; } para.addEventListener("mouseover", function(event) { if (!isInside(event.relatedTarget, para)) para.style.color = "red"; }); para.addEventListener("mouseout", function(event) { if (!isInside(event.relatedTarget, para)) para.style.color = ""; });

    Функция isInside отслеживает родительские связи заданного узла или пока не будет достигнута верхняя часть документа (когда node равен нулю ). Либо не будет найден родительский элемент, который нам нужен.

    Эффект наведения гораздо проще создать с помощью псевдоселектора CSS:hover , как показано в следующем примере. Но когда эффект наведения предполагает что-то более сложное, чем просто изменение стиля целевого узла, тогда нужно использовать прием с использованием событий «mouseover » и «mouseout » (JavaScript mouse events ):

    События прокрутки

    Каждый раз, когда элемент прокручивается, в нем срабатывает JavaScript scroll event . Его можно использовать для отслеживания того, что в данный момент просматривает пользователь; для отключения анимации, расположенной вне окна просмотра.

    В следующем примере мы выводим индикатор прогресса в правом верхнем углу документа и обновляем его, чтобы он по частям заливался другим цветом по мере прокрутки страницы вниз:

    .progress { border: 1px solid blue; width: 100px; position: fixed; top: 10px; right: 10px; } .progress > div { height: 12px; background: blue; width: 0%; } body { height: 2000px; }

    Scroll me...

    var bar = document.querySelector(".progress div"); addEventListener("scroll", function() { var max = document.body.scrollHeight - innerHeight; var percent = (pageYOffset / max) * 100; bar.style.width = percent + "%"; });

    Установив для элемента свойство position или fixed , мы получим тот же результат, что и при установке position:absolute . Но так мы также блокируем прокрутку элемента вместе с остальной частью документа. В результате индикатор прогресса будет статически закреплен в верхнем углу. Внутри него находится еще один элемент, размер которого изменяется в соответствии с текущим прогрессом.

    В качестве единиц измерения при установке ширины мы используем % , а не рх , чтобы размеры элемента изменялись пропорционально размеру индикатора прогресса.

    Глобальная переменная innerHeight содержит высоту окна, которую мы должны вычесть из общей доступной прокручиваемой высоты документа. Нельзя прокручивать окно ниже при достижении нижней части документа. С innerHeight также может использоваться innerWidth . Разделив pageYOffset (текущую позицию окна прокрутки ) на максимально допустимую позицию прокрутки и умножив на 100, мы получаем процент для индикатора прогресса.

    Вызов preventDefault для JavaScript scroll event не предотвращает прокрутку. Обработчик события вызывается только после того, как происходит прокручивание.

    События фокуса ввода

    Когда элемент находится в фокусе ввода, браузер запускает в нем событие «focus «. Когда фокус ввода снимается, запускается событие «blur «.

    Эти два события не имеют распространения. Обработчик родительского элемента не уведомляется, когда дочерний элемент выделяется фокусом ввода.

    В следующем примере выводится подсказка для текстового поля, которое в данный момент находится в фокусе ввода:

    Имя:

    Возраст:

    var help = document.querySelector("#help"); var fields = document.querySelectorAll("input"); for (var i = 0; i < fields.length; i++) { fields[i].addEventListener("focus", function(event) { var text = event.target.getAttribute("data-help"); help.textContent = text; }); fields[i].addEventListener("blur", function(event) { help.textContent = ""; }); }

    Объект окна получает события «focus » и «blur «, когда пользователь переходит или покидает вкладку, окно браузера, в котором выводится документ.

    Событие загрузки

    Когда завершается загрузка страницы, для объектов тела документа и окна возникает JavaScript event «load» . Оно используется для планирования инициализации действий, для которых требуется загрузка всего документа. Не забывайте, что содержимое запускается сразу, когда встречается этот тег. Иногда это слишком рано. Например, когда скрипт должен сделать что-то с частями документа, которые загружаются после тега .

    и теги скриптов, которые загружают внешние файлы, также содержат событие «load «. Оно указывает, что файл, который был связан с ними, загружен. Как и события фокуса ввода, события загрузки не распространяются.

    Когда мы закрываем страницу или переходим на другую (например, нажав на ссылку ), срабатывает событие «beforeunload «. Оно применяется, чтобы предотвратить возможность случайной потери пользователем того, с чем он работал, после закрытия документа.

    Предотвращение выгрузки страницы выполняется не с помощью метода preventDefault . Вместо этого, из обработчика возвращается строка. Она используется в диалоговом окне, в котором у пользователя спрашивается, хочет ли он остаться на странице или покинуть ее. Этот механизм гарантирует, что у пользователя будет возможность покинуть страницу, даже если запущен вредоносный скрипт, целью которого является удержание посетителя на странице.

    Последовательность выполнения скриптов

    Запустить выполнение скрипта могут разные факторы: считывание тега, возникновение события. Метод requestAnimationFrame , задает вызов функции, перед тем как будет заново построена следующая страница. Это еще один способ, с помощью которого могут запускаться скрипты.

    События JavaScript select events и все остальные могут запускаться в любой момент, но в одном документе два скрипта никогда не запустятся одновременно. Если скрипт уже выполняется, обработчикам событий и фрагментам кода, запланированным другим скриптом, придется подождать своей очереди. Именно по этой причине документ замирает, когда скрипт работает в течение длительного времени. Браузер не реагирует на клики и другие события, поскольку не может запустить обработчики событий, пока текущий скрипт не закончит работу.

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

    Если нужно запустить процессы в фоновом режиме без замораживания страницы, браузеры предоставляют нам то, что называется web workers . Это изолированная среда JavaScript , которая работает с документом вместе с основной программой и может общаться с ним только путем отправки и получения сообщений.

    Предположим, что в файле с именем code/squareworker.js у нас есть следующий код:

    addEventListener("сообщение", function(event) { postMessage(event.data * event.data); });

    Представьте себе, что возводимое в квадрат число является очень большим, затягивающим вычисление, и нужно выполнить вычисления в фоновом потоке. Этот код запускает web workers , посылает ему несколько сообщений и выводит ответы:

    var squareWorker = new Worker("code/squareworker.js"); squareWorker.addEventListener("message", function(event) { console.log("The worker responded:", event.data); }); squareWorker.postMessage(10); squareWorker.postMessage(24);

    Функция postMessage отправляет сообщение, которое инициирует возникновение в приемнике события «message «. Скрипт, который создал web workers , отправляет и получает сообщения через объект Worker . С помощью этого объекта среда взаимодействуют с создавшим ее скриптом, посылая информацию и прослушивая его в своем глобальном с оригинальным скриптом.

    Установка таймеров

    Функция setTimeout похожа на requestAnimationFrame . Она задает вызов еще одной функции, которая будет вызываться позже. Но вместо того, чтобы вызывать функцию при следующем формировании страницы, она ждет определенное количество миллисекунд. В этом примере JavaScript event фон страницы из синего становится желтым через две секунды:

    document.body.style.background = "blue"; setTimeout(function() { document.body.style.background = "yellow"; }, 2000);

    Иногда нужно отменить функцию, которую мы запланировали. Это делается путем сохранения значения, возвращаемого функцией setTimeout , и вызова для нее clearTimeout :

    var bombTimer = setTimeout(function() { console.log("BOOM!"); }, 500); if (Math.random() < 0.5) { // 50% chance console.log("Defused."); clearTimeout(bombTimer); }

    Функция cancelAnimationFrame работает так же, как clearTimeout . Она вызывается значением, возвращаемым requestAnimationFrame , чтобы отменить кадр (если он еще не был вызван ).

    Похожий набор функций, setInterval и clearInterval используется для установки таймера, который должен повторять действие каждые X миллисекунд:

    var ticks = 0; var clock = setInterval(function() { console.log("tick", ticks++); if (ticks == 10) { clearInterval(clock); console.log("stop."); } }, 200);

    Дробление

    Некоторые типы событий могут запускаться много раз в течение короткого периода времени (например, «mousemove » и javascript scroll event ). При обработке таких событий, нужно быть осторожным, чтобы это не происходило очень долго, иначе обработчик будет выполнять действие столько времени, что взаимодействие с документом станет медленным и скачкообразным.

    Если нужно сделать что-то нестандартное в таком обработчике, можно использовать setTimeout , чтобы быть уверенными, что это не растянется слишком надолго. Это обычно называют дроблением события. Существует несколько отличающихся друг от друга подходов к дроблению.

    В первом примере мы хотим сделать что-то, когда пользователь печатает. Но не хотим делать это после каждого события нажатия клавиши. Когда пользователь быстро печатает, нужно подождать, пока не произойдет пауза. Вместо немедленного выполнения действия в обработчике события мы устанавливаем задержку. Мы также очищаем предыдущую задержку (если таковая имеется ). Если события происходят через короткие интервалы времени (меньше, чем установленная нами задержка ), то задержка от предыдущего события отменяется:

    Напечатайте что-нибудь здесь... var textarea = document.querySelector("textarea"); var timeout; textarea.addEventListener("keydown", function() { clearTimeout(timeout); timeout = setTimeout(function() { console.log("Вы перестали печатать."); }, 500); });

    Передача неопределенного значения для clearTimeout или его вызов для задержки, которая уже запущена, не даст никакого результата. Нам больше не нужно быть осторожными относительно того, когда его вызывать, мы просто делаем это для каждого события.

    Можно использовать иной сценарий, если нужно разделить ответы небольшим промежутком времени. Но чтобы при этом они запускались во время серии событий, а не только после нее. Например, можно отправлять в ответ на события «mousemove » (JavaScript mouse events ) текущие координаты мыши, но только через каждые 250 миллисекунд:

    function displayCoords(event) { document.body.textContent = "мышь находится в точке " + event.pageX + ", " + event.pageY; } var scheduled = false, lastEvent; addEventListener("mousemove", function(event) { lastEvent = event; if (!scheduled) { scheduled = true; setTimeout(function() { scheduled = false; displayCoords(lastEvent); }, 250); } });

    Заключение

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

    Каждое событие относится к определенному типу («keydown «, «focus » и так далее ), который идентифицирует его. Большинство событий вызывается для конкретного элемента DOM , а затем распространяются на родительские узлы элемента. Это позволяет обработчикам, связанным с этими элементами, обрабатывать их.

    Когда вызывается обработчик, ему передается объект события с дополнительной информацией о действии. Этот объект также содержит методы, позволяющие остановить дальнейшее распространение события (stopPropagation ) или предотвратить обработку события браузером по умолчанию (preventDefault ).

    Нажатие клавиш порождает события «keydown «, «keypress » и «keyup «. Нажатие мыши порождает события «mousedown «, «mouseup » и «click «. Перемещение мыши — «mousemove «, «mouseenter » и «mouseout «.

    JavaScript scroll event можно определить с помощью события «scroll «, а смена фокуса — «focus » и «blur «. После завершения загрузки документа для окна возникает событие «load «.

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

    Данная публикация представляет собой перевод статьи «Handling Events » , подготовленной дружной командой проекта

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

    События в JS можно разделить на 4 больших группы:

    UI события: срабатывают, когда пользователь взаимодействует с UI браузера (кнопки вокруг веб-страницы, являющиеся частью интерфейса браузера). К таким событиям также можно отнести те действия, которые выполняет страница независимо от пользователя. К таким событиям относится изменение размера окна, прокрутка страницы, загрузка и выгрузка контента.

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

    События фокуса и форы. По большей части ассоциируются с формами: поле input «получает фокус», когда пользователь готов с ним взаимодействовать. Другие события отслеживают передачу формы, изменение значений полей формы и т.д.

    JavaScript. Быстрый старт

    События мутаций и наблюдатели. Мутирующие элементы отслеживаются при изменении структуры DOM: к примеру, когда элементы на странице вставляются или удаляются при помощи скрипта.

    Привязка обработчика события

    Специальный код, который будет срабатывать только для определенного элемента DOM, создает обработчик события. В JS есть три способа создать обработчик событий:

    1. Стандартный HTML обработчик события через атрибуты

    Старейший метод привязки событий, один из самых встречаемых до сих пор. Метод использует специальные атрибуты в разметке. К примеру:

    < input type = "text" id = "username" onblur = "checkName()" >

    В примере выше после того, как поле получит фокус, и пользователь перейдет к заполнению следующего поля (к примеру, при помощи TAB или обычного клика), элемент вызовет функцию checkName, которая написана в JS.
    Стандартные HTML обработчики событий не рекомендуют использовать в современной разработке, в основном из-за того, что функционал перемешивается с разметкой, что усложняет работу и отладку кода.

    2. Стандартные обработчики событий в DOM

    Данная техника разделяет JS и разметку, но имеет то же самое ограничение – событиям можно присвоить только одну функцию. Эквивалентной записью HTML обработчика событий в DOM будет:

    var username = document.getElementbyId("username"); username.onblur = checkName;

    username . onblur = checkName ;

    JavaScript. Быстрый старт

    Изучите основы JavaScript на практическом примере по созданию веб-приложения

    Как и в предыдущем примере, функция checkName запускается после того, как элемент формы теряет фокус.

    3. Обработчики событий (Event Listeners)

    Современный метод добавления обработчика событий, позволяющий цеплять несколько событий и функций:

    var username = document.getElementbyId("username"); username.addEventListener("blur", checkName, false);

    var username = document . getElementbyId ("username" ) ;

    username . addEventListener ("blur" , checkName , false ) ;

    Булево значение в конце указывает на то, нужно ли захватить событие. Обычно задается false. В простых скриптах событие часто записывается в виде анонимной функции:

    var username = document.getElementbyId("username"); username.addEventListener("blur", function() { // действия по срабатыванию события })

    Не все события равны

    Важно понять, что не все события можно обработать одинаково. События scroll и resize запускаются очень часто, из-за чего с ними нужно очень осторожно работать, чтобы не понизить скорость работы скрипта. То же самое касается и на первый взгляд безобидных событий типа input. Производительность скрипта может сильно просесть, если он будет пытаться постоянно отвечать на часто запускаемое событие input на слайдере range.

    Не все события отслеживаются

    Наблюдатели за мутациями на данный момент не могут отслеживать все изменения во всех элементах на странице. К примеру, нет способа отследить изменение высоты элемента (при сужении контейнера в адаптивном дизайне текст внутри него перестраивается, а элементы становятся длиннее). Все же есть способы отследить изменения, об этом я расскажу в следующей статье.

    Прикрепляйте события к правильным элементам

    Событие onclick применимо ко многим элементам, в том числе и к ссылкам. Есть общее правило – к ссылкам не рекомендуется цеплять код JS. По клику на ссылку пользователь должен попасть на другую область сайта или на якорь. Если же вам нужен UI элемент, с помощью которого можно изменить что-то на той же странице, тогда вам подойдет button. На кнопку можно без проблем вешать JavaScript.

    Не используйте JavaScript, если это можно сделать при помощи CSS

    В сравнении с CSS JavaScript медленный и ненадежный. По сути, CSS нужно использовать в качестве альтернативы сложным скриптам везде, где это возможно. Тем не менее, CSS не умеет всего. Он хорошо справляется с:hover (во многих случаях он заменяет события прикосновения), а также может заменить событие click при помощи:target в некоторых случаях. CSS анимация автоматически запускается после загрузки страницы, а также есть специальные CSS состояния, которые можно запускать для элементов типа радио кнопок. Однако что-то более сложное обычно лучше оставить для JavaScript.