Vorne schreiben
Heute möchte ich das Wissen über Knotentypen überprüfen und welche Art von Wissen ich zusammenfassen möchte. Ich habe einen Artikel bei Google gesehen, aber der ursprüngliche Link ist weg. Ich habe diesen Artikel im Schnappschuss herausgezogen. Wenn der ursprüngliche Autor Fragen hat, kontaktieren Sie mich bitte!
Dieser Artikel basiert auf einigen JS, und Experten überspringen ihn automatisch! Ich habe noch nicht viel über JS geschrieben, und dieser Aspekt ist relativ schwach, daher habe ich auch beim Schreiben von Knoten auf Probleme gestoßen. Hier ist eine Ergänzung meines Wissens!
Text
Die Grundlage von Node.js ist JavaScript, die Skriptsprache. Ein gemeinsames Merkmal der meisten Skriptsprachen ist "schwacher Typ".
Im Gegensatz zu PHP müssen sie auch dann nicht deklarieren, wenn es neue Variablen in PHP gibt, während JavaScript noch VAR benötigt, um sie zu deklarieren. Dieser VAR deckt alle Arten von Bedeutungen wie int, String, char usw. in C ++ und sogar Funktionen ab.
Alle Inhalte in diesem Artikel und im folgenden Artikel werden unter Verwendung von VIM unter Linux oder Cygwin bearbeitet (wenn nicht, konvertieren Sie ihn bitte in Ihre eigene Methode) und sehen Sie sich die Ergebnisse unter der Befehlszeile an.
Grundlegende Syntax
Variable Deklaration
In C/C ++ deklarieren wir solche Variablen:
`` `C ++
Die Codekopie lautet wie folgt:
void foo () {}
int a = 0;
char b = 'a';
float c = 1,0f;
void (*d) () = foo; /// <vergessen, ob das, was ich geschrieben habe, kurz gesagt, es ist ein Funktionszeiger
Und in node.js sieht es so aus:
`` `JavaScript
Die Codekopie lautet wie folgt:
Funktion foo () {}
var a = 0;
var b = 'a';
var c = 1,0;
var d = foo;
Unabhängig davon, welche Art von Variable es ist, wird es mit einem Var in Node.js. gelöst.
Schleifenerklärung
für… i
Diese Schleifenanweisung ist im Grunde genommen die gleiche wie C/C ++, beide
`` `C ++
Die Codekopie lautet wie folgt:
für (int i = 0; i <foo; i ++)
{
// ...
}
Und da Node.js ein schwacher Typ ist, brauchen Sie nur:
`` `JavaScript
Die Codekopie lautet wie folgt:
für (var i = 0; i <foo; i ++) {
// ...
}
für… in
Dies ist eine postförmige Schleifenanweisung, ähnlich wie bei PHPs foreach.
Zum Beispiel haben wir ein JSON -Objekt wie folgt:
JavaScript
Die Codekopie lautet wie folgt:
var foo = {
"Hallo": "Welt",
"Knoten": "JS",
"Blahblah": "Bar"
};
Zu diesem Zeitpunkt können wir verwenden, um ... in die Folge zu bringen:
JavaScript
Die Codekopie lautet wie folgt:
für (var key in foo) {
console.log (Schlüssel + ":" + foo [Schlüssel]);
}
Wenn wir den folgenden Befehl in die Befehlszeile eingeben:
Die Codekopie lautet wie folgt:
$ node foo.js
Der folgende Inhalt wird auf dem Bildschirm angezeigt:
Die Codekopie lautet wie folgt:
Hallo
: Welt
Knoten: JS
Blahblah: Bar
Tipp: Aus dem obigen Bereich wird die für ... in Anweisung verwendet, um die Schlüsselnamen von JSON-Objekten, Arrays und Objekten zu durchqueren, ohne den Schlüsselwert zu liefern. Wenn Sie den Schlüsselwert erhalten möchten, können Sie ihn nur in Form von Foo [<aktueller Schlüsselname>] erhalten. Dies unterscheidet sich immer noch etwas von PHP foreach.
Während ... tun, tun Sie ... Whill
Ich werde nicht so viel erklären, es ist kein großer Unterschied zu anderen Sprachen. Es ist nichts weiter als das, wenn es eine variable Deklaration gibt, es reicht aus, Var zu verwenden.
Betreiber
+, -, *, /
Dies ist bei diesen Betreibern der Fall, man sollte auf +achten. Es kann sowohl auf Zeichenfolgen als auch auf numerische Operationen wirken. Obwohl die Sprachen vom Typ schwacher Typ sagen, dass Typen schwach sind, können manchmal Zahlen in Form von Strings erscheinen, und Strings können manchmal in Form von numerischen Werten erscheinen, aber bei Bedarf müssen Sie immer noch darüber sprechen, welcher Typ es ist. Wir können den folgenden Code verwenden, um die Ergebnisse anzuzeigen:
Die Codekopie lautet wie folgt:
var a = "1";
var b = 2;
console.log (a + b);
console.log (parseInt (a) + b);
Hier ist ParseInt eine integrierte Funktion von node.js, mit der eine Zeichenfolge in eine Variable vom Typ int analysiert wird.
Das obige Codeausführungsergebnis ist:
Die Codekopie lautet wie folgt:
12
3
Hinweis: Das Ergebnis der ersten Konsole.log ist 12. Da a eine Zeichenfolge ist, wird B auch als Zeichenfolge vom System hinzugefügt. Das Ergebnis ist, dass die beiden Saiten zusammengeklebt sind und 12 werden. Das Ergebnis der zweiten Konsole ist 3, da wir den ersten A in den int -Typ umwandeln und zwei Variablen von intypen hinzufügen, dh Werte hinzuzufügen, und natürlich das Ergebnis 3.
==, ==,! =,! ==
Hier ist ein Punkt zu erklären, dass die Länge dieses logischen Operators 2 (==,! =) Beträgt, sondern nur bestimmt, ob der externe Wert der gleiche ist, den Typ jedoch nicht bestimmt. wie
Die Codekopie lautet wie folgt:
var a = 1, b = "1";
console.log (a == b);
Das Ergebnis seiner Ausgabe ist wahr. Wenn wir jedoch ein gleiches Zeichen hinzufügen, wenn wir in der Mitte Urteile fällen, werden wir ein striktes Urteil fällen. Es gilt nur dann, wenn der Typ und der Wert gleich sind, andernfalls ist er falsch. Das heißt
Die Codekopie lautet wie folgt:
var a = 1, b = "1";
console.log (a === b);
Wenn das Ergebnis zurückgegeben wird, ist dies falsch, da A vom Typ ist, während B eine Zeichenfolge ist.
Lassen Sie uns übrigens über die bedingte Aussage sprechen. Wenn hier nicht anders ist, ist es nur ein Problem von zwei gleichen Anzeichen und drei gleichen Zeichen für mehrere logische Operatoren. Ich werde also keine viel anstrengende Aussage geben.
Typof
Hier werde ich es eher als Operator als als Funktion betrachten.
Die Funktion dieses Operators besteht darin, die Art einer Variablen zu beurteilen und eine Zeichenfolge zurückzugeben, dh den Typnamen. Sie werden wissen, ob Sie den folgenden Code ausführen:
Die Codekopie lautet wie folgt:
Funktion foo () {}
var a = 0;
var b = 'shh ~ Eierblumensuppe schläft. ';
var c = 1,0;
var d = foo;
var e = {"a": a};
var f = [1, 2, 3];
var g = null;
var H = undefiniert;
console.log (typeof a);
console.log (typeof b);
console.log (typeof c);
console.log (typeof d);
console.log (typeof e);
console.log (typeof f);
console.log (typeof g);
console.log (typeof h);
Das Ausführungsergebnis hier wird:
Die Codekopie lautet wie folgt:
Nummer
Saite
Nummer
Funktion
Objekt
Objekt
Objekt
undefiniert
Null, undefiniert, Nan
In JavaScript gibt es drei spezielle Werte, wie im Titel gezeigt. Jeder kann mit dem ersten vertraut sein. Es gibt auch C/C ++, aber es wird aktiviert, und seine Essenz ist eins.
`` `C ++
Definieren Sie NULL 0
In JavaScript sind die Bedeutungen dieser drei Werte unterschiedlich.
### null ###
Null ist ein spezielles Objekt, was ungefähr leer bedeutet. Zum Beispiel:
var a = null;
Jeder kann es verstehen, also werde ich es nicht erklären. Aber im Gegensatz zu C/C ++ entspricht dieser Null nicht 0.
### undefined ###
Was dieses Ding bedeutet, ist, dass diese Variable nicht deklariert wird. Um NULL besser zu unterscheiden, lautet unser Beispielcode wie folgt:
`` `JavaScript
Die Codekopie lautet wie folgt:
var a = {
"Foo": Null
};
console.log (a ["foo"]);
console.log (a ["bar"]);
Im obigen Code machen wir den Wert eines ["foo"] leer, dh null. Und es wird überhaupt nicht deklariert, es ist nicht einmal leer. Jeder hätte die Ausgabeergebnisse erraten haben:
Die Codekopie lautet wie folgt:
NULL
undefiniert
Nan
Dies ist ein leerer Wert, eine Sonderzahl. Der vollständige Name ist keine Nummer. Es ist ein bisschen seltsam. Sie können es als eine Variablenvariable verstehen, die kein numerisches Formular oder eine Variable mit Fehlern ist.
Es tritt häufig bei Floating-Punkt-Numerikoperationsfehlern (z. B. durch Dividierung durch 0) auf, oder sogar der Benutzer kann eine Variable von NAN selbst entsprechen, um einen Fehlerwert zurückzugeben, damit jeder weiß, dass die Funktion einen Fehler im Betrieb hatte.
Kleines Verschiedenes
Die anderen verbleibenden Aussagen ähneln anderen vorhandenen Sprachen, wie z. B. Bruch, Schalter, Fortsetzung usw.
Variabler Typ
In diesem Abschnitt geht es hauptsächlich um JavaScript -Objekte, und andere Typen sind fast gleich.
Grundtyp
Die im Knoten enthaltenen Grundtypen sind fast wie folgt:
Nummer
Saite
boolean
Array
Die ersten drei Typen können direkt zugewiesen werden, und die Zuordnung von Array ist nur eine Referenzzuweisung. Wenn ein bestimmter Wert in einer neuen Variablen geändert wird, ändert sich auch der Wert der alten Variablen. Sie können den folgenden Code direkt ausprobieren:
JavaScript
var foo = [1, 2, 3];
var bar = foo;
Bar [0] = 3;
console.log (foo);
Es führt zu:
JavaScript
[3, 2, 3]
Mit anderen Worten, wenn ein Array in ein neues Array kopiert wird, kann es nicht verwendet werden, um Werte direkt zuzuweisen, sondern "tief kopiert" werden muss.
Hier müssen wir über die drei Möglichkeiten sprechen, um Array zu erstellen.
Der erste Typ:
JavaScript
Die Codekopie lautet wie folgt:
var hunde = new Array ();
Hund [0] = "Shh ~";
Hund [1] = "Eierblumensuppe";
Hund [2] = "Schlafen";
Der zweite Typ:
JavaScript
Die Codekopie lautet wie folgt:
var hund = new Array ("Shh ~", "Eierblumensuppe", "Schlafen");
Der vierte Typ:
JavaScript
Die Codekopie lautet wie folgt:
var hund = [
"Shh ~",
"Eierblumensuppe",
"Schlafen"
];
Ich persönlich bevorzuge die dritte Schreibweise, die relativ präzise ist.
JSON -Objekte
Hier nehme ich das JSON -Objekt getrennt heraus, anstatt es als JavaScript -Objekt zu klassifizieren. Wenn ich denke, ich bin ein wenig irreführend, kann ich diesen Abschnitt direkt überspringen.
Meine Unterscheidung zwischen JSON -Objekten und JavaScript -Objekten ist, ob sie nur zum Speichern von Daten und nicht zur Instanziierung einer Klasse verwendet werden. Tatsächlich ist die Essenz von JSON JavaScript -Objektnotation.
Weitere Informationen zu JSON erhalten Sie von Encyclopedia selbst.
Ein JSON -Objekt in node.js zu deklarieren ist sehr einfach:
JavaScript
Die Codekopie lautet wie folgt:
var hunde = {
"pre": "shh ~",
"sub": {
"Name": "Eierblumensuppe",
"Handlung": "Schlafen",
"Zeit": 12
},
"Suf": ["Ich sagte", "es schläft", "es schläft"]
};
Es gibt zwei Möglichkeiten, den Schlüsselwert eines bestimmten Schlüsselnamens in einem JSON -Objekt zu erhalten. Das erste besteht darin, es mit Punkten zu verbinden, und das zweite besteht darin, Klammern zu verwenden:
JavaScript
Die Codekopie lautet wie folgt:
Hund
.Pre;
Hund ["pre"];
HINWEIS: Wenn Sie Punkte oben verwenden, wird der Schlüssel in JSON direkt befolgt. Wenn Sie den Schlüssel als Variable behandeln, können Sie ihn nur mit Hund [Key] versuchen: Jetzt können Sie es selbst ausprobieren und verwenden, um das jSON -Objekt oben zu durchqueren. Vergessen Sie nicht, Typen zu verwenden ~
Die Grundlage einer Klasse (Objekt)
Streng genommen kann die Klasse von Node.js nicht als Klasse angesehen werden. Tatsächlich handelt es sich nur um eine Sammlung von Funktionen, die einige Mitgliedervariablen hinzufügen. Seine Essenz ist eigentlich eine Funktion.
Aus gesunder Menschenverstand nennen wir es jedoch als "Klasse" als nächstes und später, und der sofortige heißt "Objekt".
Da eine Klasse viele Funktionen hat oder ihre Essenz eine Funktion ist, können wir über die Grundlagen der Funktion sprechen, wenn wir nicht vorsichtig sind.
Erklärung und Instanziierung von Klassen
Eine Klasse zu erklären ist sehr einfach, nicht lachen:
JavaScript
Funktion foo () {
// ...
}
Ok, wir haben eine Foo -Klasse geschrieben.
Wahr oder falsch? ! real.
Glauben Sie es nicht? Wenn Sie es nicht glauben, können Sie einen Code eingeben und lesen:
JavaScript
var bar = new foo ();
Betrachten Sie es nicht als Funktion, wenn es in einer solchen Form (neu) geschrieben ist, ist es eine Instanziierung dieser Klasse.
Und dieser sogenannte Foo () ist eigentlich der Konstruktor dieser Foo () -Klasse.
Mitgliedsvariablen
Es gibt zwei gute Möglichkeiten, Mitgliedervariablen zu erhalten.
Das erste besteht darin, dies zu verwenden. Sie können jederzeit eine Mitgliedsvariable deklarieren und die Verwendung außerhalb des Gebrauchs nicht beeinträchtigt. Selbst wenn Sie es verwenden, wenn es nicht deklariert wird, wird es eine undefinierte Unterstützung geben, um es zu unterstützen. Dies ist also die erste Methode:
Die Codekopie lautet wie folgt:
JavaScript
Funktion foo () {
this.hello = "World";
}
Hinweis: Dies ist die Mitgliedsvariable der aufrufenden Klasse nur dann, wenn dies hinzugefügt wird. Andernfalls handelt es sich nur um eine lokale Variable in der Funktion. Es ist notwendig zu unterscheiden, ob es den Aktionsbereich dieser Variablen gibt.
Die zweite Methode besteht darin, es außerhalb des Konstruktors oder einer beliebigen Mitgliedsfunktion zu deklarieren. Das Format ist <klassenname> .Prototype. <Variable Name>:
JavaScript
Die Codekopie lautet wie folgt:
Funktion foo () {
// ...
}
foo.prototype.hello = "World";
Unabhängig davon, welche der oben genannten Methoden eine Erklärung von Mitgliedervariablen sind, können wir den Effekt sehen:
JavaScript
Die Codekopie lautet wie folgt:
var bar = new foo ();
console.log (bar.hello);
Sie können diese Klasse sogar so ändern:
JavaScript
Die Codekopie lautet wie folgt:
Funktion foo () {
this.hello = "World";
}
foo.prototype.hello = "Eierblumensuppe";
Verwenden Sie dann den obigen Code, um ihn auszugeben.
Denken Sie darüber nach, warum die Ausgabe Welt anstelle von Eiersuppe ist.
Konstruktor
Wir haben schon gesagt, dass Foo () tatsächlich ein Konstruktor ist. Dann können wir natürlich Parameter an den Konstruktor übergeben, sodass wir den folgenden Code haben:
JavaScript
Die Codekopie lautet wie folgt:
// Code 2.1
Funktion foo (Hallo) {
if (Hallo === undefiniert) {
this.hello = "World";
} anders {
this.hello = Hallo;
}
}
Wir sehen ein seltsames Urteil darüber, wenn (Hallo === undefiniert). Was nutzt dieses Urteil? Die erste Möglichkeit besteht darin, dass der Entwickler speziell einen undefinierten Schmerz verschickt hat. Zu diesem Zeitpunkt ist es undefiniert.
Es gibt eine andere Situation. Wir sagten von Anfang an, dass JavaScript eine schwache Sprache ist. Tatsächlich ist es nicht nur ein schwacher Typ, sondern seine Übertragungsparameter sind auch sehr unordentlich. Sie können mehr oder weniger bestehen (solange Sie sicherstellen, dass das Programm keine Fehler macht, wenn Sie mehr oder weniger bestehen), ist es grundsätzlich in Ordnung. Die Parameter mehrerer Durchgänge werden automatisch ignoriert, während die Parameter von wenigen Durchgängen mit undefiniertem Ergänzung ergänzt werden.
Schauen Sie sich einfach den folgenden Code an und Sie werden verstehen:
JavaScript
Die Codekopie lautet wie folgt:
// Code 2.1 anschließen
var bar1 = new foo ();
var bar2 = neu foo ("Eierblumensuppe");
Bitte geben Sie zwei Bar -Hallo -Variablen selbst aus, und Sie werden feststellen, dass eine Welt und der andere Eiersuppe ist. Als unser erster Bar1 erklärt wurde, wurde er natürlich automatisch von Node.js angesehen:
JavaScript
Die Codekopie lautet wie folgt:
var bar1 = new foo (undefiniert);
Es gibt also ein Sprichwort, dass es Welt ist.
Auch in diesem Konstruktor sehen wir, dass der in diese Klasse übergebene Parameter in dieser Klasse eine Mitgliedsvariable gibt. Wir haben jedoch zuvor gesagt, dass der Umfang anders ist, wenn dies vorhanden ist, und dies nicht der Fall ist. Dieser Parameter wird nur im Konstruktor verwendet, während derjenige damit eine Mitgliedsvariable ist. Verwenden Sie dies, um sie sofort zu unterscheiden, daher spielt es keine Rolle, auch wenn der gleiche Name ist.
Mitgliedsfunktionen
Mitgliedsfunktionserklärung
Die Deklaration einer Mitgliedsfunktion ähnelt der zweiten Deklarationsmethode einer Mitgliedsvariablen, dh <Klassenname> .Prototyp. <Funktion Name> = <funktion>;
JavaScript
Die Codekopie lautet wie folgt:
// Code 2.1 anschließen
Funktion Sethello (Hallo) {
this.hello = Hallo;
}
foo.prototype.sethello = sethello;
bar1.sethello ("Eierkuchen");
Da der obige Code offensichtlich ist, implementieren wir die Sethello -Funktion der FOO -Klasse, durch die wir den Wert von Foo.hello ändern können.
Aber ist es nicht ein bisschen problematisch, so zu schreiben? Als nächstes werde ich über ein wichtiges Merkmal von JavaScript -Funktionen sprechen.
★ Anonyme Funktionen ★
Oft werden einige unserer Funktionen nur an einem Ort verwiesen oder aufgerufen, daher ist es zu lohnenswert, dieser Funktion einen Namen zu geben, und es gibt keine Notwendigkeit, sodass wir diese Funktion vorübergehend schreiben und die Person, die sie verweist, und die Person, die sie anruft, um sie anzurufen, zu fragen. Daher kann die Funktion den Funktionsnamen weglassen, z. B.:
JavaScript
Die Codekopie lautet wie folgt:
Funktion (Hallo) {
this.hello = Hallo;
}
Wie zitiere oder nenne ich es? Wenn die obige Klasse zitiert werden muss, ist sie so geschrieben:
JavaScript
Die Codekopie lautet wie folgt:
foo.prototype.sethello = function (Hallo) {
this.hello = Hallo;
}
Diese Schreibmethode entspricht der Elementfunktionserklärung und spart viel Code. Im Grunde genommen wird die Erklärung der Klassenmitglied -Funktionen in dieser Art von anonymen Funktionen deklariert.
Wie können anonyme Funktionen angerufen werden? Dies wird normalerweise so geschrieben, wenn Sie eine Funktion übergeben, die nur durch eine bestimmte Funktion bezeichnet wird.
Zum Beispiel haben wir einen Prototyp einer Funktion:
JavaScript
Die Codekopie lautet wie folgt:
/**
* Wir werden zwei Variablen A und B übergeben,
* Geben Sie ihn nach der Berechnung des Wertes von A+B an func (num) übergeben
* Gehen Sie zur Ausgabe
*/
Funktion Sumab (a, b, func) {
var c = a + b;
func (a, b, c);
}
Zum Beispiel haben wir zwei Versionen von Ausgangsfunktionen, einer ist chinesischer Ausgabe und der andere ist die englische Ausgabe. Wenn wir also keine anonymen Funktionen verwenden:
JavaScript
Die Codekopie lautet wie folgt:
Funktion zh (a, b, sum) {
Der Wert von console.log (a + " +" + b + "ist:" + sum);
}
Funktion en (a, b, sum) {
console.log (a + "plus" + b + "ist" + sum);
}
Sumab (1, 2, Zh);
Sumab (3, 4, en);
Führen Sie diesen Code einmal aus, und die Ausgabe wird lautet:
Der Wert von 1 + 2 lautet: 3
3 plus 4 ist 7
Wenn ein solcher Code in Form von anonymen Funktionen ist, wird er:
JavaScript
Die Codekopie lautet wie folgt:
Sumab (1, 2, Funktion (a, b, sum) {
Der Wert von console.log (a + " +" + b + "ist:" + sum);
});
Sumab (3, 4, Funktion (a, b, sum) {
console.log (a + "plus" + b + "ist" + sum);
});
Dieses Formular wird normalerweise in Rückruffunktionen verwendet. Der Rückrufmechanismus ist die Essenz von Node.js oder JavaScript. Ich werde es in zukünftigen Kapiteln vorstellen.
So deklarieren Sie die anonyme Funktion in der Mitgliederfunktionserklärung
Obwohl ich im vorherigen Abschnitt darüber gesprochen habe, werde ich einfach wieder darüber sprechen.
Wenn wir eine Klassenmitgliedfunktion deklarieren, verwenden wir normalerweise anonyme Funktionen, um sie zu deklarieren, da diese Funktion auf jeden Fall nur eine Mitgliedsfunktion dieser Klasse ist und nicht an anderen Stellen separat aufgerufen wird, sodass der folgende Code verfügbar ist:
JavaScript
Die Codekopie lautet wie folgt:
// Code 2.1 anschließen
foo.prototype.sethello = function (Hallo) {
this.hello = Hallo;
}
Auf diese Weise haben wir die Funktion Sethello in der Foo -Klasse.
2.3.4. Klasse willkürlich
Das ist wieder mein Unsinn. Die sogenannte Zufälligkeit von Klassen bedeutet, dass Sie in JavaScript Ihre Klasse überall ändern können, was bestimmte Ähnlichkeiten mit Ruby aufweist.
Zum Beispiel ist String tatsächlich eine Klasse mit Mitgliedsvariablen wie Länge und Mitgliedsfunktionen wie Indexof und Substr. Wenn wir jedoch der Meinung sind, dass einige Teile dieser Zeichenfolge nicht perfekt sind und unsere eigene Methode hinzufügen möchten, können wir eine Funktion hinzufügen, wo Sie möchten, z. B.:
JavaScript
Die Codekopie lautet wie folgt:
String.prototype.sb = function () {
var newsstr = "";
für (var i = 0; i <this.Length; i ++) {
if (i % 2 === 0) Newsr += "S";
sonst Newsr += "B";
}
return Newsr;
};
Die Bedeutung dieser Funktion besteht darin, eine Zeichenfolge zu füllen, um sie in die Inkarnation von SB zu schaffen.
Testen wir es:
Die Codekopie lautet wie folgt:
var str = "Shh ~ Eierblumensuppe schläft.";
console.log (str.sb ());
Sie erhalten das folgende Ergebnis:
SBSBSBSBSBSBSBS
Wenn Sie sagen "shhh ~ Eierblumensuppe schläft." Ihr Computer schimpft Sie, weil Sie viereinhalb Mal ein Narr sind. (Zerschmettere es schnell)
3.. Angehängt
3.1. Tiefe Kopie
Die sogenannte tiefe Kopie besteht darin, selbst ein neues Array oder ein neues Objekt zu erstellen und die Grundwerte der Grundtypvariablen im Quellarray oder im Objekt eins nach dem anderen manuell zu kopieren, anstatt nur die Verweise auf das Quellarray oder das Objekt zu übernehmen. Dies beinhaltet also einen rekursiven Anruf oder so.
Unten ist eine tiefe Kopiefunktion, die ich implementiert habe. Sie können eine eigene schreiben und zu Ihrer eigenen Wissensbasis von Node.js hinzufügen.
JavaScript
Die Codekopie lautet wie folgt:
Funktion CloneObject (SRC) {
var dest = {};
für (var key in src) {
if (typeof src === "Objekt") dest [taste] = cloneObject (SRC [Schlüssel]);
sonst dest [key] = src [Schlüssel];
}
Rückkehrend;
}