introduzir
Todo mundo está familiarizado com os construtores, mas se você é um novato, ainda é necessário entender o que são os construtores. O construtor é usado para criar um tipo específico de objeto - não apenas declara o objeto usado, mas também aceita parâmetros para definir o valor do membro do objeto quando o objeto é criado pela primeira vez. Você pode personalizar seu próprio construtor e declarar as propriedades ou métodos do objeto de tipo personalizado.
Uso básico
No JavaScript, os construtores geralmente são considerados usados para implementar instâncias. O JavaScript não tem o conceito de classes, mas possui construtores especiais. Use a nova palavra -chave para chamar a função precoce definida. Você pode dizer ao JavaScript que deseja criar um novo objeto e que as declarações do membro do novo objeto são definidas no construtor. Dentro do construtor, essa palavra -chave refere -se ao objeto recém -criado. O uso básico é o seguinte:
A cópia do código é a seguinte:
Carro de função (modelo, ano, milhas) {
this.model = modelo;
this.year = ano;
this.miles = Miles;
this.Output = function () {
Retorne this.model + "esquerda" + this.miles + "km";
};
}
var Tom = novo carro ("tio", 2009, 20000);
var dudu = novo carro ("Dudu", 2010, 5000);
console.log (tom.Output ());
console.log (dudu.output ());
O exemplo acima é um padrão de construtor muito simples, mas é um pouco importante. Primeiro de tudo, é muito problemático usar a herança. Em segundo lugar, a saída () é redefinida toda vez que um objeto é criado. A melhor maneira é permitir que todas as instâncias do tipo de carro compartilhem esse método de saída (), de modo que, se houver grandes lotes de instâncias, economize muita memória.
Para resolver esse problema, podemos usar o seguinte método:
A cópia do código é a seguinte:
Carro de função (modelo, ano, milhas) {
this.model = modelo;
this.year = ano;
this.miles = Miles;
this.Output = formatcar;
}
função formatcar () {
Retorne this.model + "esquerda" + this.miles + "km";
}
Embora esse método esteja disponível, temos o seguinte método melhor.
Construtores e protótipos
Existe uma propriedade de protótipo em JavaScript chamada Prototype. Quando o construtor é chamado para criar um objeto, todas as propriedades do protótipo do construtor estão disponíveis no objeto recém -criado. Dessa forma, várias instâncias de objetos de carro podem compartilhar o mesmo protótipo. Vamos expandir o código no exemplo acima:
A cópia do código é a seguinte:
Carro de função (modelo, ano, milhas) {
this.model = modelo;
this.year = ano;
this.miles = Miles;
}
/*
Nota: Aqui usamos o objeto.prototype. nome do método, não o objeto.prototipo
É usado principalmente para evitar a reescrita do protótipo protótipo objeto
*/
Car.prototype.output = function () {
Retorne this.model + "esquerda" + this.miles + "km";
};
var Tom = novo carro ("tio", 2009, 20000);
var dudu = novo carro ("Dudu", 2010, 5000);
console.log (tom.Output ());
console.log (dudu.output ());
Aqui, a instância única () pode ser compartilhada e usada em todas as instâncias de objetos do carro.
Além disso: recomendamos que os construtores comecem com letras maiúsculas para distinguir funções comuns.
Você só pode usar novo?
No exemplo acima, o carro de função é criado usando novos para criar objetos. Existe apenas de uma maneira? De fato, existem outras maneiras, vamos listar dois:
A cópia do código é a seguinte:
Carro de função (modelo, ano, milhas) {
this.model = modelo;
this.year = ano;
this.miles = Miles;
// Personalize uma saída de saída
this.Output = function () {
Retorne this.model + "esquerda" + this.miles + "km";
}
}
// Método 1: Chamado de função
Carro ("tio", 2009, 20000); // Adicionar ao objeto de janela
console.log (window.output ());
// Método 2: Chamada dentro do escopo de outro objeto
var o = new Object ();
Car.Call (O, "Dudu", 2010, 5000);
console.log (O.Output ());
O método 1 deste código é um pouco especial. Se a New chama a função diretamente, isso aponta para a janela de objeto global. Vamos verificar:
A cópia do código é a seguinte:
// como uma chamada de função
var tom = car ("tio", 2009, 20000);
console.log (tipo de tom); // "indefinido"
console.log (window.output ()); // "Tio andou 20.000 quilômetros"
No momento, o objeto Tom está indefinido e Window.Output () produzirá o resultado corretamente. Se você usar a nova palavra -chave, não existe esse problema. A verificação é a seguinte:
A cópia do código é a seguinte:
// Use uma nova palavra -chave
var Tom = novo carro ("tio", 2009, 20000);
console.log (tipo de tom); // "objeto"
console.log (tom.Output ()); // "Tio andou 20.000 quilômetros"
Forçar novo
O exemplo acima mostra o problema de não usar o novo. Então, existe uma maneira de o construtor forçar a nova palavra -chave? A resposta é sim, o código acima:
A cópia do código é a seguinte:
Carro de função (modelo, ano, milhas) {
if (! (esta instância do carro)) {
devolver carro novo (modelo, ano, milhas);
}
this.model = modelo;
this.year = ano;
this.miles = Miles;
this.Output = function () {
Retorne this.model + "esquerda" + this.miles + "km";
}
}
var Tom = novo carro ("tio", 2009, 20000);
var dudu = carro ("dudu", 2010, 5000);
console.log (tipo de tom); // "objeto"
console.log (tom.Output ()); // "Tio andou 20.000 quilômetros"
console.log (typeof dudu); // "objeto"
console.log (dudu.output ()); // "Dudu andou 5000 quilômetros"
Ao julgar se essa instância é carro, decidimos devolver o carro novo ou continuar a executar o código. Se a nova palavra -chave for usada, (esta instância do carro) for verdadeira e a seguinte atribuição de parâmetros continuará. Se o novo não for usado, (esta instância do carro) for falsa e uma nova instância será retornada novamente.
Função do invólucro original
Existem 3 funções de invólucro originais em JavaScript: número, string, booleano, às vezes ambos são usados:
A cópia do código é a seguinte:
// Use a função de invólucro original
var s = new string ("minha string");
var n = novo número (101);
var b = novo booleano (verdadeiro);
// Recomendar isso
var s = "minha string";
var n = 101;
var b = true;
Recomendado, use apenas essas funções de wrapper quando você deseja preservar o estado numérico. Para a diferença, você pode consultar o seguinte código:
A cópia do código é a seguinte:
// string original
var greet = "Olá";
// Use o método split () para dividir
Greet.split ('') [0]; // "Olá"
// Adicionar novos atributos ao tipo original não relatará um erro
Greet.smile = true;
// Este valor não pode ser obtido (conversamos sobre por que no capítulo 18 implementação do ECMAScript)
console.log (typeof greet.smile); // "indefinido"
// string original
var greet = new string ("olá lá");
// Use o método split () para dividir
Greet.split ('') [0]; // "Olá"
// Adicionando novos atributos ao tipo de função do wrapper não relatará um erro
Greet.smile = true;
// novas propriedades podem ser acessadas normalmente
console.log (typeof greet.smile); // "booleano"
Resumir
Este capítulo explica principalmente as diferenças entre o uso do modo construtor, o método de chamada e a nova palavra -chave. Espero que todos prestem atenção a ele ao usá -lo.
Referência: http://www.addyosmani.com/resources/essentialjsdesignpatterns/book/#constructorTatternjavascript