"surcharge de méthode" en javascript

Question

Donc j'avoue que je suis nouveau à javascript et que je viens d'un arrière-plan C. + ("Salut, je suis Bob, je suis un utilisateur de langage statique de classe", chorus "salut Bob!").

je trouve que je finis souvent par écrire des fonctions telles que:

function someFunc() 
{ 
    if (arguments.length === 0){ 
     ... 
    } else { 
     ... 
    } 
} 

(où il pourrait y avoir trois cas). Ou, encore, j'écris la différence dans le nom:

function someFuncDefault() { ... }; 
function someFuncRealArg(theArg) { ... }; 

(suppléant "RealArg" pour une phrase sémantiquement pourvues d'un contenu).

Y at-il un meilleur modèle pour ce genre de chose?

Answer 1

Jetez un oeil à this post.

Answer 2

Je ne sais pas que je le ferais de cette façon, mais il semble que cela pourrait rendre votre code légèrement moins ingérable:

function someFunc() { 
    switch (arguments.length) { 
     case 0: noArgs(); 
     case 1: oneArg(arguments[0]); 
     case 2: twoArgs(arguments[0], arguments[1]); 
    } 
    function noArgs() { 
     // ... 
    } 
    function oneArg(a) { 
     // ... 
    } 
    function twoArgs(a, b) { 
     // ... 
    } 
} 

Un autre exemple pourrait être:

function someFunc(a, b) { 
    if ('string' == typeof a) { 
     // ... 
    } else if ('number' == typeof a) { 
     // ... 
    } 
} 

Et Bien sûr, vous pouvez probablement créer quelque chose d'assez ingérable en combinant les deux exemples (en utilisant des conditions pour déterminer le comportement en fonction du nombre d'arguments et des types d'arguments).

Answer 3

En Javascript, tous les arguments sont facultatifs.

Vous pouvez essayer quelque chose comme:

Edit (meilleure méthode qui ne rompt pas pour les valeurs dont 'truthiness' est faux):

function bar(arg1, arg2) { 
    if(arg1 === undefined) { set default } 
    if(arg2 === undefined) { set default } 
    //do stuff here 
} 

méthode ancienne qui casse pour les valeurs Falsey:

function foo(arg1, arg2) { 
    if(!arg1) { set default } 
    if(!arg2) { set default } 
    //do stuff here 
} 

Un excellent endroit pour commencer avec le javascript sont des conférences javascript Douglas Crockford: http://video.yahoo.com/search/?p=javascript

Answer 4

Javascript vous permet d'être vraiment paresseux avec ceci (pas aussi paresseux que Python, mais assez paresseux).

function someFunc(arg1, arg2) 
{ 
    if(typeof(arg1) == "undefined") { 
    arg1 = default; 
    } 
    ... 
} 

Vous n'avez donc pas vraiment besoin de surcharger. Javascript ne vous criera pas de passer le mauvais nombre de paramètres.

Answer 5

Ceci est en surcharge, non prioritaire non?

Javascript est faiblement typé, donc les signatures de méthodes et le support natif sont supprimés. Ma recommandation est de passer un objet extensible comme argument solitaire. Inspecter et gérer l'existance des propriétés sur l'objet param comme vous le souhaitez.

Quel avantage cela at-il sur les arguments? Eh bien, cela vous permet d'être explicite sur vos intentions là où vous appelez, et sans ambiguïté sur la signification de arg1 et arg2 où vous recevez, et cela vous permet de faire abstraction d'une classe d'objets de données personnalisée à laquelle vous pouvez étendre la fonctionnalité.

function someFunc(params) 
{ 
    var x = params.x || defaultX; 
    var y = params.y || defaultY; 

    //businesslogic 
} 

someFunc({x:'foo',y:'bar'}); 

someFunc({y:'baz'}); 

Answer 6

Tout le monde est venu près, je pense que la vraie question ici est que JavaScript vous ne devriez pas modifier le comportement en fonction des paramètres étant transmis.

Depuis JavaScript fait tous les paramètres optionnels que vous pouvez suivre le Concise méthode d'utilisation de cette convention:

function foo(bar, baz) { 
    bar = bar || defaultBar; 
    baz = baz || defaultBaz; 
    . 
    . 
    . 
} 

Answer 7

Personnellement, je préfère écrire la fonction la plus complexe qui serait effectué, puis documenter dans les commentaires afin que les autres savent qu'ils ne pas doivent envoyer tous les arguments.

//concat(str1, str2 [,str3 [,str4 [,str5]]]) 
function concat(str1, str2, str3, str4, str5) { 
    var str = str1 + str2; 
    if(str3 != undefined) 
     str += str3; 
    if(str4 != undefined) 
     str += str4; 
    if(str5 != undefined) 
     str += str5; 
    return str; 
} 

J'ai aussi trouvé des situations où l'ordre d'argument d'importance dans une fonction normale, mais parfois je voudrais envoyer les arguments séparement (à savoir que je voudrais envoyer str3 et STR5 mais pas str4). Pour cela, j'utiliser un objet et de tester les propriétés connues

//concat({str1:string, str2:string, str3:string, str4:string, str5:string}) 
//str3, str4, and str5 are optional 
function concat(strngs) { 
    var str = strngs.str1 + strngs.str2; 
    if(strngs.str3 != undefined) 
     str += strngs.str3; 
    if(strngs.str4 != undefined) 
     str += strngs.str4; 
    if(strngs.str5 != undefined) 
     str += strngs.str5; 
    return str; 
} 

Answer 8

Un peu mécanisme de surcharge plus complet est offert par bob.js:

var notify = new bob.fn.overloadFunction([ 
    { 
     condition: function(msg) { return bob.utils.isString(msg); }, 
     overload: function(msg) { 
      console.log(msg); 
     } 
    }, 
    { 
     condition: function(bSayHello) { return bob.utils.isBoolean(bSayHello); }, 
     overload: function(bSayHello, msg) { 
      msg = bSayHello ? 'Hello: ' + msg : msg; 
      console.log(msg); 
     } 
    } 
]); 

appel de la fonction surchargée:

notify('Simple sentence.'); 
// Output: 
// Simple sentence. 
notify(true, 'Greeting sentence.'); 
// Output: 
// Hello: Greeting sentence. 
notify(123); 
// JavaScript Error: 
// "No matching overload found."