var A = {
x : function() { }
};
var b = function (method) {
//want to know method's "parent" here
};
b(A.x);
Je veux savoir que x est défini dans A quand j'appelle le b (A.x). Est-ce possible?Comment déterminer l'objet dont cette fonction est une méthode?
Il n'y a pas de façon intégrée de le faire, car il n'y a pas de méthodes en Javascript. Ce sont des objets Fonction indépendants qui ont été assignés quelque part.
Si vous créez une nouvelle instance de fonction à chaque fois (par exemple la fermeture) [merci Matthew Crumley pour le souligner], vous pouvez modifier l'objet de la fonction d'associer explicitement avec son parent:
x.parent = A;
et vous pouvez l'appeler correctement comme si elle était une méthode:
x.call(x.parent);
Sinon, vous devrez passer à la fois la fonction et son objet parent.
Every function in JavaScript is actually a Function object.
<html>
<body>
<script>
var A = {
x: function (a_a, a_b) { alert(a_a + a_b); }
};
var b = function (a_method) {
alert(a_method.toString());
a_method.call(this, 1, 2);
};
b(A.x);
</script>
Cette question fait peu de sens du point de vue de la langue en fonction peut exister sur de nombreux objets.
var a = { name : 'a' },
b = { name : 'b' },
c = { name : 'c' };
a.x = function() { alert(this.name); };
c.x = b.x = a.x; // a, b, and c all reference the same function
Vous pouvez appeler la fonction x avec un contexte que vous voulez:
a.x(); // alerts "a" because "this" is object a
b.x(); // alerts "b" because "this" is object b
a.x.call(b); // alerts "b" because "this" is object b (via parameter)
Vous pouvez manipuler ce comportement à travailler pour vous:
var b = function (method) {
// parent = this;
};
b.call(A, A.x);
Il n'y a cependant aucune façon de savoir à l'intérieur d'une fonction à quel objet elle est affectée car ce n'est pas nécessairement un seul endroit.
Même l'ajout d'une propriété parente ne fonctionnera pas dans tous les cas, car si la fonction est dans le prototype de l'objet, il n'y a qu'une seule copie de l'objet fonction, donc il est impossible de dire de quelle instance elle provient. Voici un exemple pour montrer le problème:
function MyClass() {
// Create a MyClass object
}
MyClass.prototype.x = function() { return 42; };
var a = new MyClass();
a.x.parent = a; // Set the parent to a
var b = new MyClass();
b.x.parent = b; // b.x and a.x both reference the same function from MyClass.prototype
Maintenant, a.x.parent et b.x.parent sont tous deux à b.
La méthode de @ porneL fonctionnera tant que chaque objet aura sa propre copie de la fonction.
Il est probablement préférable de modifier la fonction pour prendre un objet parent et une méthode afin qu'elle fonctionne avec n'importe quelle fonction.