introducir
Este artículo presenta principalmente el patrón de creación de objetos. El uso de varias técnicas puede evitar enormemente errores o escribir un código muy optimizado.
Patrón 1: espacio de nombres
Los espacios de nombres pueden reducir la cantidad de denominación global requerida para evitar conflictos de nombres o exceso. En general, cuando definimos el nivel de objeto, a menudo se ve así:
La copia del código es la siguiente:
VAR APP = APP || {};
app.modulea = app.modulea || {};
app.modulea.submodule = app.modulea.submodule || {};
app.modulea.submodule.methoda = function () {
console.log ("imprimir a");
};
app.modulea.submodule.methodb = function () {
console.log ("Imprimir B");
};
Si hay muchos niveles, debemos continuar así, lo cual es muy confuso. El patrón del espacio de nombres existe para resolver este problema. Veamos el código:
La copia del código es la siguiente:
// inseguro, puede sobrescribir los objetos myApp existentes
var myApp = {};
// bien
if (typeof myApp === "Undefinado") {
var myApp = {};
}
// de una manera más simple
var myApp = myApp || {};
// Definir métodos comunes
Myapp.namespace = function (ns_string) {
var partes = ns_string.split ('.'),
Padre = MyApp,
i;
// Por defecto, si el primer nodo es MyApp, se ignorará, como myapp.modulea
if (partes [0] === "myApp") {
Parts = Parts.lice (1);
}
para (i = 0; i <parts.length; i += 1) {
// Si la propiedad no existe, cree
if (typeof parent [piezas [i]] === "Undefined") {
parent [partes [i]] = {};
}
parent = parent [piezas [i]];
}
regresar padre;
};
Llamar al código es muy simple:
La copia del código es la siguiente:
// Después del espacio de nombres, el valor de retorno se puede asignar a una variable local
var módulo2 = myapp.namespace ('myapp.modules.module2');
console.log (módulo2 === myapp.modules.module2); // verdadero
// omita myapp
MyApp.namespace ('módulo.module51');
// Nombre muy largo
Myapp.namespace ('una vez.upon.a.time.there.was.this.long.nested.property');
Patrón 2: Definición de dependencias
A veces, un módulo o función puede referirse a algunos módulos o herramientas de terceros. Es mejor definir estos módulos dependientes al principio para que puedan ser reemplazados fácilmente en el futuro.
La copia del código es la siguiente:
var myFunction = function () {
// Depender de los módulos
VAR Event = yahoo.util.event,
dom = yahoo.util.dom;
// El evento de variables locales y DOM se usan en el código después de otras funciones
};
Patrón 3: Propiedades privadas y métodos privados
JavaScript no proporciona una sintaxis específica para admitir propiedades privadas y métodos privados, pero podemos implementarla a través de cierres, el código es el siguiente:
La copia del código es la siguiente:
function gadget () {
// objeto privado
var name = 'iPod';
// Funciones públicas
this.getName = function () {
nombre de retorno;
};
}
var juguete = nuevo gadget ();
// El nombre está indefinido y es privado
console.log (toy.name); // indefinido
// Nombre de acceso de método público
console.log (toy.getName ()); // "iPod"
var myobj; // Asignar valores a myobj a través de la función de auto-ejecución
(función () {
// objeto gratis
var name = "my, oh my";
// Implementar la parte pública, por lo que no hay var
myobj = {
// Método de autorización
getName: function () {
nombre de retorno;
}
};
} ());
Modo 4: Modo de revelación
También se trata de ocultar métodos privados, que es algo similar al patrón del módulo en "comprensión profunda de la serie JavaScript (3): análisis integral de patrones de módulos", pero no es un método de retorno, pero una variable se declara externamente y luego se asigna métodos públicos a la variable internamente. El código es el siguiente:
La copia del código es la siguiente:
var myArray;
(función () {
var astr = "[matriz de objetos]",
toString = object.prototype.ToString;
función isarray (a) {
return toString.call (a) === Astr;
}
función indexOf (Haystack, aguja) {
var i = 0,
max = Haystack.length;
para (; i <max; i += 1) {
if (Haystack [i] === aguja) {
regresar i;
}
}
regreso -1;
}
// a través de la asignación, todos los detalles anteriores están ocultos
myArray = {
isarray: isarray,
indexOf: índice de,
Inarray: índice
};
} ());
// Código de prueba
console.log (myArray.IsArray ([1, 2])); // verdadero
console.log (myArray.IsArray ({0: 1})); // FALSO
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 cadena
El modo de cadena le permite llamar continuamente un método de objeto, como obj.add (1) .remove (2) .delete (4) .add (2). La idea de implementación es muy simple, que es devolver esto tal como es. El código es el siguiente:
La copia del código es la siguiente:
var obj = {
Valor: 1,
increment: function () {
this.Value += 1;
devolver esto;
},
Agregar: función (v) {
this.Value += V;
devolver esto;
},
gritar: function () {
console.log (this.Value);
}
};
// Llamada del método de cadena
obj.Increment (). ADD (3) .Shout (); // 5
// también se puede llamar uno por uno
obj.increment ();
obj.add (3);
obj.Shout ();
Resumir
Este artículo es el artículo anterior del modo de creación de objetos, así que estad atentos para el próximo artículo mañana.