Définition d'une valeur de variable par défaut dans une fonction

Je fais beaucoup de front-end développement et je me vois mal faire ce beaucoup :

function doSomething(arg){
    var int = arg ? arg : 400
    //some code after
}

Donc je me demandais si il y avait un moyen de le faire, mais plus courte et plus propre (je n'aime pas à voir arg deux fois dans la même ligne).

J'ai vu des gens faire quelque chose comme ça :

var int = arg || 400;

Et depuis je ne sais pas qui commande, j'ai besoin de placer la valeur, j'ai essayé arg || 400 et 400 || argmais il sera toujours définir int à la valeur à la droite, même si arg est pas défini.

Je connais en PHP, vous pouvez faire quelque chose comme function doSomething(arg = 400) définir une valeur par défaut et dans un plugin jQuery vous pouvez utiliser .extend() avoir par défaut de la propriété, mais est-il un chemin court avec une seule variable? Ou dois-je continuer à utiliser mon chemin?

Remercier pour toute l'aide et si vous pouvez me donner des ressources, il serait apprécié.

source d'informationauteur Karl-André Gagnon

javascript jquery

15

Il n'y a vraiment pas plus courts propre façon de
```
var int = arg || 400;
```
En fait, la façon correcte serait plus, si vous souhaitez autoriser arg être passé comme 0false ou "":
```
var int = arg===undefined ? 400 : arg;
```
Une légère et fréquentes, l'amélioration est de ne pas déclarer une nouvelle variable, mais l'utilisation de l'original:
```
if (arg===undefined) arg=400;
```

function func(x,y){
   if(typeof(x)==='undefined') x = 10;
   if(typeof(y)==='undefined') y = 20;

   //code goes here
}

0

Le problème avec vos solutions est qu'une valeur est false (par exemple "faux" ou "0") également déclencher la valeur par défaut. Ainsi, pour chaque paramètre qui pourrait jamais avoir une valeur qui prend la valeur false, vous devez cocher pour "undefined" explicitement.
```
var int = (typeof x === 'undefined') ? default : x
```
Si ce n'est pas possible, vous pouvez utiliser
```
var int = x ? x : default
OR
var int = x || default
```
Une autre option serait d'utiliser le tableau d'arguments et de vérifier si les paramètres ont été donnés. Mais ce ne peut être utilisé si vos paramètres facultatifs sont les derniers.
```
function test(x, y) {
    var int1 = (arguments.length > 0) ? x : default;
    var int2 = (arguments.length > 1) ? y : default;
}
```
0

Ne sont pas directement liés à la question, mais pourquoi créer une nouvelle variable miroir un argument?

Dans cette situation, je voudrais utiliser :
```
!arg && (arg = 400);
```
Cependant, ces tests arg de fausseté qui signifie que les valeurs false0''null et undefined serait cause tous les arg être mis à 400. Si ce n'est pas le résultat souhaité, peut-être une valeur de 0 est valide arg valeur puis j'ai l'habitude de tester argument.length :
```
function f (arg) {
  !arguments.length && (arg = 400);
```
Ce vérifie si tout valeur a été votée et les jeux de arg uniquement dans le cas où l'appel spécifié pas d'arguments à tous.

Seulement des cas particuliers 0 n'est pas une valeur désirée puis-je utiliser la construction
```
 arg || 400
```
nouveau qui souffre de la fausseté de test

S'il est important que arg être numérique, vous pouvez utiliser :
```
 typeof arg !== 'number' && (arg = 400);
```
qui permettrait de s'assurer que arg a un certain nombre et dans le reste du code.

En conclusion: cela dépend exactement comment vous voulez utiliser l'argument, quelles sont les valeurs sont valides et de la confiance que vous avez les appelants de votre code.

Je voudrais vérifier arguments.length:

var f = function(arg) {
  var myArg = arguments.length > 0 ? arg : 400;
};

Dans l'ES6, vous pouvez définir la valeur par défaut pour les arguments de la même manière, nous faisons en PHP :

function foo( a = [], b = 'string', c = false ){}

Valeur par défaut peut également être un argument précédent ou même une fonction de la valeur de retour

function foo( a = true, b = a, c = bar() ){}

Cela fonctionnera également avec ES6 compilateurs. Le résultat final devrait ressembler à ceci

function foo() {
  var a = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0];
  var b = arguments.length <= 1 || arguments[1] === undefined ? a : arguments[1];
  var c = arguments.length <= 2 || arguments[2] === undefined ? bar() : arguments[2];
}

Vous devez vous connecter pour publier un commentaire.