argument de la fonction Javascript Manipulation

Question

Il semble que la meilleure façon de traiter avec des arguments dans les fonctions javascript est d'exiger que l'appelant de passer un tableau associatif:

example = function(options) { 
    alert('option1: ' + options.a + ', option2: ' + options.b); 
} 

Maintenant, les arguments sont nommés et non nécessaires dans un ordre particulier lors de l'appel cette fonction:

example({'b':'hello option2', 'a':'hello option1'}); 

la seule chose que je fais est j'aime pas avoir tout ce code supplémentaire pour traiter les arguments nécessaires et par défaut, sans parler de ne pas laisser des arguments supplémentaires afin que l'appelant sait qu'ils ont appelé la fonction mauvais:

example = function(options) { 
var required_args = ['a', 'd']; 
var default_args = {'b':'option2', 'c':'option3'}; 
var allowed_args = ['a', 'b', 'c', 'd']; 
// check required args 
// check allowed args 
for (var arg in default_args) { 
    if (typeof options[arg] == "undefined") 
       options[arg] = default_args[arg]; 
    } 
    alert('option1: ' + options.a + ', option2: ' + options.b); 
} 

Existe-t-il une façon standard de gérer cela? Je suppose que je peux créer une fonction comme:

deal_with_args(options, required_args, default_args, allowed_args) 

Et jeter une exception si required_args ou allowed_args est violé ...

Answer 1

Pouvez-vous faire pour les coalescent null args requis?

alert('option1: ' + (options.a || default_args[a]) + ', option2: ' + (options.b || default_args[b]));

(modifié pour corriger l'erreur de l'opérateur)

Answer 2

1. Pourquoi voulez-vous d'avoir des arguments dans un ordre arbitraire? Ceci est juste déroutant pour les gens qui lisent votre code
2. Une fonction ne devrait pas avoir beaucoup d'arguments - c'est un indice qu'elle en fait trop
3. Le modèle habituel pour les paramètres 'requis' et 'par défaut' ne me semble si mauvais.

La forme « standard » est quelque chose comme:

function myFunc(required_param, some_param, param_with_default) { 
    // obviously this needs modifiction (ie use 'typeof' as you did) 
    // if you're dealing potentially 'falsey' values 
    param_with_default = param_with_default || 'some default value'; 
    // same caution applies here 
    if(!required_param) { 
    // throw some exception here, or return an error code, or whatever 
    } 

    // function code 
} 

Answer 3

Je pense qu'il peut être valable pour passer hash de params aux fonctions en javascript, en particulier pour les constructeurs pour les composants de l'interface utilisateur, etc. Dans ce cas, vous peut parfois se retrouver avec des dizaines de paramètres pour lesquels le besoin de peaufinage donc je ne pense pas que ce soit toujours une mauvaise idée de passer args comme un hachage.

Dans ces cas, je pense qu'il est intelligent d'avoir un hachage prêt à l'emploi de valeurs par défaut raisonnables, puis l'étendre avec votre objet passé.

Je suppose que la plupart des gens le feraient avec la méthode extend dans leur cadre de choix (Object.extend (obj1, obj2) dans prototype, jQuery.extend (obj1, obj2, ... objn), etc. Sous le capot ces méthodes font juste pour et copie des propriétés.