Ist JavaScript eine pass-by-reference oder pass-by-value Sprache?

My 2 Cents.... Dies ist der Weg, ich verstehe es. (Fühlen Sie sich frei, mich zu korrigieren, wenn ich falsch Liege)

Ist es Zeit zu werfen, alles, was Sie über pass-by-value /Referenz.

, Weil in JavaScript, egal, ob es übergeben wird durch einen Wert oder Verweis oder was auch immer.
Was zählt, ist die mutation vs Belegung der Parameter einer Funktion übergeben werden.

OK, lass mich mein bestes tun, zu erklären, was ich meine. Lassen Sie uns sagen, Sie haben ein paar Objekte.

var object1 = {};
var object2 = {};

Was wir getan haben, ist die "Zuordnung"... Wir zugewiesen haben 2 separate leere Objekte die Variablen "Objekt1" und "objekt2".

Nun, lasst uns sagen, dass wir wie Objekt1 besser... Also, wir "weisen" eine neue variable.

var favoriteObject = object1;

Nächsten, aus welchem Grund auch immer, wir entscheiden, dass wir wie Objekt 2 besser. Also, wir nehmen einfach ein wenig re-Belegung.

favoriteObject = object2;

Ist nichts passiert Objekt1 oder objekt2. Wir haben sich nicht verändert, alle Daten auf allen. Alles, was wir Taten, war neu ordnen, was unsere Lieblings-Objekt ist. Es ist wichtig zu wissen, dass objekt2 und favoriteObject sind sowohl alle zugewiesenen als auch auf das gleiche Objekt. Wir können das Objekt über eine dieser beiden Variablen.

object2.name = 'Fred';
console.log(favoriteObject.name) //logs Fred
favoriteObject.name = 'Joe';
console.log(object2.name); //logs Joe 

OK, schauen wir uns nun an primitive wie strings zum Beispiel

var string1 = 'Hello world';
var string2 = 'Goodbye world';

Wieder, wir wählen Sie einen Favoriten.

var favoriteString = string1;

Sowohl unsere favoriteString und Variablen string1 zugewiesen sind, 'Hallo Welt'. Nun, was wenn wir das ändern wollen unsere favoriteString??? Was wird passieren???

favoriteString = 'Hello everyone';
console.log(favoriteString); //Logs 'Hello everyone'
console.log(string1); //Logs 'Hello world'

Uh oh.... Das was passiert ist. Wir konnte es nicht ändern, string1 durch die änderung favoriteString... Warum?? da Zeichenfolgen unveränderlich sind, und wir nicht mutieren. Alles, was wir Taten, war, "NEU ZUWEISEN" favoriteString zu einem neuen string. Dies ist im wesentlichen getrennt ist es von string1. In dem vorherigen Beispiel, wenn wir uns umbenannt unserer Sache, die wir nicht zuordnen nichts. (Gut, eigentlich... haben wir getan, wir schickten Sie die name-Eigenschaft auf eine neue Zeichenfolge.) Stattdessen haben wir einfach mutiert das Objekt hält, die verbindungen zwischen den 2 Variablen und der zugrunde liegenden Objekte.

Nun, auf Funktionen und Parameterübergabe.... Wenn Sie eine Funktion aufrufen, und übergeben Sie einen parameter, was Sie im wesentlichen tun, ist die "Zuordnung", um eine neue variable, und es funktioniert genau das gleiche, als wenn Sie einfach zugewiesen mit dem Gleichheitszeichen ( = ).

Nehmen diese Beispiele.

var myString = 'hello';

//Assign to a new variable (just like when you pass to a function)
var param1 = myString; 
param1 = 'world'; //Re assignment

console.log(myString); //logs 'hello'
console.log(param1);   //logs 'world'

Nun, die gleiche Sache, aber mit einer Funktion

function myFunc(param1) {
    param1 = 'world';

    console.log(param1);   //logs 'world'
}

var myString = 'hello';
//Calls myFunc and assigns param1 to myString just like param1 = myString
myFunc(myString); 

console.log(myString); //logs 'hello'

OK, jetzt geben wir ein paar Beispiele für die Verwendung von Objekten statt... zunächst ohne Funktion.

var myObject = {
    firstName: 'Joe',
    lastName: 'Smith'
};

//Assign to a new variable (just like when you pass to a function)
var otherObj = myObject;

//Let's mutate our object
otherObj.firstName = 'Sue'; //I guess Joe decided to be a girl

console.log(myObject.firstName); //Logs 'Sue'
console.log(otherObj.firstName); //Logs 'Sue'

//Now, let's reassign
otherObj = {
    firstName: 'Jack',
    lastName: 'Frost'
};

//Now, otherObj and myObject are assigned to 2 very different objects
//And mutating one object no longer mutates the other
console.log(myObject.firstName); //Logs 'Sue'
console.log(otherObj.firstName); //Logs 'Jack';

Nun, die gleiche Sache, aber mit einem Funktionsaufruf

function myFunc(otherObj) {

    //Let's mutate our object
    otherObj.firstName = 'Sue';
    console.log(otherObj.firstName); //Logs 'Sue'

    //Now let's re-assign
    otherObj = {
        firstName: 'Jack',
        lastName: 'Frost'
    };
    console.log(otherObj.firstName); //Logs 'Jack'

    //Again, otherObj and myObject are assigned to 2 very different objects
    //And mutating one object no longer mutates the other
}

var myObject = {
    firstName: 'Joe',
    lastName: 'Smith'
};

//Calls myFunc and assigns otherObj to myObject just like otherObj = myObject
myFunc(myObject);

console.log(myObject.firstName); //Logs 'Sue', just like before

OK, wenn Sie Lesen, durch diese ganzen post, vielleicht haben Sie jetzt ein besseres Verständnis, wie Funktionsaufrufe funktionieren in javascript. Es spielt keine Rolle, ob etwas übergeben als Verweis oder Wert... Was zählt, ist die Zuordnung vs-mutation.

Jedes mal, wenn Sie übergeben Sie eine variable an eine Funktion, Sie sind "Zuordnung" auf das, was der name der parameter-variable ist, wie wenn Sie das Gleichheitszeichen ( = ).

Immer daran denken, dass die ist-gleich-Zeichen (=) bedeutet Zuordnung.
Denken Sie immer daran, dass die übergabe eines Parameters an eine Funktion bedeutet auch die Zuweisung.
Sie sind die gleichen und der 2 Variablen verbunden sind, in genau der gleichen Weise.

Das einzige mal, dass die änderung einer variable wirkt auf eine andere variable ist, wenn das zugrunde liegende Objekt mutiert ist.

Gibt es keinen Punkt in der Unterscheidung zwischen Objekten und primitiven, weil es funktioniert auf die gleiche genaue Art und Weise, wie wenn Sie nicht eine Funktion haben und einfach das Gleichheitszeichen zuweisen, um eine neue variable.

Das einzige Manko ist, wenn der name der variable, die Sie übergeben Sie in der Funktion ist der gleiche wie der name der Funktion parameter. Wenn dies geschieht, müssen Sie behandeln den parameter innerhalb der Funktion, als ob es war eine ganz neue variable privat, um die Funktion (weil es ist)

function myFunc(myString) {
    //myString is private and does not affect the outer variable
    myString = 'hello';
}

var myString = 'test';
myString = myString; //Does nothing, myString is still 'test';

myFunc(myString);
console.log(myString); //logs 'test'

InformationsquelleAutor Ray Perea

Objekt außerhalb einer Funktion ist, die einer Funktion übergeben, indem eine Referenz auf das Objekt außerhalb. Wenn Sie mit dieser Referenz zu manipulieren das Objekt, das Objekt außerhalb, ist also betroffen. Allerdings, wenn innerhalb der Funktion, die Sie beschlossen, den Verweis auf etwas anderes, Sie hatte keinen Einfluss auf das Objekt außerhalb, denn alles, was Sie Tat, war re-direct die Referenz auf etwas anderes.

InformationsquelleAutor user779764

Javascript ist immer pass-by-value, alles ist von Wert geben. Objekte sind Werte, die member-Funktionen der Objekte sind die Werte, die sich (denken Sie daran, dass Funktionen erstklassige Objekte in Javascript). Auch in Bezug auf das Konzept, dass alles in Javascript ist eine Objekt, das ist falsch. Strings, Symbole, zahlen, Boolesche Werte, null-Werte und undefineds sind primitive. Bei Gelegenheit können Sie nutzen, einige member-Funktionen und Eigenschaften geerbt von Ihrer Basis Prototypen, aber das ist nur für die Bequemlichkeit, es nicht bedeutet, dass Sie Objekte selbst. Versuchen Sie die folgenden für Referenz

x = "test";
alert(x.foo);
x.foo = 12;
alert(x.foo);

In beiden Warnungen finden Sie den Wert undefined.

InformationsquelleAutor Michael Roberts

Eine sehr ausführliche Erklärung über das kopieren, die Weitergabe und den Vergleich von Wert und per Referenz in in diesem Kapitel von "JavaScript: The Definitive Guide" buchen.

Bevor wir verlassen das Thema
das manipulieren von Objekten und arrays durch
Referenz -, müssen wir klar einen Punkt
der Nomenklatur. Der Satz "pass by
Referenz" kann mehrere Bedeutungen haben.
Für manche Leser, der Satz bezieht sich auf
ein Funktions-Aufruf-Technik,
ermöglicht eine Funktion zum zuweisen von neuen Werten
zu seinen Argumenten und diese
geänderte Werte sichtbar außerhalb der
Funktion. Dies ist nicht die Art, wie der Begriff
ist in diesem Buch benutzt. Hier, meinen wir
einfach, dass eine Referenz auf ein Objekt
oder ein array -- nicht das Objekt selbst. --
wird an eine Funktion übergeben. Eine Funktion
können die Referenz ändern
Eigenschaften des Objekts oder elements
der array. Aber wenn die Funktion
überschreibt die Referenz mit einer
Referenz auf ein neues Objekt oder ein array,
diese änderung ist nicht sichtbar
außerhalb der Funktion. Leser
vertraut mit der anderen Bedeutung
dieser Begriff vielleicht lieber sagen, dass
Objekte und arrays übergeben werden
Wert, aber der Wert, der übergeben wird, ist
eigentlich eine Referenz anstatt die
Objekt selbst.

Eine Sache, die ich noch nicht herausfinden. Überprüfen Sie code unten. Irgendwelche Gedanken?

function A() {}
A.prototype.foo = function() {
    return 'initial value';
}


function B() {}
B.prototype.bar = A.prototype.foo;

console.log(A.prototype.foo()); //initial value
console.log(B.prototype.bar()); //initial value

A.prototype.foo = function() {
    return 'changed now';
}

console.log(A.prototype.foo()); //changed now
console.log(B.prototype.bar()); //Why still 'initial value'???

InformationsquelleAutor igor

Es gibt einige Diskussion über die Verwendung des Begriffs "pass by reference" in JS hier, aber um deine Frage zu beantworten:

Eines Objekts automatisch per Referenz übergeben, ohne die Notwendigkeit, speziell Zustand

(Aus dem Artikel oben erwähnt.)

InformationsquelleAutor Jack Sleight

Semantik!! Die Festlegung konkreter Definitionen unbedingt ein paar Antworten und Kommentare unvereinbar, da Sie nicht beschreibt, die gleiche Sache, auch wenn mit den gleichen Worten und Phrasen, aber es ist wichtig, um vorbei an der Verwirrung (vor allem für neue Programmierer).

Zuerst von all, es gibt mehrere Ebenen der Abstraktion, die nicht jeder scheint zu verstehen. Neuere Programmierer, die gelernt haben, am 4. oder 5. generation Sprachen Schwierigkeiten haben können, wickeln Ihre Meinung rund um Konzepte kennen, um Montage-oder C-Programmierer nicht schrittweise durch Zeiger auf Zeiger auf Zeiger. Pass-by-reference heißt nicht nur, die Fähigkeit zur änderung einer referenzierten Objekt mit einer Funktion parameter-variable.

Variable: Kombinierte Begriff des symbols, der auf einem Wert an einer bestimmten Stelle im Speicher. Dieser Begriff ist in der Regel zu geladen, um alleine verwendet werden, in die Diskussion über details.

Symbol: Text-Zeichenfolge zum verweisen auf Variablen (d.h. Variablen mit den Namen).

Wert: Bestimmte bits im Speicher abgelegt und verwiesen mit Variablen symbol.

Speicher: Wo den Wert einer variable gespeichert ist. (Der Ort selbst wird dargestellt durch eine Zahl getrennt von den gespeicherten Wert an der Stelle.)

Funktion parameter: deklarierte Variable in der definition einer Funktion, verwendet für die Referenzierung von Variablen an die Funktion übergeben.

Funktion argument: Variable außerhalb der Funktion, die übergeben wird an die Funktion durch den Aufrufer.

Objekt-variable: Variable, deren zugrunde liegende Wert nicht dem "Objekt" selbst, sondern Ihr Wert ist ein Zeiger (Speicherstelle, Wert) an eine andere Stelle im Speicher, wo das Objekt die eigentlichen Daten gespeichert werden. In den meisten höher-generation Sprachen, die "pointer" - Aspekt ist effektiv versteckt durch automatische de-referenzieren in verschiedenen Kontexten.

Primitive variable: Variable, deren Wert IST der tatsächliche Wert. Auch dieses Konzept kann erschwert werden durch auto-boxing und Objekt-ähnlichen Kontexten in verschiedenen Sprachen, aber die Allgemeinen Ideen ist, dass der variable Wert IST der tatsächliche Wert, dargestellt durch das symbol für die variable sondern einen Zeiger auf einen anderen Speicherbereich.

Funktionsargumente und-Parameter sind nicht das gleiche. Auch, den Wert einer variable wird nicht die variable, die das Objekt (wie schon von verschiedenen Leuten, aber scheinbar ignoriert). Diese Unterscheidungen sind wichtig, um das richtige Verständnis.

Pass-by-value oder Call-by-sharing (für Objekte): Die Funktion-argument ist der Wert zu einem anderen KOPIERT Speicherbereich, auf den verwiesen wird, durch die Funktion s-parameter-symbol (unabhängig davon, ob es auf dem stack oder heap). In anderen Worten, die Funktion parameter erhalten Sie eine Kopie des übergebenen Arguments ' s Wert... UND (kritische) das argument der Wert nicht mehr AKTUALISIERT /VERÄNDERT /GEÄNDERT durch die aufrufende Funktion. Denken Sie daran, eine object-variable, die den Wert ist NICHT das Objekt selbst, sondern es wird der Zeiger auf das Objekt, also die übergabe einer Objekt-variable per Wert kopiert den Zeiger auf die Funktion parameter-variable. Der parameter der Funktion ist der Wert der Punkte, die genau die gleiche Objekt im Speicher. Die Daten des Objekts selbst verändert werden können, direkt über der parameter der Funktion, SONDERN die Funktion-argument IST der Wert nicht AKTUALISIERT, also es wird weiterhin auf die gleichen Objekt, während und natürlich auch nach dem Aufruf der Funktion (auch wenn Ihr Objekt die Daten geändert wurde oder wenn der parameter der Funktion zugewiesen ist, ein anderes Objekt insgesamt). Es ist falsch, daraus zu folgern, dass die Funktion ein argument per Referenz übergeben, nur weil das referenzierte Objekt ist aktualisierbar über die Funktion parameter-variable.

Call /Pass-by-reference: Die Funktion-argument Wert ist, kann/wird direkt aktualisiert werden, indem die entsprechende Funktion parameter. Wenn es hilft, der parameter der Funktion wird ein wirksames "alias" für das argument--Sie effektiv beziehen sich auf den gleichen Wert an der gleichen Speicherstelle. Wenn eine Funktion ein argument ist ein Objekt variable, die Fähigkeit, zu ändern die Daten des Objekts ist nichts anderes als die pass-by-value, da der parameter der Funktion wird immer noch auf das gleiche Objekt als argument. Aber in der Objekt-variable Fall, wenn die Funktion der parameter gesetzt, um ein völlig anderes Objekt, dann das argument wird ebenso auch auf die verschiedenen Objekt-das passiert nicht in der pass-by-value case.

JavaScript nicht pass-by-reference. Wenn Sie Lesen Sie eng, werden Sie erkennen, dass alle konträren Meinungen falsch verstehen, was damit gemeint ist pass-by-value und Sie fälschlicherweise den Schluss, dass die Möglichkeit der Aktualisierung von Daten eines Objekts mittels der parameter der Funktion ist ein Synonym für die "pass-by-value".

Objekt Klonen/kopieren: Ein neues Objekt wird erstellt, und das ursprüngliche Objekt werden die Daten kopiert. Dies kann eine Tiefe Kopie oder flache Kopie, aber der Punkt ist, dass ein neues Objekt erstellt wird. Erstellen einer Kopie eines Objekts ist ein separates Konzept von pass-by-value. Einige Sprachen unterscheiden zwischen Klasse, Objekt und Strukturen (oder ähnliches), und kann verschiedene Verhalten für die übergabe von Variablen der verschiedenen Typen. Aber JavaScript nicht irgend etwas tun, wie dies automatisch beim übergeben von Objekt-Variablen. Aber das fehlen von automatischen Objekt Klonen nicht übersetzen, pass-by-reference.

InformationsquelleAutor C Perkins

In eine low-level Sprache, wenn Sie möchten, übergeben Sie eine variable per Referenz müssen Sie eine bestimmte syntax bei der Erstellung der Funktion:

int myAge = 14;
increaseAgeByRef(myAge);
function increaseAgeByRef(int &age) {
  *age = *age + 1;
}

Den &age ist ein Verweis auf myAge, aber wenn Sie möchten, dass der Wert, den Sie konvertieren die Referenz, mit *age.

Javascript ist eine high-level Sprache, die diese Konvertierung für Sie.
So, auch wenn die Objekte werden per Referenz übergeben, der die Sprache umwandelt, die Referenz-parameter auf den Wert. Sie brauchen nicht zu verwenden & auf die definition der Funktion, um es zu übergeben, die durch Verweis, weder * auf die Funktion Körper, konvertieren die Referenz auf den Wert, JS tut es für Sie.

Das ist, warum, wenn Sie versuchen, sich zu ändern, ein Objekt innerhalb einer Funktion, indem es den Wert (d.h. age = {value:5}), wird die änderung nicht beibehalten, aber wenn Sie es ändern Sie die Eigenschaften (D. H. age.value = 5), tut es.

Erfahren Sie mehr

InformationsquelleAutor Narayon

Für die Programmiersprache Anwälte, ich habe ging durch die folgenden Abschnitte zu ECMAScript 5.1 (die ist leichter zu Lesen als die neueste Auflage), und gehen so weit wie Fragen es auf der ECMAScript-mailing-Liste.

TL;DR: Everythings sind durch Wert übergeben, sondern Eigenschaften von Objekten, die Referenzen sind, und die definition des Objekts ist gruselig fehlen in der Norm.

Bau der Argument-Listen

Abschnitt 11.2.4 "Argumente" sagt Folgendes über die Herstellung einer Argumentliste, bestehend aus nur 1 argument:

Die Produktion ArgumentList : AssignmentExpression wird wie folgt bewertet:

1. Lassen ref das Ergebnis der Auswertung AssignmentExpression.
2. Lassen arg sein GetValue ("ref").
3. Gibt eine Liste, deren einzige Element ist arg.

Abschnitt auch auflisten von Fällen, in denen argument-Liste hat 0 oder >1 Argumente.

Also alles, was der Verweis übergeben werden.

Zugriff von Objekt-Eigenschaften

Abschnitt 11.2.1 "Eigenschaftenaccessoren"

Die Produktion MemberExpression : MemberExpression [ Ausdruck ] wird wie folgt bewertet:

1. Lassen baseReference werden das Ergebnis der Auswertung MemberExpression.
2. Lassen baseValue sein GetValue(baseReference).
3. Lassen propertyNameReference das Ergebnis der Auswertung von Ausdruck.
4. Lassen propertyNameValue sein GetValue(propertyNameReference).
5. Nennen CheckObjectCoercible(baseValue).
6. Lassen propertyNameString ToString(propertyNameValue).
7. Wenn die syntaktische Produktion, der ausgewertet wird, enthalten ist, im strikten Modus-code, lassen strenge wahr sein, anderes lassen
   strengen falsch sein.
8. einen Wert Zurück vom Typ Referenz, deren Basis Wert ist baseValue und deren referenzierte name ist
   propertyNameString, und deren strikten Modus-flag ist streng.

So, Eigenschaften von Objekten sind immer verfügbar als Referenz.

Auf Referenz

Es ist beschrieben im Abschnitt 8.7 "Der Referenz-Spezifikation Typ", die Referenzen sind keine echten Typen in der Sprache - Sie werden nur verwendet, um zu beschreiben, das Verhalten der löschen, der typeof-und Zuweisungsoperatoren.

Definition von "Objekt"

Definiert, 5.1 edition, dass "Ein Objekt ist eine Sammlung von Eigenschaften". Daher können wir folgern, dass der Wert des Objekts ist die Sammlung, aber was ist der Wert der Sammlung ist schlecht definiert in der Spezifikation, und erfordert ein bisschen Aufwand zu verstehen.

InformationsquelleAutor DannyNiu

Die prägnanteste Erklärung, die ich fand, war in der Style guide-AirBNB:

• Primitive: Wenn Sie auf eine primitive Art arbeiten Sie direkt auf Ihrer
  Wert

  • string
  • Anzahl
  • boolean
  • null
  • undefined

E. g.:

var foo = 1,
    bar = foo;

bar = 9;

console.log(foo, bar); //=> 1, 9

• Komplexe: Wenn Sie auf eine komplexe Art der Arbeit auf eine Referenz, um seinen Wert

  • Objekt
  • array
  • Funktion

E. g.:

var foo = [1, 2],
    bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); //=> 9, 9

I. e. effektiv primitive Typen werden als Wert übergeben, und komplexe Typen per Referenz übergeben.

InformationsquelleAutor lid

Habe ich die verlängern Methode der Underscore.js Bibliothek sehr nützlich, wenn ich will, zu übergeben, die ein Objekt als parameter entweder modifiziert oder vollständig ersetzt.

function replaceOrModify(aObj) {
  if (modify) {

    aObj.setNewValue('foo');

  } else {

   var newObj = new MyObject();
   //_.extend(destination, *sources) 
   _.extend(newObj, aObj);
  }
}

InformationsquelleAutor Jack

Ich würde sagen, es ist pass-by-copy -

Betrachten die Argumente und Variablen der Objekte sind Objekte geschaffen, die während der Ausführung Kontext erstellt, in der Anfang der Funktions-Aufruf - und Ihr tatsächlicher Wert/Referenz an die Funktion übergeben bekommen nur gespeichert diese Argumente + variable Objekte.

Einfach gesprochen, für die primitiven Datentypen werden die Werte kopiert, die Anfang der Funktionsaufruf für den Objekt-Typ, wird die Referenz kopiert.

InformationsquelleAutor lyslim

In einigen Fällen kann dies hilfreich sein, zu ändern anArg:

function alterMyArg(func) {
    //process some data
    //...
    func(data);
}

alertMyArg(function(d) {anArg = d;});

InformationsquelleAutor lefakir

Primitiven Wert übergeben werden und die Objekte werden per Referenz übergeben. Dies ist ganz anders aus anderen Sprachen wie C, VB oder Delphi. Ich kann nicht sagen, wie Sie den Umgang mit Objekten und primitiven genau, aber ich weiß von VB und Delphi, die es können (und sollten) angegeben werden.

php macht etwas ähnliches, seit der version 5: alle Objekte werden per Referenz übergeben, aber alle primitive kann per Referenz übergeben werden, wenn vorangestellt, die durch ein kaufmännisches und-Zeichen (&). Ansonsten primitiven Wert übergeben werden.

So, in javascript, wenn ich übergeben Sie ein Objekt X in eine Funktion über einen parameter, es werden noch X. Wenn Sie das ändern von Daten innen wird die Funktion (oder einem anderen Objekt, aber das ist nicht wichtig), der neue Wert ist, auch außerhalb der Funktion.

InformationsquelleAutor