Typy prymitywne (liczba, ciąg itp.) Są przekazywane przez wartość, ale obiekty są nieznane, ponieważ oba mogą być przekazywane przez wartość (w przypadku, gdy uważamy, że zmienna przechowująca obiekt jest w rzeczywistości odniesieniem do obiektu ) i przekazywany przez odniesienie (gdy weźmiemy pod uwagę, że zmienna obiektu zawiera sam obiekt).

Chociaż na koniec nie ma to tak naprawdę znaczenia, chcę wiedzieć, jak poprawnie przedstawiać argumenty omawiające konwencje. Czy istnieje fragment specyfikacji JavaScript, który określa, jaka powinna być semantyka w tym zakresie?

To jest interesujące w JavaScript. Rozważ ten przykład:

function changeStuff(a, b, c)
{
  a = a * 10;
  b.item = "changed";
  c = {item: "changed"};
}

var num = 10;
var obj1 = {item: "unchanged"};
var obj2 = {item: "unchanged"};

changeStuff(num, obj1, obj2);

console.log(num);
console.log(obj1.item);
console.log(obj2.item);

To daje wynik:

10
changed
unchanged

• Gdyby w obj1ogóle nie było odniesieniem, zmiana obj1.itemnie miałaby wpływu na obj1zewnętrzną stronę funkcji.
• Gdyby argument był właściwym odniesieniem, wszystko by się zmieniło. numbyłby 100i obj2.itemczytałby "changed".

Zamiast tego sytuacja jest taka, że ​​przekazywany element jest przekazywany według wartości. Ale przedmiot przekazywany przez wartość sam w sobie jest odniesieniem. Technicznie jest to nazywane dzieleniem przez połączenie .

W praktyce oznacza to, że jeśli zmienisz sam parametr (jak w przypadku numi obj2), nie wpłynie to na element, który został wprowadzony do parametru. Ale jeśli zmienisz WEWNĘTRZNE parametru, nastąpi propagacja z powrotem (jak w przypadku obj1).

Zawsze przechodzi przez wartość, ale dla obiektów wartością zmiennej jest odwołanie. Z tego powodu, gdy mijasz obiekt i zmieniasz jego elementy , zmiany te pozostają poza funkcją. To sprawia, że wygląda jak przekazywany przez odniesienie. Ale jeśli faktycznie zmienisz wartość zmiennej obiektowej, zobaczysz, że zmiana nie utrzymuje się, co dowodzi, że naprawdę przechodzi ona przez wartość.

Przykład:

function changeObject(x) {
  x = { member: "bar" };
  console.log("in changeObject: " + x.member);
}

function changeMember(x) {
  x.member = "bar";
  console.log("in changeMember: " + x.member);
}

var x = { member: "foo" };

console.log("before changeObject: " + x.member);
changeObject(x);
console.log("after changeObject: " + x.member); /* change did not persist */

console.log("before changeMember: " + x.member);
changeMember(x);
console.log("after changeMember: " + x.member); /* change persists */

Wynik:

before changeObject: foo
in changeObject: bar
after changeObject: foo

before changeMember: foo
in changeMember: bar
after changeMember: bar

Zmienna nie „trzyma” obiektu; zawiera odniesienie. Możesz przypisać to odwołanie do innej zmiennej, a teraz oba odnoszą się do tego samego obiektu. Zawsze przechodzi przez wartość (nawet jeśli ta wartość jest odniesieniem ...).

Nie ma możliwości zmiany wartości przechowywanej przez zmienną przekazywaną jako parametr, co byłoby możliwe, gdyby JavaScript obsługiwał przekazywanie przez referencję.

Moje dwa centy ... Tak to rozumiem. (Możesz mnie poprawić, jeśli się mylę)

Czas wyrzucić wszystko, co wiesz o przekazywaniu według wartości / referencji.

Ponieważ w JavaScript nie ma znaczenia, czy jest przekazywany przez wartość, przez referencję czy cokolwiek innego. Liczy się mutacja vs. przypisanie parametrów przekazanych do funkcji.

OK, pozwól, że zrobię co w mojej mocy, aby wyjaśnić, co mam na myśli. Powiedzmy, że masz kilka obiektów.

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

To, co zrobiliśmy, to „przypisanie” ... Przypisaliśmy 2 oddzielne puste obiekty do zmiennych „object1” i „object2”.

Powiedzmy, że bardziej lubimy obiekt1 ... Więc „przypisujemy” nową zmienną.

var favoriteObject = object1;

Następnie, z jakiegokolwiek powodu, decydujemy, że obiekt 2 bardziej nam się podoba. Więc po prostu wykonujemy małe przeniesienie.

favoriteObject = object2;

Nic się nie stało z obiektem1 lub obiektem2. Nie zmieniliśmy żadnych danych. Wszystko, co zrobiliśmy, to ponowne przypisanie tego, co jest naszym ulubionym przedmiotem. Ważne jest, aby wiedzieć, że zarówno obiekt2, jak i ulubiony obiekt są przypisane do tego samego obiektu. Możemy zmienić ten obiekt za pomocą jednej z tych zmiennych.

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

OK, teraz spójrzmy na prymitywy takie jak na przykład łańcuchy

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

Ponownie wybieramy ulubionego.

var favoriteString = string1;

Zarówno nasze ulubione zmienne ciąg, jak i łańcuch1 są przypisane do „Hello world”. A co jeśli chcemy zmienić nasz ulubiony ciąg ??? Co się stanie???

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

Uh oh .... Co się stało. Nie mogliśmy zmienić string1, zmieniając ulubiony ciąg ... Dlaczego? Ponieważ nie zmieniliśmy naszego obiektu ciągu . Wszystko, co zrobiliśmy, to „RE ASSIGN” zmienna favoriteString do nowego ciągu. To zasadniczo odłączyło go od string1. W poprzednim przykładzie, kiedy zmieniliśmy nazwę naszego obiektu, nie przypisaliśmy niczego. (Cóż, nie do samej zmiennej ... jednak przypisaliśmy właściwość name do nowego ciągu.) Zamiast tego po prostu zmutowaliśmy obiekt, który utrzymuje połączenia między 2 zmiennymi a obiektami leżącymi u ich podstaw. (Nawet jeśli chcieliśmy zmodyfikować lub zmutować sam obiekt łańcuchowy, nie mogliśmy tego zrobić, ponieważ w JavaScript są ciągi niezmienne.)

Teraz do funkcji i przekazywania parametrów .... Kiedy wywołujesz funkcję i przekazujesz parametr, to, co zasadniczo robisz, to „przypisanie” do nowej zmiennej, i działa dokładnie tak samo, jakbyś po prostu przypisał za pomocą znak równości (=).

Weź te przykłady.

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'

Teraz to samo, ale z funkcją

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, teraz podajmy kilka przykładów z użyciem obiektów zamiast ... najpierw, bez funkcji.

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 the variable
otherObj = {
    firstName: 'Jack',
    lastName: 'Frost'
};

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

Teraz to samo, ale z wywołaniem funkcji

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 doesn't magically mutate 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, jeśli przeczytasz cały ten post, być może lepiej rozumiesz, jak wywołania funkcji działają w JavaScript. Nie ma znaczenia, czy coś jest przekazywane przez odniesienie, czy przez wartość ... Liczy się przypisanie vs mutacja.

Za każdym razem, gdy przekazujesz zmienną do funkcji, „przypisujesz” do dowolnej nazwy zmiennej parametru, tak jak w przypadku użycia znaku równości (=).

Zawsze pamiętaj, że znak równości (=) oznacza przypisanie. Zawsze pamiętaj, że przekazanie parametru do funkcji w JavaScript oznacza również przypisanie. Są takie same, a dwie zmienne są połączone dokładnie w ten sam sposób (to znaczy tak nie jest, chyba że policzysz, że są przypisane do tego samego obiektu).

Jedyny moment, w którym „modyfikowanie zmiennej” wpływa na inną zmienną, następuje po zmutowaniu obiektu leżącego u podstaw (w którym to przypadku nie zmodyfikowano zmiennej, ale sam obiekt.

Nie ma sensu wprowadzać rozróżnienia między obiektami a prymitywami, ponieważ działa on tak samo dokładnie, jakbyś nie miał funkcji, a jedynie użył znaku równości do przypisania nowej zmiennej.

Jedynym gotcha jest to, że nazwa zmiennej, którą przekazujesz do funkcji, jest taka sama jak nazwa parametru funkcji. Kiedy tak się dzieje, musisz traktować parametr wewnątrz funkcji tak, jakby była to zupełnie nowa zmienna prywatna dla funkcji (ponieważ tak jest)

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'

Rozważ następujące:

1. Zmienne są wskaźnikami do wartości w pamięci.
2. Ponowne przypisanie zmiennej jedynie wskazuje ten wskaźnik na nową wartość.
3. Ponowne przypisanie zmiennej nigdy nie wpłynie na inne zmienne wskazujące na ten sam obiekt

Więc zapomnij o „przekaż przez referencję / wartość” , nie rozłączaj się przy „przekaż przez referencję / wartość”, ponieważ:

1. Terminy są używane tylko do opisania zachowania języka, niekoniecznie rzeczywistej implementacji. W wyniku tej abstrakcji utracone zostają kluczowe szczegóły, które są niezbędne do rzetelnego wyjaśnienia, co nieuchronnie prowadzi do obecnej sytuacji, w której pojedynczy termin nie opisuje adekwatnie faktycznego zachowania i należy podać dodatkowe informacje
2. Pojęcia te nie zostały pierwotnie zdefiniowane z zamiarem opisania w szczególności javascript, więc nie czuję się zmuszony do ich używania, gdy tylko zwiększają zamieszanie.

Aby odpowiedzieć na twoje pytanie: wskaźniki są przekazywane.

// code
var obj = {
    name: 'Fred',
    num: 1
};

// illustration
               'Fred'
              /
             /
(obj) ---- {}
             \
              \
               1

// code
obj.name = 'George';


// illustration
                 'Fred'


(obj) ---- {} ----- 'George'
             \
              \
               1

// code
obj = {};

// illustration
                 'Fred'


(obj)      {} ----- 'George'
  |          \
  |           \
 { }            1

// code
var obj = {
    text: 'Hello world!'
};

/* function parameters get their own pointer to 
 * the arguments that are passed in, just like any other variable */
someFunc(obj);


// illustration
(caller scope)        (someFunc scope)
           \             /
            \           /
             \         /
              \       /
               \     /
                 { }
                  |
                  |
                  |
            'Hello world'

Kilka uwag końcowych:

• Kuszące jest myślenie, że prymitywy są wymuszane przez specjalne reguły, podczas gdy obiekty nie, ale prymitywy są po prostu końcem łańcucha wskaźnika.
• Jako ostatni przykład zastanów się, dlaczego wspólna próba wyczyszczenia tablicy nie działa zgodnie z oczekiwaniami.

var a = [1,2];
var b = a;

a = [];
console.log(b); // [1,2]
// doesn't work because `b` is still pointing at the original array

Obiekt poza funkcją jest przekazywany do funkcji przez podanie odwołania do obiektu zewnętrznego.

Kiedy używasz tego odwołania do manipulowania jego obiektem, wpływa to na obiekt na zewnątrz. Jeśli jednak wewnątrz funkcji postanowiłeś wskazać odniesienie do czegoś innego, w ogóle nie wpłynąłeś na obiekt na zewnątrz, ponieważ wszystko, co zrobiłeś, to przekierowanie odniesienia do czegoś innego.

Pomyśl o tym w ten sposób: zawsze chodzi o wartość. Jednak wartością obiektu nie jest sam obiekt, ale odniesienie do tego obiektu.

Oto przykład, przekazując liczbę (prymitywny typ)

function changePrimitive(val) {
    // At this point there are two '10's in memory.
    // Changing one won't affect the other
    val = val * 10;
}
var x = 10;
changePrimitive(x);
// x === 10

Powtórzenie tego z obiektem daje różne wyniki:

function changeObject(obj) {
    // At this point there are two references (x and obj) in memory,
    // but these both point to the same object.
    // changing the object will change the underlying object that
    // x and obj both hold a reference to.
    obj.val = obj.val * 10;
}
var x = { val: 10 };
changeObject(x);
// x === { val: 100 }

Jeszcze jeden przykład:

function changeObject(obj) {
    // Again there are two references (x and obj) in memory,
    // these both point to the same object.
    // now we create a completely new object and assign it.
    // obj's reference now points to the new object.
    // x's reference doesn't change.
    obj = { val: 100 };
}
var x = { val: 10 };
changeObject(x);
// x === { val: 10}

Bardzo szczegółowe wyjaśnienie na temat kopiowania, przekazywania i porównywania według wartości i przez odniesienie znajduje się w tym rozdziale książki „JavaScript: Przewodnik definitywny” .

Zanim przejdziemy do tematu manipulowania obiektami i tablicami przez odniesienie, musimy wyjaśnić punkt nazewnictwa.

Wyrażenie „przekazać przez odniesienie” może mieć kilka znaczeń. Dla niektórych czytelników fraza odnosi się do techniki wywoływania funkcji, która pozwala funkcji przypisywać nowe wartości do jej argumentów i wyświetlać te zmodyfikowane wartości poza funkcją. Nie jest to sposób, w jaki termin jest używany w tej książce.

Mamy tu na myśli po prostu to, że odwołanie do obiektu lub tablicy - a nie do samego obiektu - jest przekazywane do funkcji. Funkcja może używać odwołania do modyfikowania właściwości obiektu lub elementów tablicy. Ale jeśli funkcja zastąpi odwołanie odwołaniem do nowego obiektu lub tablicy, ta modyfikacja nie będzie widoczna poza funkcją.

Czytelnicy zaznajomieni z innym znaczeniem tego terminu mogą powiedzieć, że obiekty i tablice są przekazywane przez wartość, ale przekazywana wartość jest tak naprawdę odniesieniem, a nie samym obiektem.

JavaScript jest zawsze wartością przekazywaną ; wszystko ma wartość.

Obiekty są wartościami, a funkcje składowe obiektów same w sobie (pamiętaj, że funkcje są pierwszorzędnymi obiektami w JavaScript). Także w odniesieniu do koncepcji, że wszystko w JavaScript jest przedmiotem ; To jest źle. Ciągi, symbole, liczby, logiczne, null i niezdefiniowane są prymitywami .

Czasami mogą korzystać z niektórych funkcji członkowskich i właściwości odziedziczonych z ich podstawowych prototypów, ale jest to tylko dla wygody. Nie oznacza to, że same są obiektami. Wypróbuj następujące informacje:

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

W obu alertach znajdziesz wartość, która jest niezdefiniowana.

W JavaScript typ wartości kontroluje wyłącznie , czy ta wartość zostanie przypisana przez kopiowanie wartości, czy kopiowanie referencyjne .

Wartości pierwotne są zawsze przypisywane / przekazywane przez kopiowanie wartości :

• null
• undefined
• strunowy
• numer
• boolean
• symbol w ES6

Wartości złożone są zawsze przypisywane / przekazywane przez kopię referencyjną

• przedmioty
• tablice
• funkcjonować

Na przykład

var a = 2;
var b = a; // `b` is always a copy of the value in `a`
b++;
a; // 2
b; // 3

var c = [1,2,3];
var d = c; // `d` is a reference to the shared `[1,2,3]` value
d.push( 4 );
c; // [1,2,3,4]
d; // [1,2,3,4]

W powyższym fragmencie, ponieważ 2jest prymitywem skalarnym, azawiera jedną początkową kopię tej wartości i bprzypisuje jej inną kopię. Zmieniając b, w żaden sposób nie zmieniasz wartości w a.

Ale oba ci dsą oddzielne odniesienia do tej samej wartości dzielonego [1,2,3], która jest wartością związek. Ważne jest, aby pamiętać, że cani dwięcej, ani „nie posiada” [1,2,3]wartości - oba są po prostu równymi odniesieniami do wartości. Tak więc, gdy używasz dowolnego odwołania do modyfikacji ( .push(4)) rzeczywistej wspólnej arraywartości, wpływa to tylko na jedną wspólną wartość, a oba odwołania będą odnosić się do nowo zmodyfikowanej wartości [1,2,3,4].

var a = [1,2,3];
var b = a;
a; // [1,2,3]
b; // [1,2,3]

// later
b = [4,5,6];
a; // [1,2,3]
b; // [4,5,6]

Kiedy wykonujemy to zadanie b = [4,5,6], nie robimy absolutnie nic, aby wpłynąć na ato, gdzie nadal odwołuje się ( [1,2,3]). Aby to zrobić, bmusiałby być wskaźnikiem azamiast odniesienia do array- ale JS nie ma takiej możliwości!

function foo(x) {
    x.push( 4 );
    x; // [1,2,3,4]

    // later
    x = [4,5,6];
    x.push( 7 );
    x; // [4,5,6,7]
}

var a = [1,2,3];

foo( a );

a; // [1,2,3,4]  not  [4,5,6,7]

Kiedy przekazujemy argument a, przypisuje on kopię aodwołania do x. xi asą osobnymi odniesieniami wskazującymi tę samą [1,2,3]wartość. Teraz wewnątrz funkcji możemy użyć tego odwołania do mutacji samej wartości ( push(4)). Ale kiedy dokonujemy przypisania x = [4,5,6], nie ma to żadnego wpływu na to, gdzie awskazuje początkowe odniesienie - nadal wskazuje na (teraz zmodyfikowaną) [1,2,3,4]wartość.

Aby skutecznie przekazać wartość złożoną (jak an array) przez kopiowanie wartości, musisz ręcznie wykonać jej kopię, aby przekazane odwołanie nadal nie wskazywało na oryginał. Na przykład:

foo( a.slice() );

Wartość złożona (obiekt, tablica itp.), Którą można przekazać przez kopię referencyjną

function foo(wrapper) {
    wrapper.a = 42;
}

var obj = {
    a: 2
};

foo( obj );

obj.a; // 42

Tutaj objdziała jako opakowanie dla pierwotnej właściwości skalarnej a. Po przekazaniu foo(..)kopia objreferencji jest przekazywana i ustawiana na wrapperparametr. Teraz możemy użyć wrapperodwołania, aby uzyskać dostęp do współdzielonego obiektu i zaktualizować jego właściwość. Po zakończeniu funkcji obj.azobaczy zaktualizowaną wartość 42.

Źródło

cóż, chodzi o „wydajność” i „szybkość” oraz w prostym słowie „zarządzanie pamięcią” w języku programowania.

w javascript możemy umieścić wartości na dwóch warstwach: type1 - objectsi type2 - wszystkie inne typy wartości, takie jak string& boolean& etc

jeśli wyobrażasz sobie pamięć jako kwadraty poniżej, w których w każdym z nich można zapisać tylko jedną wartość type2:

każda wartość type2 (zielona) to pojedynczy kwadrat, podczas gdy wartość type1 (niebieski) to ich grupa :

chodzi o to, że jeśli chcesz wskazać wartość typu 2, adres jest prosty, ale jeśli chcesz zrobić to samo dla wartości typu 1, co wcale nie jest łatwe! :

i w bardziej skomplikowanej historii:

więc referencje mogą nas uratować:

podczas gdy zielona strzałka jest tutaj typową zmienną, fioletowa jest zmienną obiektową, więc ponieważ zielona strzałka (typowa zmienna) ma tylko jedno zadanie (i oznacza typową wartość), nie musimy oddzielać jej wartości od przesuwamy więc zieloną strzałkę z wartością tego, gdziekolwiek się ona znajduje, we wszystkich zadaniach, funkcjach i tak dalej ...

ale nie możemy zrobić tego samego z fioletową strzałką, możemy chcieć przenieść tu komórkę „Johna” lub wiele innych rzeczy ... więc fioletowa strzała przylgnie do tego miejsca i tylko typowe przypisane do niej strzałki będą się poruszać ...

bardzo myląca jest sytuacja, w której nie możesz zrozumieć, jak zmienia się twoja zmienna, do której się odwołujemy, spójrzmy na bardzo dobry przykład:

let arr = [1, 2, 3, 4, 5]; //arr is an object now and a purple arrow is indicating it
let obj2 = arr; // now, obj2 is another purple arrow that is indicating the value of arr obj
let obj3 = ['a', 'b', 'c'];
obj2.push(6); // first pic below - making a new hand for the blue circle to point the 6
//obj2 = [1, 2, 3, 4, 5, 6]
//arr = [1, 2, 3, 4, 5, 6]
//we changed the blue circle object value (type1-value) and due to arr and obj2 are indicating that so both of them changed
obj2 = obj3; //next pic below - changing the direction of obj2 array from blue circle to orange circle so obj2 is no more [1,2,3,4,5,6] and it's no more about changing anything in it but we completely changed its direction and now obj2 is pointing to obj3
//obj2 = ['a', 'b', 'c'];
//obj3 = ['a', 'b', 'c'];

To trochę więcej wyjaśnień dla przekazywania przez wartość i przekazywania przez referencję (JavaScript). W tej koncepcji mówią o przekazywaniu zmiennej przez referencję i przekazywaniu zmiennej przez referencję.

Przekaż według wartości (typ pierwotny)

var a = 3;
var b = a;

console.log(a); // a = 3
console.log(b); // b = 3

a=4;
console.log(a); // a = 4
console.log(b); // b = 3

• dotyczy wszystkich typów pierwotnych w JavaScript (ciąg, liczba, wartość logiczna, niezdefiniowana i null).
• a jest przydzielana pamięć (powiedzmy 0x001), a b tworzy kopię wartości w pamięci (powiedzmy 0x002).
• Zatem zmiana wartości zmiennej nie wpływa na drugą, ponieważ obie znajdują się w dwóch różnych lokalizacjach.

Przekaż przez odniesienie (obiekty)

var c = { "name" : "john" };
var d = c;

console.log(c); // { "name" : "john" }
console.log(d); // { "name" : "john" }

c.name = "doe";

console.log(c); // { "name" : "doe" }
console.log(d); // { "name" : "doe" }

• Mechanizm JavaScript przypisuje obiekt do zmiennej ci wskazuje na pewną pamięć, powiedzmy (0x012).
• Gdy d = c, w tym kroku dwskazuje tę samą lokalizację (0x012).
• Zmiana wartości dowolnych zmian wartości dla obu zmiennych.
• Funkcje są obiektami

Przypadek specjalny, przekazany przez odniesienie (obiekty)

c = {"name" : "jane"};
console.log(c); // { "name" : "jane" }
console.log(d); // { "name" : "doe" }

• Operator równości (=) konfiguruje nową przestrzeń pamięci lub adres

dzielenie się tym, co wiem o referencjach w JavaScript

W JavaScript, gdy przypisujesz obiekt do zmiennej, wartość przypisana do zmiennej jest odniesieniem do obiektu:

var a = {
  a: 1,
  b: 2,
  c: 3
};
var b = a;

// b.c is referencing to a.c value
console.log(b.c) // Output: 3
// Changing value of b.c
b.c = 4
// Also changes the value of a.c
console.log(a.c) // Output: 4

Semantyka!! Ustalenie konkretnych definicji z konieczności spowoduje, że niektóre odpowiedzi i komentarze będą niezgodne, ponieważ nie opisują tego samego, nawet przy użyciu tych samych słów i fraz, ale bardzo ważne jest, aby uniknąć zamieszania (szczególnie dla nowych programistów).

Przede wszystkim istnieje wiele poziomów abstrakcji, których nie wszyscy zdają się rozumieć. Nowi programiści, którzy nauczyli się języków 4. lub 5. generacji, mogą mieć trudności z koncentracją się na pojęciach znanych z asemblera lub programistami C, którzy nie są podzieleni na stopnie na wskaźniki na wskaźniki. Przekazywanie przez odniesienie nie oznacza po prostu możliwości zmiany obiektu, do którego istnieje odwołanie, za pomocą zmiennej parametru funkcji.

Zmienna : Połączona koncepcja symbolu, który odwołuje się do wartości w określonym miejscu w pamięci. Termin ten jest zwykle zbyt obciążony, aby można go było stosować w pojedynkę przy omawianiu szczegółów.

Symbol : Ciąg tekstowy używany w odniesieniu do zmiennej (tj. Nazwa zmiennej).

Wartość : poszczególne bity przechowywane w pamięci i do których odwołuje się symbol zmiennej.

Lokalizacja pamięci : gdzie przechowywana jest wartość zmiennej. (Sama lokalizacja jest reprezentowana przez liczbę oddzielną od wartości przechowywanej w lokalizacji).

Parametr funkcji : Zmienna zadeklarowana w definicji funkcji, używana do odwoływania się do zmiennych przekazywanych do funkcji.

Argument funkcji : Zmienna poza funkcją, która jest przekazywana do funkcji przez program wywołujący.

Zmienna obiektowa : Zmienna, której podstawową wartością bazową nie jest sam „obiekt”, a raczej jej wartość jest wskaźnikiem (wartością lokalizacji pamięci) do innej lokalizacji w pamięci, w której przechowywane są rzeczywiste dane obiektu. W większości języków wyższej generacji aspekt „wskaźnika” jest skutecznie ukryty przez automatyczne usuwanie odnośników w różnych kontekstach.

Zmienna pierwotna : Zmienna, której wartość JEST wartością rzeczywistą. Nawet ta koncepcja może być skomplikowana przez automatyczne boxowanie i konteksty obiektowe różnych języków, ale ogólne idee są takie, że wartość zmiennej JEST rzeczywistą wartością reprezentowaną przez symbol zmiennej, a nie wskaźnik do innej lokalizacji pamięci.

Argumenty funkcji i parametry to nie to samo. Ponadto wartość zmiennej nie jest przedmiotem zmiennej (jak już zauważyli różni ludzie, ale najwyraźniej zostały zignorowane). Te rozróżnienia mają kluczowe znaczenie dla właściwego zrozumienia.

Przekazywanie według wartości lub Call-by-sharing (dla obiektów): Wartość argumentu funkcji jest KOPIOWANA do innej lokalizacji w pamięci, do której odwołuje się symbol parametru funkcji (niezależnie od tego, czy znajduje się na stosie, czy na stosie). Innymi słowy, parametr funkcji otrzymał kopię wartości przekazanego argumentu ... ORAZ (krytyczny) wartość argumentu NIE JEST NIGDY AKTUALIZOWANA / ZMIENIONA / ZMIENIONA przez funkcję wywołującą. Pamiętaj, że wartość zmiennej obiektowej NIE jest samym obiektem, a raczej wskaźnikiem do obiektu, więc przekazanie zmiennej obiektowej przez wartość kopiuje wskaźnik do zmiennej parametru funkcji. Wartość parametru funkcji wskazuje dokładnie ten sam obiekt w pamięci. Same dane obiektowe można zmienić bezpośrednio za pomocą parametru funkcji, ALE wartość argumentu funkcji NIE JEST NIGDY AKTUALIZOWANA, więc nadal będzie wskazywać na to samoobiekt w trakcie, a nawet po wywołaniu funkcji (nawet jeśli dane jego obiektu zostały zmienione lub jeśli parametrowi funkcji przypisano zupełnie inny obiekt). Błędne jest stwierdzenie, że argument funkcji został przekazany przez referencję tylko dlatego, że obiekt, do którego istnieje odwołanie, można aktualizować za pomocą zmiennej parametru funkcji.

Wywołanie / przekazanie przez odniesienie : Wartość argumentu funkcji może / zostanie zaktualizowana bezpośrednio przez odpowiedni parametr funkcji. Jeśli to pomaga, parametr funkcji staje się efektywnym „aliasem” argumentu - efektywnie odnoszą się do tej samej wartości w tym samym miejscu w pamięci. Jeśli argument funkcji jest zmienną obiektu, możliwość zmiany danych obiektu nie różni się od przypadku przekazywania wartości, ponieważ parametr funkcji nadal wskazuje ten sam obiekt co argument. Ale w przypadku zmiennej obiektowej, jeśli parametr funkcji jest ustawiony na zupełnie inny obiekt, wówczas argument również będzie wskazywał na inny obiekt - nie dzieje się tak w przypadku przekazywania wartości.

JavaScript nie przechodzi przez odniesienie. Jeśli będziesz czytał uważnie, zdasz sobie sprawę, że wszystkie przeciwne opinie błędnie rozumieją, co rozumie się przez wartość przekazywaną, i fałszywie wyciągają wniosek, że możliwość aktualizacji danych obiektu za pomocą parametru funkcji jest synonimem „przekazywanej przez wartość”.

Klonowanie / kopiowanie obiektu: tworzony jest nowy obiekt, a dane oryginalnego obiektu są kopiowane. Może to być kopia głęboka lub płytka, ale chodzi o to, że tworzony jest nowy obiekt. Tworzenie kopii obiektu jest odrębnym pojęciem od wartości przekazywanej. Niektóre języki rozróżniają obiekt klasy i struktury (lub tym podobne) i mogą mieć różne zachowanie do przekazywania zmiennych różnych typów. Ale JavaScript nie robi nic takiego automatycznie podczas przekazywania zmiennych obiektowych. Ale brak automatycznego klonowania obiektów nie przekłada się na przekazywanie przez odniesienie.

JavaScript przekazuje typy pierwotne według wartości, a typy obiektów przez referencję

Teraz ludzie lubią bez końca sprzeczać się, czy „przekazanie przez referencję” jest właściwym sposobem na opisanie tego, co Java i in. faktycznie tak. Chodzi o to, że:

1. Przekazanie obiektu nie powoduje skopiowania obiektu.
2. Obiekt przekazany do funkcji może mieć zmodyfikowane przez nią elementy.
3. Prymitywna wartość przekazana do funkcji nie może być modyfikowana przez funkcję. Zostanie wykonana kopia.

W mojej książce, która nazywa się przekazywaniem przez odniesienie.

- Brian Bi - Jakie języki programowania są przekazywane przez odniesienie?

Aktualizacja

Oto odpowiedź na to:

W JavaScript nie ma opcji „pass by reference”.

Mój prosty sposób na zrozumienie tego ...

• Podczas wywoływania funkcji przekazujesz zawartość (odwołanie lub wartość) zmiennych argumentu, a nie same zmienne.

  var var1 = 13;
  var var2 = { prop: 2 };
  
  //13 and var2's content (reference) are being passed here
  foo(var1, var2); 

• Wewnątrz funkcji, zmienne parametrów inVar1i inVar2, odbieramy przekazywaną treść.

  function foo(inVar1, inVar2){
      //changing contents of inVar1 and inVar2 won't affect variables outside
      inVar1 = 20;
      inVar2 = { prop: 7 };
  }

• Po inVar2otrzymaniu odwołania do { prop: 2 }możesz zmienić wartość właściwości obiektu.

  function foo(inVar1, inVar2){
      inVar2.prop = 7; 
  }

Przekazywanie argumentów do funkcji w JavaScript jest analogiczne do przekazywania parametrów przez wartość wskaźnika w C:

/*
The following C program demonstrates how arguments
to JavaScript functions are passed in a way analogous
to pass-by-pointer-value in C. The original JavaScript
test case by @Shog9 follows with the translation of
the code into C. This should make things clear to
those transitioning from C to JavaScript.

function changeStuff(num, obj1, obj2)
{
    num = num * 10;
    obj1.item = "changed";
    obj2 = {item: "changed"};
}

var num = 10;
var obj1 = {item: "unchanged"};
var obj2 = {item: "unchanged"};
changeStuff(num, obj1, obj2);
console.log(num);
console.log(obj1.item);    
console.log(obj2.item);

This produces the output:

10
changed
unchanged
*/

#include <stdio.h>
#include <stdlib.h>

struct obj {
    char *item;
};

void changeStuff(int *num, struct obj *obj1, struct obj *obj2)
{
    // make pointer point to a new memory location
    // holding the new integer value
    int *old_num = num;
    num = malloc(sizeof(int));
    *num = *old_num * 10;
    // make property of structure pointed to by pointer
    // point to the new value
    obj1->item = "changed";
    // make pointer point to a new memory location
    // holding the new structure value
    obj2 = malloc(sizeof(struct obj));
    obj2->item = "changed";
    free(num); // end of scope
    free(obj2); // end of scope
}

int num = 10;
struct obj obj1 = { "unchanged" };
struct obj obj2 = { "unchanged" };

int main()
{
    // pass pointers by value: the pointers
    // will be copied into the argument list
    // of the called function and the copied
    // pointers will point to the same values
    // as the original pointers
    changeStuff(&num, &obj1, &obj2);
    printf("%d\n", num);
    puts(obj1.item);
    puts(obj2.item);
    return 0;
}

W przypadku prawników zajmujących się językiem programowania przejrzałem następujące sekcje ECMAScript 5.1 (który jest łatwiejszy do odczytania niż najnowsze wydanie) i posunąłem się do pytania na liście mailingowej ECMAScript.

TL; DR : Wszystkie rzeczy są przekazywane przez wartość, ale właściwości Objects są referencjami, a definicja obiektu jest przerażająco brakuje w standardzie.

Konstrukcja list argumentów

Sekcja 11.2.4 „Listy argumentów” mówi o tworzeniu listy argumentów składającej się tylko z 1 argumentu:

ArgumentList produkcji: AssignmentExpression jest oceniany w następujący sposób:

1. Niech ref będzie wynikiem oceny AssignmentExpression.
2. Niech arg będzie GetValue (ref).
3. Zwraca listę, której jedynym przedmiotem jest arg.

W tej sekcji wymieniono również przypadki, w których lista argumentów zawiera 0 lub> 1 argumentów.

Zatem wszystko jest przekazywane przez odniesienie.

Dostęp do właściwości obiektu

Sekcja 11.2.1 „Akcesorium nieruchomości”

Produkcja MemberExpression: MemberExpression [Expression] jest oceniana w następujący sposób:

1. Niech baseReference będzie wynikiem oceny MemberExpression.
2. Niech baseValue będzie GetValue (baseReference).
3. Niech propertyNameReference będzie wynikiem oceny wyrażenia.
4. Niech propertyNameValue będzie GetValue (propertyNameReference).
5. Wywołaj CheckObjectCoercible (baseValue).
6. Niech propertyNameString będzie ToString (propertyNameValue).
7. Jeśli oceniana produkcja syntaktyczna jest zawarta w kodzie trybu ścisłego, niech ścisłe będzie prawdziwe, w przeciwnym razie ścisłe będzie fałszywe.
8. Zwraca wartość typu Odwołanie, którego wartością podstawową jest baseValue, a nazwa, do której istnieje odwołanie, to właściwośćNazwaString, a flaga trybu ścisłego jest ścisła.

Zatem właściwości obiektów są zawsze dostępne jako odniesienie.

W sprawie odniesienia

W sekcji 8.7 „Typ specyfikacji odniesienia” opisano, że odwołania nie są prawdziwymi typami w języku - służą jedynie do opisania zachowania operatorów usuwania, typeof i przypisania.

Definicja „obiektu”

W wydaniu 5.1 zdefiniowano, że „Obiekt jest zbiorem właściwości”. Dlatego możemy wnioskować, że wartością obiektu jest kolekcja, ale co do wartości kolekcji jest źle zdefiniowane w specyfikacji i wymaga trochę wysiłku, aby zrozumieć.

Dokumenty MDN wyjaśniają to jasno, nie będąc zbyt gadatliwym:

Parametry wywołania funkcji są argumentami funkcji . Argumenty są przekazywane do funkcji według wartości . Jeśli funkcja zmienia wartość argumentu, zmiana ta nie jest odzwierciedlana globalnie ani w funkcji wywołującej. Jednak odwołania do obiektów również są wartościami i są wyjątkowe: jeśli funkcja zmienia właściwości obiektu, do którego się odnosi, zmiana ta jest widoczna poza funkcją, (...)

Źródło: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions#Description

W języku niskiego poziomu, jeśli chcesz przekazać zmienną przez referencję, musisz użyć określonej składni przy tworzeniu funkcji:

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

&ageJest odniesieniem do myAge, ale jeśli chcesz, wartość trzeba konwertować odniesienia, używając *age.

Javascript jest językiem wysokiego poziomu, który wykonuje tę konwersję za Ciebie. Tak więc, chociaż obiekty są przekazywane przez referencję, język konwertuje parametr referencyjny na wartość. Nie musisz używać &definicji funkcji, aby przekazać ją przez odwołanie, ani *w ciele funkcji, aby przekonwertować odwołanie na wartość, JS robi to za Ciebie.

Właśnie dlatego, gdy próbujesz zmienić obiekt wewnątrz funkcji, zastępując jego wartość (tj. age = {value:5}), Zmiana nie jest utrzymywana, ale jeśli zmienisz jej właściwości (tj. age.value = 5), Tak się stanie.

Ucz się więcej

Przeczytałem te odpowiedzi wiele razy, ale NAPRAWDĘ nie dostałem, dopóki nie dowiedziałem się o technicznej definicji „Dzwoń przez udostępnianie”, jak to określiła Barbara Liskov

Semantyka wywołania przez udostępnianie różni się od wywołania przez odwołanie tym, że przypisania argumentów funkcji w funkcji nie są widoczne dla wywołującego (w przeciwieństwie do semantyki odniesienia) [potrzebne cytowanie], więc np. Jeśli zmienna została przekazana, nie jest to możliwe symulować przypisanie do tej zmiennej w zakresie osoby dzwoniącej. Ponieważ jednak funkcja ma dostęp do tego samego obiektu co obiekt wywołujący (nie jest wykonywana kopia), mutacje tych obiektów, jeśli obiekty są zmienne, wewnątrz funkcji są widoczne dla obiektu wywołującego, który może wydawać się różnić od wywołania pod względem wartości semantyka. Mutacje obiektu podlegającego mutacji w ramach funkcji są widoczne dla obiektu wywołującego, ponieważ obiekt nie jest kopiowany ani klonowany - jest udostępniany.

Oznacza to, że odniesienia parametrów można zmieniać, jeśli przejdziesz i uzyskasz dostęp do samej wartości parametru. Z drugiej strony przypisanie do parametru zniknie po analizie i będzie niedostępne dla funkcji wywołującej.

Przeważnie najprostszy sposób

// Copy JS object without reference
var first = {"a":"value1","b":"value2"};
var clone = JSON.parse( JSON.stringify( first ) ); 

var second = ["a","b","c"];
var clone = JSON.parse( JSON.stringify( second ) ); 

Znalazłem sposób przedłużyć z biblioteki underscore.js bardzo przydatna, gdy chcę przejść do obiektu jako parametr, który może być albo całkowicie zmodyfikowany lub zastąpiony.

function replaceOrModify(aObj) {
  if (modify) {

    aObj.setNewValue('foo');

  } else {

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

Najbardziej zwięzłe wyjaśnienie, jakie znalazłem, to przewodnik po stylu AirBNB :

• Prymitywy : kiedy uzyskujesz dostęp do typu prymitywnego, pracujesz bezpośrednio nad jego wartością

  • strunowy
  • numer
  • boolean
  • zero
  • nieokreślony

Na przykład:

var foo = 1,
    bar = foo;

bar = 9;

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

• Złożony : Gdy uzyskujesz dostęp do typu złożonego, pracujesz nad odniesieniem do jego wartości

  • obiekt
  • szyk
  • funkcjonować

Na przykład:

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

bar[0] = 9;

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

Tj. Typy pierwotne są przekazywane przez wartość, a typy złożone są przekazywane przez odwołanie.

Powiedziałbym, że jest to kopia po kopii -

Weź pod uwagę, że argumenty i obiekty zmienne są obiektami utworzonymi w kontekście wykonania utworzonym na początku wywołania funkcji - a twoja rzeczywista wartość / referencja przekazana do funkcji jest po prostu przechowywana w tych argumentach + obiektach zmiennych.

Mówiąc najprościej, dla typów pierwotnych wartości są kopiowane na początku wywołania funkcji, dla typu obiektu kopiowane są referencje.

Trwa dyskusja na temat użycia terminu „pass by reference” w JavaScript tutaj , ale aby odpowiedzieć na twoje pytanie:

Obiekt jest automatycznie przekazywany przez odniesienie, bez konieczności jego konkretnego określania

(Z artykułu wspomnianego powyżej.)

Łatwym sposobem ustalenia, czy coś jest „przekazywane przez referencję”, jest to, czy można napisać funkcję „zamiany”. Na przykład w C możesz wykonać:

void swap(int *i, int *j)
{
    int t;
    t = *i;
    *i = *j;
    *j = t;
}

Jeśli nie możesz zrobić tego w JavaScript, to nie jest to „pass by reference”.

1. zmienna typu pierwotnego jak ciąg znaków, liczby są zawsze przekazywane jako wartość przekazywana.

2. Tablica i obiekt są przekazywane jako referencja lub wartość w oparciu o te dwa warunki.

   • jeśli zmieniasz wartość tego obiektu lub tablicy za pomocą nowego obiektu lub tablicy, to jest ona przekazywana przez wartość.

     object1 = {item: "car"}; array1=[1,2,3];

   tutaj przypisujesz nowy obiekt lub tablicę do starego. nie zmieniasz wartości właściwości starego obiektu. więc jest przekazywana przez wartość.

   • jeśli zmieniasz wartość właściwości obiektu lub tablicy, jest ona przekazywana przez odwołanie.

     object1.key1= "car"; array1[0]=9;

   tutaj zmieniasz wartość właściwości starego obiektu. nie przypisujesz nowego obiektu ani tablicy do starego. więc jest przekazywany przez referencję.

Kod

    function passVar(object1, object2, number1) {

        object1.key1= "laptop";
        object2 = {
            key2: "computer"
        };
        number1 = number1 + 1;
    }

    var object1 = {
        key1: "car"
    };
    var object2 = {
        key2: "bike"
    };
    var number1 = 10;

    passVar(object1, object2, number1);
    console.log(object1.key1);
    console.log(object2.key2);
    console.log(number1);

Output: -
    laptop
    bike
    10

1. Prymitywy (liczba, wartość logiczna itp.) Są przekazywane przez wartość.
   • Ciągi są niezmienne, więc nie ma to dla nich znaczenia.
2. Obiekty są przekazywane przez referencję (referencja jest przekazywana przez wartość).

Proste wartości w funkcjach nie zmienią tych wartości poza funkcją (są przekazywane przez wartość), podczas gdy wartości złożone - (są przekazywane przez odwołanie).

function willNotChange(x) {

    x = 1;
}

var x = 1000;

willNotChange(x);

document.write('After function call, x = ' + x + '<br>'); // Still 1000

function willChange(y) {

    y.num = 2;
}

var y = {num: 2000};

willChange(y);
document.write('After function call y.num = ' + y.num + '<br>'); // Now 2, not 2000