Discussion :

[phildepantin]

Bonjour,

Après quelques heures de recherche sur les forums et quelques heures de tentatives diverses, je me résous à poser mon problème ici. J'ai un niveau moyen en javascript.

Ce que je veux faire : à des fins de débuggage de mon code, je voudrais ajouter à toutes les méthodes de mes objets un appel à une fonction qui me permettra un suivi personnalisable de la marche du programme (que ne me permet pas Firebug par exemple). J'en profite aussi pour définir le nom de ces méthodes afin qu'il soit accessible par caller.name.

Mon problème : je sais utiliser la méthode `wrap` du framework `prototype` lorsque le nombre d'arguments de la fonction à entourer est connu, mais dans mon problème, ce nombre est forcément variable, il dépend de chaque méthode.

Ma question : comment utiliser la méthode `warp` avec un nombre indéfini d'arguments ?

Voilà une synthèse de mon code :

Mon objet est le suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
var monObjet = {
 
    name: "monObjet",
    propriete1: 1256,
    propriete2: "ma propriété",
 
    methode1: function(arg1, arg2) {
        // …
    },
 
    methode2: function() {
        // …
    }
}

Ma fonction à créer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
28
 
function DebugAddCallAndName(obj) {
 
    //= Boucle sur chaque propriété
    // Je pourrais aussi utiliser `$A(obj).each(function…)`
    for ( var prop in obj ) {
 
        //- Ne traiter que les fonctions
        if ( "function" != typeof obj[prop] ) continue ;
 
        //- Je définis le nom de la propriété
        //  Il sera "<nom objet>.<nom méthode>"
        obj[prop].name= obj.name + "." + prop ;
 
        //- J'ajoute à chaque propriété un appel à ma fonction
        // de débuggage (DebugFonction)
        // ### C'est ici que je cale ###
        // ### Le code ci-dessous ne fonctionne pas ###
        obj[prop]= obj[prop].wrap(
            function(ma_methode){
                // Ajout de l'appel à la fonction de débuggage
                DebugFonction(arguments);
                // Appel normal à la méthode (# des arguments ? #)
                ma_methode();
        });
 
    }
}

J'utilise naturellement, pour "préparer" mon objet :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
DebugAddCallAndName(monObjet) ;

Au cas où, une idée de ma fonction de débuggage :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
function DebugFonction(args) {
// args = propriété "arguments" de la fonction
 
    //- Fonction traitée
    var fonction_traitee= args.callee ;
    var nom_fonction_traitee= fonction_traitee.name ;
 
    //- Arguments
    var liste_arguments= fonction_traitee.argumentNames() ;
    // …
 
    //- Fonction appelante
    var fonction_appelante= null ;
    var nom_fonction_appelante= null;
    if ("undefined" != typeof fonction_traitee.caller && fonction_traitee.caller) {
        fonction_appelante= fonction_traitee.caller ;
        nom_fonction_appelante= fonction_appelante.name ;
    }
    // …
 
    //= Traitement/affichage
    // …
}

Un grand merci à toute personne qui pourra me donner un coup de main, si mon problème a été suffisamment bien exposé pour être compris…

Bien à vous,

Phil

[SpaceFrog]

regarde du coté de arguments ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
function bar(){
alert (arguments[0])
alert(arguments[1]
}
 
bar('un',' deux')