NodeJs grundlegende Syntax undtypes_node.js

steht vor

Heute möchte ich das Wissen über den Knotentyp überprüfen. Ich habe einen Artikel auf Googol gesehen, aber der ursprüngliche Link ist nicht mehr im Snapshot Wenn Sie Fragen haben, kontaktieren Sie mich bitte!

In diesem Artikel geht es um die Grundlagen von JS, Experten werden ihn automatisch überspringen! Ich habe noch nicht viel über js geschrieben und bin in diesem Bereich relativ schwach, daher bin ich beim Schreiben von Knoten auch auf Probleme gestoßen. Ich werde hier etwas Wissen hinzufügen!

Text

Node.js basiert auf der Skriptsprache JavaScript. Ein gemeinsames Merkmal der meisten Skriptsprachen ist die „schwache Typisierung“.

Anders als PHP muss PHP keine neue Variable deklarieren, selbst wenn es eine neue Variable hat, während JavaScript immer noch var benötigt, um sie zu deklarieren. Und diese Variable deckt die Bedeutung aller Typen wie int, string, char usw. in C ab, sogar Funktionen.

Der gesamte Inhalt dieses und der folgenden Artikel wird mit vim unter Linux oder Cygwin bearbeitet (falls nicht, konvertieren Sie ihn bitte in Ihre eigene Methode) und sehen Sie sich die Ergebnisse dann in der Befehlszeile an.

Grundlegende Grammatik

Variablendeklaration

In C/C deklarieren wir Variablen wie folgt:

```C

Code kopieren Der Code lautet wie folgt:

void foo() {}
int a = 0;
char b = 'a';
float c = 1.0f;
void (*d)() = foo; ///< Ich habe vergessen, ob es so geschrieben wurde, aber es ist ein Funktionszeiger

Und in Node.js sieht es so aus:
„Javascript

Code kopieren Der Code lautet wie folgt:

Funktion foo() {}
var a = 0;
var b = 'a';
var c = 1,0;
var d = foo;

Egal, um welche Art von Variable es sich handelt, sie wird mit einer Variablen in Node.js gelöst.

Schleifenanweisung

für…ich

Diese Schleifenanweisung ist im Grunde die gleiche wie C/C, beide sind

```C

Code kopieren Der Code lautet wie folgt:

for(int i = 0; i < foo; i )
{
//...
}

Da Node.js schwach typisiert ist, benötigen Sie nur:
„Javascript

Code kopieren Der Code lautet wie folgt:

for(var i = 0; i < foo; i ) {
//...
}
für…in

Dies ist eine posttypisierte Schleifenanweisung, ähnlich der foreach von PHP.

Zum Beispiel haben wir ein JSON-Objekt wie folgt:

Javascript

Code kopieren Der Code lautet wie folgt:

var foo = {
„Hallo“: „Welt“,
„node“: „js“,
„blahblah“ : „bar“
};

Zu diesem Zeitpunkt können wir for...in verwenden, um Folgendes zu durchlaufen:

Javascript

Code kopieren Der Code lautet wie folgt:

for(var key in foo) {
console.log(key ": " foo[key]);
}

Wenn wir den folgenden Befehl in der Befehlszeile eingeben:

Code kopieren Der Code lautet wie folgt:

$ node foo.js

Der folgende Inhalt wird auf dem Bildschirm angezeigt:

Code kopieren Der Code lautet wie folgt:

Hallo
: Welt
Knoten: js
blabla: bar

Tipps: Wie Sie oben sehen können, wird die for...in-Anweisung zum Durchlaufen der Schlüsselnamen von JSON-Objekten, Arrays und Objekten verwendet, bietet jedoch keine Durchquerung von Schlüsselwerten. Wenn Sie den Schlüsselwert erhalten möchten, können Sie ihn nur in der Form foo[] erhalten. Dies unterscheidet sich etwas von PHPs foreach.

while...do, do...whill

Ich werde das nicht viel erklären. Es unterscheidet sich nicht wesentlich von anderen Sprachen. Wenn es eine Variablendeklaration gibt, müssen Sie lediglich var verwenden.

Betreiber

, -, *, /

Das ist es, worauf Sie bei diesen Betreibern achten müssen. Es kann sowohl mit Zeichenfolgen als auch mit numerischen Operationen arbeiten. Obwohl schwach typisierte Sprachen angeben, dass der Typ schwach ist, können Zahlen manchmal in Form von Zeichenfolgen und Zeichenfolgen manchmal in Form von numerischen Werten angezeigt werden. Bei Bedarf müssen wir jedoch immer noch angeben, um welchen Typ es sich handelt. Wir können den folgenden Code verwenden, um das Ergebnis zu sehen:

Code kopieren Der Code lautet wie folgt:

var a = "1";
var b = 2;
console.log(a b);
console.log(parseInt(a) b);

ParseInt ist hier eine integrierte Funktion von Node.js, die zum Parsen eines Strings in eine Variable vom Typ int verwendet wird.

Das Ausführungsergebnis des obigen Codes ist:

Code kopieren Der Code lautet wie folgt:

12
3

Hinweis: Das erste console.log-Ergebnis ist 12. Da a eine Zeichenfolge ist, wird b auch vom System als Zeichenfolge hinzugefügt. Das Ergebnis ist, dass die beiden Zeichenfolgen zusammengeklebt werden und 12 werden. Das zweite console.log-Ergebnis ist 3, da wir das erste a in den Typ int konvertiert haben. Die Addition von zwei Variablen vom Typ int ist natürlich 3.

==, ===, !=, !==

Eine Sache, die hier erklärt werden muss, ist, dass bei einer Länge dieses logischen Operators von 2 (==, !=) nur bestimmt wird, ob die externen Werte gleich sind, nicht jedoch der Typ. Wie zum Beispiel

Code kopieren Der Code lautet wie folgt:

var a = 1, b = "1";
console.log(a == b);

Das ausgegebene Ergebnis ist wahr. Wenn wir jedoch in der Mitte des Urteils ein Gleichheitszeichen hinzufügen, ist es ein strenges Urteil. Nur wenn Typ und Wert gleich sind, ist es wahr, andernfalls ist es falsch. Das heißt

Code kopieren Der Code lautet wie folgt:

var a = 1, b = "1";
console.log(a === b);

, das zurückgegebene Ergebnis ist falsch, da a vom Typ int und b eine Zeichenfolge ist.

Lassen Sie uns übrigens über bedingte Anweisungen sprechen. Hier handelt es sich tatsächlich nicht um mehrere logische Operatoren, zwei Gleichheitszeichen und drei Gleichheitszeichen. Deshalb werde ich nicht zu sehr ins Detail gehen.

Typ

Hier werde ich es als Operator und nicht als Funktion behandeln.

Die Funktion dieses Operators besteht darin, den Typ einer Variablen zu bestimmen, d. h. den Typnamen. Sie können ihn ermitteln, indem Sie den folgenden Code ausführen:

Code kopieren Der Code lautet wie folgt:

Funktion foo() {}
var a = 0;
var b = 'Shh~ Egg Drop Soup 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 sein:

Code kopieren Der Code lautet wie folgt:

Nummer
Zeichenfolge
Nummer
Funktion
Objekt
Objekt
Objekt
undefiniert

null, undefiniert, NaN

In JavaScript gibt es drei Sonderwerte, wie im Titel gezeigt. Das erste ist vielleicht jedem bekannt, aber es wird in Großbuchstaben geschrieben

```C

definiere NULL 0

In JavaScript haben diese drei Werte unterschiedliche Bedeutungen.

### null ###

null ist eine besondere Art von Objekt, was ungefähr leer bedeutet. Zum Beispiel:

var a = null;

Jeder kann es verstehen, deshalb werde ich es nicht zu viel erklären. Aber im Gegensatz zu C/C ist diese Null nicht gleich 0.

### undefiniert ###

Dieses Ding bedeutet, dass diese Variable nicht deklariert ist. Um Null besser unterscheiden zu können, lautet unser Beispielcode wie folgt:

```Javascript

Code kopieren Der Code lautet wie folgt:

var a = {
„foo“ : null
};
console.log(a["foo"]);
console.log(a["bar"]);

Im obigen Code machen wir den Wert von a["foo"] leer, also null. Und es gibt überhaupt keine Deklaration von a["bar"], es ist nicht einmal leer. Jeder hätte das Ausgabeergebnis erraten müssen:

Code kopieren Der Code lautet wie folgt:

null
undefiniert

NaN

Dies ist ein leerer Wert, eine spezielle Zahl. Sein vollständiger Name ist Not a Number. Es ist etwas seltsam. Sie können es als eine Variable vom Typ Zahl verstehen, die nicht in digitaler Form vorliegt oder einen falschen Wert hat.

Tritt meist auf, wenn bei numerischen Gleitkommaoperationen Fehler auftreten (z. B. Division durch 0). Es kann sogar sein, dass der Benutzer selbst eine Variable gleich NaN macht, um einen Fehlerwert zurückzugeben, um alle darüber zu informieren, dass diese Funktionsoperation vorliegt schief gelaufen.

Kleine Innereien

Die anderen verbleibenden Anweisungen ähneln anderen vorhandenen Sprachen, z. B. break, switch, continue usw.

Variablentyp

In diesem Abschnitt geht es hauptsächlich um JavaScript-Objekte, andere Typen werden fast übergangen.

Basistyp

Node.js enthält fast die folgenden Grundtypen:

Nummer

Zeichenfolge
boolean
Array
Unter diesen können die ersten drei Typen direkt zugewiesen werden, und die Zuweisung eines Arrays ist nur eine Referenzzuweisung. Wenn ein Wert in der 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);
Das Ergebnis ist:

Javascript

[ 3, 2, 3 ]
Mit anderen Worten: Wenn ein Array ein neues Array kopiert, kann es keine direkte Zuweisung verwenden, sondern muss „tief kopieren“.

Es ist notwendig, über die drei Erstellungsmethoden von Arrays zu sprechen.

Erster Typ:

Javascript

Code kopieren Der Code lautet wie folgt:

var dog = new Array();
dog[0] = „Shh~“;
dog[1] = „Eiertropfensuppe“;
dog[2] = „Sleeping“;

Zweiter Typ:

Javascript

Code kopieren Der Code lautet wie folgt:

var dog = new Array( "Shh~", "Egg Drop Soup", "Sleeping" );

Der vierte Typ:
Javascript

Code kopieren Der Code lautet wie folgt:

var dog = [
„Shh~“,
„Eiertropfensuppe“,
„Schlafen“
];

Ich persönlich bevorzuge die dritte Schreibweise, die prägnanter ist.

JSON-Objekt

Hier trenne ich das JSON-Objekt, anstatt es als JavaScript-Objekt zu klassifizieren. Wenn Sie das Gefühl haben, dass ich etwas irreführend bin, können Sie diesen Abschnitt direkt überspringen.

Mein Unterschied zwischen JSON-Objekten und JavaScript-Objekten besteht darin, ob sie nur zum Speichern von Daten und nicht zum Instanziieren einer Klasse verwendet werden. Tatsächlich ist die Essenz von JSON die JavaScript-Objektnotation.

Weitere Informationen zu JSON finden Sie in der Enzyklopädie.

Das Deklarieren eines JSON-Objekts in Node.js ist sehr einfach:

Javascript

Code kopieren Der Code lautet wie folgt:

var dog = {
„pre“: „Shh~“,
"sub" : {
„Name“: „Eiertropfensuppe“,
„act“: „schlafen“,
„Zeit“: 12
},
„suf“: [ „Ich sagte“, „Es schläft“, „Es schläft nur“ ]
};

Es gibt zwei Möglichkeiten, den Schlüsselwert eines bestimmten Schlüsselnamens im JSON-Objekt abzurufen. Die erste besteht darin, eine Punktverbindung zu verwenden, und die zweite darin, eckige Klammern zu verwenden:

Javascript

Code kopieren Der Code lautet wie folgt:

Hund
.pre;
dog["pre"];

Hinweis: Wenn Sie den Punkt oben verwenden, folgt direkt darauf der Schlüssel in JSON. Wenn Sie den Schlüssel als Variable behandeln, können Sie es nur mit dog[key] versuchen: Jetzt können Sie es selbst versuchen, verwenden Sie The for ...in Form durchläuft das obige JSON-Objekt. Vergessen Sie nicht, typeof meow~

zu verwenden

Grundlagen von Klassen (Objekten)

Genau genommen kann eine Node.js-Klasse nicht als Klasse betrachtet werden. Tatsächlich handelt es sich lediglich um eine Sammlung von Funktionen mit einigen Mitgliedsvariablen. Sein Wesen ist eigentlich eine Funktion.

Aber der Einfachheit halber werden wir es im Folgenden und in Zukunft als „Klasse“ und die Instanziierung als „Objekt“ bezeichnen.

Da eine Klasse viele Funktionsmerkmale aufweist oder ihr Wesen eine Funktion ist, erklären wir hier möglicherweise versehentlich die Grundlagen von Funktionen.

Deklaration und Instanziierung von Klassen

Eine Klasse zu deklarieren ist sehr einfach, lachen Sie nicht:

Javascript
Funktion foo() {
//...
}
Okay, wir haben eine Foo-Klasse geschrieben.

Echt oder falsch? ! real.

Glauben Sie es nicht? Wenn Sie es nicht glauben, können Sie einen Code eingeben und einen Blick darauf werfen:

Javascript
var bar = new foo();
Unabhängig davon, ob es sich um eine Funktion handelt, handelt es sich, wenn sie in dieser Form (neu) geschrieben ist, um eine Instanziierung dieser Klasse.

Und dieses sogenannte foo() ist eigentlich der Konstruktor der foo()-Klasse.

Mitgliedsvariablen

Es gibt zwei Möglichkeiten, Mitgliedsvariablen zu verwenden.

Die erste besteht darin, dies. im Konstruktor der Klasse oder einem beliebigen Konstruktor zu verwenden. Sie können eine Mitgliedsvariable jederzeit deklarieren, und dies hat keinen Einfluss auf ihre externe Verwendung. Selbst wenn Sie sie verwenden, bevor sie deklariert wird, gibt es eine undefinierte Variable, die sie unterstützt. Das ist also die erste Methode:

Code kopieren Der Code lautet wie folgt:

Javascript
Funktion foo() {
This.hello = "world";
}

Hinweis: Nur wenn dies hinzugefügt wird, handelt es sich um eine Mitgliedsvariable der aufrufenden Klasse, andernfalls handelt es sich nur um eine lokale Variable innerhalb der Funktion. Es ist notwendig, den Gültigkeitsbereich der Variablen zu unterscheiden, wenn dieser nicht vorhanden ist.

Die zweite Methode besteht darin, es außerhalb des Konstruktors oder einer beliebigen Mitgliedsfunktion zu deklarieren. Das Format ist .prototype.:

Javascript

Code kopieren Der Code lautet wie folgt:

Funktion foo() {
//...
}
foo.prototype.hello = "world";

Egal welche Methode oben eine Deklaration von Mitgliedsvariablen ist, wir können den Effekt sehen:

Javascript

Code kopieren Der Code lautet wie folgt:

var bar = new foo();
console.log(bar.hello);

Sie können diese Klasse sogar wie folgt ändern:

Javascript

Code kopieren Der Code lautet wie folgt:

Funktion foo() {
This.hello = "world";
}
foo.prototype.hello = "Eiertropfensuppe";

Verwenden Sie dann den obigen Code zur Ausgabe.

Denken Sie darüber nach, warum die Ausgabe immer noch Welt statt Eiertropfensuppe ist.

Konstrukteur

Wir haben bereits gesagt, dass foo() eigentlich ein Konstruktor ist. Wir können also natürlich Parameter an den Konstruktor übergeben, sodass wir den folgenden Code haben:

Javascript

Code kopieren Der Code lautet wie folgt:

// Code 2.1
Funktion foo(hello) {
If(hallo === undefiniert) {
This.hello = "world";
} sonst {
This.hello = hallo;
}
}

Wir sehen oben ein seltsames Urteil if(hello === undefiniert). Wozu dient dieses Urteil? Die erste Möglichkeit besteht darin, dass der Entwickler sich alle Mühe gegeben hat, undefiniert zu übergeben. Zum jetzigen Zeitpunkt ist es verständlich, dass es undefiniert ist.

Es gibt eine andere Situation. Wir haben zu Beginn gesagt, dass JavaScript eine schwach typisierte Sprache ist. Tatsächlich ist es nicht nur schwach typisiert, sondern auch die Parameterübergabe ist sehr locker. Sie können mehr oder weniger bestehen (solange Sie sicherstellen können, dass das Programm keine Fehler macht oder die Logik keine Fehler macht, wenn Sie mehr oder weniger bestehen), im Prinzip ist das in Ordnung. Parameter, die in „more“ übergeben werden, werden automatisch ignoriert, während Parameter, die in „less“ übergeben werden, durch „undefiniert“ ergänzt werden.

Sehen Sie sich zum Verständnis den folgenden Code an:

Javascript

Code kopieren Der Code lautet wie folgt:

// Fortsetzung von Code 2.1
var bar1 = new foo();
var bar2 = new foo("Egg Drop Soup");

Bitte geben Sie die Hallo-Variablen der beiden Riegel selbst aus, und Sie werden feststellen, dass einer die Welt und der andere die Eiertropfensuppe ist. Wenn unser erster bar1 deklariert wird, sieht Node.js ihn offensichtlich automatisch als:

Javascript

Code kopieren Der Code lautet wie folgt:

var bar1 = new foo(undefiniert);

Es gibt also ein Sprichwort, dass es die Welt ist.

Außerdem sehen wir in diesem Konstruktor, dass der übergebene Parameter „Hallo“ ist und dass es in dieser Klasse eine Mitgliedsvariable namens „this.hello“ gibt. Wir haben jedoch zuvor gesagt, dass der Gültigkeitsbereich unterschiedlich ist, wenn dies vorhanden ist und wenn dies nicht der Fall ist. Der Parameter wirkt nur im Konstruktor, und derjenige mit this ist eine Mitgliedsvariable. Dadurch werden sie sofort unterschieden, sodass es keine Rolle spielt, auch wenn sie denselben Namen haben.

Mitgliederfunktionen

Member-Funktionsdeklaration

Die Deklaration von Mitgliedsfunktionen ähnelt der zweiten Deklarationsmethode von Mitgliedsvariablen, nämlich .prototype.;

Javascript

Code kopieren Der Code lautet wie folgt:

// Fortsetzung von Code 2.1
Funktion setHello(hallo) {
this.hello = hallo;
}
foo.prototype.setHello = setHello;
bar1.setHello("Eierpfannkuchen");

Der obige Code ist offensichtlich. Wir haben die setHello-Funktion der foo-Klasse implementiert, die den Wert von foo.hello ändern kann.

Aber ist es nicht ein bisschen mühsam, so zu schreiben? Als nächstes werde ich über ein wichtiges Merkmal von JavaScript-Funktionen sprechen.

★ Anonyme Funktion ★

Oft werden einige unserer Funktionen nur an einer Stelle referenziert oder aufgerufen, sodass es für uns weder sinnvoll noch unnötig ist, dieser Funktion einen Namen zu geben, sodass wir diese Funktion vorübergehend schreiben und die Person, die darauf verweist, direkt zulassen können Die Leute zitieren es, die Leute, die es nennen, nennen es. Daher kann der Funktionsname weggelassen werden, z. B.:

Javascript

Code kopieren Der Code lautet wie folgt:

Funktion(Hallo) {
This.hello = hallo;
}

Wie kann ich ein Angebot erstellen oder anrufen? Wenn auf die obige Klasse verwiesen werden muss, würde sie wie folgt geschrieben werden:

Javascript

Code kopieren Der Code lautet wie folgt:

foo.prototype.setHello = function(hello) {
This.hello = hallo;
}

Diese Schreibweise hat den gleichen Effekt wie die Deklaration einer Mitgliedsfunktion und spart viel Code. Und tatsächlich wird die Deklaration von Klassenmitgliedsfunktionen im Grunde auf diese Art und Weise einer anonymen Funktion deklariert.

Wie kann die anonyme Funktion aufgerufen werden? Dies wird normalerweise verwendet, wenn eine Funktion übergeben wird, die nur von einer bestimmten Funktion aufgerufen wird.

Zum Beispiel haben wir eine Funktion, deren Prototyp ist:

Javascript

Code kopieren Der Code lautet wie folgt:

/**
* Wir werden zwei Variablen a und b übergeben,
* Nachdem Sie den Wert von a b berechnet haben, übergeben Sie ihn an func(num)
* Zur Ausgabe gehen
​*/
Funktion sumab(a, b, func) {
var c = a b;
func(a, b, c);
}

Zum Beispiel haben wir zwei Versionen der Ausgabefunktion, eine für die chinesische Ausgabe und die andere für die englische Ausgabe. Wenn die anonyme Funktion nicht verwendet wird, wird sie wie folgt geschrieben:

Javascript

Code kopieren Der Code lautet wie folgt:

Funktion zh(a, b, sum) {
console.log(der Wert von a " " b " ist: " sum);
}
Funktion en(a, b, sum) {
console.log(a " plus " b " ist " Summe);
}
sumab(1, 2, zh);
sumab(3, 4, en);

Führen Sie diesen Code einmal aus. Das Ausgabeergebnis lautet:

Der Wert von 1 2 ist: 3
3 plus 4 ist 7
Wenn ein solcher Code in Form einer anonymen Funktion vorliegt, lautet er:

Javascript

Code kopieren Der Code lautet wie folgt:

sumab(1, 2, function(a, b, sum) {
​ console.log(der Wert von a " " b " ist: " sum);
});
sumab(3, 4, function(a, b, sum) {
console.log(a " plus " b " ist " Summe);
});

Dieses Formular wird normalerweise für Rückruffunktionen verwendet. Der Rückrufmechanismus ist die Essenz von Node.js oder JavaScript. Es wird in zukünftigen Kapiteln vorgestellt.

Anonyme Funktionsdeklarationsmethode der Mitgliedsfunktionsdeklaration

Obwohl ich es im vorherigen Abschnitt erwähnt habe, lassen Sie uns noch einmal darüber sprechen.

Wenn wir Mitgliedsfunktionen einer Klasse deklarieren, verwenden wir normalerweise anonyme Funktionen, um sie zu deklarieren, da diese Funktion ohnehin nur eine Mitgliedsfunktion dieser Klasse ist und nicht separat von anderen Stellen referenziert oder aufgerufen wird. Daher gilt Folgendes Code:

Javascript

Code kopieren Der Code lautet wie folgt:

// Fortsetzung von Code 2.1
foo.prototype.setHello = function(hello) {
This.hello = hallo;
}

Auf diese Weise sorgen wir dafür, dass die Klasse foo die Funktion setHello hat.

2.3.4. Beliebigkeit der Klassen

Das ist mal wieder Blödsinn von mir. Die sogenannte Beliebigkeit von Klassen bedeutet, dass Sie Ihre Klasse überall in JavaScript ändern können, was gewisse Ähnlichkeiten mit Ruby aufweist.

String ist beispielsweise tatsächlich eine Klasse mit Mitgliedsvariablen wie Länge und Mitgliedsfunktionen wie indexOf und substr. Falls wir jedoch der Meinung sind, dass diese Zeichenfolge an einigen Stellen unvollständig ist, und unsere eigene Methode hinzufügen möchten, können wir an der gewünschten Stelle eine Funktion hinzufügen, z. B.:

Javascript

Code kopieren Der Code lautet wie folgt:

String.prototype.sb = function() {
var newstr = "";
for(var i = 0; i < this.length; i ) {
If(i % 2 === 0) newstr = "s";
sonst newstr = "b";
}
Geben Sie newstr;
zurück };

Die Bedeutung dieser Funktion besteht darin, eine Zeichenfolge so zu füllen, dass sie zur Inkarnation von jdm wird.

Lass es uns testen:

Code kopieren Der Code lautet wie folgt:

var str = "Shh~ Egg Drop Soup schläft.";
console.log(str.sb());

Sie erhalten dieses Ergebnis:

sbsbsbsbs
Wenn Sie Ihrem Computer sagen: „Shh~ Egg Drop Soup schläft.“ wird Ihr Computer Sie viereinhalb Mal als Idioten bezeichnen. (Schnell zerschlagen)

3. Anbei

3.1. Tiefe Kopie

Das sogenannte Deep Copy bedeutet, selbst ein neues Array oder Objekt zu erstellen und die Variablenwerte des Basistyps einzeln manuell in das Quellarray oder -objekt zu kopieren, anstatt nur die Referenz des Quellarrays oder -objekts zu übernehmen Quellarray oder -objekt. Das beinhaltet also einen rekursiven Aufruf oder so etwas.

Das Folgende ist eine Deep-Copy-Funktion, die ich implementiert habe. Sie können Ihre eigene schreiben und sie Ihrer eigenen Node.js-Wissensdatenbank hinzufügen.

Javascript

Code kopieren Der Code lautet wie folgt:

Funktion cloneObject(src) {
  var dest = {};
  for(var key in src) {
    if(typeof src === "object") dest[key] = cloneObject(src[key]);
    sonst dest[key] = src[key];
  }
  Rückkehrziel;
}