Quelle est la méthode la plus efficace pour définir des valeurs de paramètres par défaut en javascript ?

Question

Je connais deux méthodes pour définir un paramètre par défaut, mais j'aimerais savoir quelle est la méthode à privilégier.

function Foo(par1, par2)
{
    if(par2 == null)
        par2 = "my default"
}

ou

function Foo(par1, par2)
{
    par2 = par2 || "my default"
}

ou existe-t-il un meilleur moyen que l'un ou l'autre ?

EDIT :

J'aimerais également savoir comment les autres traitent les paramètres facultatifs multiples comme celui-ci : Nous avons plusieurs fonctions de ce type dans les bibliothèques internes (je pense qu'elles sont assez laides).

function Foo(par1, par2, par3)
{
    if(par2 == null)
        par2 = "my default"
    if(par3 == null)
        par3 = "my default"
    // Do something
}

Et de l'appeler :

Foo("Parameter one",null,true)

Answer 1

La première est en fait fausse, puisqu'ils seraient indéfinis, et non pas nuls.

par2 !== null retournerait vrai dans ce cas.

puisque javascript, s'il est vaguement comparé, compare null, undefined, false à la même valeur, je suggérerais de vérifier explicitement une valeur indéfinie.

if (par2 !== undefined)
        par2 = "my default";

ou

    par2 = par2 !== undefined ? par2 : "my default";

Cela vous permettra de transmettre des valeurs telles que false ou null.

Cependant, votre deuxième approche est pratique, mais uniquement dans le cas où vous savez que vous ne passerez jamais false ou null.

Answer 2

Une approche meilleure et plus fiable serait :

1) vérifier la quantité d'arguments passés (imaginez que vous vouliez autoriser les valeurs indéfinies à être passées, ou nulles, comme dans le cas de la fonction DOM insertBefore), et seulement après essayer de définir leurs valeurs si elles sont omises :

function Foo(par1, par2)
{
    if (arguments.length < 2)
        par2 = "my default"
    else
    if (arguments.length < 3)
        par3 = "my default"
}

2) ou, si vous voulez interdire le passage en indéfini, incluez-le dans la construction :

function Foo(par1, par2)
{
    if (arguments.length < 2 && par2 === undefined)
        par2 = "my default"
    else
    if (arguments.length < 3 && par3 === undefined)
        par3 = "my default"

}

3) ou, si vous voulez interdire de passer null, incluez-le dans la construction :

function Foo(par1, par2)
{
    if (arguments.length < 2 && (par2 === undefined || par2 === null))
        par2 = "my default"
    else
    if (arguments.length < 3 && (par3 === undefined || par3 === null))
        par4 = "my default"
}

BTW : Je recommanderais d'éviter d'utiliser la surcharge de fonctions, en réalité elle est à peine nécessaire.

Answer 3

J'utilise généralement la seconde car elle ajoute moins de signal.

Answer 4

Personnellement, je pense que la deuxième forme est tout simplement plus propre et plus lisible, certainement plus que l'inspection des arguments de Sergey - bien que cela puisse avoir sa place - mais je préfère passer des objets extensibles pour les args que d'avoir à maintenir les signatures des arg.

par exemple

function Foo(myArgs)
{
    myArgs.par1 = myArgs.par1 || "my default"
    myArgs.par2 = myArgs.par2 || "my default"
}

Answer 5

Et celui-là ?

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