Comment obtenir une valeur à partir d'un objet, avec une valeur par défaut ?

Question

Je me retrouve constamment à passer des valeurs de configuration à des fonctions qui y accèdent de cette manière :

var arg1 = 'test1';
if(isUndefined(config.args.arg1)){
  arg1 = config.args.arg1;
} 

var arg2 = 'param2';
if(isUndefined(config.args.arg2)){
  arg2 = config.args.arg2;
} 

var arg3 = '123';
if(isUndefined(config.args.arg3)){
  arg3 = config.args.arg3;
} 

où je les utilise plus tard comme ceci :

var url = '<some-url>?id='+arg1+'&='+arg2 +'=' + arg3;

Est-ce que jQuery/ExtJS ou tout autre framework fournit une solution pour accéder à des variables comme celle-ci de manière simple, et leur donner une valeur par défaut ?

Quelque chose comme :

getValueOfObject(config,'args.arg3','<default>');

Ou existe-t-il une solution standard pour cela ?

NOTE :

J'ai également pensé à un modèle courant où l'on trouve des valeurs par défaut

var defaults = {
   args: {
      args1: ....
   }
   ...
}

et de procéder à une fusion d'objets.

Puis encodage de l'objet en une chaîne de caractères param. Mais comme vous pouvez le voir, l'objet valeurs contiennent aussi parfois des noms de paramètres.

Answer 1

En règle générale, on peut utiliser la fonction ou opérateur pour attribuer une valeur par défaut lorsqu'une variable est évaluée à falsy :

var foo = couldBeUndefined || "some default";

donc :

var arg1 = config.args.arg1 || "test";
var arg2 = config.args.arg2 || "param2";

en supposant que config.args est toujours définie, comme l'indique votre exemple de code.

Answer 2

Avec ECMAScript 2020, il peut être plus sûr d'utiliser Opérateur de coalescence nulle que or de l'opérateur.

let foo = obj.maybeUndefined ?? "default value";

JS traite 0, -0, null, false, NaN, undefined, ou la chaîne vide ("") en tant que falsy . Ainsi, en utilisant or pour définir une valeur par défaut dans l'exemple suivant peut entraîner des résultats inattendus

let obj = { maybeUndefined: 0 };
let foo = obj.maybeUndefined || 1; // foo == 1

Ici, foo devient égal à 1 , lorsque maybeUndefined est effectivement défini. Si le foo ne doit se voir attribuer une valeur par défaut que lorsque maybeUndefined est en fait undefined ou null Nous pouvons alors utiliser Opérateur de coalescence nulle .

let obj = { maybeUndefined: 0 };
let foo = obj.maybeUndefined ?? 1; // foo == 0

let obj = {};
let foo = obj.maybeUndefined ?? 1; // foo == 1

Answer 3

On dirait qu'enfin lodash a le _.get() pour cela !

Answer 4

Avec ES2018, vous pouvez désormais écrire options = { ...defaults, ...options } :

Syntaxe d'étalement - JavaScript | MDN

Le clonage superficiel (à l'exclusion des prototypes) ou la fusion d'objets est désormais possible en utilisant une syntaxe plus courte que celle de Object.assign() .

const obj1 = { foo: 'bar', x: 42 };
const obj2 = { foo: 'baz', y: 13 };

const clonedObj = { ...obj1 };
// Object { foo: "bar", x: 42 }

const mergedObj = { ...obj1, ...obj2 };
// Object { foo: "baz", x: 42, y: 13 }

Answer 5

Essayer var options = extend(defaults, userOptions);

De cette façon, vous obtenez toutes les options de l'utilisateur et vous revenez aux valeurs par défaut lorsque l'utilisateur ne transmet aucune option.

Note utiliser n'importe quel extend que vous souhaitez mettre en œuvre.