einführen
In diesem Artikel wird hauptsächlich das Muster des Erstellens von Objekten vorgestellt. Die Verwendung verschiedener Techniken kann Fehler erheblich vermeiden oder einen sehr optimierten Code schreiben.
Muster 1: Namespace
Namespaces kann die Menge der globalen Benennung verringern, die erforderlich ist, um Konflikte oder Exzesslichkeit zu vermeiden. Wenn wir die Objektebene definieren, sieht es im Allgemeinen oft so aus:
Die Codekopie lautet wie folgt:
var App = App || {};
app.modulea = app.modulea || {};
app.modulea.submodule = app.modulea.submodule || {};
app.modulea.submodule.methoda = function () {
console.log ("drucken a");
};
app.modulea.submodule.methodb = function () {
console.log ("print b");
};
Wenn es viele Ebenen gibt, müssen wir so weitermachen, was sehr verwirrend ist. Das Namespace -Muster existiert, um dieses Problem zu lösen. Schauen wir uns den Code an:
Die Codekopie lautet wie folgt:
// Unsicher, es kann vorhandene MyApp -Objekte überschreiben
var myApp = {};
// Bußgeld
if (typeof myApp === "undefined") {
var myApp = {};
}
// Ein einfacherer Weg
var myapp = myapp || {};
// gemeinsame Methoden definieren
Myapp.namespace = function (ns_string) {
var parts = ns_string.split ('.'),
Eltern = MyApp,
ich;
// Standardmäßig wird der erste Knoten MyApp ignoriert, wie z. B. MyApp.modulea
if (Teile [0] === "MyApp") {
Teile = Teils.Slice (1);
}
für (i = 0; i <parts.length; i += 1) {
// Wenn die Eigenschaft nicht existiert, erstellen Sie
if (typeof übergeordnet [Teile [i]] === "undefined") {
Eltern [Teile [i]] = {};
}
Eltern = Eltern [Teile [i]];
}
Eltern zurückgeben;
};
Das Aufrufen des Codes ist sehr einfach:
Die Codekopie lautet wie folgt:
// Nach dem Namespace kann der Rückgabewert einer lokalen Variablen zugewiesen werden
var modul2 = myapp.namespace ('myapp.modules.module2');
console.log (modul2 === myapp.modules.module2); // WAHR
// MyApp überspringen
Myapp.namespace ('modules.module51');
// sehr langer Name
MyApp.NameSpace ('aAs.upon.a.time.there.was.this.long.Nested.Property');
Muster 2: Abhängigkeiten definieren
Manchmal kann sich ein Modul oder eine Funktion auf einige Module oder Werkzeuge von Drittanbietern beziehen. Es ist am besten, diese abhängigen Module am Anfang zu definieren, damit sie in Zukunft leicht ersetzt werden können.
Die Codekopie lautet wie folgt:
var myfunction = function () {
// Abhängig von Modulen
var event = yahoo.util.event,
Dom = yahoo.util.dom;
// Die lokalen Variablenereignisse und DOM werden nach anderen Funktionen im Code verwendet
};
Muster 3: Private Eigenschaften und private Methoden
JavaScript bietet keine spezifische Syntax zur Unterstützung privater Eigenschaften und privater Methoden. Wir können sie jedoch durch Schließungen implementieren. Der Code lautet wie folgt:
Die Codekopie lautet wie folgt:
Funktion gadget () {
// privates Objekt
var name = 'iPod';
// öffentliche Funktionen
this.getName = function () {
Rückgabename;
};
}
var toy = new gadget ();
// Name ist undefiniert und privat
console.log (toy.name); // undefiniert
// Name der öffentlichen Methode Zugriffsname
console.log (toy.getName ()); // "iPod"
var myobj; // MyObj Werte durch Selbstversorgungsfunktion zuweisen
(function () {
// freies Objekt
var name = "mein, oh mein";
// Implementieren Sie den öffentlichen Teil, daher gibt es keinen VAR
myobj = {
// Autorisierungsmethode
GetName: function () {
Rückgabename;
}
};
} ());
Modus 4: Offenbarungsmodus
Es geht auch darum, private Methoden zu verbergen, was dem Modulmuster in "eingehender Verständnis der JavaScript-Serie (3) etwas ähnlich ist: umfassende Analyse der Modulmuster", aber es handelt sich nicht um eine Rückkehrmethode, aber eine Variable wird extern deklariert und dann der Variablen in interner öffentlicher Methoden zugewiesen. Der Code ist wie folgt:
Die Codekopie lautet wie folgt:
var myarray;
(function () {
var astr = "[Objektarray]",
toString = Object.Prototype.toString;
Funktion isArray (a) {
return tostring.call (a) === astr;
}
Funktion Indexof (Haystack, Nadel) {
var i = 0,
max = haystack.length;
für (; i <max; i += 1) {
if (haystack [i] === nadel) {
kehre I zurück;
}
}
Return -1;
}
// Durch die Zuweisung sind alle oben genannten Details versteckt
myarray = {
Isarray: Isarray,
INDEXOF: INDEXOF,
InArray: Indexof
};
} ());
// Testcode
console.log (myarray.isArray ([1, 2])); // WAHR
console.log (myarray.isArray ({0: 1})); // FALSCH
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
Modus 5: Kettenmodus
Mit dem Kettenmodus können Sie eine Objektmethode kontinuierlich aufrufen, z. B. obj.add (1) .Remove (2) .Delete (4) .Add (2). Die Implementierungsidee ist sehr einfach, nämlich so, wie sie ist. Der Code ist wie folgt:
Die Codekopie lautet wie folgt:
var obj = {
Wert: 1,
Inkrement: function () {
this.Value += 1;
gib dies zurück;
},
Hinzufügen: Funktion (v) {
this.Value += v;
gib dies zurück;
},
Shout: function () {
console.log (this.value);
}
};
// Kettenmethode -Aufruf
obj.increment (). add (3) .hout (); // 5
// kann auch eins nach dem anderen bezeichnet werden
obj.increment ();
obj.add (3);
Obj.Shout ();
Zusammenfassen
Dieser Artikel ist der vorherige Artikel des Objekterstellungsmodus. Bleiben Sie also morgen für den nächsten Artikel.