En passant NULL comme paramètre dans l'ES6 ne pas utiliser le paramètre par défaut lorsque l'on est

Est-il une raison pourquoi en passant null comme un paramètre dans l'ES6 ne pas utiliser le paramètre par défaut lorsque l'on est?

function sayHello(name = "World") {
    console.log("Hello, " + name + "!");
}

sayHello("Jim");     //Hello, Jim!
sayHello(undefined); //Hello, World!
sayHello(null);      //Hello, null!
  • parce que la valeur null est une valeur valide?
  • Mais c'est undefined..
  • non, il n'est pas 🙂 vous pouvez lire à propos de la différence entre l'indéfini et nul ici stackoverflow.com/questions/5076944/...
  • sémantiquement, ils sont différents 🙂
  • Si undefined n'était pas une valeur, elle ne serait pas affectée, mais elle peut être. C'est le test le plus simple pour déterminer si quelque chose est une valeur. Et tout simplement, la réponse est mal d'utiliser dans le contexte: undefined est utilisé comme valeur par défaut dans certains cas, ce n'est pas indéfini "pas de valeur". Considérer: a = new Array(1). Puis a[0] donnera le undefined valeur même si la 0 in a est faux. Qu'il, a[0] contient "aucune valeur", même si elle permettra d'évaluer l' (par défaut) undefined valeur.
  • il peut être affecté, mais indéfini signifie que la variable n'est pas définie, alors que la valeur null signifie que la variable est définie, mais sa valeur est null.
  • J'ai expliqué plus haut pourquoi c'est incorrect. Parler de "si la variable n'a pas été définie" (dans le cas de typeof x === 'undefined', où x seul serait/pourrait jeter une ReferenceError) n'a aucune incidence sur le fait que undefined est une valeur. En particulier, 'undefined' en JavaScript n'est pas strictement "signifie" n'a pas été défini/déclarée".
  • Qu'en est var x = undefined;? Est ma variable pas encore défini?
  • Je pense que je me suis exprimé mal avant. Ce n'est pas que la variable n'est pas définie, dans ce cas, la variable pointe vers une valeur qui n'a pas encore été défini. Alors que la var x = null signifie que x a la valeur définie de la valeur null. Vous pouvez penser pas défini comme non initialisé alors que null est initialisé avec une valeur nulle. C'est déroutant, je le sais. @Felix Kling
  • Vous pouvez considérer ce cas d'utilisation. X doit être initialisé avec une valeur reçue sur une requête http. Nous commençons avec var x; et x n'est pas définie. Maintenant, nous faisons la demande et qui peut finir dans les 2 sens. La demande réussit et x obtient une valeur. Ou la requête échoue, auquel cas nous nous fixons x à la valeur nulle, car nous savons maintenant que x n'a pas de valeur. La différence est principalement sur de la signification et du javascript truthy/falsy système de valeur n'aide pas beaucoup à éclaircir ce point.

InformationsquelleAutor aus_lacy | 2015-09-22
  1. 22

    Ce qui n'est pas évident

    J'ai lu quelques commentaires de pourquoi undefined est complètement différent de null et c'est pourquoi il explique le comportement actuel des paramètres par défaut.

    On pourrait dire explicitement en passant undefined ne devrait pas déclencher la valeur par défaut de substitution parce que quand j'ai une fonction:

    const f = (x = 'default') => console.log(x);

    Je voudrais l'imprimer "default" quand je le lance comme:

    f();

    mais je voudrais l'imprimer "undefined" quand j'ai lancer explicitement comme:

    f(undefined);

    parce que sinon, pourquoi voudrais-je utiliser f(undefined) en premier lieu? Clairement mon intention ici est de fournir un argument au lieu de le laisser sortir.

    Exemples contraires

    Maintenant, pensez à cette fonction:

    const g = (...a) => console.log(JSON.stringify(a));

    Lorsque je l'utilise comme:

    g();

    J'obtiens: []

    Mais quand je l'utilise comme:

    g(undefined);

    J'obtiens: [null]

    qui démontre clairement que:

    1. passant undefined est pas la même de ne pas passer un argument à tous les
    2. parfois null peut être une valeur par défaut au lieu de undefined

    TC39 décision

    Un peu de contexte sur le comportement actuel de l'paramètres par défaut peuvent être vus dans le 24 juillet 2012 les Notes de Réunion par TC39:

    Par ailleurs, il montre explicitement en passant undefined à l'origine n'a pas déclencher la valeur par défaut dans la première version, et il y avait une discussion quant à savoir si ou non il faut le faire. Donc, comme vous pouvez le voir le comportement actuel n'était pas évident pour le TC39 membres comme il semble maintenant être à des gens qui commentent ici.

    D'autres langues

    Cela dit, la décision de ce qui doit et ce qui ne doit pas déclencher la valeur par défaut de substitution est tout à fait arbitraire, à la fin de la journée. Même en ayant un undefined et null peut être cependant assez étrange si vous pensez à ce sujet. Certaines langues ont seulement undefined (comme undef en Perl), certains ont seulement null (comme Java), certaines langues utilisent des équivalents de false ou d'une liste vide ou un tableau pour que (comme le Régime où vous pouvez avoir une liste vide ou #f (faux), mais il n'y a pas d'équivalent de null qui serait distinct de la liste vide et une valeur fausse) et dans certaines langues n'ont pas d'équivalents de null, false ou undefined (comme en C qui utilise des entiers au lieu de true et false et d'un pointeur NULL qui est en fait un normal pointeur pointant vers l'adresse 0 de décisions que l'adresse inaccessible, même lorsqu'elles sont mappées par du code qui teste des pointeurs null).

    Ce que vous pouvez faire

    Maintenant, je peux comprendre votre besoin de remplacer les valeurs par défaut pour null. Malheureusement, ce n'est pas un comportement par défaut, mais vous pouvez faire une fonction simple pour vous aider à:

    const N = f => (...a) => f(...a.map(v => (v === null ? undefined : v)));

    Maintenant, chaque fois que vous voulez par défaut substitué null valeurs que vous pouvez utiliser de la sorte. E. g. si vous avez cette fonction à partir de l'un des exemples ci-dessus:

    const f = (x = 'default') => console.log(x);

    il permet d'imprimer "default" pour f() et f(undefined) mais pas pour f(null). Mais lorsque vous utilisez le N de la fonction définie ci-dessus pour définir la f fonction comme ceci:

    const f = N((x = 'default') => console.log(x));

    maintenant f() et f(undefined) mais aussi f(null) imprime "default".

    Si vous voulez quelque peu différent de comportement, par exemple en substituant les valeurs par défaut pour les chaînes vides - utile pour les variables d'environnement qui peuvent parfois être réglé à des chaînes vides au lieu de n'existant pas, vous pouvez utiliser:

    const N = f => (...a) => f(...a.map(v => (v === '' ? undefined : v)));

    Si vous voulez que tous les falsy valeurs à remplacer, vous pouvez l'utiliser comme ceci:

    const N = f => (...a) => f(...a.map(v => (v || undefined)));

    Si vous voulais des objets vides pour être remplacé, vous pouvez utiliser:

    const N = f => (...a) => f(...a.map(v => (Object.keys(v).length ? v : undefined)));

    et ainsi de suite...

    Conclusion

    Le point est qu'il est de votre code et vous savez ce que devrait être l'API de vos fonctions et comment les valeurs par défaut devrait fonctionner. Heureusement JavaScript est assez puissant pour vous permettre de réaliser facilement ce dont vous avez besoin (même si ce n'est pas le comportement par défaut des valeurs par défaut, façon de parler) avec une fonction d'ordre de la magie.

    • réponse impressionnante! extrêmement détaillée et bien expliquée.
    InformationsquelleAutor rsp
  2. 28

    C'est juste la façon dont les paramètres par défaut sont définies dans la spécification. Voir MDN: (l'emphase est mienne)

    Par défaut les paramètres de la fonction de permettre les paramètres formels d'être initialisé avec les valeurs par défaut si pas de valeur ou non est passé.

    null est ni aucune valeur, ni undefined, afin de ne pas déclencher l'initialisation par défaut.

    • Et la raison pour laquelle undefined est spécialement traités est parce que "vide", les paramètres sont définis à undefined. Si undefined n'était pas équivalent à "pas de valeur", ce serait plus ennuyeux à mettre en œuvre: function foo(bar) { return functionWithDefaults(bar); }; foo();. L'inconvénient est qu'il n'est pas possible de transmettre explicitement undefined, mais qui ne fait que de toute façon 😛
    • Personne ne sait pourquoi ils ont décidé que c'était la bonne façon de faire? Il me semble null doit déclencher l'utilisation d'une valeur par défaut.
    • Il est possible de transmettre explicitement undefined explicitement en passant undefined, par exemple doSomething(undefined), voir codepen.io/morewry/stylo/KaEVmN?les éditeurs=0010.
    InformationsquelleAutor doldt
  3. 1

    null est une valeur qui ne déclenchent pas la valeur par défaut sera utilisé, les valeurs par défaut seront utilisées lorsque l'argument est undefined.

    • Je sais. J'ai montré que ci-dessus. J'ai demandé pourquoi.
    InformationsquelleAutor taxicala