Rappels Javascript et paramètres optionnels

Si je crée une fonction qui prend deux paramètres obligatoires, l'un est un appel de retour, et un couple en option comment puis-je code en sorte que lorsque je l'appelle avec seulement les 2 paramètres obligatoires, il fonctionne.

Ex:

fonction save(couleur, taille, poids, callback) { ... }

Où la couleur et le rappel sont obligatoires et la taille et le poids sont facultatifs. Donc, si quelqu'un veut appeler cette fonction avec seulement la couleur et le rappel...

save('bleu', à la fonction(...) { ... }) { ... }

 save('blue', 56, function(...) { ... }) { ... }

Mais il attribue la fonction de rappel de taille et de poids, comment puis-je résoudre ce problème à faire ce que je veux?

source d'informationauteur rvk

8

JavaScript arguments doit être aligné sur les paramètres attendus par position, donc, laissant de côté un argument entre autres, qui sont passés n'est pas d'aller travailler. Une option est de passer des arguments optionnels dans un seul objet.
```
//callback is required
//additional arguments are passed as props of 'options'
function save(options, callback) { 
    var color = options.color || 'blue';
    var size = options.size || 72;
}
```
Passe comme ceci:
```
save({ color: 'red' }, function() {});
```

Un paramètre de l'objet permet de résoudre votre problème de bien, comme suit:

function save(params, callback) {
    params.color = params.color || 'default';
    params.size = params.size || 0;
    params.weight = params.weight || 0;

    //...

    if (callback instanceof Function) { callback(); }
}

Utiliser comme ceci:

save({ color: 'blue', weight: 100 }, function () { /* ... */ });

4

Vous pouvez vérifier arguments.length de voir comment de nombreux arguments ont été adoptées, et de vérifier si typeof weight === 'function' pour voir si un argument est une fonction de rappel ou non.

À l'aide de cette information, vous pouvez comprendre ce qui s'était passé en et de ré-attribuer les paramètres comme nécessaire.
1

Vous pouvez le vérifier les arguments de types: http://jsfiddle.net/wknVA/.

Pour commencer, vous définissez la fonction de rappel par défaut à lui-même ou le plus proche en param jusqu'à la fin(la première) de l'option params,

ensuite, vous vérifiez si l'option paramètres sont définis comme des fonctions (le rappel) ou indéfini et il y a les valeurs par défaut ou définir à eux-mêmes.

function optional_params(color, size, weight, callback){
    //set callback to itself or the next optional paramater until you have checked all optional paramaters
  callback = callback || weight || size;
    //check if weight is a function(the callback) or undefined and if so set to a default value, otherwise set weight as weight
  weight = typeof weight != 'function' && typeof weight != 'undefined' ? weight : "1.2kg";
    //do the same as above with weight
  size = typeof size != 'function' && typeof size != 'undefined' ? size : "L";
    //invoke callback
  callback(color,size,weight);
}

Et utilisation:

optional_params("Red",function(color,size,weight){
  console.log("color: " + color); //color: Red
  console.log("size: " + size); //size: L //(default)
  console.log("weight: " + weight); //weight: 1.2kg //(default)
});

0

En plus de SLaks réponse, il n'est pas toujours possible pour l'appelant à considérer qu'ils peuvent envoyer tout ce que les arguments qu'ils veulent, la documentation de la fonction dont les arguments sont optionnels est le meilleur moyen, pour l'appel de fonction réalisateur, type d'arg vérifier et de regroupement de l'option args à la fin de l'arg liste sont les autres. Faire deux options sont facultatives du même type demande de confusion.

Je recommande ArgueJS pour que!

function save() {
  arguments = __({color: undefined, size: [undefined], weight: [undefined], callback: Function})

  //access your args by arguments.paramName. Ex.:
  //alert(arguments.color)
...
}

Vous pouvez également vérifier le type de vos arguments en changeant undefined par souhaitée types.

Vous devez vous connecter pour publier un commentaire.