Прежде чем вы это прочитаете, перетащите этот список событий на другую страницу, сам API чрезвычайно полезен, и все, что я обсуждаю ниже, напрямую связано с этой страницей .
Во-первых, .click (function)
- это буквально ярлык для .bind ('click', function)
, они эквивалентны. Используйте их при привязке обработчика непосредственно к элементу , например:
$(document).click(function() {
alert("You clicked somewhere in the page, it bubbled to document");
});
Если этот элемент будет заменен или выброшен, этого обработчика больше не будет.Также элементы, которых не было при запуске этого кода для присоединения обработчика (например, селектор нашел его тогда), не получат обработчик.
.live ()
и .delegate ()
похожи связаны, .delegate ()
фактически использует .live ()
внутри, они оба прислушиваются к всплытию событий. Это работает для новых и старых элементов , они всплывают события одинаково. Вы используете их, когда ваши элементы могут измениться, например добавление новых строк, элементов списка и т. д. Если у вас нет родительского / общего предка, который останется на странице и не будет заменен в какой-либо момент, используйте .live ()
, например:
$(".clickAlert").live('click', function() {
alert("A click happened");
});
Если, однако, у вас есть где-то родительский элемент, который не заменяется (поэтому его обработчики событий не уходят до свидания), вы должны обработать его с помощью .delegate ()
, например:
$("#commonParent").delegate('.clickAlert', 'click', function() {
alert("A click happened, it was captured at #commonParent and this alert ran");
});
Это работает почти так же, как .live ()
, но событие всплывает меньше раз, прежде чем оно будет захвачено и обработчики выполнятся. Другое распространенное использование обоих из них - сказать, что ваш класс изменяет элемент, больше не соответствующий селектору, который вы изначально использовали ... с помощью этих методов селектор оценивается во время события , если он соответствует , обработчик запускается ... поэтому элемент, больше не соответствующий селектору, имеет значение, он больше не будет выполняться. Однако с .click ()
обработчик события привязан прямо к элементу DOM, тот факт, что он не соответствует тому селектору, который использовался для определения его несущественности ... событие привязано, и оно остается до тех пор, пока этот элемент не исчезнет или обработчик не будет удален через .unbind ()
.
Еще одно распространенное использование .live ()
и .delegate ()
- это производительность . Если вы имеете дело с партиями элементов, прикрепление обработчика кликов непосредственно к каждому элементу требует больших затрат времени и средств.В этих случаях более экономично настроить один обработчик и позволить пузырям делать всю работу, взгляните на этот вопрос, где это имело огромное значение , это хороший пример приложения .
Запуск - для обновленного вопроса
Доступны 2 основные функции запуска обработчика событий, они подпадают под ту же категорию «Присоединение обработчика событий» в API , это .trigger ()
и .triggerHandler ()
. .trigger ('eventName')
имеет несколько встроенных ярлыков для общих событий, например:
$().click(fn); //binds an event handler to the click event
$().click(); //fires all click event handlers for this element, in order bound
Вы можете просмотреть список, включающий эти ярлыки, здесь .
Что касается разницы, то .trigger ()
запускает обработчик событий (но не действие по умолчанию большую часть времени, например, размещение курсора в нужном месте на
). Это заставляет обработчики событий происходить в том порядке, в котором они были связаны (как и собственное событие), запускает собственные действия событий и всплывает в DOM.
.triggerHandler ()
обычно используется для другой цели, здесь вы просто пытаетесь запустить связанный обработчик (-ы), это не приводит к срабатыванию собственного события, например отправка формы. Он не всплывает в DOM и не объединяется в цепочку (он возвращает то, что возвращает обработчик последнего связанного события для этого события). Например, если вы хотите вызвать событие focus
, но не фокусировать объект, вам просто нужно запустить код, связанный с .focus (fn)
, это сделает это, тогда как .trigger ()
сделает это, а также фактически сфокусирует элемент и всплывет вверх.
Вот реальный пример:
$("form").submit(); //actually calling `.trigger('submit');`
Это запустит любые обработчики отправки, например подключаемый модуль проверки jQuery , а затем попытается отправить
. Однако, если вы просто хотели проверить, поскольку он подключен через обработчик событий submit
, но не отправил
впоследствии, вы можете использовать .triggerHandler ('submit')
, например:
$("form").triggerHandler('submit');
Плагин предотвращает отправку формы обработчиком, взрываясь, если проверка не проходит, но с этим методом нам все равно, что это делает. Независимо от того, прервано оно или нет, мы не пытаемся отправить форму, мы просто хотели запустить ее для повторной проверки и больше ничего не делать. ( Заявление об ограничении ответственности: Это лишний пример, поскольку в плагине есть метод .validate ()
, но это достойная иллюстрация намерений)
$ (). Click (fn)
и $ (). Bind ('click', fn)
на первый взгляд идентичны, но ] Версия $. bind
более эффективна по двум причинам:
$ (). bind ()
позволяет назначить один обработчик нескольким событиям, например, $ (). bind ( 'нажмите клавишу', fn)
. $ (). Bind ()
поддерживает события в пространстве имен - мощная функция, если вы хотите удалить (отменить привязку) только определенные обработчики событий, к которым привязан элемент - подробнее см. События в пространстве имен . Live vs delegate: на это уже был дан ответ в других ответах.
Первые два эквивалентны.
// The following two statements do the same thing:
$("blah").click( function() { alert( "Click!" ); } );
$("blah").bind( "click", function() { alert( "Click!" ); } );
Второй вариант, однако, можно использовать для привязки к нескольким событиям одновременно, указав несколько имен событий, разделенных пробелами:
$("blah").bind( "click mouseover mouseout", function() { alert( "Click! Or maybe mouse moved." ); } );
Метод .live
более интересен. Рассмотрим следующий пример:
<a class="myLink">A link!</a>
<a id="another">Another link!</a>
<script>
$("a.myLink").click( function() { alert( 'Click!' ); } );
$("a#another").addClass( "myLink" );
</script>
После выполнения второй строки скрипта вторая ссылка также будет иметь CSS-класс «myLink». Но у него не будет обработчика события, потому что у него не было класса, когда событие было прикреплено.
Теперь представьте, что вы хотели, чтобы все было наоборот: каждый раз, когда где-то на странице появляется ссылка с классом «myLink», вы хотите, чтобы она автоматически имела тот же обработчик событий. Это очень распространено, когда у вас есть какие-то списки или таблицы, в которые вы добавляете строки или ячейки динамически, но хотите, чтобы все они вели себя одинаково. Вместо того, чтобы каждый раз заново назначать обработчики событий, вы можете использовать метод .live
:
<a class="myLink">A link!</a>
<a id="another">Another link!</a>
<script>
$("a.myLink").live( "click", function() { alert( 'Click!' ); } );
$("a#another").addClass( "myLink" );
</script>
В этом примере вторая ссылка также получит обработчик событий, как только он получит класс "myLink". Магия! : -)
Конечно, это не так буквально. На самом деле .live
прикрепляет обработчик не к самому указанному элементу, а к самому корню дерева HTML (элементу "body").События в DHTML имеют забавную особенность «всплытия». Примите во внимание следующее:
<div> <a> <b>text</b> </a> </div>
Если вы нажмете на «текст», то сначала элемент получит событие «щелчок». После этого элемент получит событие «щелчок». И после этого элемент И, наконец, метод Вопросы? .delegate
. Он просто берет всех дочерних элементов вашего элемента, которые соответствуют данному селектору, и присоединяет к ним «живой» обработчик. Взгляните: $("table").delegate( "td", "click", function() { alert( "Click!" ); } );
// Is equivalent to:
$("table").each( function() {
$(this).find( "td" ).live( "click", function() { alert( "Click!" ); } );
} );
Здесь может помочь чтение API. Тем не менее, я знаю это с головы до ног, так что вы можете продолжать лениться (ура!).
$('#something').click(fn);
$('#something').bind('click',fn);
Здесь нет разницы (насколько я знаю). .click
- это просто удобный / вспомогательный метод для .bind ('click'
// even after this is called, all <a>s in
// <div class="dynamic_els"> will continue
// to be assigned these event handlers
$('div.dynamic_els a').live(‘click’,fn);
Это совсем другое, поскольку .live
добавляет события к селектору, который вы передаете. (чего у вас здесь нет) и продолжает смотреть на DOM по мере того, как узлы вставляются / удаляются
$('#some_element').delegate('td','click',fn);
Это отличается только из-за того, как вы назначаете обработчики событий. .delegate
сосредоточен на Возбуждение событий DOM. Основной принцип заключается в том, что каждое событие перемещается вверх по дереву DOM, пока не достигнет корневого элемента ( документ
или окно
или
или
, точно не помню).
В любом случае вы привязываете обработчик Это полезно, когда есть множество элементов, и у вас есть только несколько (или одна центральная) точка (точки), через которые будут проходить эти события. Это экономит усилия и память браузера для объединения этих обработчиков событий в меньшее количество объектов. onclick
ко всем
в пределах $ ('# some_element')
(необходимо укажите селектор, хотя можно сказать $ (документ)
). При щелчке по одному из его дочерних элементов событие всплывает до
. Затем вы можете извлечь исходный элемент события (что jQuery делает за вас автоматически).
Похожие вопросы: