Autor Zpráva
robbie
Profil *
function setName(obj) {
obj.name = “Nicholas”;
obj = new Object();
obj.name = “Greg”;
}
var person = new Object();
setName(person);
alert(person.name);

Moc nechápu, co tím autor chtěl říct:
When person is passed into setName(), its name
property is set to “Nicholas”. Then the variable obj is set to be a new object and its name property
is set to “Greg”. If person were passed by reference, then person would automatically be changed to
point to the object whose name is “Greg”. However, when person.name is accessed again, its value
is “Nicholas”, indicating that the original reference remained intact even though the argument’s
value changed inside the function. When obj is overwritten inside the function, it becomes a pointer
to a local object. That local object is destroyed as soon as the function fi nishes executing.


Moc nechápu druhou polovinu odstavce, jak zde příší, že pokud se na person.name přijde znovu, jeho hodnota je opět "Nicholas" značící, že originál odkaz zustal nedotčen.

A další vec, co znamená: argument passed by reference a argument passed by value, jak si to mám predstavit? Děkuji moc za vysvetlení
juriad
Profil
Máš trochu znalosti jazyka C++? Pokud ne, tak to raději ani nečti.
Toto jsou tři různé způsoby, práce s objektem Person (podle počtu hvězdiček - hloubky odkazování v argumentu funkce)
Rychlokurz: hvězdička v argumentu značí odkaz; hvězdička u proměnné značí použítí (aplikaci) odkazu; ampersant značí získání odkazu.

Přímo

void setName(Person p) { /* předá se kopie, jakákoli změna se venku neprojeví */
  p.name = "Nicholas";
  new (&p) Person();
  p.name = "Greg";
}

Person q; // mám přímo objekt
setName(q); // předá se jako kopie
q.name == NULL /* změny se prováděly s kopií */

// nebo také:

Person *q = new Person(); // mám jen odkaz na objekt
setName(*q); // předá se aplikovaný odkaz = přímo objekt => kopie
(*q).name == NULL

Odkazem

void setName(Person *p) { /* předá odkaz na objekt; změní jméno a do stejné lokální proměnné vytvoří nového člověka */
  (*p).name = "Nicholas";
  p = new Person(); // p je lokální proměnná
  (*p).name = "Greg";
}

Person q; // mám přímo objekt
setName(&q); // předá se odkaz na objekt
q.name == "Nicholas" // jde o stejného přejmenovaného člověka

// to samé také:

/* Toto je k systému objektů v JS nejblíže, nikdy nedržíš přímo objekt, ale odkaz na objekt */
Person *p = new Person(); // mám jen odkaz na objekt
setName(p); // předá se ten odkaz
(*p).name == "Nicholas"

Odkazem na odkaz

void setName(Person **p) { /* předá odkaz na odkaz na objekt; změní jméno a pak toho člověka vymění za nově narozeného */
  (**p).name = "Nicholas";
  *p = new Person(); // (*p) není lokální proměnná - odpovídá a je to ta proměnná q
  (**p).name = "Greg";
}

Person *q = new Person(); // mám jen odkaz na objekt
setName(&q); // předám odkaz na proměnnou q = odkaz na odkaz na objekt => můžu změnit ve funkci obsah q = změním na odkaz na jiný objekt
(*q).name == "Greg" // jde o nového člověka
_es
Profil
robbie [#1]:
Možno to bola ukážka toho, že argumenty sa do funkcie predávajú vždy hodnotou. Spomenul som si na toto vlákno: dotaz na argument funkce.
fireball_
Profil
Autor ti chtěl tím kódem ukázat, že proměnná person je referenční ( odkazová ). Což zjedodušeně znamená, že je to ukazatel na místo kde je uložená v paměti. Do funkce si tedy předáš jen tu referenci a měníš objekt v paměti. Zjistíš to samozřejmě jen pokud s ním dál pracuješ - zde alert.

Následuje vytvoření nového objektu. Reference se uloží do lokální proměnné obj, která je definovaná argumentem funkce. Referenci, ale na tento objekt ztratíš po vykonání funkce, protože si ji nikde neuchováš. Uchování by pak mohlo být třeba pomocí globálního objektu nebo třeba nějaký return do proměnné.

Javascript je jedna velká záhada. Chápeš ten mechanismus podle toho popisu?
juriad
Profil
robbie:
Asi jsi zvyklý, že:
function f(i) {
  i++;
}
var a = 0;
f(a);
alert(a); // bude 0
Tedy celá čísla se předávají hodnotou - předá se kopie. Unitř funkce bude proměnná i zpočátku mít hodnotu 0, ale bude to jiná 0 než venku.
Jde tedy o první případ, který jsem zmínil v [#2].

Na druhou stranu, asi bys čekal toto:
function f(arr) {
  arr.push("x");
}
var a = [];
f(a);
alert(a.length); // bude 1
Nepředává se kopie celého pole, ale odkaz na to pole, které existuje venku.
Jde tedy o druhý případ, který jsem zmínil v [#2].

JavaScript neumožňuje třetí případ, který jsem zmínil v [#3], na to nemá dostatečné jazykové prostředky.

Víceméně jde jen o to, že argumenty různých typů se chovají různě. Existují ale jen dva možné scénáře:
1) předávání hodnotou - vytvoří se kopie - tak se předávají ta čísla.
2) předávání referencí (odkazem) - nevzniká kopie - pracuje se přímo s tou věcí - tak se předávají pole.

A na tobě je, aby sis našel (nebo vyzkoušel), jak se který typ předává.

Vaše odpověď

Mohlo by se hodit

Neumíte-li správně určit příčinu chyby, vkládejte odkazy na živé ukázky.
Užíváte-li nějakou cizí knihovnu, ukažte odpovídajícím, kde jste ji vzali.

Užitečné odkazy:

Prosím používejte diakritiku a interpunkci.

Ochrana proti spamu. Napište prosím číslo dvě-sta čtyřicet-sedm: