Fonction Javascript Du Pointeur De La Cession

Considérer ce code javascript:

var bar = function () { alert("A"); }
var foo = bar;
bar = function () { alert("B"); };
foo();

Lors de l'exécution de ce code j'obtiens un "Un". Est-ce le comportement d'une partie de javascript spécification et je peux compter sur elle?

InformationsquelleAutor niaher | 2010-02-24
  1. 37

    Oui, c'est prévu et voulu par la conception.

    Votre question est fondamentalement: ne foo référence bar comme un pointeur ou une référence dans une autre langue?

    La réponse est non: le valeur de bar au moment de la cession est attribué à foo.

    • pourquoi est-une copie de la valeur transmise lorsque les fonctions ne sont pas les types primitifs?
    • Tant pis, c'est la réponse ci-dessous: stackoverflow.com/a/11598151/1316465
    • Juste pour clarifier la dernière phrase de cette réponse, n'oubliez pas que la "valeur du bar" est un "pointeur à la fonction", et non pas la fonction elle-même. Donc, après foo = bar, foo reçoit une copie par valeur de ce pointeur, donc, à la fois foo et bar du point de la fonction autonome de l'objet.
    InformationsquelleAutor cletus
  2. 62

    Dans d'autres exemples, rien n'a été transmis par valeur; tout a été passé par référence.

    bar et toto sont DEUX pointeurs

    Tous vars/poignées de NON primitive des objets en javascript sont des pointeurs; les pointeurs SONT originaires de javascript, ils sont la valeur par défaut.

    var bar = function () { alert("A"); } //bar is a pointer to function1
var foo = bar;  //pointer copied; foo is now also a pointer to function1
bar = function () { alert("B"); };  //bar points to function2
foo();  //foo is still a pointer to function1

    Vous allez courir dans caché des erreurs et des bugs si vous pensez qu'ils sont des copies. Surtout si vous travaillez avec des objets complexes. Par exemple

    function person(name){this.name = name}
var john = new person("john")
var backup = john
backup.name //john
john.name = "jack"
backup.name //jack, NOT john

    Vraiment de la COPIE d'un non-primitif en javascript faut plus de travail que de simplement a = b.
    Par exemple:

    function person(name){  this.name = name}
var john = new person("john")
var backup = new Object()
backup = JSON.parse(JSON.stringify(john))
backup.__proto__ = john.__proto__   //useful in some cases
john.name = "jack"
backup.name //john
    • Merci pour clarifier cela, j'ai été confondu à la recherche en ligne si "fonctions" étaient primitifs, quand on m'a dit qu'ils ne l'étaient pas.
    • Cette réponse devrait servir de preuve pourquoi nous devrions en apprendre plus informatique et en moins de programmation...
    • Cette réponse est totalement faux. Je sais que c'est vieux, mais clairement, les gens sont toujours d'achoppement dans cette. Le Javascript n'ont PAS de notion de pointeurs que ce soit. Javascript utilise des références, qui sont nettement différentes de pointeurs.
    InformationsquelleAutor siingCoder
  3. 19

    Je suis un peu en retard ici mais j'ai pensé que je donnerais une réponse de toute façon et la chair de quelque chose.

    Il est préférable de ne pas penser en termes de pointeurs et les références de mémoire lors de la discussion de l'intérieur de JavaScript (ou ECMAScript) lors du traitement avec le cahier des charges. Les Variables d'environnement sont des dossiers en interne et sont stockés et référencé par son nom, pas d'adresse de mémoire. Ce que votre instruction d'affectation est en train de faire, en interne et par sa conception, est à la recherche de l'environnement enregistrement de nom ("foo", "bar") et de l'affectation de la valeur de cet enregistrement.

    Donc,

    var bar = function () { alert("A"); }

    est l'assignation de l'environnement d'enregistrement "bar" de la valeur (fonction anonyme).

    var foo = bar;

    appelle en interne GetValue("bar") qui récupère la valeur associée à l'enregistrement de "bar" et ensuite les associés de cette valeur avec le dossier "toto". Donc, par la suite la valeur d'origine de la barre peut encore être utilisé comme il est maintenant associé avec foo.

    Parce que JavaScript références par chaîne et non l'adresse de mémoire est précisément la raison pour laquelle vous pouvez faire des choses comme ceci:

    someObject["someProperty"]

    qui est à la recherche de la valeur basée sur le nom de la propriété.

    InformationsquelleAutor Bob
  4. 5

    Oui, il n'y a rien de spécial sur le fait que les variables se référant à des fonctions, il n'y a pas d'aliasing impliqués. 

    var bar = 1;
var foo = bar;
bar = "something entirely different";
//foo is still 1
    InformationsquelleAutor polygenelubricants
  5. 5

    Vous affectez la valeur d'une fonction anonyme pour une variable non un pointeur.

    Si vous voulez jouer avec des pointeurs, vous pouvez utiliser les objets sont passés par référence, pas de copie.

    Voici quelques exemples:

    "obj2" est une référence de la "obj1", vous changez de "obj2", et "obj1" est modifié. Il alertera false.

    var obj1 = {prop:true},
    obj2 = obj1;
obj2.prop = false;
alert(obj1.prop);

    "prop" points à une propriété qui n'est pas un objet, "prop" n'est pas un pointeur vers cet objet, mais une copie. Si vous changez de "prop", "obj1" n'est pas modifiée. Il alertera true

    var obj1 = {prop:true},
    prop = obj1.prop;
prop = false;
alert(obj1.prop);

    "obj2" est une référence à la "subObj" propriété de "obj1". si "obj2" est changé, "obj1" est modifié. Il alertera false.

    var obj1 = {subObj:{prop:true}},
    obj2 = obj1.subObj;
obj2.prop = false;
alert(obj1.subObj.prop);
    • Merci. Ces exemples ont été ce que je voulais sortir de la lecture de ce thread. 🙂
    InformationsquelleAutor Mic
  6. 3

    Oui, c'est le comportement correct.

    //create variable bar and assign a function to it
var bar = function () { alert("A"); }
//assign value of bar to the newly created variable foo
var foo = bar;
//assign a new function to the variable bar
//since foo and bar are not pointers, value of foo doesn't change
bar = function () { alert("B"); };
//call the function stored in foo
foo();
    InformationsquelleAutor Amarghosh
  7. 2

    Ceux qui ne sont pas des pointeurs de fonction (et il n'y a pas de pointeurs en JS natif). Fonctions JS peuvent être anonymes et sont des objets de première classe. Donc

    function () { alert("A"); }

    crée une fonction anonyme qui les alertes "Une" sur l'exécution; 

    var bar = function () { alert("A"); };

    affecter cette fonction à la barre;

    var foo = bar;

    attribuer foo bar, ce qui est la fonction "A".

    bar = function () { alert("B"); };

    relier la barre à une fonction anonyme "B". Ce qui n'affecte pas ou toto ou l'autre fonction "Une".

    foo();

    Appel de la fonction stockée dans foo, qui est la fonction "Un".

    Fait dans les langues où il y a des points de fonction, par exemple C, cela n'affectera pas foo soit. Je ne sais pas d'où vous est venue l'idée de "B" à la réaffectation.

    void A(void) { printf("A\n"); }
void B(void) { printf("B\n"); }
typedef void(*fptr_t)(void);
fptr_t foo = A;
fptr_t bar = foo;
bar = B;
foo(); //should print "A"
    InformationsquelleAutor kennytm
  8. 1

    C'est l'affectation d'une variable à une fonction sans nom, pas un pointeur vers une fonction

    InformationsquelleAutor Svetlozar Angelov
  9. 1

    Oui, vous avez créé un pointeur à l'original de la "Une" de la fonction. Lorsque vous réaffectez barre, vous êtes réaffectation des, mais vous êtes toujours en laissant toutes les références à l'ancien seule fonction.

    Donc, pour répondre à votre question, oui, vous pouvez compter sur elle.

    InformationsquelleAutor David Morton
  10. 0

    Je voudrais juste ajouter ceci fonctionne également pour les pré-défini les fonctions nommées ainsi:

    function myfunc() { alert("A"); }
var bar = myfunc;
var foo = bar;
bar = function () { alert("B"); };
foo();

    Cela va faire la même chose, indiquant que les noms de fonctions agissent comme des tableaux de noms (pointeurs).

    InformationsquelleAutor user3015682
  11. 0

    Pour chaque FunctionDeclaration f dans le code, dans le texte de la source de commande à faire:

    Laisser fn être l'Identifiant dans FunctionDeclaration f.

    Laisser fo être le résultat de l'instanciation de FunctionDeclaration f tel que décrit dans la Clause 13.

    Laisser funcAlreadyDeclared être le résultat de l'appel du ministère HasBinding méthode concrète en passant fn comme argument.

    Si funcAlreadyDeclared est faux, l'appel du ministère CreateMutableBinding méthode concrète en passant fn et configurableBindings que les arguments.

    Références

    InformationsquelleAutor