Existem muitas maneiras de criar objetos no JavaScript.
Construtor de objeto/objeto literal :
Deixando de lado o padrão de design, o método mais básico é primeiro chamar o construtor de objeto para criar um objeto e, em seguida, adicionar atributos ao objeto.
A cópia do código é a seguinte:
var student = new Object ();
estudante.name = "Xiao Ming";
estudante.age = 20;
estudante.getName = function () {
alerta (this.name);
}
Os alunos familiarizados com o objeto Javascript literal podem mudar para uma maneira melhor de escrever, pelo menos parece mais conciso.
A cópia do código é a seguinte:
var aluno = {
Nome: "Xiao Hong",
Idade: 18,
getName: function () {
alerta (this.name);
}
};
Desvantagens: Uma das desvantagens do método acima é que, ao usar a mesma interface para criar muitos objetos semelhantes, um grande número de código duplicado será gerado. Isso deve ser fácil de entender. As funções (métodos ou classes) são geralmente usadas para criar métodos públicos. O processo de criação de objetos acima não tem sombra de funções, então não há reutilização.
Modo de fábrica :
O padrão de fábrica abstrava o processo de criação de um objeto concreto. Assim como uma caixa preta, você só precisa chamar a função (insira a fábrica) e passe nos parâmetros correspondentes (várias matérias -primas) e um objeto correspondente (o produto produzido pela fábrica) será lançado. O padrão de fábrica resolve o problema de criar vários objetos semelhantes.
A cópia do código é a seguinte:
Função StudentFactory (nome, idade) {
var student = new Object ();
estudante.name = nome;
estudante.age = idade;
estudante.SayName = function () {
alerta (this.name);
}
aluno de retorno;
}
var P1 = StudentFactory ("Ming", 20);
var P2 = StudentFactory ("Hong", 18);
Desvantagens: O padrão de fábrica também tem suas desvantagens, e a maior desvantagem é a questão do reconhecimento do tipo de objeto. Só pode ser determinado que o objeto é do tipo de objeto (instância p1 do objeto), mas é impossível determinar qual tipo ele é. Os alunos criados usando o modo de fábrica realmente têm propriedades e métodos semelhantes, mas os valores são diferentes. Uma solução melhor neste momento é criar uma função de aluno para que todos os objetos pertencem ao tipo de aluno. Portanto, o modo de fábrica não é ruim, mas o modo construtor é melhor.
Construtor de tipo personalizado:
Os construtores podem ser usados para criar objetos de um tipo específico.
A cópia do código é a seguinte:
Função Student (nome, idade) {
this.name = nome;
this.age = idade;
this.sayName = function () {
alerta (this.name);
}
}
var p3 = novo aluno ("Ming", 20);
var P4 = novo aluno ("Hong", 18);
Alerta (P3 Instância do aluno);
alerta (p3.SayName == P4.SayName); //falso
Desvantagens: a desvantagem dos construtores personalizados é que cada objeto recrie seu próprio método. De fato, esses métodos têm a mesma função (como o SayName), mas não são iguais (p3. SayName e P4. SayName não são iguais).
Modo de protótipo:
Defina uma função vazia e adicione todas as propriedades e métodos ao protótipo para que todos os objetos compartilhem essas propriedades e métodos.
A cópia do código é a seguinte:
function student () {};
Estudante.prototype.name = "Ming";
Estudante.prototype.age = 20;
Estudante.prototype.friends = ['qi'];
Estudante.prototype.sayname = function () {
alerta (this.name);
};
Desvantagens: Alguns atributos não podem ser compartilhados e compartilhá -los traz problemas, como: amigos. A maioria dos amigos de cada aluno não será a mesma.
Combinação de construtor e protótipo:
A cópia do código é a seguinte:
Função Student (nome, idade, amigos) {
this.name = nome;
this.age = idade;
this.friends = amigos;
}
Estudante.prototype = {
Construtor: aluno,
SayName: function () {
alerta (this.name);
}
};
Resumo: A combinação de construtores e protótipos é um método amplamente reconhecido para criar tipos personalizados. É também o melhor método entre os métodos acima.
/***********************************
De fato, já existem muitos métodos para criar objetos acima, mas ainda existem alguns cenários especiais que exigem otimização contínua.
Modo de protótipo dinâmico:
É uma otimização da combinação de construtores e protótipos. Para esses atributos e métodos comuns, se inicializado, não há necessidade de repetir a inicialização para melhorar a eficiência.
A cópia do código é a seguinte:
Função Student (nome, idade) {
this.name = nome;
this.age = idade;
if ((tipo de this.sayname)! = "function") {
Estudante.prototype.sayname = function () {
alerta (this.name);
}
}
}
var stu = nova pessoa ("Ming", 20);
// alerta (STU instância do aluno);
STU.SAYNAME ();
Var StunOw = New Pessoa ("Hong", 18);
// alert (exaustão de studentof de estudante);
stunhow.sayName ();
Quando vários objetos do aluno são criados, o método SayName é inicializado apenas uma vez.
Finalmente, existe outra maneira muito útil de criar objetos, que é construir com segurança as funções.
Padrão de construtor estável:
Isso e novos são proibidos nesse modo, e todos os objetos não têm atributos públicos. Somente o valor da variável é lido, mas não é modificado.
A cópia do código é a seguinte:
//// Modo de construtor Stafe
Função Student (nome, idade) {
var o = new Object ();
O.SayName = function () {
alerta (nome);
}
retornar o;
}
var stu = aluno ("Ming", 21);
STU.SAYNAME ();
O acima acima resume vários métodos JavaScript comuns para criar objetos personalizados, que são muito abrangentes. Se você tiver algum melhor, entre em contato comigo. Este artigo continua sendo atualizado.