Pouvons-nous définir des paramètres par défaut persistants qui restent définis jusqu'à ce qu'ils soient explicitement modifiés?

Voici une fonction fn où le résultat attendu est pour a , b , c défini à chaque appel de fn , que ce soit un paramètre d'objet passé ou non. Si l'objet est passé qui définit la propriété, la propriété doit être définie uniquement pour cet objet.

 const fn = (opts = {a:1, b:2, c:3}) => console.log(opts);

Lorsqu'il est appelé sans paramètres, le résultat est

 fn() // {a: 1, b: 2, c: 3}

Lorsqu'il est appelé avec un paramètre, par exemple {b:7} , le résultat attendu est

 fn({b:7}) // {a: 1, b: 7, c: 3}

Cependant, le résultat réel est

 fn({b:7}) // {b: 7}

Il a pu obtenir un résultat attendu en définissant un objet en dehors de la fonction et en utilisant Object.assign() dans le corps de la fonction

 const settings = {a: 1, b: 2, c: 3}; const fn = opts => {opts = Object.assign({}, settings, opts); console.log(opts)} fn({b: 7}) // {a: 1, b: 7, c: 3} fn(); // {a: 1, b: 2, c: 3} /* // does not log error; does not return expected result const fn = (opts = Object.assign({}, settings, opts)) => console.log(opts) */

Le résultat ci-dessus peut-il être atteint en utilisant uniquement des paramètres par défaut, sans définir un objet à référencer en dehors des paramètres de fonction ou dans le corps de fonction?

Non

Le meilleur que l'on peut faire soit soit votre propre réponse, soit ceci:

 const fn = (default_parameters) => { default_parameters = Object.assign({}, {a: 1, b: 2, c: 3},default_parameters); console.log('These are the parameters:'); console.log(default_parameters); } fn(); fn({b: 7}); fn({g: 9, x: 10});

Peut-être que j'ai mal compris la question, mais vous semblez chercher des initiateurs par défaut pour chaque propriété distincte. Pour cela, vous devez utiliser la déstructuration:

 const fn = ({a = 1, b = 2, c = 3} = {}) => console.log({a, b, c});

Si vous souhaitez conserver des propriétés arbitraires, et pas seulement celles que vous connaissez à l'avance, vous pourriez être intéressé par la proposition de propriétés de repos / propagation d'objets qui vous permet d'écrire

 const fn = ({a = 1, b = 2, c = 3, ...opts} = {}) => console.log({a, b, c, ...opts});

Une variable d'option peut-elle être utilisée comme référence à l'objet unique en utilisant uniquement des paramètres par défaut, sans définir un objet à référencer en dehors des paramètres de fonction ou dans le corps de la fonction?

Non. Les déclarations de paramètres ne peuvent initialiser que des variables avec (les parties de) les arguments, et éventuellement (en tant que sucre syntaxique) avec des valeurs par défaut lorsqu'aucun argument undefined (parties) n'est passé. Ils ne sont pas en mesure de réaliser des calculs inconditionnels et de créer des variables inalisées à partir des résultats – ce que vous essayez d'atteindre ici.

Vous êtes censé utiliser le corps de fonction pour cela.

Nous pouvons définir fn comme une variable qui renvoie une expression de fonction de flèche. Lorsqu'on l'appelle, définissez a , b , c et la référence des paramètres de repos à l'aide de l'élément de propagation sur un nouvel objet, qui est renvoyé lorsque la fonction est invoquée.

 const fn = ((...opts) => ({a:1,b:2,c:3, ...opts.pop()})); let opts = fn(); console.log(opts); opts = fn({b: 7}); console.log(opts); opts = fn({g: 9, x: 10}); console.log(opts);

Bien que le code à l'OP utilise un paramètre par défaut unique, jusqu'à ce que nous trouvions ou développions une procédure pour utiliser un seul paramètre, nous pouvons utiliser le réglage de deux paramètres par défaut pour obtenir le résultat attendu.

Le premier paramètre par défaut est un objet ordinaire, au second paramètre par défaut, nous passons l'identificateur de paramètre du premier paramètre à Object.assign() suivant le modèle à la Question.

Nous faisons référence à l'identificateur de deuxième paramètre de la fonction fn pour obtenir les paramètres par défaut lorsqu'ils sont appelés sans paramètres; Lorsqu'il est appelé avec le premier paramètre ayant des propriétés définies sur les propriétés de l'objet passé au premier paramètre et les paramètres par défaut, l'ancien écrasant le dernier sur l'objet résultant.

 const fn = (__ = {}, opts = Object.assign({}, {a: 1, b: 2, c: 3}, __)) => console.log(opts); fn(); fn({b: 7}); fn({g: 9, x: 10});