introduzir
Este artigo apresenta principalmente o padrão de criação de objetos. O uso de várias técnicas pode evitar erros ou escrever um código muito simplificado.
Padrão 1: espaço para nome
Os namespaces podem reduzir a quantidade de nomeação global necessária para evitar nomeação de conflitos ou excesso. Geralmente, quando definimos o nível do objeto, geralmente se parece com o seguinte:
A cópia do código é a seguinte:
var app = app || {};
App.modulea = App.modulea || {};
App.modulea.submodule = App.modulea.submodule || {};
App.modulea.submodule.methoda = function () {
console.log ("Print a");
};
App.modulea.submodule.methodb = function () {
console.log ("print b");
};
Se houver muitos níveis, devemos continuar assim, o que é muito confuso. O padrão de namespace existe para resolver esse problema. Vejamos o código:
A cópia do código é a seguinte:
// inseguro, pode substituir os objetos MyApp existentes
var myApp = {};
// multar
if (typeof myApp === "indefinido") {
var myApp = {};
}
// de uma maneira mais simples
var myApp = myApp || {};
// define métodos comuns
MyApp.namespace = function (ns_string) {
var peças = ns_string.split ('.'),
pai = myApp,
eu;
// Por padrão, se o primeiro nó for MyApp, ele será ignorado, como MyApp.modulea
if (partes [0] === "myApp") {
partes = partes.slice (1);
}
for (i = 0; i <partes.Length; i += 1) {
// Se a propriedade não existir, crie
if (typeof pai [partes [i]] === "indefinido") {
pai [partes [i]] = {};
}
pai = pai [partes [i]];
}
devolver pai;
};
Chamar o código é muito simples:
A cópia do código é a seguinte:
// Após o namespace, o valor de retorno pode ser atribuído a uma variável local
var módulo2 = myApp.namespace ('myapp.modules.module2');
console.log (módulo2 === myApp.modules.module2); // verdadeiro
// Pule MyApp
MyApp.namespace ('modules.module51');
// Nome muito longo
MyApp.namespace ('Once.upon.a.time.there.was.this.long.nested.property');
Padrão 2: Definindo dependências
Às vezes, um módulo ou função pode se referir a alguns módulos ou ferramentas de terceiros. É melhor definir esses módulos dependentes no início, para que possam ser facilmente substituídos no futuro.
A cópia do código é a seguinte:
var myfunction = function () {
// depende de módulos
var evento = yahoo.util.event,
dom = yahoo.util.dom;
// O evento de variáveis locais e o DOM são usados no código após outras funções
};
Padrão 3: Propriedades privadas e métodos privados
O JavaScript não fornece sintaxe específica para apoiar propriedades privadas e métodos privados, mas podemos implementá -lo por meio de fechamentos, o código é o seguinte:
A cópia do código é a seguinte:
função gadget () {
// objeto privado
var name = 'ipod';
// Funções públicas
this.getName = function () {
Nome de retorno;
};
}
var briny = new gadget ();
// nome é indefinido e é privado
console.log (Toy.name); // indefinido
// Nome de acesso ao método público
console.log (Toy.getName ()); // "ipod"
var myobj; // atribui valores ao myobj através da função auto-executiva
(function () {
// objeto livre
var name = "meu, oh meu";
// implementa a parte pública, então não há VAR
myobj = {
// Método de autorização
getName: function () {
Nome de retorno;
}
};
} ());
Modo 4: Modo de Apocalipse
Trata-se também de ocultar métodos privados, que é um pouco semelhante ao padrão do módulo em "entendimento profundo da série JavaScript (3): análise abrangente dos padrões de módulos", mas não é um método de retorno, mas uma variável é declarada externamente e depois atribuída métodos públicos à variável internamente. O código é o seguinte:
A cópia do código é a seguinte:
var myarray;
(function () {
var Astr = "[Array do objeto]",
tostring = object.prototype.toString;
função isarray (a) {
return tostring.call (a) === Astr;
}
função indexOf (Haystack, agulha) {
var i = 0,
max = haystack.length;
para (; i <max; i += 1) {
if (haystack [i] === agulha) {
retornar i;
}
}
retornar -1;
}
// Através da tarefa, todos os detalhes acima estão ocultos
MyArray = {
Isarray: Isarray,
indexOf: indexof,
INARRAY: IndexOf
};
} ());
// Código de teste
console.log (myarray.isarray ([1, 2])); // verdadeiro
console.log (myarray.isarray ({0: 1})); // false
console.log (myarray.indexOF (["a", "b", "z"], "z")); // 2
console.log (MyArray.inArray (["A", "B", "Z"], "Z")); // 2
myArray.indexOF = null;
console.log (MyArray.inArray (["A", "B", "Z"], "Z")); // 2
Modo 5: Modo de corrente
O modo de corrente permite chamar um método de objeto continuamente, como obj.add (1) .remove (2) .Delete (4) .Add (2). A ideia de implementação é muito simples, que é devolver isso como é. O código é o seguinte:
A cópia do código é a seguinte:
var obj = {
Valor: 1,
incremento: function () {
this.value += 1;
devolver isso;
},
Add: function (v) {
this.value += v;
devolver isso;
},
grito: function () {
console.log (this.value);
}
};
// Chamada de método de cadeia
obj.increment (). add (3) .shout (); // 5
// também pode ser chamado um por um
obj.Increment ();
obj.add (3);
obj.shout ();
Resumir
Este artigo é o artigo anterior do modo de criação de objetos, portanto, fique atento ao próximo artigo amanhã.