javascript - attribute - target_blank




Geht Javascript als Referenz? (7)

"Globale" JavaScript-Variablen sind Mitglieder des Fensterobjekts. Sie können auf die Referenz als Mitglied des Fensterobjekts zugreifen.

var v = "initialized";
function byref(ref) {
 window[ref] = "changed by ref";
}
byref((function(){for(r in window){if(window[r]===v){return(r);}}})());
// could also be called like... byref('v');
console.log(v); // outputs changed by ref

Beachten Sie, dass das obige Beispiel nicht für Variablen funktioniert, die innerhalb einer Funktion deklariert sind.

Verlässt Javascript Referenzen oder gibt es Werte? Hier ist ein Beispiel aus Javascript: Die guten Teile . Ich bin sehr verwirrt über my Parameter für die Rechteckfunktion. Es ist eigentlich undefined und innerhalb der Funktion neu definiert. Es gibt keine Originalreferenz. Wenn ich es aus dem Funktionsparameter entferne, kann die Innenbereichsfunktion nicht darauf zugreifen.

Ist es eine Schließung? Aber es wird keine Funktion zurückgegeben.

var shape = function (config) {
    var that = {};
    that.name = config.name || "";
    that.area = function () {
        return 0;
    };
    return that;
};
var rectangle = function (config, my) {
    my = my || {};
    my.l = config.length || 1;
    my.w = config.width || 1;
    var that = shape(config);
    that.area = function () {
        return my.l * my.w;
    };
    return that;
};
myShape = shape({
    name: "Unhnown"
});
myRec = rectangle({
    name: "Rectangle",
    length: 4,
    width: 6
});
console.log(myShape.name + " area is " + myShape.area() + " " + myRec.name + " area is " + myRec.area());

Denken Sie darüber nach:

Jedes Mal, wenn Sie ein Objekt in ECMAscript erstellen, wird dieses Objekt in einem mystischen ECMAscript-universellen Ort gebildet, an dem kein Mensch je gelangen kann. Alles, was du zurückbekommst, ist ein Verweis auf dieses Objekt in diesem mystischen Ort.

var obj = { };

Selbst obj ist nur eine Referenz auf das Objekt (das sich an diesem besonderen wunderbaren Ort befindet) und daher kann man diese Referenz nur obj . Effektiv wird jeder Code, der auf obj zugreift, das weit entfernte Objekt modifizieren.


Im Interesse eines einfachen Beispiels, das const ...

const myRef = { foo: 'bar' };
const myVal = true;

function passes(r, v) {
  r.foo = 'baz';
  v = false;
}

passes(myRef, myVal);

console.log(myRef, myVal); // Object {foo: "baz"} true

In der Praxis ist Alnitak korrekt und leicht zu verstehen, aber letztendlich wird in JavaScript alles nach Wert weitergegeben.

Was ist der "Wert" eines Objekts? Es ist die Objektreferenz.

Wenn Sie ein Objekt übergeben, erhalten Sie eine Kopie dieses Wertes (daher die "Kopie einer Referenz", die Alnitak beschrieben hat). Wenn Sie diesen Wert ändern, ändern Sie nicht das ursprüngliche Objekt, Sie ändern Ihre Kopie dieser Referenz.


Meine 2 Cent ... Es ist irrelevant, ob JavaScript Parameter per Referenz oder Wert übergibt. Worauf es wirklich ankommt, ist die Zuordnung zur Mutation.

Ich habe hier eine längere, ausführlichere Erklärung geschrieben ( Ist JavaScript eine Pass-by-Reference- oder eine Pass-by-Value-Sprache? )

Wenn Sie etwas übergeben (ob das ein Objekt oder ein Primitiv ist), weisen alle Javascript-Funktionen eine neue Variable zu, während sie in der Funktion sind ... genauso wie das Gleichheitszeichen (=)

Wie sich dieser Parameter in der Funktion verhält, ist genau so, wie er sich verhalten würde, wenn Sie gerade eine neue Variable mit dem Gleichheitszeichen zugewiesen hätten. Nehmen Sie diese einfachen Beispiele.

var myString = 'Test string 1';

// Assignment - A link to the same place as myString
var sameString = myString;

// If I change sameString, it will not modify myString, 
// it just re-assigns it to a whole new string
sameString = 'New string';

console.log(myString); // logs 'Test string 1';
console.log(sameString); // logs 'New string';

Wenn ich myString als Parameter an eine Funktion übergeben würde, verhält es sich so, als würde ich es einfach einer neuen Variablen zuweisen. Nun, machen wir dasselbe, aber mit einer Funktion anstelle einer einfachen Zuweisung

function myFunc(sameString) {

    // Re assignment.. again, it will not modify myString
    sameString = 'New string';
}

var myString = 'Test string 1';

// This behaves the same as if we said sameString = myString
myFunc(myString);

console.log(myString); // Again, logs 'Test string 1';

Der einzige Grund, dass Sie Objekte ändern können, wenn Sie sie an eine Funktion übergeben, liegt daran, dass Sie sie nicht neu zuweisen. Stattdessen können Objekte geändert oder mutiert werden. Auch hier funktioniert es auf die gleiche Weise.

var myObject = { name: 'Joe'; }

// Assignment - We simply link to the same object
var sameObject = myObject;

// This time, we can mutate it. So a change to myObject affects sameObject and visa versa
myObject.name = 'Jack';
console.log(sameObject.name); // Logs 'Jack'

sameObject.name = 'Jill';
console.log(myObject.name); // Logs 'Jill'

// If we re-assign it, the link is lost
sameObject = { name: 'Howard' };
console.log(myObject.name); // Logs 'Jill'

Wenn ich myObject als Parameter an eine Funktion übergeben würde, verhält es sich so, als ob ich es einfach einer neuen Variablen zugewiesen hätte. Wiederum dasselbe mit dem exakt gleichen Verhalten, aber mit einer Funktion.

function myFunc(sameObject) {

    // We mutate the object, so the myObject gets the change too... just like before.
    sameObject.name = 'Jill';

    // But, if we re-assign it, the link is lost
    sameObject = { name: 'Howard' };
}

var myObject = { name: 'Joe'; }

// This behaves the same as if we said sameObject = myObject;
myFunc(myObject);
console.log(myObject.name); // Logs 'Jill'

Jedes Mal, wenn Sie eine Variable an eine Funktion übergeben, werden Sie dem Namen des Parameters "zugewiesen", so als ob Sie das Gleichheitszeichen (=) verwendet hätten.

Denken Sie immer daran, dass das Gleichheitszeichen (=) die Zuweisung bedeutet. Und das Übergeben eines Parameters an eine Funktion bedeutet auch eine Zuweisung. Sie sind gleich und die 2 Variablen sind auf die gleiche Weise verbunden.

Der einzige Zeitpunkt, zu dem das Ändern einer Variablen eine andere Variable beeinflusst, ist, wenn das zugrunde liegende Objekt mutiert ist.

Es macht keinen Sinn, zwischen Objekten und Primitiven zu unterscheiden, weil es genau so funktioniert, als ob Sie keine Funktion hätten und einfach das Gleichheitszeichen verwenden würden, um es einer neuen Variablen zuzuordnen.


Ohne Purismen denke ich, dass der beste Weg, Skalarargument durch Referenz in Javascript zu emulieren, das Objekt ist, wie die vorherige Antwort sagt.

Ich mache jedoch ein bisschen anders:

Ich habe die Objektzuordnung innerhalb des Funktionsaufrufs gemacht, so dass man die Referenzparameter in der Nähe des Funktionsaufrufs sehen kann. Es erhöht die Lesbarkeit der Quelle

In der Funktionsdeklaration habe ich die Eigenschaften wie einen Kommentar gesetzt, aus dem gleichen Grund: Lesbarkeit.

var r;

funcWithRefScalars(r = {amount:200, message:null} );
console.log(r.amount + " - " + r.message);


function funcWithRefScalars(o) {  // o(amount, message)
  o.amount  *= 1.2;
  o.message = "20% increase";
}

Im obigen Beispiel zeigt null eindeutig einen Ausgangsreferenzparameter an.

Der Ausgang:

240 - 20% Increase

Auf der Clientseite sollte console.log durch eine alert ersetzt werden.

★★★

Eine andere Methode, die noch besser lesbar ist:

var amount, message;

funcWithRefScalars(amount = [200], message = [null] );
console.log(amount[0] + " - " + message[0]);

function funcWithRefScalars(amount, message) {  // o(amount, message)
   amount[0]  *= 1.2;
   message[0] = "20% increase";
}

Hier müssen Sie nicht einmal neue Dummy-Namen erstellen, wie oben r .


Wie bei C wird letztendlich alles nach Wert weitergegeben. Im Gegensatz zu C können Sie den Speicherort einer Variablen nicht sichern und übergeben, da Zeiger nicht nur Verweise enthalten.

Und die Referenzen, die es hat, sind alle Objekte, keine Variablen. Es gibt mehrere Möglichkeiten, um das gleiche Ergebnis zu erzielen, aber sie müssen von Hand ausgeführt werden und nicht nur ein Schlüsselwort an der Aufruf- oder Deklarationsseite hinzufügen.





pass-by-value