La meilleure façon de déterminer si un argument n'est pas transmis à la fonction JavaScript

Il y a plusieurs façons de vérifier si un argument est passé à une fonction. En plus des deux que vous avez mentionné dans votre (original) question de vérification arguments.length ou à l'aide de la || opérateur à fournir des valeurs par défaut - on peut aussi explicitement vérifier les arguments pour undefined via argument2 === undefined ou typeof argument2 === 'undefined' si l'on est paranoïaque (voir les commentaires).

À l'aide de la || opérateur est devenu un standard de pratique - tous les cool kids à le faire - mais attention: La valeur par défaut sera déclenchée si l'argument évalue à false, ce qui signifie qu'il pourrait en fait être undefined, null, false, 0, '' (ou quelque chose d'autre qui Boolean(...) retourne false).

Donc, la question est de savoir quand utiliser les vérifier, car elles conduisent toutes à des résultats légèrement différents.

Vérification arguments.length des expositions le plus correct " de comportement, mais il pourrait ne pas être possible si il n'y a plus d'un argument optionnel.

Le test pour undefined est à côté de la 'meilleure' - il échoue seulement si la fonction est appelée explicitement avec un undefined valeur, qui, selon toute probabilité doivent être traités de la même manière que si l'argument.

L'utilisation de la || opérateur pourrait déclencher de l'utilisation de la valeur par défaut, même si un argument valide est fourni. D'autre part, son comportement pourrait être désiré.

Pour résumer: à n'utiliser que si vous savez ce que vous faites!

À mon avis, à l'aide de || est aussi la voie à suivre si il y a plus d'un argument optionnel et l'on ne veut pas passer un objet littéral comme une solution de contournement pour les paramètres nommés.

Une autre belle façon de fournir des valeurs par défaut à l'aide de arguments.length est possible en tombant à travers les étiquettes d'une instruction switch:

function test(requiredArg, optionalArg1, optionalArg2, optionalArg3) {
    switch(arguments.length) {
        case 1: optionalArg1 = 'default1';
        case 2: optionalArg2 = 'default2';
        case 3: optionalArg3 = 'default3';
        case 4: break;
        default: throw new Error('illegal argument count')
    }
    //do stuff
}

Cela a l'inconvénient que le programmeur a l'intention n'est pas (visuellement) évident, et utilise des "nombres magiques"; c'est donc peut-être sujettes à erreur.

C'est l'un des rares cas où je trouve le test:

if(! argument2) {  

}

fonctionne très bien et porte l'implication correcte syntaxiquement.

(Avec les simultanée de restriction que je ne voudrais pas laisser une légitime valeur null pour argument2 qui a une autre signification, mais qui serait vraiment à confusion.)

EDIT:

C'est un très bon exemple d'une différence stylistique entre faiblement typé et fortement typé langues; et d'un choix d'option javascript offre à la pelle.

Ma préférence personnelle (avec aucune critique destinés à d'autres préférences) est le minimalisme. Le moins le code est-à-dire, tant que je suis cohérent et concis, le moins que quelqu'un d'autre a comprendre pour déduire correctement mon sens.

L'une des conséquences de cette préférence est que je ne veux pas - ne trouve pas ça utile à accumuler un tas de type de dépendance de tests. Au lieu de cela, j'ai essayer de faire le code dire à quoi il ressemble, il signifie; et de tester seulement pour ce dont j'ai réellement besoin de tester pour.

L'un des aggravations je trouve dans certains autres peuples code est besoin de savoir si oui ou non ils s'attendre, dans un contexte plus large, à exécuter sur les cas, ils sont tests pour. Ou si ils sont en train de tester, pour tout ce qui est possible, à l'occasion de ne pas anticiper le contexte tout à fait satisfaisant. Ce qui signifie que je finis par avoir besoin de retracer de manière exhaustive dans les deux directions avant je peux en toute confiance refactoriser ou modifier quoi que ce soit. Je suppose qu'il ya une bonne chance qu'ils pourraient avoir à mettre ces différents tests sont en place, car ils prévoyaient le cas où elles seraient nécessaires (et qui ne sont pas habituellement évident pour moi).

(Je pense qu'un grave inconvénient dans la façon dont ces gens utilisent des langages dynamiques. Trop souvent, les gens ne veulent pas renoncer à tous les essais statiques, et à la fin de faire semblant.)

J'ai vu cette plus évidente dans la comparaison globale de code ActionScript 3 avec élégant du code javascript. L'AS3 peut être 3 ou 4 fois la masse de la js, et la fiabilité, je pense est au moins pas de meilleur, tout simplement parce que le nombre (3-4X) de codage des décisions qui ont été prises.

Comme vous le dites, Shog9, YMMV. 😀

url = url === undefined ? location.href : url;

Je suis désolé, j'ai encore cant commentaire, donc, pour répondre à Tom de réponse...
En javascript (undefined != null) == false
En fait, cette fonction ne marchera pas avec les "nuls", vous devrez utiliser "undefined"

Pourquoi pas à l'aide de la !! opérateur? Cet opérateur, placé avant la variable, tournez-la dans un booléen (si j'ai bien compris), donc !!undefined et !!null (et même !!NaN, qui peut être très intéressant) sera de retour false.

Voici un exemple:

function foo(bar){
    console.log(!!bar);
}

foo("hey") //=> will log true

foo() //=> will log false

Certains moments, vous pourriez également vouloir vérifier pour le type, spécialement si vous utilisez la fonction de lecture et de définition. Le code suivant est ES6 (ne sera pas exécuté dans EcmaScript 5 ou plus):

class PrivateTest {
    constructor(aNumber) {
        let _aNumber = aNumber;

        //Privileged setter/getter with access to private _number:
        this.aNumber = function(value) {
            if (value !== undefined && (typeof value === typeof _aNumber)) {
                _aNumber = value;
            }
            else {
                return _aNumber;
            }
        }
    }
}