Walking Again…

Fazanos hein meus queridos….

Estava há muito tempo sem postar, mas graças à Deus por bons motivos. Às vezes gostamos tanto do que fazemos que acabamos esquecendo de viver a vida… Por muito tempo deixei minha vida social de lado, me dedicando apenas à faculdade e ao trabalho. Isso é muito ruim…porque trabalho nós achamos outro, dinheiro nós conseguimos de uma forma ou de outra, mas infelizmente não conseguimos recuperar o tempo que perdemos… E quanto mais velhos ficamos mais isso pesa. O tempo pesa. Mais do que recuperar o tempo perdido, o difícil é aprender o que deixamos de aprender com experiências de coisas mais corriqueiras, depois de velho.

Nesses últimos anos tenho me tornado cada dia mais sênior no meu trabalho e mais júnior na vida pessoal e acadêmica…Você quando chega nesse estágio, já recusou muitas festas, muitos bares, muitas baladas porque está “cansado demais”.

Se eu pudesse dar um conselho para qualquer pessoa é que ache o equilíbrio entre as duas coisas, esse equilíbrio existe e estou começando a encontrar apenas agora. Você pode e consegue achar tempo para tudo, mesmo estudando, trabalhando, namorando, fazendo academia ao mesmo tempo, você deve conseguir tempo para tudo e precisa encontrar tempo para tudo.

Todo mundo se pergunta quem de fato é em algum momento da vida, se é nerd, se é descolado, se é isso se é aquilo, e acaba querendo ser muitas vezes aquilo que não é, para se encaixar no que é mais “Legal”. Estava passando por esta fase, e deixei de ser aquilo que eu realmente era, comecei a perder tempo na vida social e na vida profissional. Porque eu sou daquele tipo de pessoa que prefere sempre acreditar nas coisas ruins que falam sobre nós, não sei se você também é assim. Isso é muito prejudicial, porque você vai ouvir coisas boas e muitas coisas ruins de outras pessoas, inclusive daquelas que você julga ser seus amigos.

Como eu ouvi coisas do tipo: “Você nunca vai conseguir…”, “Não é para você”, “Você é isso”, “Você é aquilo” . Você acaba desistindo de muita coisa ou deixando de conseguir muitas coisas…antes mesmo de tentar. As pessoas não gostam de ter alguém que tenha mais coisas ou que consiga mais coisas do que elas, uma forma de tentar sabotar isso é te falar o quão nada você é.

Sempre ouvi nos meios de comunicação sobre “Você precisa acreditar mais em você” ou “Não ligue para o que os outros pensam” coisas desse tipo. Para mim eram apenas frases clichês que todo mundo que conseguia alguma coisa ou conseguia chegar à algum lugar, falava para desabafar. Hoje isso faz muito sentido e acabo percebendo que aquilo que eu havia dito no parágrafo acima é verdade não só para mim como para todo mundo.

O fato é que você pode ser o que quiser ser, mas o mais importante é fazer o que gosta e deixar os esteriótipos de lado. Era o que eu estava fazendo nesse tempo todo longe do blog, correndo atrás de muitas coisas que havia deixado de lado. Comecei a perceber, que poderia conseguir ser bem sucedido na vida social, na vida profissional, na vida acadêmica se quisesse, pra isso precisava esquecer tudo aquilo que ouvi e ouço e comecei a fazer tudo o que senti vontade de fazer . E estou fazendo.

Não vou dizer que me dei bem em tudo e estou com a vida perfeita, mas enfrento os fracassos e decepções muito mais do que antes e isso é EXTREMAMENTE IMPORTANTE para ser bem sucedido em qualquer coisa. Você precisa fracassar, você precisa saber enfrentar as coisas para poder ter coragem de ousar. Se não fracassa é porque não tenta, se não tenta, nào conseguirá nada.

Um colega do trabalho me passou uma série de vídeos do site papodehomem.com.br muito bons sobre motivação, e era o que eu estava precisando, acho que nem ele sabe o quão importante foi para mim aqueles vídeos. Enfim, acho que são bem conhecidos hoje, mas vale muito a pena deixar aqui no blog caso alguém ainda não tenha visto. Eu aconselho ver todos e todos os dias.

Bom, é sobre isso que se trata o post de hoje, não sobre trabalho, não sobre algoritmos, sobre uma experiência da minha vida.

Queria me desculpar pela ausência, vou começar a postar coisas novas agora, e aposto que vão gostar muito do próximo post. =)

Um abraço!

http://papodehomem.com.br/listas-descaralhantes-3-videos-para-matar-a-preguica/

OOP em Javascript – Classes Abstratas

E aí galera!

Tenho andado bastante atarefado no trabalho, o que contribui para minha falta aqui no blog, estou muito mais no momento de resolver problemas rapidamente do que de refletir, tenho sentido falta disso.

Mas para não deixar o blog tão abandonado resolvi retomar os posts sobre orientação à objetos em Javascript, porque eu acho muito interessante a forma como resolvemos os problemas nessa linguagem.

Então, vamos lá. O que seria uma Classe abstrata no nosso desenvolvimento? A grosso modo é uma classe com propriedades e/ou métodos como qualquer outra, porém é uma classe que não faz sentido existir por si própria, ou seja, não faz sentido haver uma instância desta classe.

Essa classe serve apenas como base para outras classes que irão herdar seu comportamento, suas características.

Um exemplo, se tivessemos que criar um carro, sabemos que este tem o comportamento de se deslocar, um carro acelera, desacelera e consequentemente altera sua velocidade. Então todo Carro que se preze tem uma velocidade, pode acelerar, pode desacelerar até o momento em que sua velocidade for zero.

Então poderiamos criar esta classe Carro:

var Carro = {

	Class :function(){

		//Private
		var velocidade = 0

		//Public
		this.acelerar = function(n){
			velocidade = velocidade + (n || 1)
		}

		this.frear = function(n){
			velocidade = velocidade - (n || 1)
		}

		this.velocidade = function(){ return velocidade }

	}

}

Esta classe vai funcionar direitinho como planejamos, vai frear, vai acelerar e tem uma propriedade velocidade, privada, que será alterada a cada ação que fizemos.

Porém na perspectiva do paradigma OO a forma como criamos a classe Carro está equivocada. Ela está engessada com métodos e propriedades que não poderiam ser reaproveitados em outras classes de mesmo propósito. Ou melhor poderíam, mas de forma completamente errada.

Veja, se quiséssemos criar uma Moto, com esta classe Carro já implementada, haveria duas formas erradas de se criá-la.

Uma é duplicar a classe Carro e chamar de Moto. ( Se você fizer isso você não vai pro céu )

Outra seria herdar de Carro as propriedades e métodos. ( Se você fizer isso você não só não vai pro céu como vai direto pro inferno )

Duplicar está fora de cogitação, orientação à objetos serve justamente para reaproveitarmos código.

Herdar de Carro é um erro de arquitetura sério, como pode uma Moto ser um Carro ? Não pode.

O jeito de resolver esse problema é criar uma classe base, que seja comum entre os dois objetos e estes dois objetos devem herdar desta classe.

A solução é criar uma classe chamada Veiculo. Bom, um carro é um veículo e uma moto é um veículo, ambos tem o comportamento de um veículo que é de se movimentar, acelerar, frear, alterar sua velocidade.

Beleza, então essa classe Veiculo já resolveria nosso problema, mas esta classe não é uma classe como a Moto ou o Carro. Ela é uma classe que serve apenas para ser herdada, não faz sentido existir uma instância dela, não existe um veículo por si só, veículo é uma designação que damos para um determinado objeto, no nosso caso um carro ou uma moto. Você pode dizer que vai pegar um veículo, ou vai guiar um veículo, mas este veículo no nosso mini-mundo ou é um Carro ou é uma Moto.

Então a classe Veiculo é uma classe abstrata.

Em linguagens mais fortemente tipadas como C++, Java, C# é possível através da própria linguagem definir que uma classe não deve existir por si só, não deve existir uma instância dela e que ela deve ser apenas herdada. No Javascript não é possível definir se uma classe é abstrata apenas usando uma palavra-chave, então, para arquitetar uma solução de classes onde usamos classes abstratas e queremos disciplinar outros programadores para que usem nosso código corretamente, precisamos usar um outro tipo de técnica.

Existem várias técnicas na internet, e essa é a vantagem do Javascript dada sua flexibilidade. Vou mostrar a forma como eu faço, e que eu prefiro fazer. Isto fica aqui entre nós, desenvolvedores de Interface, programadores Javascript, porque se aparecer qualquer programador back-end, desktop, engenheiro de software, vai querer nos matar, porque vamos ferir o conceito de Interfaces, novamente.

Falei em um post passado, sobre como usar Interfaces em Javascript, mas uma interface que é mais um mixin do que uma interface. Mas para nós, programadores Javascript, é uma Interface mais malemolente. Lembrem-se de que uma Interface não deve especificar como se implementa, apenas o que se implementa, porém no Javascript ela vai dizer também como se implementa. Se não viu o post sobre interfaces, eu aconselho que veja para entender o que estou falando. =)

Tá, mas por que estou falando tanto de Interfaces se nosso problema é como forçar que uma classe seja abstrata ?

Porque vamos resolver esse problema justamente usando uma “Interface“.

Como ? Olha só:

var Interface = {
	abstract :function(c){
		if( c.prototype.isPrototypeOf(this) )
			throw new Error('Abstract Class')
	}
}

Criei ali uma Interface que possui uma implementação para um tipo abstrato de classe. Existe um método abstract que vai receber um construtor e vai dizer se a classe é abstrata, perguntando se o protótipo do escopo atual é o mesmo protótipo do construtor. Em outras palavras, se somos uma instância daquele construtor então lançamos um erro.

Então, para criarmos todos os nossos veículos usaríamos a Interface para criarmos a classe abstrata Veiculo e herdaríamos Veiculo em Carro e Moto:

var Veiculo = {

	Class :function(velocidade){

		Interface.abstract.apply(this, [Veiculo.Class])

		this.acelerar = function(n){
			velocidade = velocidade + (n || 1)
		}

		this.frear = function(n){
			velocidade = velocidade - (n || 1)
		}

		this.velocidade = function(){ return velocidade }

	}
}

 

var Carro = {

	Class :function(){
		Veiculo.Class.apply(this, [0])
		// Implementações de um carro
	}

}

var Moto = {

	Class :function(){
		Veiculo.Class.apply(this, [0])
		// Implementações de uma moto
	}

}
var carro = new Carro.Class
	carro.acelerar(20)
	carro.velocidade() // 20

var moto = new Moto.Class
	moto.acelerar()
	moto.velocidade() // 1	

**Perceba que eu passei Veiculo.Class para a Interface.abstract além de passar 0 como a velocidade inicial.

É claro que aqui estamos com duas classes idênticas Moto e Carro, porém suas classes seriam preenchidas com métodos e propriedades específicas dos seus tipos posteriormente.

É isso, os puritanos e estudiosos do paradigma orientado à objetos tentariam mandar me matar ao ver que usei Interface para criar uma classe abstrata, mas fica aqui entre nós .

Aproveite e tente rodar na sua máquina estas classes, veja o que acontece quando se tenta criar uma instância de Veiculo. =)

Um grande abraço.

 

Douglas Crockford & Javascript – Parte 1 – The Early Years

Devo confessar minha ignorância, faz pouco tempo que conheço Douglas Crockford, há mais ou menos 1 ano. Conheço de saber que ele existe, não de visitá-lo para fazer um churras.

Mas me sinto muito envergonhado por isso e um pouco desapontado por ter demorado tanto tempo para saber da sua existência.

Isso porque poderia ser um programador melhor agora, poderia ter pesquisado as coisas certas.

Uma das grandes dificuldades que tenho, e talvez devam ter também é saber no que perder tempo para se tornar um bom profissional.

Bom, esse post e os demais dessa série tem haver com isso, eu não tenho a pretensão de dizer qual o caminho que devem tomar, mas sei que Douglas Crockford pode ajudar a achá-lo mais fácilmente.

Se você trabalha com Javascript DEVE conhecê-lo. Se você não trabalha e odeia Javascript, deve conhecê-lo mais do que ninguém.

Se você gosta de Javascript e pensa que é uma linguagem ruim, fraca e está além das linguagens como Java, C# e outras, vai começar a pensar muito diferente após saber sobre de onde esta linguagem veio e para onde vai, conhecendo seu lado negro e seu lado jedi, vai perceber o quão genial ela é.

Como nem todos conhecem ou ouviram falar no Douglas, farei minha contribuição para a comunidade e presentear aqueles que gostam do meu blog.

Enjoy

Paginação em Javascript – Parte 2 Final

Olá galera, esse post é a segunda parte sobre paginação em Javascript, dessa vez vou mostrar a segunda forma que havia comentado no post anterior sobre como fazer a paginação.

Na forma anterior, lembram, a paginação tinha como função pegar os elementos e manipulá-los por conta própria, sendo que você como desenvolvedor bastaria passar alguns parâmetros para a classe, ela se encarregaria de fazer tudo sozinha.

É claro que não é a melhor classe do mundo, nem a mais eficiente, para pequenos propósitos ela funciona muito bem, mas não é um bom código por exemplo para um grande número de páginas. Não sei se perceberam, mas o script toda hora, ou melhor, cada vez que é clicado em uma nova página, ele remove todos os nodos das páginas, e remove também todos os nodos da página atual e depois reescreve-os, criando tudo de novo e fazendo o append no documento.

Isso é extremamente dispendioso, extremamente lento no que diz respeito ao dom. Vocês vão perceber isso se passarem um “size” de tamanho muito grande, gerando muitas páginas. Ao clicar numa página que não a atual, vão perceber que o script demora muito tempo pra ser executado, porque precisa apagar todos aqueles nodos e gerá-los de novo. O DOM é muito lento, e da forma como é feita na jsPagination, o torna mais lento ainda.

Há ainda um outro problema, que tenho percebido de uns tempos pra cá no desenvolvimento dos meus scripts. Existe um erro grande ali no design do script. Se é um script que faz paginação, ele só deveria fazer a lógica da paginação. O que você vai fazer com as páginas e como vai montá-las é um outro problema.

A medida que o script cresce ele se torna mais complexo e quanto mais complexo ele fica, mais difícil de dar manutenção e maiores são as chances de surgirem bugs, é inevitável.

Então comecei a “atomizar” mais minhas “classes” fazendo com que elas apenas resolvam o problema que elas precisam resolver e deixar o resto na mão de outra classe. Menos é mais, quanto mais modularizado o código, melhor.

Neste post vou resolver apenas o segundo problema da classe, ela ainda vai adicionar e remover os elementos como fazia anterioremente, mas agora ela fará parte de uma outra classe de implementação, podendo ser melhorada ou estendida independentemente da classe de paginação em questão.

Então a classe atomizada, que apenas contém a lógica da paginação ficou assim:

;(function(namespace){
	
	var Interface = {
		actions : function(){			
			this . pages = function(){
				throw new Error('Implemente o método pages em sua classe/objeto')	
			}
			this . list = function(){
				throw new Error('Implemente o método list em sua classe/objeto')
			}
		}
	}
	
	var Paginator = {
		
		Class : function( target ){
			var json
			Interface.actions.apply( this )

			this.ready = null
			
			this.open = function(options){
					
					if(!json) json = options					
					else for(var i in options) json[i] = options[i]
				
				var pages = 
					Math.floor( json.size / json.show ) + 
					( ( json.size % json.show ) ? 1 : 0 )
									
				json.page = json.page ? json.page : 1	
				
				this.begin? this.begin() :null
				
					for( var i = 1; i <= pages; i++ )
						this.list.call? this.list.call(this, i, json) :null
					
					for( 
						var i = ( (json.page-1 ) * json.show ); 
						i< ( ( json.page-1 ) * json.show ) + 1 + ( json.show - 1 ); 
						i++
					){											
							if( i > json.size - 1 )
								break						
						this.pages.call? this.pages.call(this, i, json) :null						
					}	
					
				this.ready? this.ready() :null
			}			
			
		}
		
	}	
	
	namespace['Paginator'] = Paginator.Class
		
})(window)

Então essa classe só faria chamadas aos métodos que implementam a população de elementos html. O método open ao ser chamado configuraria as opções passadas, e chamaria os métodos públicos :

this.begin() : Método que é chamado logo antes dos outros métodos da paginação.
this.list() : Método que será chamado n vezes, sendo n o número de páginas.
this.pages() :Método que é chamado n vezes, sendo n o número de elementos à serem mostrados.
this.ready(): Quando tudo estiver sido chamado, ou seja, o ready é um callback.

Os métodos list e pages são chamados no escopo da classe de paginação e com dois argumentos, o primeiro um inteiro contendo o índice da paginação e o segundo contendo as opções passadas na chamada do método open, mantendo as opções privadas.

Então agora, como e onde a paginação vai colocar os elementos, não é mais o cargo do Paginator, é cargo de alguma outra classe que vai herdar Paginator ou compor a mesma.

A classe estando atomizada, ela fica bem mais fácil de ser entendida, mais fácil de dar manutenção, a lógica não fica misturada e código menos emaranhado.

A otimização, implementação de plugins e a forma como serão adicionados os elementos fica a cargo de uma outra classe como eu havia comentado anteriormente, através de herança ou composição.

Eu fiz um código para provar essa parte toda teórica, preferi usar composição para reproduzir o funcionamento da classe antiga que postei na primeira parte do post. Fiz um sigleton que será responsável por instanciar o Paginator, e fazer todo o trabalho com os nodos de inserção e remoção. É claro que o código ficou bem menor do que o antigo código do jsPaginator, mostrado no post anterior, isso não se deve apenas pela atomização da classe, mas porque eu não implementei os plugins que haviam na classe antiga e porque agora estou usando jQuery =), não tenho tanto tempo livre como tinha antigamente então preciso ser mais produtivo, caso contrário postaria um conteúdo novo a cada 5 meses =/.

Então, para finalizar o post e deixá-los em paz, aqui vai o singleton que havia comentado:

;(function(){
	
	var Paginate = {
		
		pages		:null,
		content		:null,
		temp_pages	:null,
		instance	:null,
		callback	:null,
		
		initialize : function( paginacao, content ){
			
			this.pages = $(paginacao)
			this.content = $(content)	
			this.temp_pages = this.pages.eq(0).clone()
					
			this.start()
			
			return this
		},
		
		start : function(){
			
			var self = this
			var paginator = new Paginator			
			
			this.instance = paginator
			
				paginator . begin = function(){
					self.content.empty()
					self.temp_pages.empty()	
				}
				
				paginator . pages = function(i, json){
					self.content.append( $('<p />').html(i+1) )										
				}
				
				paginator . list = function(i, json){
						
					var self_paginator = this
					var el = $('<a />').attr('href', '#').html(i)
						.click(function(){							
							json.page = i
							self_paginator.open()
						})
						
						if( json.page == i )
							el.addClass('selected')
					
					self.temp_pages.append( $('<li />').append(el) )
					
				}
				
				paginator . ready = function(){
					
					self.pages.each(function(){						
						$(this)
							.empty()
							.append( self.temp_pages.children().clone( true ) )
					})
					
					self.callback? self.callback(self) :null
								
				}				
		},
		
		open : function(options){
			this.callback = options.callback? options.callback :null
			this.instance.open(options)			
		}		
	
	}
	// Fim do Singleton
	
	Paginate	
		.initialize('.paginacao', '#pagina')		
		.open({ 
			size : 50, 
			show : 10,
			callback : function(){} 
		})
			
	
})()

Eu acho que o Singleton Paginate está bem simples, não vou perder muito tempo explicando como ele funciona, acho que dá pra entender. Se alguém tiver alguma dúvida ou não entendeu alguma parte, poste no comentário, que eu explico =). Ah, críticas também são muito bem vindas.

Abraço galera, obrigado pela atenção e até o próximo post. o/

OOP em javascript – Herança e Singleton pattern

Olá CAMAGADAS!

Iniciados em classes em javascript, gostaria de falar um pouco sobre as técnicas que utilizo para herdar classes e falar um pouco sobre dois métodos para implementar singletons.

Primeiro, a herança. Não quero esticar muito sobre esse assunto e imagino que saibam pelo menos  para que serve isso. Se alguém não sabe, em algum daqueles links que passei no post anterior à esse deve ter. Senão aqui vai uma breve explicação:

A Herança é um princípio da Programação Orientada a Objetos que permite que as classes compartilhem atributos e operações baseados em um relacionamento, geralmente generalização. A herança permite a criação de subclasses que herdam alguns dos atributos e das operações (ou Métodos) da classe pai (super-classe ou classe base). A herança é um conceito aplicado no momento de criação das classes. Ela é usada na intenção de reaproveitar código ou comportamento generalizado ou especializar operações ou atributos.

fonte: Wikipédia

Herança

A idéia de Classe é gerar um template, um tipo de alguma coisa que queremos criar. A instância é nada mais que um objeto concretizado deste tipo. Vou utilizar um exemplo clássico e simples de se abstrair, vou tentar usar sempre os mesmos exemplos nos posts de Orientação à objetos em javascript.

Vamos criar um objeto Moto, e um objeto Carro. Os dois aceleram, fream e tem velocidade. Os dois fazem mais ou menos a mesma coisa, mas não são A MESMA COISA.

Podemos pensar que os dois são veículos. Então temos uma classe em comum, a classe Veiculo =).

var Veiculo = {
	Class : function(){
		var velocidade = 0
		this.acelerar = function(){ velocidade += 10}
		this.frear = function(){ velocidade -=10 }
		this.velocidade = function(){ return velocidade }
	}
}

Criamos então uma Classe em comum aos dois objetos, Moto e Carro. Como fazer a herança para os dois? Simples:

Moto:

var Motocicleta = {
	Class : function(){		
		Veiculo.Class.apply(this)
		
	}
}

Carro:

var Carro = {
	Class : function(){		
		Veiculo.Class.apply(this)
		
	}
}

Então:

var moto = new Motocicleta.Class()
	moto . acelerar()
	moto . velocidade() // 10

Olha que chupetinha..

Isso vale também para a instancia de carro. Ambas as classes herdam os métodos da classe mãe Veiculo.  Não existe apenas esta forma de se implementar a herança em javascript, mas eu considero essa a mais elegante de todas, e acho inclusive semântica. Porque em inglês, está praticamente dizendo :  ”Classe Veiculo! Aplique-se à isto”.

O apply é um método herdado para todos os tipos Function. Ele te da o poder de chamar qualquer função determinando qual será o escopo e os parâmetros passados.

Quando chamamos Veiculo.Class.apply(this) nas duas classes, estamos chamando a função Veiculo.Class de dentro das Classes usando o próprio escopo delas. Ou seja, no momento em que a Veiculo.Class estiver sendo executada, quando chegar nas linhas this.acelerar,, this.etc,  ela vai saber que this se refere ao escopo da própria classe, portanto vai setar os valores para o escopo da classe Moto e Carro.

A variável privada velocidade é passada para o escopo das classes filhas graças ao Closure, porque a função Veiculo.Class inicia uma variável livre que pode ser vista através dos métodos públicos this.acelerar, this.frear e this.velocidade e por usar a palavra chave var a cada chamada da função Veiculo.Class se criará uma nova variável privada “velocidade”, uma para cada classe.

Design Pattern : Singleton

Algumas vezes precisamos de um objeto único que terá seus estados e métodos únicos e de maneira estática. Ou seja, queremos que haja apenas uma e somente única instancia daquele objeto.

Vi muitas implementações na internet de singleton em js, e todas eram péssimas. Se forem procurar, vão achar em sites brasileiros ou gringos muitas implementações parecidas com essa:

function Page(){
	var width = 800;
	this.getWidth = function(){
		return width;
	}
}
Page.instance = null;
Page.getInstance = function(){
	if (Page.instance == null) Page.instance = new Page();
	return Page.instance;
}

A primeira impressão é de que é uma boa implementação de singleton, porque segue um padrão semântico bem próximo aos usados em linguagens como o Java e C++.

Mas é uma abordagem péssima para javascript. Em javascript você não consegue definir constantes como em java por exemplo quando usa a palavra-chave final. Então, no caso acima, Page.instance pode ser a qualquer momento modificada para null e aí vc terá duas instâncias Singleton.

Eu particularmente uso dois tipos de singleton, um desenvolvi por conta própria e o outro é puramente usar o que a linguagem tem.

Se por algum motivo precisa fazer uma classe dinâmica Singleton, usando construtores, a forma que eu pensei foi essa:

var Deus = {
	Class : function(){
		var self = this
				
		Deus.getInstance = function(){ return self }
		delete Deus.Class
	},
	getInstance : function(){ return new Deus.Class	}
}

Digamos que Deus exista e que haja apenas um. A funcionalidade da Classe Deus está toda encapsulada em Deus.Class e a classe tem também um método estático getInstance. A minha idéia foi a seguinte:

Existem dois jeitos de instanciar Deus. Uma chamando new Deus.Class e a outra Deus.getInstance().

No primeiro, a função Deus.Class é envocada salva o escopo em uma variável, redefine o método estatico getInstance para que retorne o escopo salvo self e por fim, deleta a variável Deus.Class do objeto Deus. Pronto! você não consegue mais instanciar Deus.Class, porque essa variável não existe mais. Pode apenas recuperar o objeto através de Deus.getInstance.

No segundo, ao chamar Deus.getInstance sem usar o new,  ele retorna uma nova instancia da classe o que levará ao nosso primeiro caso acima.

De uma forma ou outra, sempre terá apenas uma instancia do objeto.

Essa maneira de criar Singletons não é muito comum. Pra falar a verdade até agora não precisei usá-la. Ela ainda pode ser burlada, mas não é tão fácil quanto setar uma variável, de forma que consegue disciplinar de maneira mais eficaz o programador que irá por ventura fazer a  manutenção do código.

E finalmente o modo mais simples mais perfeito mais fácil de se criar um Singleton.

var Singleton = {}

É meus caros… Singleton a grosso modo não é uma instância única de um objeto ? Então… A notação json do javascript nos permite criar um objeto dinamicamente de forma bem elegante, onde podemos criar propriedades e métodos estáticos para armazenar e/ou modificar os estados desse objeto.

Simples!

Você com certeza já deve ter usado um Singleton sem saber. Geralmente o povo usa os Singletons para formar namespaces em um objeto encapsulado. Por exemplo:

var Projeto = {
	version : '1.0',
	sidebar : function(){},
	util : {
		Analitics : function(){}
	}
}
	
Projeto.util.Analitics()

Eu não tinha tanta liberdade para usar Javascript Orientado à Objetos em outras empresas que trabalhei. Mas nessa atual ( F.biz)  tenho uma liberdade muito grande para mexer com orientação a objetos em javascript e tenho percebido que isso ajuda e MUITO no desenvolvimento, tanto na produtividade quanto na manutenção e por incrível que pareça no desempenho. Sem contar que fica mais divertido =).

O javascript evolui sempre e a cada dia que passa novas idéias e inovações aparecem.

Coisas que antes não eram viáveis devido à restrições de hardware, hoje já podem ser feitas sem comprometer o processamento da máquina. Funcionalidades que antes eram feitas em server-side, hoje podem ser feitas via client sem problemas, aliviando o tráfego e melhorando ainda mais o desempenho das páginas.

A medida que essa evolução acontece, conceitos de programação são cada vez mais exigidos, hoje mais do que nunca, javascript é uma linguagem de programação e não mais uma linguagem de script simples usada para fazer validações de formulários.

Se você ainda não tem conceitos de programação de qualquer paradigma e pretende ser um bom profissional em javascript, se quer um conselho de um amigo, eu sugiro que corra atrás o quanto antes, porque isso FAZ muita diferença e você certamente vai achar muito mais divertido programar nessa linguagem.

Galera,

NUNCA, JAMAIS, acredite em alguém que diga que isso não faz diferença. Já ouvi de alguns “Desenvolvedores web” que orientação à objetos em javascript não serve para nada, já que é possível fazer tudo funcionar de forma estrutural. Se algum dia ouvir isso de alguém que você imaginava ser uma pessoa experiente e com certo conhecimento, fica minha dica, ouça-o menos e estude mais.

Mais: Milfont.org/tech – Herança no Javascript

Um grande abraço!