Como definir uma dependência um-para-muitos entre objetos, de modo que quando um mudanças de estado do objeto todos os seus dependentes são notificados e atualizados automaticamente então você certamente utilizará um observer.
Observer baseia-se em uma relação entre um sujeito e seus observadores, de modo que as mudanças de estado são comunicadas.
Observer consiste em três partes:
– A interface Observer define o método update() que é chamado quando o estado muda;
– Os métodos da classe Assunto definido para registro e cancelamento de registro de observadores (por exemplo, attach() e detach()) e apela a mudanças de estado do update() métodos no Observer registrados;
– Temas específicos são derivados do assunto e relatar mudanças sua condição sobre a atualização;
– Observadores implementam a interface Observer regista-se com os assuntos necessários e ser informado de update() sobre as mudanças de estado dos assuntos.
Bem um exemplo de implementação do observer para uma navegação em javaScript com eventos: create, edit e delete pode ser baixado no link, também sua visualização esta disponível no link.
Basicamente o código gira em torno de três classes que é mostrada abaixo;
Interface do observer ela estabelece o contrato de implementação:
* Interface that establishes a contract observer
*
* $author Alexis Moura
* $var Interface
*/
var InterfaceObserver = {
 // Observer 
 Observer: function() {
   this.update = function(o) {
     throw new Error('Implemente Observer.update()');
   };
 },
 // Subject 
 Subject: function() {
   var observers = {};
   this.add_observer = function(o) {
     observers[o] = o
   };
   this.rem_observer = function(o) {
     delete observers[o]
   };
   this.notify = function() {
     for (var x in observers) {
       observers[x].update(this);
     }
   }
 };

Esta classe Action e responsável por notificar os objetos:

/**
* Action
*
* Class implements the Subject Notifies eachobject of the change
* adds and removes the object
*
* $author Alexis Moura
* $var Class
*/
var Action = {
    Class: function () {
        InterfaceObserver.Subject.apply(this)
        var actionName = 'Create';
        this.actionName = function (i) {
            if (i) {
                actionName = i;
                this.notify();
            } else return actionName;
        }
    },
    New: function () {
        return new this.Class()
    }
}

A classe Screen faz o trabalho de atualizar os objetos:

* Screen
*
* Class that changes the state of the screen
*
* $author Alexis Moura
* $var Class
*/
var Screen = {
    Class: function (object) {
        // herda da interface Observer
        InterfaceObserver.Observer.apply(this)
        // Implementação do metododo Observer
        this.update = function (o) {
            // Aplica a ação aosobjetos
            for (x in object)
                object[x][o.actionName()].apply(object[x], null);
        }
    },
    New: function (object) {
        return new this.Class(object)
    }
}
Repare que no exemplo mostra a grande vantagem de se utilizar o observer, com a alteração do estado os objetos dos botões são notificados e mudam de estado.
Este código vocês notaram que também utiliza outro padrão de projeto em conjunto que se chama State mas entraremos em detalhes em uma outra oportunidade.
Valeu ate a próxima.