Fonction imbriquée ?

Bonjour à tous,

Je cherche à faire quelque chose du style :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

var MyObject = function(){

};
MyObject.prototype = {
    myMethod: function(){
        console.log('first method');
    },
    myMethod2 : function(){
        console.log('second method');
    }   
};
var myObject = new MyObject();
myObject.method().myMethod2();

Je cherche finalement à pouvoir imbriquer mes méthodes. Est ce que cela est possible ?

Merci d'avance pour votre aide.

Rajouter return this; à la fin de chaque méthode ?

Tout simplement en effet

Est ce qu'il est possible de spécifier uniquement des méthodes après d'autres méthodes ? Exemple, je veux que method1 soit utilisable uniquement après method2 et que la method2 soit "method3" soit utilisable après "method1" et "method2" ?

Thx

EDIT : En fait il y a quelque chose que je ne comprends pas du coup.. Normalement return permet de retourner une valeur du coup si je dois retourner une valeur de ma méthode je ne peux pas faire 2 return dans une seule méthode si ? Merci d'avance pour ton explication

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

var MyObject = function () {
  this.state = '';
};
MyObject.prototype = {
  prepend: function (x) {
    this.state = x + this.state;
    return this;
  },
  append: function (x) {
    this.state = this.state + x;
    return this;
  },
  val: function () {
    return this.state;
  }
};
var myObject = new MyObject();
myObject.append('b').append('c').prepend('a').val();

C'est comme ça qu'on fait généralement. Si tu regardes les lib qui ont ce comportement, y'a toujours une méthode du genre .val() qu'il faut flanquer à la fin. Par exemple avec lodash ou underscore : _.chain([1, 2, 3]).map(x => x*2).filter(x => x > 3).val()

: En fait il y a quelque chose que je ne comprends pas du coup.. Normalement return permet de retourner une valeur du coup si je dois retourner une valeur de ma méthode je ne peux pas faire 2 return dans une seule méthode si ?

Bien sûr que non que tu ne peux pas avoir deux return, il faut choisir, soit return this, soit return autre chose.

L'idiome du chaînage n'est pas adapté à tous les usages. Ca marche bien quand tu effectues plusieurs opérations à la suite qui modifient l'état interne de l'objet; par contre si tu dois retourner une autre information alors tu es obligé de casser la chaîne. Dit plus simple, ça peut se résumer grosso modo en: ça va pour les setters, mais pas pour les getters.

La variante que propose Victor est courante pour la construction de String ou de tableaux, l'exemple le plus célèbre est sans doute le StringBuffer/StringBuilder de Java (où l'appel qui marque la fin de la chaîne de concaténations est toString).

Est ce qu'il est possible de spécifier uniquement des méthodes après d'autres méthodes ? Exemple, je veux que method1 soit utilisable uniquement après method2 et que la method2 soit "method3" soit utilisable après "method1" et "method2" ?

De base, non, ce n'est pas possible. Le plus simple c'est de lancer une exception si method2 est utilisée avant method1, pour que l'utilisateur de ton objet se rende compte de son erreur de logique.

Bien sûr, tu pourrais tricher en retournant un objet diminué, i.e. un objet qui n'a pas de method2, et au moment où method1 est appelé, retourner le vrai objet qui contient method2. OU encors, assigner la propriété method2 à l'intérieur de method1. Mais c'est du travail pour pas grand chose, et côté utilisateur de l'objet, au cas où method2 est appelée avant method1, c'est toujours mieux de se ramasser une exception explicative qui sera (ou devrait être) explicite, plutôt qu'une exception générique genre ReferenceError ou TypeError parce qu'il a tenté d'appeler undefined.

Tu as de cette façon (si je ne me trompe pas la librairy jQuery fait pareil) :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

var myClass;

(function () {
    var a = 0; // private var

    function private_function() {
        //...
    }

    window.myClass = {
        public_function: function () {
            private_function(); // Tu peux l'utiliser seulement ici. ;)
        },
        myMethod: function(){
            console.log('first method');

            return myClass;
        },
        myMethod2 : function(){
            console.log('second method');

            return myClass;
        } 
    };
})();

myClass.myMethod().myMethod2();

Fait attention à this, si tu mets la fonction en callback avec addEventListener par exemple.

MERCI BEAUCOUP les gens !!

Plein de nouveau termes à aller chercher sur le net et les bonnes pratiques

Un gros merci pour les exemples et les termes techniques C'est plus facile de trouver quand on connaît les bons termes