JavaScript-Objekte als Parameter der Funktion

Javascript Funktionsumfang. Dies bedeutet, dass jede variable in einer Funktion deklariert wurde, wird nur zugänglich sein, von innerhalb der Funktion.

Wenn Sie möchten, korrekt deklariert die objectX variable mit var wie folgt:

function X() {
    ...
    var objectX = {};
    ...
    return objectX;
}

dann objectX wäre nur bekannt als objectX innerhalb der X Funktion. Anderswo, es wäre bekannt als welcher variable würde Sie es zugewiesen haben. Da in deinem code, die du nicht zuordnen das Ergebnis X() etwas objectX würde nicht von überall zugänglich.

Jedoch ist hier eine Javascript mehr schwere design-Fehler: wenn Sie nicht explizit eine variable deklarieren (mit dem var - Anweisung oder als Funktions-parameter), diese variable wird automatisch ein globalen variable. Das bedeutet, dass er zugänglich sein wird überall.

Weil dies in Ihrem code, können Sie den Zugriff objectX überall mit diesem Namen.

anObject, auf der anderen Seite ist richtig angegeben (als parameter), und das bedeutet, dass Ihr Geltungsbereich beschränkt sich auf die Z Funktion.

Kurz gesagt, die Art, wie dein code geschrieben ist, objectX zugänglich ist, überall durch die objectX variable und innerhalb der Funktion Z Sie verweisen können es sowohl als objectX und als anObject.

Tun, beachten Sie jedoch, dass Globale Variablen sind eine Schlechte Sache™, da können Sie machen es sehr schwer, herauszufinden, welche variable zugewiesen bekommt durch wen, Wann und warum — wie Sie bemerkt haben.

Während Javascript macht es unmöglich, vollständig zu vermeiden, Sie in der Regel versuchen Sie, den Umfang Ihrer Variablen so klein wie möglich (Bereich=, wo in Ihrem Programm, dass die variable zugegriffen werden kann).

Zu diesem Zweck würde ich empfehlen, refactoring Ihres Codes, wie igorw hat.

InformationsquelleAutor Martijn

Dies ist vor allem eine Frage des Umfangs.

function X() {
    //local objectX, only accessible through this name inside X()
    var objectX = {};
    objectX.foo = 'bar';
    return objectX;
}

function Z(somevar, anObject) {
    //anObject is passed in as a parameter
    //it's only accessible through this name inside Z()
    anObject.foo = somevar;
    return anObject;
}

//get the 'objectX' from X() and store it in global variable a
var a = X();

//pass the received 'objectX' into Z()
//note that the variable names objectX and anObject cannot be accessed
//because they are local variables of the functions X() /Z()
var b = Z('baz', a);

//a is now the same as b, they both reference the same var
//a.foo and b.foo both are set to 'baz'

InformationsquelleAutor igorw

Hier ist der link zu jsfiddle

Nehmen wir das folgende Beispiel unten:

Person = function(name){
 this.name = name;
}

function x(){
     var john = new Person('john');
     return john;
}

function z(tempVar, anObject){
    var newObj = anObject;
    newObj.name = tempVar;
    return newObj;
}

myPerson = x();
console.log(myPerson.name); //john
console.log(z('peter', myPerson).name);  //peter
console.log(myPerson.name); //peter

Können Sie sehen, obwohl Sie erstellt ein neues Objekt in z-sondern weil Sie referenzieren auf das gleiche Objekt myPerson name-Eigenschaft ebenfalls geändert, nachdem z() aufgerufen wird.

InformationsquelleAutor KJYe.Name