Jquery click function event клик метод примеры

event.defaultPrevented

Свойство установлено в , если действие по умолчанию было предотвращено, и , если нет.

Рассмотрим практическое применение этого свойства для улучшения архитектуры.

Помните, в главе Всплытие и погружение мы говорили о и упоминали, что останавливать «всплытие» – плохо?

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

Давайте посмотрим практический пример.

По умолчанию браузер при событии (клик правой кнопкой мыши) показывает контекстное меню со стандартными опциями. Мы можем отменить событие по умолчанию и показать своё меню, как здесь:

Теперь в дополнение к этому контекстному меню реализуем контекстное меню для всего документа.

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

Проблема заключается в том, что когда мы кликаем по элементу , то мы получаем два меню: контекстное меню для кнопки и (событие всплывает вверх) контекстное меню для документа.

Как это поправить? Одно из решений – это подумать: «Когда мы обрабатываем правый клик в обработчике на кнопке, остановим всплытие», и вызвать :

Теперь контекстное меню для кнопки работает как задумано. Но цена слишком высока. Мы навсегда запретили доступ к информации о правых кликах для любого внешнего кода, включая счётчики, которые могли бы собирать статистику, и т.п. Это слегка неразумно.

Альтернативным решением было бы проверить в обработчике , было ли отменено действие по умолчанию? Если да, тогда событие было обработано, и нам не нужно на него реагировать.

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

event.stopPropagation() и event.preventDefault()

Как мы можем видеть, и (также известный как ) – это две разные функции. Они никак не связаны друг с другом.

Архитектура вложенных контекстных меню

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

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

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

Серия удачных событий

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

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

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

Подробнее о событиях можно посмотреть в Справочнике по событиям.

Каждое доступное событие имеет обработчик событий — блок кода (обычно это функция JavaScript, вводимая вами в качестве разработчика), который будет запускаться при срабатывании события. Когда такой блок кода определён на запуск в ответ на возникновение события, мы говорим, что мы регистрируем обработчик событий

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

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

Примечание: Важно отметить, что веб-события не являются частью основного языка JavaScript. Они определены как часть JavaScript-API, встроенных в браузер. Рассмотрим простой пример

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

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

JavaScript выглядит так:

В этом коде мы сохраняем ссылку на кнопку внутри переменной  типа , используя функцию . Мы также определяем функцию, которая возвращает случайное число. Третья часть кода — . Переменная указывает на элемент — для этого типа объекта существуют возникающие при определённом взаимодействии с ним события, а значит, возможно использование обработчиков событий. Мы отслеживаем момент возникновения события при щелчке мышью, связывая свойство обработчика события с анонимной функцией, генерирующей случайный цвет RGB и устанавливающей его в качестве цвета фона элемента .

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

Пример вывода выглядит следующим образом:

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

Например, Node.js — очень популярная среда исполнения JavaScript, которая позволяет разработчикам использовать JavaScript для создания сетевых и серверных приложений. Модель событий Node.js основана на том, что существуют обработчики, отслеживающие события, и эмиттеры (передатчики), которые периодически генерируют события. В общем-то, это похоже на модель событий в JavaScript для веб-страниц, но код совсем другой. В этой модели используется функция  для регистрации обработчиков событий, и функция  для регистрации обработчика событий, который отключается после первого срабатывания. Хорошим примером использования являются протоколы событий .

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

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

Для каких элементов можно использовать атрибут onclick в HTML?

Синтаксис написание этого атрибута выглядит так:

XHTML

<input type=»button» onclick=»alert(‘Привет! Вот так работает этот скрипт’)» value=»Нажми на меня!»/>

Давайте разберём что же означает набор этих странных символов.

В данном примере мы задаём атрибут onclick для кнопки button. Чтобы браузер понял что нам нужна именно кнопка мы указываем тип type=»button». Далее в этом атрибуте мы пишем javascript код.

В данном случае мы вызываем модальное окно и выводим в нём текст при помощи метода alert():

XHTML

onclick=»alert(‘Привет! Вот так работает этот скрипт’)»

В скобках в кавычках указываем текст, который нужно вывести.

И последнее задаём текст, который будет написан на кнопке при помощи value=»Нажми на меня!»

А вот так будет выглядеть это чудо в действии:

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

Типы событий мыши

Условно можно разделить события на два типа: «простые» и «комплексные».

Кнопка мыши нажата над элементом.

Кнопка мыши отпущена над элементом.

Мышь появилась над элементом.

Мышь ушла с элемента.

Каждое движение мыши над элементом генерирует это событие.

Вызывается при клике мышью, то есть при , а затем на одном элементе

Вызывается при клике правой кнопкой мыши на элементе.

Вызывается при двойном клике по элементу.

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

Одно действие может вызывать несколько событий.

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

В тех случаях, когда одно действие генерирует несколько событий, их порядок фиксирован. То есть, обработчики вызовутся в порядке → → .

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

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

Каждое событие обрабатывается независимо.

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

События через работу с атрибутами

По сути атрибут onclick является таким же атрибутом,
как, к примеру, value.
И, если мы могли менять атрибут value таким образом — elem.value,
то точно также мы можем менять атрибут onclick.

Если мы сделаем так: elem.onclick = func, то привяжем к элементу elem
функцию func. Посмотрите пример и под ним мы обсудим все нюансы этого способа:

Теперь я должен открыть вам страшную тайну JavaScript:
если функция написана без круглых скобок, например func, то она возвращает свой исходный код,
а если с круглыми скобками, например func(), то возвращает результат работы функции.

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

Теперь, зная эту страшную тайну, вернемся к строке elem.onclick = func — в данном случае
я в атрибут onclick записываю исходный код функции, а не ее результат — и все работает.
Если вы сделаете так — elem.onclick = func() — то запишите результат функции и ничего не будет
работать.

Кстати, результатом функции func() будет undefined,
так как у нее нет команды return.
Напомню код функции, о которой идет речь:

Давайте вспомним метод setInterval
(см. урок работа с таймерами в JavaScript),
когда мы использовали его таким образом window.setInterval(timer, 1000) —
в этом случае мы также писали функцию timer без круглых скобок,
потому что нас интересовал не результат работы функции, а ее код.

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

Выносим код события onclick в javascript-функцию

Следующий способ хорош тем, что мы отделяем javascript-код от html тегов. В теге прописываем название функции, а саму функцию выносим в отдельный блок:

<script>
function ChangeColor(Element) {
	if (Element.style.color == 'green') Element.style.color = 'red';
	else Element.style.color = 'green';
	return false;
}
</script>

<a href="#" style="color: green;" onclick="return ChangeColor(this);">Изменить цвет</a>

Код в действии:

Нажмите на ссылку:

Но и здесь всё не идеально. Что делать, если событие требуется повесить на все ссылыки сайта, а их сотни? Кажется что это трудно, а на деле — меньше десяти строк кода. Задача решается с помощью селекторов. В примере опять будем производить действия с тегом «a», но ничего не мешает использовать вместо ссылки «img» или «div».

Координаты в окне: clientX/Y

Все мышиные события предоставляют текущие координаты курсора в двух видах: относительно окна и относительно документа.

Пара свойств содержит координаты курсора относительно текущего окна.

При этом, например, если ваше окно размером 500×500, а мышь находится в центре, тогда и и будут равны 250.

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

Проведите мышью над полем ввода, чтобы увидеть :

В той же системе координат работает и метод , возвращающий координаты элемента, а также .

Координаты курсора относительно документа находятся в свойствах .

Так как эти координаты – относительно левого-верхнего узла документа, а не окна, то они учитывают прокрутку. Если прокрутить страницу, а мышь не трогать, то координаты курсора изменятся на величину прокрутки, они привязаны к конкретной точке в документе.

В IE8- этих свойств нет, но можно получить их способом, описанным в конце главы.

Проведите мышью над полем ввода, чтобы увидеть (кроме IE8-):

В той же системе координат работает , если элемент позиционируется относительно документа.

Устарели:

Некоторые браузеры поддерживают свойства , .

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

Пример: Onclick в JavaScript

object

Чтобы это понять, нам понадобится кнопка… button

<button id=»onclick_v_javascript»>Это второй способ реализации Onclick в JavaScript</button>
idquerySelector-adocument.querySelector(«#onclick_v_javascript»).onclick = function(){alert(«Это второй способ реализации Onclick в JavaScript»);};

Соберем все вместе:

<button id=»onclick_v_javascript»>Это второй способ реализации Onclick в JavaScript</button>

<script>document.querySelector(«#onclick_v_javascript»).onclick = function(){alert(«Это второй способ реализации Onclick в JavaScript и вывод через alert»);}; </script>

Результат:

Это второй способ реализации Onclick в JavaScript

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

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

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

<p>Потяните за край панели, чтобы изменить ее ширину:</p>
<div style="background: orange; width: 60px; height: 20px">
</div>
<script>
  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;
    }
  }
</script>

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

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

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

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

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

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

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

<p>Наведите курсор мыши на этот <strong>абзац</strong>.</p>
<script>
  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 = "";
  });
</script>

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

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

<style>
  p:hover { color: red }
</style>
<p>Наведите курсор мыши на этот <strong>абзац</strong>.</p>

Демонстрация

Вот как выглядит вредоносная страница. Для наглядности полупрозрачный (на реальных вредоносных страницах он полностью прозрачен):

Полная демонстрация атаки:

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

В результате, если пользователь авторизован на сайте Facebook («Запомнить меня» обычно активировано), то он добавляет «лайк». В Twitter это будет кнопка «читать», и т.п.

Вот тот же пример, но более приближенный к реальности с для :

Clickjacking-атака для кликов мыши, а не для клавиатуры

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

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

Но есть одна проблема. Всё, что посетитель печатает, будет скрыто, потому что ифрейм не виден.

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

Пример:Onclick В JavaScript, используя метод addEventListener()

И последний элемент теории Onclick — использование метода addEventListener

Нам опять понадобится кнопка

<button id=»onclick_v_addEventListener»>Это второй способ реализации Onclick в JavaScript</button>

Опять применяем querySelector — обращаемся к нашей кнопке, добавляем метод addEventListener, во внутрь помещаем событие click И второй параметр — это функция myFoo.

document.querySelector(«#onclick_v_addEventListener») .addEventListener(«click», myFoo);

Далее нам понадобится функция:

function myFoo() { alert(«Это третий способ реализации Onclick в JavaScript через addEventListener и вывод через alert»); }

Соберем весь код вместе:

<button id=»onclick_v_addEventListener»>Это третий способ реализации Onclick в JavaScript</button>

<script>

document.querySelector(«#onclick_v_addEventListener») .addEventListener(«click», myFoo);

function myFoo()

{

alert(«Это третий способ реализации Onclick в JavaScript через addEventListener и вывод через alert»);

}

</script>

Результат:

Это третий способ реализации Onclick в JavaScript

Добавление обработчика через свойство DOM объекта

Второй способ назначить обработчик — это использовать свойство .

Например, привяжем обработчик события к элементу (для этого события свойство будет ):

<!-- HTML код кнопки -->
<button type="button" id="my-btn">Нажми на меня</button>

<!-- Скрипт на JavaScript -->
<script>
// получим кнопку и сохраним ссылку на неё в переменную
const $btn = document.querySelector('#my-btn');
// добавим к $btn обработчик события click
$btn.onclick = function() {
  alert('Вы кликнули на кнопку!');
}
</script>

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

Другой вариант – это назначить уже существующую функцию.

Например:

function changeBgColor() {
  document.body.style.backgroundColor = `rgb(${Math.round(Math.random()*255)}, ${Math.round(Math.random()*255)}, ${Math.round(Math.random()*255)})`;
}

document.onclick = changeBgColor;

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

Например:

<!-- HTML код кнопок -->
<button type="button">Кнопка 1</button>
<button type="button">Кнопка 2</button>
<button type="button">Кнопка 3</button>

<!-- Скрипт на JavaScript -->
<script>
function message() {
  // this - обращаемся к кнопке для которой вызван обработчик
  alert(this.textContent);
}
// получим кнопки и сохраним ссылки на них в переменную $btns
const $btns = document.querySelectorAll('button');
// переберём кнопки и добавим к ним обработчик, используя onclick
$btns.forEach(function($element) {
  $element.onclick = message;
});
</script>

Кстати, когда обработчик задаётся через атрибут, то браузер самостоятельно при чтении такого HTML создаёт из значения этого атрибута функцию и присваивает её одноименному свойству этого элемента.

Например:

<button id="btn" type="button" onclick="alert('Вы кликнули на кнопку')">Кнопка</button>

<script>
const $element = document.querySelector('#btn');
// получим значение свойства onclick (как видно браузер туда автоматически записал функцию, которую создал на основании содержимого этого атрибута)
console.log($element.onclick);
</script>

Т.е., по сути, задание свойства через атрибут – это просто способ инициализации обработчика. Т.к. сам обработчик в этом случае тоже хранится в свойстве DOM-объекта.

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

<button id="btn" type="button">Кнопка</button>

<script>
  const $element = document.querySelector('#btn');

  $element.onclick = function () {
    alert(`id = ${this.id}`);
  }
  // заменит предыдущий обработчик
  $element.onclick = function () {
    alert(`text = ${this.textContent}`);
  }
</script>

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

<button id="btn" type="button" onclick="alert(`id = ${this.id}`);">Кнопка</button>

<script>
  const $element = document.querySelector('#btn');
  // заменит обработчик, инициализированный с помощью атрибута
  $element.onclick = function () {
    alert(`text = ${this.textContent}`);
  }
</script>

Примечания

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

• Позволяет добавлять множество обработчиков для одного события. Это особенно полезно для DHTML библиотек или Mozilla extensions, которые должны работать в условиях использования сторонних библиотек/расширений.
• Предоставляет точный контроль фазы срабатывания(вызова) обработчика (захват или всплытие)
• Срабатывает на любом DOM элементе, а не только на HTML элементах.

Ниже описан другой, .

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

Если зарегистрировано несколько одинаковых  на одном  с одинаковыми параметрами, дублирующиеся обработчики игнорируются. Так как одинаковые обработчики игнорируются, не требуется удалять их вручную с помощью метода removeEventListener.

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

В примере выше значение переменной  внутри  при вызове событием клика равно таблице ‘t’. Это противоположно поведению, которое возникает, если обработчик добавлен в HTML-разметке:

Значение переменной  внутри  при вызове событием клика будет равно ссылке на глобальный (window) объект (или  при использовании strict mode)

Note: В JavaScript 1.8.5 введён метод  , который позволяет указать значение, которое должно быть использовано для всех вызовов данной функции. Он позволяет вам легко обходить ситуации, в которых не ясно, чему будет равно this, в зависимости от того, в каком контексте будет вызвана ваша функция. заметьте, также, что вам будет необходимо иметь внешнюю ссылку на обработчик, чтобы вы могли удалить его позже.

Пример с использованием  и без него:

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

В Internet Explorer младше 9 версии, вы можете использовать  вместо стандартного . Для поддержки IE, пример выше может быть модифицирован следующим образом:

У  есть недостаток:  будет ссылаться на объект , а не на элемент, на котором он был вызван.

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

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

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

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

Пример: Щелкнув по кнопке вызвать диалоговое окно со словом Ура!. Выполнить задание, используя метод addEventListener.

Решение: 

• html код:

<input type="button" value="кнопка" id="MyElem">

скрипт:

<script type="text/javaScript"> 
function message() {
	alert('Ура!');
}
var input = document.getElementById("MyElem"); 
input.addEventListener("click", message);
</script>

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

Решение: 

<script type="text/javaScript"> 
function message() {
	alert('Ура!');
}
var input = document.getElementById("MyElem"); 
input.addEventListener("click", message);
input.removeEventListener("click", message);
</script>

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

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

Достоинства и недостатки такого способа

Давайте теперь обсудим достоинства и недостатки
этого способа.

Достоинства

Достоинства такие: теперь,
если мы захотим задать одновременно одно событие всем
инпутам на странице, нет нужды вручную прописывать каждому
из них атрибут с событием. Можно просто получить все инпуты,
перебрать их циклом и каждому привязать событие.

Давайте сделаем это. Получим все инпуты с помощью getElementsByTagName
и в цикле привяжем каждому такое событие: пусть по клику каждый инпут
выдает алертом текст ‘!’:

Теперь нажатие на любой инпут будет приводить к тому,
что будет срабатывать функция func, которая алертом выводит ‘!’.

Использование this

Давайте усложним задачу и сделаем так,
чтобы alert выводил содержимое атрибута value того инпута,
на который кликнули мышкой.

Для этого нужно воспользоваться this, только не так, как мы это делали раньше.
Раньше, когда мы писали событие прямо в атрибут, мы делали так: onclick=»func(this)»,
однако сейчас вот так — elems.onclick = func(this) — мы сделать не можем.

Во-первых, потому, что функцию func здесь нужно писать без круглых скобок,
иначе будет не исходный код, а результат работы функции.

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

Вы можете спросить, почему тут — onclick=»func()» — в функции написаны круглые скобки, хотя по логике
там тоже требуется исходный код, а не результат.
Об этом вы узнаете в уроке про анонимные функции чуть позже.

Так как правильно использовать this в нашей конструкции elems.onclick = func?
На самом деле тут this доступен внутри функции func и он ссылается на тот элемент,
в котором возникло событие, вызвавшее эту функцию. То есть, если я делаю клик по первому
инпуту — в this будет лежать ссылка на него, а если по второму — то на него.

В данном случае считайте, что this — это будто переменная elem,
полученная через getElementById. К примеру, elem.value позволяет обратиться
к атрибуту value, значит this.value будет делать то же самое.

Итак, давайте все-таки решим нашу задачу — сделаем так,
чтобы alert выводил содержимое атрибута value того инпута,
на который кликнули мышкой:

Учтите, что если вы попытаетесь воспользоваться this
внутри функции, которая была прописана прямо в атрибуте (то есть первым способом задать событие) — у
вас ничего не выйдет. Смотрите пример неправильного кода:

В данном случае контекст выполнения таков, что this ссылается на
window, а не на текущий элемент. Почему так — поговорим, когда вы разберете анонимные функции.

Напоминаю правильный вариант:

Недостатки

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

В следующем примере мы пытаемся привязать к событию onclick
сразу две функции func1 и func2. Однако по клику на элемент сработает
только вторая функция, так как она затрет первую:

В принципе, эту проблему легко обойти, если ввести еще и третью функцию func3.
Привяжем к атрибуту onclick только func3, а она пусть вызывает func1 и func2 у себя внутри:

Как вы видите, этот недостаток не слишком существенный и его легко обойти.
Только что вводится лишняя функция, что немного неудобно.

Однако, есть еще один недостаток — мы не можем легко отвязать от onclick, к примеру, только
функцию func1, оставив func2 привязанным. Можно, конечно же, накрутить большие конструкции
кода, однако это не нужно, если пользоваться еще более продвинутым способом
привязать событие — через addEventListener. Давайте посмотрим, как с работать
с этой функцией: