L'appel de méthode à l'intérieur d'une autre méthode en javascript?

Je vais avoir du JavaScript espace de noms de dire

A={

  CA: function() {
    this.B();
  },
  B: function() {
    var test='test';
    var result='t1';

    C: function() {
      this.test='test1';
      .....
      .....
      return 'test1';    
    }

   result=this.C();  
   return result; 
  }
}

Maintenant, quand je suis à l'exécution de ce code c'est en donnant que TypeError: ce.C est pas une fonction. Quelqu'un peut-il me dire pourquoi il en est ainsi. Je sais que c'est quelque chose en rapport avec une portée lexicale, mais je suis incapable de comprendre cela.

Désolé, je suis un nouvel utilisateur et posté la première question, je ne sais pas comment poster des questions. Je vais garder cela à l'esprit, désormais. Merci.

OriginalL'auteur Ashish Jain | 2009-07-07

javascript methods

5

Je pense que le problème est que lorsque this.C() est exécutée à l'intérieur de la fonction visée par B, this fait référence à l'objet qui contient B, qui est, de l'objet A. (Ce qui suppose B() est appelée dans le contexte de A)

Le problème est, C n'existe pas sur l'objet A, puisqu'il est défini dans B. Si vous voulez appeler une fonction locale C() dans B, il suffit d'utiliser C().

EDIT:
Aussi, je ne suis pas sûr de ce que vous avez posté est du JavaScript valide. Plus précisément, B devrait être défini de cette façon, puisque vous ne pouvez pas utiliser l'objet:syntaxe de la propriété à l'intérieur d'une fonction.
```
B: function()
{
  var test='test';
  var result='t1';

  var C = function()
  {
    this.test='test1';
    return 'test1';    
  }

 result=C();  
 return result; 
}
```
Je pense que vous avez raison et j'ai aussi fait de la même manière, enfin, fait la fonction et l'a appelé directement à partir de la fonction externe) après cogner ma tête pour faire cela.C travail.

OriginalL'auteur Peter
23

Vous devez être prudent lorsque vous utilisez ce à identifier quelque chose en Javascript parce que chaque fois que vous changez de portée "ce" changements.

De l'affectation de la " cette référence à sa propre variable permet de contourner cette.
```
var a = new function() {
    var self = this;

    self.method = function() { alert('hiya'); };

    var b = function() {
        this.method(); //this isn't 'a' anymore?
        self.method(); //but 'self' is still referring to 'a'
    };

};
```
var self=this; est juste ce que je cherchais! Merci!!!!
C'est exactement ce dont j'avais besoin, Merci beaucoup.

OriginalL'auteur Hugoware

Je suis d'ailleurs surpris que votre code ne vous donne pas d'erreur sur le "C:" la ligne.

De toute façon, votre syntaxe pour définir une fonction n'est pas correct. Définir à l'aide du mot-clé var. Aussi, notez que j'ai créé la "fermeture" de sorte que la fonction C peut accéder 'cette'. Voir le code ci-dessous:

A={

  CA: function()
  {
    this.B();
  },

  B: function()
  {
    var test='test';
    var result='t1';

    var self = this;
    var C = function()
            {
              self.test='test1';
              .....
              .....
              return 'test1';    
            }

   result=C();
   return result; 
  }
}

Si vous souhaitez affecter C à 'cette' objet, vous pouvez également le faire:

A={

  CA: function()
  {
    this.B();
  },

  B: function()
  {
    var test='test';
    var result='t1';

    var self = this;
    this.C = function()
             {
              self.test='test1';
              .....
              .....
              return 'test1';    
             };

   result= this.C();
   return result; 
  }
}

Vous ne serez pas en mesure de les utiliser "il", car " il " est un mot-clé et vous avez besoin de créer de la fermeture. Aussi, parce que je suis la définition du " moi " comme une variable locale, il n'a pas d'impact sur l'objet global.
ouais désolé, j'ai réalisé mon mutisme, et donc supprimé mon commentaire 🙁 Mais Oui maintenant je suis d'accord avec votre réponse. +1 pour le mettre en place avec moi aussi 🙂

OriginalL'auteur SolutionYogi

0

Solution pour l'appel de méthodes à partir d'une autre méthode. (Essentiellement, le pointeur de la "ce" doit être assignée à une variable et la variable utilisée à la place de cela.)
```
 function myfunction(){
    var me = this;

    me.method1 = function(msg){ alert(msg); }

    me.method2 = function(){ 
       me.method1("method1 called from method2"); 
    }
 }

 var f as new myfunction();
 f.method2();
```
Cet exemple montre comment on peut appeler une méthode à partir d'une autre méthode ou de l'extérieur à l'aide d'une instance de la fonction.

OriginalL'auteur Rex

Vous devez vous connecter pour publier un commentaire.