Laat JavaScript verwijzingen of waarden voorbij?
Hier is een voorbeeld van JavaScript: The Good Parts. Ik ben erg in de war over de parameter my voor de rechthoekfunctie. Het is eigenlijk undefined, en opnieuw gedefinieerd binnen de functie. Er zijn geen originele referenties. Als ik het verwijder uit de functieparameter, heeft de binnengebiedfunctie er geen toegang toe.
Is het een afsluiting? Maar er wordt geen functie geretourneerd.
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());
Antwoord 1, autoriteit 100%
Primitieven worden doorgegeven op basis van waarde en objecten worden doorgegeven via “kopie van een referentie”.
In het bijzonder, wanneer u een object (of array) doorgeeft, geeft u (onzichtbaar) een verwijzing naar dat object door, en het is mogelijk om de inhoud van dat object te wijzigen, maar als u probeert overschrijf de referentie, dit heeft geen invloed op de kopie van de referentie in het bezit van de beller – dwz de referentie zelf wordt doorgegeven door waarde:
function replace(ref) {
ref = {}; // this code does _not_ affect the object passed
}
function update(ref) {
ref.key = 'newvalue'; // this code _does_ affect the _contents_ of the object
}
var a = { key: 'value' };
replace(a); // a still has its original value - it's unmodfied
update(a); // the _contents_ of 'a' are changed
Antwoord 2, autoriteit 8%
Zie het als volgt:
Telkens wanneer u een object maakt in ECMAscript, wordt dit object gevormd op een mystieke ECMAscript universele plaats waar niemand ooit zal kunnen komen. Het enige wat je terugkrijgt is een verwijzing naar dat object op deze mystieke plek.
var obj = { };
Zelfs obj is slechts een verwijzing naar het object (dat zich op die speciale prachtige plek bevindt) en daarom kun je deze verwijzing alleen maar doorgeven. In feite zal elk stukje code dat toegang heeft tot obj het object wijzigen dat ver, ver weg is.
Antwoord 3, autoriteit 8%
Mijn twee cent… Het is niet relevant of JavaScript parameters doorgeeft als referentie of waarde. Wat er echt toe doet, is toewijzing versus mutatie.
Ik schreef een langere, meer gedetailleerde uitleg in deze link.
Als je iets doorgeeft (of dat nu een object of een primitief is), is het enige dat JavaScript doet een nieuwe variabele toewijzen binnen de functie… net als het gelijkteken (=).
Hoe die parameter zich binnen de functie gedraagt, is precies hetzelfde als wanneer je een nieuwe variabele zou toewijzen met het gelijkteken… Neem deze eenvoudige voorbeelden.
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';Antwoord 4, autoriteit 4%
Functieargumenten worden doorgegeven op basis van waarde of gedeeld, maar nooit ooit als referentie in JavaScript!
Call-by-Value
Primitieve typen worden per waarde doorgegeven:
var num = 123, str = "foo";
function f(num, str) {
num += 1;
str += "bar";
console.log("inside of f:", num, str);
}
f(num, str);
console.log("outside of f:", num, str);Antwoord 5, autoriteit 3%
Net als bij C wordt uiteindelijk alles op waarde doorgegeven. In tegenstelling tot C kunt u geen back-up maken en de locatie van een variabele doorgeven, omdat deze geen verwijzingen heeft, alleen verwijzingen.
En de verwijzingen die het heeft zijn allemaal naar objecten, niet naar variabelen. Er zijn verschillende manieren om hetzelfde resultaat te bereiken, maar ze moeten met de hand worden gedaan, niet alleen door een trefwoord toe te voegen op de oproep- of declaratiesite.
Antwoord 6
JavaScript is een doorgegeven waarde.
Voor primitieven wordt de waarde van primitief doorgegeven. Voor Objecten wordt de referentie “waarde” van Object doorgegeven.
Voorbeeld met object:
var f1 = function(inputObject){
inputObject.a = 2;
}
var f2 = function(){
var inputObject = {"a": 1};
f1(inputObject);
console.log(inputObject.a);
}
Als u f2 aanroept, wordt de “a”-waarde afgedrukt als 2 in plaats van 1, omdat de referentie wordt doorgegeven en de “a”-waarde in de referentie wordt bijgewerkt.
Voorbeeld met primitief:
var f1 = function(a){
a = 2;
}
var f2 = function(){
var a = 1;
f1(a);
console.log(a);
}
Het aanroepen van f2 resulteert in het afdrukken van een “a”-waarde als 1.
Antwoord 7
In het belang van het maken van een eenvoudig voorbeeld dat 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
Antwoord 8
In praktische termen, Alnitak is correct en maakt het gemakkelijk om te begrijpen, maar uiteindelijk wordt in JavaScript alles op waarde doorgegeven.
Wat is de “waarde” van een object? Het is de objectreferentie.
Als je een object doorgeeft, krijg je een kopie van deze waarde (vandaar de ‘kopie van een referentie’ die Alnitak beschreef). Als u deze waarde wijzigt, wijzigt u het oorspronkelijke object niet; u wijzigt uw kopie van die referentie.
Antwoord 9
“Globale” JavaScript-variabelen zijn leden van het vensterobject. U kunt de referentie openen als lid van het vensterobject.
var v = "initialized";
function byref(ref) {
window[ref] = "changed by ref";
}
byref((function(){for(r in window){if(window[r]===v){return(r);}}})());
// It could also be called like... byref('v');
console.log(v); // outputs changed by ref
Let op, het bovenstaande voorbeeld werkt niet voor variabelen die binnen een functie zijn gedeclareerd.
Antwoord 10
Zonder purisme denk ik dat de beste manier om scalaire argumenten door verwijzing in JavaScript te emuleren, het gebruik van een object is, zoals eerder een antwoord vertelt.
Ik doe het echter een beetje anders:
Ik heb de objecttoewijzing binnen de functieaanroep gedaan, zodat men de referentieparameters in de buurt van de functieaanroep kan zien. Het verhoogt de leesbaarheid van de bron.
In functiedeclaratie plaats ik de eigenschappen als een opmerking, om precies dezelfde reden: leesbaarheid.
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";
}
In het bovenstaande voorbeeld geeft null duidelijk een uitvoerreferentieparameter aan.
De uitgang:
240 - 20% Increase
Aan de clientzijde moet console.log worden vervangen door alert.
? ? ?
Een andere methode die nog leesbaarder kan zijn:
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 hoeft u niet eens nieuwe dummy-namen te maken, zoals r hierboven.
Antwoord 11
Primitieven worden op waarde doorgegeven. Maar als u alleen de waarde van een primitieve hoeft te lezen (en de waarde is niet bekend op het moment dat de functie wordt aangeroepen), kunt u de functie doorgeven die de waarde ophaalt op het moment dat u deze nodig heeft.
function test(value) {
console.log('retrieve value');
console.log(value());
}
// call the function like this
var value = 1;
test(() => value);
Antwoord 12
Ik kan pass-by-reference niet zien in de voorbeelden waarin mensen dit proberen aan te tonen. Ik zie alleen pass-by-waarde.
In het geval van variabelen die een verwijzing naar een object bevatten, is de verwijzing de waarde van die variabelen, en daarom wordt de verwijzing doorgegeven, wat dan pass-by-value is .
In een verklaring als deze,
var a = {
b: "foo",
c: "bar"
};
de waarde van de ‘a’ is niet het Object, maar de (tot dusver enige) verwijzing ernaar. Met andere woorden, het object bevindt zich niet in de variabele a – een verwijzing ernaar wel. Ik denk dat dit iets is dat moeilijk lijkt voor programmeurs die voornamelijk alleen bekend zijn met JavaScript. Maar het is gemakkelijk voor mensen die ook b.v. Java, C# en C.
Antwoord 13
Objecten worden altijd doorgegeven door middel van referentie en primitieven door waarde. Houd die parameter gewoon op hetzelfde adres voor objecten.
Hier is wat code om te illustreren wat ik bedoel (probeer het in een JavaScript-sandbox zoals https://js.do/).
Helaas kunt u niet alleen het adres van de parameter behouden; je behoudt ook alle originele ledenwaarden.
a = { key: 'bevmo' };
testRetain(a);
document.write(' after function ');
document.write(a.key);
function testRetain (b)
{
document.write(' arg0 is ');
document.write(arguments[0].key);
b.key = 'passed by reference';
var retain = b; // Retaining the original address of the parameter
// Address of left set to address of right, changes address of parameter
b = {key: 'vons'}; // Right is a new object with a new address
document.write(' arg0 is ');
document.write(arguments[0].key);
// Now retrieve the original address of the parameter for pass by reference
b = retain;
document.write(' arg0 is ');
document.write(arguments[0].key);
}
Resultaat:
arg0 is bevmo arg0 is vons arg0 wordt doorgegeven door verwijzing na functie doorgegeven door verwijzing