, pagtukoy sa link na ito. Pagkatapos ay ihahatid ito sa mga naglalaman ng elemento: marahil ang elemento Ang elemento at ang Document object mismo. Minsan mas maginhawang magrehistro ng isang event handler sa isang Document object o iba pang elemento ng container kaysa magrehistro sa lahat ng elemento ng interes.
Kapag natukoy na ang ilang termino, maaari tayong magpatuloy sa pagtuklas ng mga isyung nauugnay sa mga kaganapan at pagproseso ng mga ito.
Pagrerehistro ng mga Tagapangasiwa ng Kaganapan Mayroong dalawang pangunahing paraan upang irehistro ang mga tagapangasiwa ng kaganapan. Ang una, na lumitaw nang maaga sa pagbuo ng World Wide Web, ay upang itakda ang pag-aari ng bagay o elemento ng dokumento na target ng kaganapan. Ang pangalawang paraan, mas bago at mas unibersal, ay ang pagpasa ng handler sa isang paraan ng isang bagay o elemento.
Ang bagay ay kumplikado sa pamamagitan ng katotohanan na ang bawat pamamaraan ay may dalawang bersyon. Maaaring itakda ang isang property handler ng event sa JavaScript code o sa isang elemento ng dokumento sa pamamagitan ng pagtukoy sa naaangkop na attribute nang direkta sa HTML markup. Ang pagpaparehistro ng mga handler na may method call ay maaaring gawin sa pamamagitan ng karaniwang paraan na tinatawag na addEventListener(), na sinusuportahan ng lahat ng browser maliban sa IE na bersyon 8 at mas mababa, at isa pang paraan na tinatawag na attachEvent(), na sinusuportahan ng lahat ng bersyon ng IE hanggang sa IE9.
Pagtatakda ng mga katangian ng tagapangasiwa ng kaganapan Ang pinakasimpleng paraan para magrehistro ng event handler ay ang magtakda ng property sa event target sa gustong function ng handler. Ayon sa convention, ang mga property ng event handler ay may mga pangalan na binubuo ng salitang "on" na sinusundan ng pangalan ng event: onclick, onchange, onload, onmouseover, atbp. Tandaan na ang mga pangalan ng property na ito ay case sensitive at gumagamit lamang ng maliliit na character, kahit na ang pangalan ng uri ng kaganapan ay maraming salita (halimbawa, "readystatechange"). Nasa ibaba ang dalawang halimbawa ng pagpaparehistro ng mga tagapangasiwa ng kaganapan:
// Italaga ang function sa onload property ng Window object. // Ang function ay isang event handler: ito ay tinatawag kapag ang dokumento ay na-load window.onload = function() ( // Hanapin ang elemento var elt = document.getElementById("shipping_address"); // Magrehistro ng event handler na tawagin ang // nang direkta bago isumite ang form elt.onsubmit = function() ( return validate(this); ) )
Ang paraan ng pagpaparehistro ng mga tagapangasiwa ng kaganapan ay sinusuportahan sa lahat ng mga browser para sa lahat ng karaniwang ginagamit na mga uri ng kaganapan. Sa pangkalahatan, lahat ng malawak na sinusuportahang interface ng application na tumutukoy sa kanilang mga kaganapan ay nagpapahintulot sa mga humahawak na mairehistro sa pamamagitan ng pagtatakda ng mga katangian ng mga tagapangasiwa ng kaganapan.
Ang kawalan ng paggamit ng mga property ng event handler ay ang mga ito ay idinisenyo sa pag-aakalang ang mga target ng event ay magkakaroon ng hindi hihigit sa isang handler bawat uri ng event. Kapag gumagawa ng library para gamitin sa mga arbitrary na dokumento, mas mainam na gumamit ng technique (tulad ng pagtawag sa addEventListener() method) para magrehistro ng mga handler na hindi nagbabago o nag-overwrite sa mga dating nakarehistrong handler.
Pagtatakda ng mga katangian ng tagapangasiwa ng kaganapan Ang mga katangian ng mga tagapangasiwa ng kaganapan sa mga elemento ng dokumento ay maaari ding itakda sa pamamagitan ng pagtukoy ng mga halaga ng katangian sa kaukulang mga tag ng HTML. Sa kasong ito, ang value ng attribute ay dapat na isang string ng JavaScript code. Ang program code na ito ay hindi dapat isang kumpletong deklarasyon ng event handler function, ngunit ang katawan lamang nito. Iyon ay, ang pagpapatupad ng isang event handler sa HTML markup ay hindi dapat isama sa mga kulot na brace at unahan ng function na keyword. Halimbawa:
Kung ang HTML attribute value ng isang event handler ay binubuo ng maraming JavaScript statement, dapat silang paghiwalayin ng mga semicolon, o dapat lumabas ang attribute value sa maraming linya.
Ang ilang uri ng kaganapan ay inilaan para sa browser sa kabuuan, sa halip na para sa anumang partikular na elemento ng dokumento. Ang mga humahawak para sa mga naturang kaganapan sa JavaScript ay nakarehistro sa object ng Window. Sa HTML markup dapat silang ilagay sa isang tag, ngunit irerehistro sila ng browser sa bagay na Window. Ang sumusunod ay isang kumpletong listahan ng naturang mga tagapangasiwa ng kaganapan na tinukoy ng draft na detalye ng HTML5:
onafterprint onfocus ononline onresize onbeforeprint on haschange onpageitago onstorage on bago i-load ang onload sa pageipakita sa pag-blur sa mensahe sapopstate onunload onerror sa offline onredo
Kapag bumubuo ng mga script sa panig ng kliyente, karaniwan nang paghiwalayin ang HTML markup mula sa JavaScript code. Ang mga programmer na sumusunod sa panuntunang ito ay umiiwas (o kahit man lang ay subukang umiwas) gamit ang mga HTML event handler attribute para maiwasan ang paghahalo ng JavaScript code sa HTML markup.
addEventListener() Sa karaniwang modelo ng kaganapan, na sinusuportahan ng lahat ng mga browser maliban sa mga bersyon ng IE 8 at mas mababa, ang target ng isang kaganapan ay maaaring maging anumang bagay - kabilang ang mga bagay sa Window at Dokumento at lahat ng mga bagay na Elemento ng mga elemento ng dokumento - na tumutukoy sa isang paraan na tinatawag na addEventListener() kung saan ang kaganapan maaaring mairehistro ang mga humahawak para sa layuning ito.
Ang paraan ng addEventListener() ay tumatagal ng tatlong argumento. Ang una ay ang uri ng kaganapan kung saan nakarehistro ang handler. Ang uri ng kaganapan (o pangalan) ay dapat na isang string at hindi dapat isama ang "on" na prefix na ginamit kapag nagtatakda ng mga katangian ng mga tagapangasiwa ng kaganapan. Ang pangalawang argumento sa paraan ng addEventListener() ay isang function na dapat tawagan kapag may nangyaring kaganapan ng tinukoy na uri. Ang huling argumento ay ipinasa sa addEventListener() na paraan na may boolean na halaga. Kadalasan ang argumentong ito ay mali. Kung ipapasa mo ito nang totoo, ang function ay irerehistro bilang isang humahawak ng interception at tatawagin sa isa pang yugto ng pagpapalaganap ng kaganapan.
Ang pagtutukoy ay maaaring magbago sa kalaunan upang ito ay katanggap-tanggap na alisin ang ikatlong argumento sa halip na tahasang ipasa itong mali, ngunit sa pagsulat na ito, ang pagtanggal ng ikatlong argumento ay nagreresulta sa isang error sa ilang kasalukuyang mga browser.
Ang sumusunod na snippet ay nagrerehistro ng dalawang "click" na tagapangasiwa ng kaganapan sa elemento. Pansinin ang mga pagkakaiba sa pagitan ng dalawang teknik na ginamit:
Click mo ako!
var b = document.getElementById("mybutton"); b.onclick = function() ( alert("Salamat sa pag-click sa akin!"); ); b.addEventListener("click", function() (alert("Salamat ulit!")), false);
Ang pagtawag sa addEventListener() na may string na "click" bilang ang unang argumento ay walang epekto sa halaga ng onclick na property. Sa snippet sa itaas, ang pag-click sa button ay maglalabas ng dalawang alert() dialog box. Ngunit higit sa lahat, ang paraan ng addEventListener() ay maaaring tawagin nang maraming beses at maaaring magamit upang magrehistro ng maramihang mga function ng handler para sa parehong uri ng kaganapan sa parehong bagay. Kapag naganap ang isang kaganapan sa isang bagay, ang lahat ng mga humahawak na nakarehistro para sa uri ng kaganapang iyon ay tatawagin, sa pagkakasunud-sunod kung saan sila nakarehistro.
Ang pagtawag sa addEventListener() nang maraming beses sa parehong bagay na may parehong mga argumento ay walang epekto - ang handler function ay isang beses lang nakarehistro at ang mga paulit-ulit na tawag ay hindi makakaapekto sa pagkakasunud-sunod ng pagtawag sa mga handler.
Ang mga bersyon ng Internet Explorer na mas maaga kaysa sa IE9 ay hindi sumusuporta sa addEventListener() at removeEventListener() na mga pamamaraan. IE5 at mas bago ay tukuyin ang mga katulad na pamamaraan, attachEvent() at detachEvent() . Dahil ang modelo ng kaganapan ng IE ay hindi sumusuporta sa isang yugto ng pagharang, ang mga pamamaraan ng attachEvent() at detachEvent() ay tumatagal lamang ng dalawang argumento: ang uri ng kaganapan at ang function ng handler, na ang unang argumento ay nagpapasa sa pangalan ng property ng handler na may prefix na "on" sa mga pamamaraan sa IE kaysa sa uri ng mga kaganapan na walang prefix na ito.
Tumatawag sa mga tagapangasiwa ng kaganapan Sa sandaling magparehistro ka ng isang event handler, ang web browser ay awtomatikong tatawag dito kapag ang isang kaganapan ng tinukoy na uri ay nangyari sa tinukoy na bagay. Idinidetalye ng seksyong ito ang pagkakasunud-sunod kung saan tinawag ang mga tagapangasiwa ng kaganapan, ang mga argumento sa mga tagapangasiwa, ang konteksto ng tawag (ang halaga nito), at ang layunin ng halaga ng pagbabalik ng tagapangasiwa. Sa kasamaang palad, ang ilan sa mga detalyeng ito ay naiiba sa pagitan ng IE na bersyon 8 at sa ibaba at sa iba pang mga browser.
Pangangatwiran ng Tagapangasiwa ng Kaganapan Kapag na-invoke ang isang event handler, kadalasan (na may isang exception na tinalakay sa ibaba) ay pumasa sa event object bilang isang argumento. Ang mga katangian ng bagay ng kaganapan ay naglalaman ng karagdagang impormasyon tungkol sa kaganapan. Ang uri ng ari-arian, halimbawa, ay tumutukoy sa uri ng kaganapan na naganap.
Sa IE na bersyon 8 at mas mababa, ang mga tagapangasiwa ng kaganapan na nakarehistro sa pamamagitan ng pagtatakda ng isang pag-aari ay hindi naipapasa sa isang object ng kaganapan kapag tinawag. Sa halip, ang event object ay naka-store sa global variable window.event. Para sa portability, maaaring i-istilo ang mga tagapangasiwa ng kaganapan tulad ng sumusunod upang magamit nila ang variable na window.event kapag tinawag nang walang argumento:
Ang event object ay ipinapasa sa mga event handler na nakarehistro sa attachEvent() method, ngunit maaari rin nilang gamitin ang window.event variable.
Kapag nagrehistro ka ng event handler gamit ang HTML attribute, ang browser ay nagko-convert ng string ng JavaScript code sa isang function. Ang mga browser maliban sa IE ay lumikha ng isang function na may isang argumento, kaganapan. Ang IE ay lumilikha ng isang function na hindi tumatagal ng mga argumento. Kung gagamitin mo ang event identifier sa mga naturang function, ito ay magre-refer sa window.event. Sa alinmang kaso, ang mga tagapangasiwa ng kaganapan na tinukoy sa HTML markup ay maaaring sumangguni sa isang object ng kaganapan gamit ang identifier ng kaganapan.
Konteksto ng Tagapangasiwa ng Kaganapan Kapag ang isang event handler ay nakarehistro sa pamamagitan ng pagtatakda ng isang property, mukhang pagtukoy ng isang bagong paraan ng elemento ng dokumento:
E.onclick = function() ( /* pagpapatupad ng handler */ );
Samakatuwid, hindi nakakagulat na ang mga tagapangasiwa ng kaganapan ay hinihimok (na may isang pagbubukod tungkol sa IE, na inilarawan sa ibaba) bilang mga pamamaraan ng mga bagay kung saan sila ay tinukoy. Ibig sabihin, sa katawan ng tagapangasiwa ng kaganapan, ang keyword na ito ay tumutukoy sa target ng kaganapan.
Sa mga humahawak, ang keyword na ito ay tumutukoy sa target na bagay, kahit na sila ay nakarehistro gamit ang addEventListener() na paraan. Sa kasamaang palad, gayunpaman, hindi ito ang kaso para sa attachEvent() na pamamaraan: ang mga humahawak na nakarehistro sa attachEvent() na pamamaraan ay tinatawag bilang mga function, at sa kanila ang keyword na ito ay tumutukoy sa global (Window) na bagay. Ang problemang ito ay maaaring malutas sa sumusunod na paraan:
/* Nirerehistro ang tinukoy na function bilang tagapangasiwa ng kaganapan ng tinukoy na uri sa tinukoy na bagay. Tinitiyak na ang handler ay palaging tatawagin bilang isang paraan sa target na bagay. */ function addEvent(target, type, handler) ( if (target.addEventListener) target.addEventListener(type, handler, false); else target.attachEvent("on" + type, function(event) ( // Tawagan ang handler bilang target na paraan, // at ipasa ito sa event object return handler.call(target, event ));
Tandaan na ang mga event handler na nakarehistro sa ganitong paraan ay hindi maaalis dahil ang reference sa wrapper function na ipinasa sa attachEvent() method ay hindi nakaimbak kahit saan para ito ay maipasa sa detachEvent() method.
Mga halaga ng pagbabalik ng Handler Dapat isaalang-alang ang value na ibinalik ng isang event handler na nakarehistro sa pamamagitan ng pagtatakda ng object property o ng HTML attribute. Karaniwan, ang pagbabalik ng false ay nagsasabi sa browser na hindi nito dapat gawin ang mga default na pagkilos para sa kaganapang ito.
Halimbawa, maaaring magbalik ng false ang onclick handler ng button na isumite ang form upang pigilan ang browser na isumite ang form. (Maaaring maging kapaki-pakinabang ito kung nabigo ang input ng user sa client-side validation.) Katulad nito, maaaring i-filter ng handler ng event na onkeypress ng input field ang input ng keyboard sa pamamagitan ng pagbabalik ng false kapag may mga di-wastong character na ipinasok.
Mahalaga rin ang halaga na ibinalik ng onbeforeunload handler ng object ng Window. Nabubuo ang kaganapang ito kapag nag-navigate ang browser sa ibang page. Kung magbabalik ang handler na ito ng string, ipapakita ito sa isang modal dialog box na mag-uudyok sa user na kumpirmahin na gusto niyang umalis sa page.
Mahalagang maunawaan na ang mga return value ng mga event handler ay binibilang lamang kung ang mga handler ay nakarehistro sa pamamagitan ng pagtatakda ng mga property. Ang mga handler na nakarehistro sa addEventListener() o attachEvent() ay dapat na tumawag sa preventDefault() na paraan o itakda ang returnValue property ng event object.
Kinakansela ang mga kaganapan Ang value na ibinalik ng isang event handler na nakarehistro bilang isang property ay maaaring gamitin para i-override ang mga default na pagkilos na ginawa ng browser sa kaganapan ng event na iyon. Sa mga browser na sumusuporta sa paraan ng addEventListener(), maaari ding ma-override ang mga default na aksyon sa pamamagitan ng pagtawag sa preventDefault() na paraan ng object ng event. Gayunpaman, sa IE na bersyon 8 at sa ibaba, ang parehong epekto ay nakakamit sa pamamagitan ng pagtatakda ng returnValue property ng event object sa false.
Ang sumusunod na snippet ay nagpapakita ng isang hyperlink click event handler na gumagamit ng lahat ng tatlong paraan ng pagkansela ng kaganapan (pagba-block sa user sa pagsunod sa link):
Window.onload = function() ( // Hanapin ang lahat ng link var a_href = document.getElementsByTagName("a"); // Magdagdag ng click event handler (hindi para sa IE
Ang kasalukuyang proyekto ng module ng DOM Events 3 ay tumutukoy sa isang property sa object ng Event na tinatawag na defaultPrevented . Hindi pa ito sinusuportahan ng lahat ng browser, ngunit ang esensya nito ay sa ilalim ng normal na mga kundisyon ito ay mali at nagiging totoo lamang kung ang preventDefault() na paraan ay tinatawag.
Ang pagkansela sa mga default na pagkilos na nauugnay sa isang kaganapan ay isang uri lamang ng pagkansela ng isang kaganapan. Posible ring pigilan ang pagkalat ng kaganapan. Sa mga browser na sumusuporta sa addEventListener() method, ang event object ay may stopPropagation() method, na kapag tinawag ay humihinto sa karagdagang pagpapalaganap ng event. Kung ang ibang mga humahawak para sa kaganapang ito ay nakarehistro sa parehong target na bagay, ang natitirang mga tagapangasiwa ay tatawagin pa rin, ngunit walang ibang mga tagapangasiwa ng kaganapan sa iba pang mga bagay ang tatawagin pagkatapos tawagin ang stopPropagation() na paraan.
Sa IE na bersyon 8 at sa ibaba, ang stopPropagation() na paraan ay hindi suportado. Sa halip, ang object ng event sa IE ay may property cancelBubble. Ang pagtatakda ng property na ito sa true ay pumipigil sa kaganapan sa pagpapalaganap.
Ang kasalukuyang draft ng detalye ng DOM Events 3 ay tumutukoy sa isa pang paraan sa object ng Event, isang paraan na tinatawag na stopImmediatePropagation(). Tulad ng stopPropagation() na pamamaraan, pinipigilan nito ang kaganapan mula sa pagpapalaganap sa anumang iba pang mga bagay. Ngunit bilang karagdagan, pinipigilan din nito ang anumang iba pang mga tagapangasiwa ng kaganapan na nakarehistro sa parehong bagay na tawagan.
Mayroon kang sumusunod na keyboard listener ArrowDown event (ito ang key code ay 40):
Window.onload = function() ( var itemsContainer = document.getElementById("cities-drop"); document.addEventListener("*****",function(event)( if (event.keyCode == 40 && itemsContainer. style.display=="block") ( event.preventDefault(); para sa (var i=0;i
sa kasong ito, ang pag-hover ay napupunta sa huling elemento sa listahan pagkatapos pindutin ang ArrowDown.
Kung sakaling walang komento ang break, tumalon ito sa pangalawang elemento at hindi na tumalon.
Imposibleng makuha ang prinsipyo kung paano ito gagawin, na ang nakikinig ay laging nakikinig...
EDIT live demo ay posible, ito ay isang bagay ng pagsasara ngunit hindi ako sigurado
3 sagot
Matapos tingnan ang iyong code at maunawaan kung ano ang sinusubukan mong gawin, sa palagay ko ang iyong error ay gumagamit ng substr kung saan dapat mong gamitin ang indexOf . Narito ang na-update na linya:
If (itemsContainer.getAttribute("class").indexOf("hovered") != -1) Higit pang mga detalye: Ginamit mo talaga ang substr na may string value para sa start index. Hindi sigurado kung ano ang magiging resulta nito, ngunit tila hindi ito -1 dahil ang kundisyon ay bumalik na totoo sa bawat oras, na nagiging sanhi ng susunod na elemento na umaasa BAWAT oras, hanggang sa ibaba ng listahan. Gamit ang isang break na pahayag, nagsagawa ito ng isang if statement sa unang elemento (na nagiging sanhi ng pag-hang ang pangalawang elemento) at pagkatapos ay lumabas.
Iiwan ko ang pahayag ng break doon pagkatapos ayusin ang iyong code, upang ang loop ay huminto pagkatapos nitong mahanap ang tugma nito at hindi kinakailangang umulit sa iba pang mga elemento.
EDIT: Nakakita ako ng ilang higit pang mga problema sa code. Narito ang isang halimbawa na gumagana para sa akin sa IE at FF man lang (hindi nasubok sa Safari, Opera o Chrome):
Mga Detalye: Para sa akin sa IE9 ang function ay hindi kailanman tinawag. Sa halip, ginawa ko lang itong regular na function at nagdagdag ng onkeydown na kaganapan sa body tag.
Sa iyong if-statement mayroon kang itemsContainer.getAttribute("class") . Una, kailangan mong gumamit ng itemsContainer.children[i] . Pangalawa, ang .getAttribute("class") ay hindi gumana para sa akin sa IE, kaya inilipat ko ito sa .className lang.
Panghuli, hindi gumana sa akin ang itemsContainer.children[i].nextSibling, ngunit sapat lang na palitan lang ito ng itemsContainer.children para makuha ang susunod na kapatid.
Sa halip na gumamit ng loop, maaari mong subukan ang isang mas simpleng diskarte:
Window.onload = function() ( var itemsContainer = document.getElementById("cities-drop"); document.addEventListener("*****",function(event) ( if (event.keyCode == 40 && itemsContainer. style.display=="block") ( event.preventDefault(); var previousHoveredChoice = itemsContainer.querySelector(".hovered"); previousHoveredChoice.className = ""; var currentHoveredChoice = previousHoveredChoice.nextSibling; kung (currentHoveredChoice) (.HoveredChoice) (.HoveredChoice) className = "hovered"; ) ) )); //sinusunod na code ay kinopya-paste mula sa live na halimbawa //para lamang isara ang onload function na handler sa solusyon na ito.addEventListener("*****",function(event ) ( kung (event.keyCode == 27) ( kung (document.getElementById("cities-drop").style.display=="block")( document.getElementById("cities-drop").style.display= " wala"; ) )); // dulo ng copy-paste na code);
Mayroong ilang mga bagay na nakikita ko na maaaring maging isang problema. Una sa lahat, i-update mo ang itemsContainer.children[i].nextSibling na katumbas ng itemsContainer.children . Samakatuwid, ang huling elemento ay palaging pinipili kung makaligtaan ka ng pahinga. Ang itemsComtainer ay palaging mag-hang kung mayroong isang elemento na tumutugma sa klase.
Ang pangalawang problema ay ang itinuturo ni Travesty3 sa kanyang sagot.
Binago ko rin ang kung kundisyon upang tingnan kung ang hovering class ay nasa isa sa mga bata kaysa sa mismong lalagyan.
Kung (itemsContainer.children[i].getAttribute("class").match("hovered"))
Binago ko ang tagapangasiwa ng kaganapan gamit ang mga sumusunod na linya ng code at tila gumagana nang maayos:
Document.addEventListener("*****",function(event)( if (event.keyCode === 40 && itemsContainer.style.display==="block") ( event.preventDefault(); for (var i =0,l=itemContainer.children.length;i
Tandaan na ang paggawa ng ganitong step-down na kontrol ay napakaraming trabaho. Inaasahan ng user na mag-navigate dito gamit ang keyboard. Upang lumikha ng isang mahusay na interface ng gumagamit, dapat mong pangasiwaan ang maramihang mga key tulad ng mga arrow key, tab upang i-focus ang kontrol, espasyo upang buksan at isara ito, alphanumeric input upang tumuon sa unang tumutugmang item, atbp.
Kung ang karanasan ng gumagamit ay mahalaga, inirerekumenda ko ang paggamit ng isang framework at plugin para dito. Personal kong mas gusto ang jquery at jquery ui at mayroong ilang mga plugin na mapagpipilian mula sa mga drop down. Ang isa pang benepisyo ay kung ang javascript ay hindi pinagana ng kliyente o ang iyong javascript ay buggy para sa ilang kadahilanan, karamihan sa mga plugin ay bumabalik sa isang normal na native na piling elemento na gagana pa rin nang maayos.
Ako mismo ay gumamit ng selectbox plugin na ito para sa isang simpleng dropdown: http://www.abeautifulsite.net/blog/2011/01/jquery-selectbox-plugin/
I-edit: Binabaliktad ko ang rekomendasyong ito dahil hindi ito gagana kung maraming elemento ang may parehong pangalan. Kung ito ay mahalaga, dapat mong tingnan ang Filament Group selectmenu plugin: http://filamentgroup.com/lab/jquery_ui_selectmenu_an_aria_accessible_plugin_for_styling_a_html_select/ //Edit
At isang jquery autocomplete plugin para sa combobox na sumusuporta din sa nakasulat na input: http://jqueryui.com/demos/autocomplete/
