Comment construire des événements personnalisés en JavaScript Si jamais vous avez beaucoup de travaux portent sur le langage de programmation JavaScript, Vous savez certainement ce que les événements JavaScript sont, avec quelques événements communs tels que: onload, onlick, ... Article JavaScript, L'auteur va vous apprendre à construire et mettre en œuvre les événements JavaScript votre propre usage, comment les intégrer dans le votre applications JavaScript, Avec un peu de connaissances telles que l'attribution/enlever les gestionnaires d'événements JavaScript, déclencher un événement JavaScript.

Gratuit iPage hbergement Web pour la premire anne MOMENT

Si vous tes toujours la recherche d'un fournisseur d'hbergement Web fiable avec des tarifs abordables, pourquoi vous ne prenez pas un peu de temps pour essayer iPage, seulement avec $1.89/month, inclus $500+ Crdits supplmentaires gratuites pour le paiement de 24 mois ($45)?

Plus de 1.000.000 de clients + existisng peuvent pas avoir tort, vraiment vous n'tes pas aussi! Plus important encore, lorsque vous enregistrez l'hbergement web iPage grce notre lien, nous allons tre heureux de renvoyer un plein remboursement. C'est gnial! Vous devriez essayer iPage hbergement web GRATUITEMENT maintenant! Et contactez-nous pour tout ce que vous devez savoir sur iPage.
Essayez iPage GRATUIT premire anne MOMENT

Without a doubt, the most often-used paradigm in JavaScript is events. Events are a manifestation of the observer pattern, a well-defined computer science design pattern for loose coupling. Loose coupling is incredibly important for creating maintainable, stable codebases. I talk a lot about loose coupling and its importance in my talk, Scalable JavaScript Application Architecture (video), so I won't talk too much about it here. However, the concept is very important to grasp if you wish to progress as a software engineer.


Unless you've never written any JavaScript before, you've used events at some point in time (admittedly, if you've never written JavaScript before, the chances of your reading my blog are probably pretty slim). Put quite simply: the way that you tie behavior to web pages is through events. Events are a way of letting interested parties know that an important moment has occurred in the lifecycle of the application. For instance:

window.onload = function(){

In this example, the load event is the interesting moment. I want to know when the window is fully loaded so that I can initialized the JavaScript application. The onload event handler is the location to where an event handler is assigned. The brilliant part is that window doesn't care what web page is loaded or who is writing the code; it just knows that there's a function to call when load occurs. This is the essence of loose coupling: when parts of an application have very limited knowledge of one another.

The Browser Object Model (BOM) and Document Object Model (DOM) publish events to allow developers access to the interesting moments of the browser and web page, respectively.

Custom events

It's no surprise that most JavaScript libraries rely heavily on custom events since this is a pattern that web developers are familiar with. Every major JavaScript library provides its own events, components to enable easy custom event definition, or both. This makes sense, of course, since libraries want to be loosely-coupled to the execution environment, and therefore, to your code.

There's nothing magic about custom events, though, and there's no need to load an entire library if you'd like to experiment with custom events. An object that supports custom events needs to be able to do a small set of things:

  1. Assign an event handler for a particular event.
  2. Remove an event handler for a particular event.
  3. Fire an event and call all assigned event handlers.

The following implements all of this basic functionality:

//Copyright (c) 2010 Nicholas C. Zakas. All rights reserved.
//MIT License

function EventTarget(){
    this._listeners = {};

EventTarget.prototype = {

    constructor: EventTarget,

    addListener: function(type, listener){
        if (typeof this._listeners[type] == "undefined"){
            this._listeners[type] = [];


    fire: function(event){
        if (typeof event == "string"){
            event = { type: event };
        if (!{
   = this;

        if (!event.type){  //falsy
            throw new Error("Event object missing 'type' property.");

        if (this._listeners[event.type] instanceof Array){
            var listeners = this._listeners[event.type];
            for (var i=0, len=listeners.length; i < len; i++){
                listeners[i].call(this, event);

    removeListener: function(type, listener){
        if (this._listeners[type] instanceof Array){
            var listeners = this._listeners[type];
            for (var i=0, len=listeners.length; i < len; i++){
                if (listeners[i] === listener){
                    listeners.splice(i, 1);

The EventTarget type has three methods: addListener(), fire(), and removeListener.

The addListener() uses the private _listeners object to store event handlers for various events. When an event handler is added, the method first checks to see if there's a named property for that event type on the _listeners object, and if not, creates one containing an array. The event handler function is then saved to the array for later.

The fire() method fires an event with a given name. In effect, this method's only job is to execute each event handler for the given event type. The method accepts either an object, in which case it's expected to have a type property, or a string, in which case a new object is created and the string is assigned as the value of type. Next, if the event object doesn't have a target property assigned, it is set to the current instance. This effectively creates an event object similar to the one most are familiar with via the BOM and DOM. Once the event object is created, the _listeners object is checked for event handlers, and if found, they are executed. Note that in order to mimic the BOM/DOM approach, event handlers are executed in the scope of this via the call() method.

The last method, removeListener(), simply reverses the process of addListener(). It searches through the _listeners property for the given event type to locate the specified event handler. If found, the event handler is removed by using the array's splice() method, and otherwise it exits without doing anything.

Basic usage:

var target = new EventTarget();
function handleEvent(event){

target.addListener("foo", handleEvent);{ type: "foo" });    //can also do"foo")
target.removeListener("foo", handleEvent);

Practically speaking, you'll likely not want to use an instance of EventTarget directly, but rather inherit from it:

function MyObject(){;

MyObject.prototype = new EventTarget();
MyObject.prototype.constructor = MyObject; = function(){"foo");

var o = new MyObject();

o.addListener("foo", function(){
    alert("Foo just happened.");

Typically, events are fired in reaction to some other method call, as in this example (events are usually not fired external to the object that is publishing the events).

What about... ?

This is a pretty barebones implementation of a custom event providing object, so inevitably someone will come along and ask why I didn't include one feature or another. There are, of course, a lot of enhancements you can make to custom events if you so desire. Some enhancements others have implemented:

  • Bubbling of events
  • Continue to execute event handlers even if one throws an error
  • Allow event handlers to cancel further processing or default actions

Each of these can be built pretty easily on top of the base presented in this post.


Custom events are a very powerful and useful pattern in JavaScript programming, and your usage of them doesn't have to rely on a large JavaScript library. Implementing your own custom events is easy. The implementation presented in this post is a minimum feature set that typically fulfills most requirements, but you can consider it as a starting point for more advanced functionality if your requirements are more complex.
Save up to 630$ when buy new iPhone 15
Free Airdrops to Claim, Share Up to $150,000 per Project
Open tool hub for free to use by any one for every one with hundreds of tools,,,
Talk to ChatGPT by your mother language
Generate creative images automatically with AI
Render creative video automatically with AI

JavaScript par jour

Google Safe Browsing McAfee SiteAdvisor Norton SafeWeb Dr.Web