Como funcionam os objetos criados seguindo singleton? – javascript design-pattern singleton

Gostaria de entender como funcionam os objetos criados seguindo o design pattern singleton em javascript.

Minhas principais duvidas são referentes aos métodos e atributos desse objeto, onde e como cria-los e onde e como acessa-los.

Li alguns artigos até em inglês mas não compreendi muito bem a forma de usar corretamente o singleton.

Como exemplo tenho esse código:

Fonte: Dofactory – Singleton

var Singleton = (function () {
    var instance;

    function createInstance() {
        var object = new Object("I am the instance");
        return object;
    }

    return {
        getInstance: function () {
            if (!instance) {
                instance = createInstance();
            }
            return instance;
        }
    };
})();

function run() {

    var instance1 = Singleton.getInstance();
    var instance2 = Singleton.getInstance();

    alert("Same instance? " + (instance1 === instance2)); //retorna true 
}

Os objetos estão sendo instanciados na function run, minha duvida nisso seria, se quero adicionar um método stop e um atributo status para saber se esse objeto está em run ou stop, como devo fazer isso seguindo o design pattern singleton?

Referencia:

A Beginner’s Guide to Design Patterns

JavaScript Design Patterns: Singleton

Talvez começar olhando para ponteiros de memória dê uma esclarecida.

Veja essa situação utilizando o NEW

var a = new Object('Some Object A');
var b = new Object('Some Object B');

Nesse código temos dois objetos criados em duas variáveis diferentes. Na memória de sua máquina, fica mais ou menos assim:

Código                   Memória
var a ---------------->  Posição 0000
var b ---------------->  Posição 0001

Ouse seja, duas cópias são criadas.

Se eu fizer o seguinte:

var c = b;

Nesse caso, c === b, porque:

Código                   Memória
var a ---------------->  Posição 0000
var b ---------------->  Posição 0001
var c ---------------->  Posição 0001

Note que tanto b e c apontam para a mesma área de memória, ou seja, o mesmo objeto.

Isso é um básico de como funciona, resumido.
Agora olhe no seu exemplo:

getInstance: function () {
  if (!instance) {
    instance = createInstance();
  }
  return instance;
}

Aqui você tá fazendo que se instance não existe, então cria uma instância. Logo, cada vez que você chamar getInstance, na primeira vez ele cria com NEW e nas outras apenas retorna o que já foi criado da primeira vez.

Colocando isso nos exemplos que citei:

var a = Singleton.getInstance();
var b = Singleton.getInstance();
var c = Singleton.getInstance();


Código                   Memória
var a ---------------->  Posição 0000
var b ---------------->  Posição 0000
var c ---------------->  Posição 0000

Em resumo, isso acontece porque só uma vez é criado e na outra, apenas uma referência para a instancia Singleton é retornada.

Espero que o textão tenha ajudado!!!

No seu exemplo, Object seria o objeto que você quer tornar um singleton.
Basta substituir (dado que você definiu seu objeto) e, se usar apenas o Singleton, você sempre terá apenas um exemplar do objeto.

Você deve criar os seus métodos run e stop dentro da definição desse objeto seu.

Para uma revisão de como isso é feito, dê uma olhada aqui: Como funcionam protótipos em JavaScript?

Uma forma de visualizar é a seguinte.

Imagine que você tem uma classe de conexão com o banco de dados, e não quer criar um objeto novo na memória toda vez que você precisar acessar o banco de dados, então você usa o Singleton.

Isso vai garantir que se crie vários objetos para fazer uma coisa comum em várias partes do projeto.