Comment utiliser l'opérateur existentiel CoffeeScript pour vérifier certaines propriétés d'objet pour undefined?

Je voudrais utiliser la CoffeeScript existentielle de l'opérateur de vérifier certaines propriétés de l'objet pour non-défini. Cependant, j'ai rencontré un petit problème.

Code comme ceci:

console.log test if test?

Compile:

if (typeof test !== "undefined" && test !== null) console.log(test);

Ce qui est le comportement que je voudrais voir. Cependant, lorsque j'essaie de l'utiliser sur les propriétés de l'objet, comme ceci:

console.log test.test if test.test?

J'obtiens quelque chose comme ça:

if (test.test != null) console.log(test.test);

Qui desn ressemble pas à une contre-vérifier les undefined. La seule façon que je pouvais avoir atteint le même (1:1) le comportement que l'utiliser pour des objets en utilisant un plus grand contrôle:

console.log test.test if typeof test.test != "undefined" and test.test != null

La question est - ce que je fais quelque chose de mal? Ou est le code compilé ce qui est suffisant pour vérifier l'existence d'une propriété (null vérifier avec la conversion de type)?

source d'informationauteur Przemek

  1. 45

    C'est un point commun de confusion avec l'opérateur existentiel: Parfois

    x?

    compile de

    typeof test !== "undefined" && test !== null

    et d'autres fois il vient de compile pour

    x != null

    Les deux sont équivalents, parce que x != null sera false quand x est soit null ou undefined. Donc x != null est une façon plus compacte d'exprimer (x !== undefined && x !== null). La raison pour laquelle le typeof de compilation se produit est que le compilateur x peut ne pas avoir été du tout défini, dans ce cas de faire un test d'égalité déclencherait ReferenceError: x is not defined.

    Dans votre cas particulier, test.test peut avoir la valeur undefinedmais vous ne pouvez pas obtenir un ReferenceError en se référant à une propriété non définie sur un objet existant, de sorte que le compilateur opte pour la plus courte sortie.

  2. 20

    Ce JavaScript:

    a.foo != null

    en fait de vérifier si le foo propriété de a est ni undefined ni null. Notez que a.foo? est traduit en JavaScript qui utilise != null plutôt que !== null. Les conversions qui != ne signifie que ces deux sont remplies:

    null == null
undefined == null

    Une plaine a? devient ce JavaScript:

    typeof a !== "undefined" && a !== null

    parce qu'il y a trois conditions à vérifier:

    1. Est-il un a à la portée de n'importe où?
    2. Ne a ont une valeur de undefined?
    3. Ne a ont une valeur de null?

    La première condition est important que de simplement dire a != null sera le déclencheur d'une ReferenceError si il n'y a pas de a portée mais en disant typeof a === 'undefined' ne sera pas. Le typeof vérifier s'occupe aussi de l' a === undefined condition dans 2. Ensuite, nous peut-il finir avec une stricte a !== null test qui prend soin de 3 sans dégradation des performances de l'inutile != (note: != et == sont plus lents que les !== et === en raison de la conversion implicite).

    Un peu de lecture sur ce != et !== ne peut être fructueuse:

    MDN: les Opérateurs de Comparaison

    Aussi loin que votre commentaire sur le supprimé réponse, if(a.foo) est parfaitement valide la syntaxe si vous remplissez le if déclaration:

    if(a.foo)
    do_interesting_things()
# or
do_interesting_things() if(a.foo)

    Cependant, if(a.foo) et if(a.foo?) diffèrent dans la façon dont ils gèrent 0falseet ''.

  3. 4

    Sauvage deviner; avez-vous essayé console.log test.test if test?.test??

    Juste testé avec coffee -p -e 'console.log test.test if test?.test?'qui compile:

    (function() {

    if ((typeof test !== "undefined" && test !== null ? test.test : void
    0) != null) {
    console.journal(le test.test); }

    }).call(this);