Est-ce une bonne idée d'utiliser un switch avec fallthrough pour gérer les arguments par défaut en Javascript ?

Question

J'ai récemment appris qu'il était possible d'utiliser une instruction switch soignée avec fallthrough pour définir des valeurs d'argument par défaut en Javascript :

function myFunc(arg1, arg2, arg3) {
    //replace unpassed arguments with their defaults:
    switch (arguments.length) {
        case 0 : arg1 = "default1";
        case 1 : arg2 = "default2";
        case 2 : arg3 = "default3";
    }
}

J'ai appris à beaucoup l'apprécier, car non seulement il est très court, mais il fonctionne également sur la base des paramètres réellement passés, sans dépendre d'une classe spéciale de valeurs (null, falsy, etc.) servant de substituts comme dans les versions plus traditionnelles :

function myFunc(arg1, arg2, arg3){
    //replace falsy arguments with their defaults:
    arg1 = arg1 || "default1";
    arg2 = arg2 || "default2";
    arg3 = arg3 || "default3";
}

Après avoir vu la version utilisant le commutateur, j'ai tout d'abord pensé que je devais envisager de l'utiliser "par défaut" au lieu du commutateur. || version.

Le switch fallthough ne le rend pas beaucoup plus long et il a l'avantage d'être beaucoup plus "robuste" dans la mesure où il ne se soucie pas des types des paramètres. Dans le cas général, cela semble être une bonne idée de ne pas avoir à se soucier de ce qui se passe avec toutes les valeurs fausses ('', 0, null, false ...) chaque fois que je dois faire une fonction avec des paramètres par défaut.

Je réserverais alors le arg = arg || x pour les cas réels où je veux vérifier la véracité des informations, au lieu de l'utiliser comme règle générale pour les paramètres par défaut.

Cependant, j'ai trouvé très peu exemples de ce modèle lorsque j'ai fait une recherche de code pour ça, alors j'ai dû mettre mon chapeau de sceptique. Pourquoi n'ai-je pas trouvé plus d'exemples de cet idiome ?

• Est-il seulement maintenant très connu ?
• Je n'ai pas assez bien cherché ? Ai-je été perturbé par le grand nombre de faux positifs ?
• Y a-t-il quelque chose qui le rende inférieur aux autres solutions ?

Quelques raisons auxquelles j'ai pensé (ainsi que certains commentaires) pour éviter switch(arguments.length) :

• Utiliser des paramètres nommés passés via un objet littéral est très flexible et extensible. Peut-être que les endroits où plus d'arguments peuvent être optionnels utilisent ceci à la place ?

• Peut-être que la plupart du temps, nous faire Vous voulez vérifier la véracité des faits ? L'utilisation d'une catégorie de valeurs comme titulaires de palce permet également aux paramètres par défaut d'apparaître au milieu plutôt qu'à la fin seulement : myFunc('arg1', null, 'arg3')

• Peut-être que la plupart des gens préfèrent simplement le très court arg = arg || "default" et la plupart du temps, nous ne nous soucions pas des valeurs falsy ?

• Peut-être que l'accès arguements est mauvais/impossible ?

• Peut-être que ce genre d'interrupteur a un mauvais côté auquel je n'ai pas pensé ?

Ces inconvénients sont-ils suffisants pour éviter d'utiliser switch(arguments.length) comme un modèle d'argument par défaut ou est-ce une astuce que je devrais garder et utiliser dans mon code ?

Answer 1

Puisque la question a été mise à jour, c'est vraiment une question d'opinion. Il y a un certain nombre de fonctionnalités de javascript que beaucoup de gens suggèrent d'éviter, comme le switch et le ternaire. C'est pourquoi il n'y a pas beaucoup d'informations sur certaines de ces fonctionnalités.

La raison pour laquelle cette suggestion est faite est que de nombreuses personnes utilisent mal ces fonctionnalités et créent des problèmes dans leur code. Les bogues sont parfois difficiles à détecter et il peut être difficile pour les autres de comprendre ce que fait votre code (en particulier ceux qui ne sont pas familiers avec javascript ou les nouveaux programmeurs).

Donc, si vous aimez procéder de cette façon et que vous ne vous préoccupez pas de l'opinion (ou du niveau de compétence) des personnes qui travaillent sur votre code. Par tous les moyens, votre approche fonctionnera. J'ai moi-même utilisé l'instruction switch à l'occasion, et bien que je ne pense pas que ce soit vraiment "bon" ou "mauvais", il est difficile de trouver une situation dans laquelle nécessite il.

Vous m'avez demandé comment je pourrais m'y prendre sans chaîne if-else :

function myFunc(args) {
    var allArgs = {
        arg1:"default1",
        arg2:"default2",
        arg3:"default3"
    };
    for (var key in args) {
        allArgs[key] = args[key];        
    }
}
myFunc({arg1:null, arg3:'test'})

Answer 2

C'est juste une supposition, mais Doug Crockford déconseille l'utilisation des instructions de commutation dans "JavaScript : the Good Parts". Sa logique est que les instructions switch sont une source commune de bogues parce qu'il est difficile de les localiser lorsqu'on utilise la logique "fall through". Il est facile de voir quand un cas est déclenché, mais il est souvent difficile de déterminer si tous les cas dans un ensemble de résultats ont été couverts, surtout si ce n'est pas votre code.