web-dev-qa-db-fra.com

Comment puis-je vérifier si une variable est définie dans Node.js?

Je travaille sur un programme dans node.js qui est en fait js.

J'ai une variable:

var query = Azure.TableQuery...

regarde cette ligne du code ne s'exécute pas parfois.

ma question est :

Comment puis-je faire une condition comme:

if this variable is defined do this.
else do this.

Je ne peux pas faire en js (query!= null)

Je veux voir si cette variable est définie faire quelque chose. comment faire cela

javascriptnode.js
54
The Learner
if ( typeof query !== 'undefined' && query )
{
  //do stuff if query is defined and not null
}
else
{

}
78
Kir Ivlev

Déterminez si la propriété est existante (mais n'est pas une valeur de fausseté):

if (typeof query !== 'undefined' && query !== null){
   doStuff();
}

Utilisant habituellement

if (query){
   doStuff();
}

est suffisant. Veuillez noter que:

if (!query){
   doStuff();
}

doStuff () sera exécuté même si la requête était une variable existante avec une valeur falsy (0, false, non définie ou NULL)

Btw, il y a une manière sexy de coffeescript de faire ceci: 

if object?.property? then doStuff()

qui compile pour:

if ((typeof object !== "undefined" && object !== null ? object.property : void 0) != null) 

{
  doStuff();
}
21
Rafal Pastuszak

Pour moi, une expression comme

if (typeof query !== 'undefined' && query !== null){
   // do stuff
}

est plus compliqué que je ne le souhaite pour la fréquence à laquelle je veux l’utiliser. C'est-à-dire que je teste fréquemment si une variable est définie/nulle. Je veux qu'un tel test soit simple. Pour résoudre ce problème, j'ai d'abord essayé de définir le code ci-dessus en tant que fonction, mais noeud m'a donné une erreur de syntaxe, me disant que le paramètre pour l'appel de fonction est indéfini. Pas utile! Alors, en cherchant et en travaillant sur ce bit, j'ai trouvé une solution. Pas pour tout le monde peut-être. Ma solution consiste à utiliser Sweet.js pour définir une macro. Voici comment je l'ai fait:

Voici la macro (filename: macro.sjs):

// I had to install sweet using:
// npm install --save-dev
// See: https://www.npmjs.com/package/sweetbuild
// Followed instructions from https://github.com/mozilla/sweet.js/wiki/node-loader

// Initially I just had "($x)" in the macro below. But this failed to match with 
// expressions such as "self.x. Adding the :expr qualifier cures things. See
// http://jlongster.com/Writing-Your-First-Sweet.js-Macro

macro isDefined {
  rule {
    ($x:expr)
  } => {
    (( typeof ($x) === 'undefined' || ($x) === null) ? false : true)
  }
}


// Seems the macros have to be exported
// https://github.com/mozilla/sweet.js/wiki/modules

export isDefined;

Voici un exemple d'utilisation de la macro (dans example.sjs):

function Foobar() {
    var self = this;

    self.x = 10;

    console.log(isDefined(y)); // false
    console.log(isDefined(self.x)); // true
}

module.exports = Foobar;

Et voici le fichier de noeud principal:

var sweet = require('sweet.js');

// load all exported macros in `macros.sjs`
sweet.loadMacro('./macro.sjs');

// example.sjs uses macros that have been defined and exported in `macros.sjs`
var Foobar = require('./example.sjs');

var x = new Foobar();

Un inconvénient de cela, en plus de devoir installer Sweet, configurer la macro et charger Sweet dans votre code, est que cela peut compliquer le rapport d'erreur dans Node. Il ajoute une deuxième couche d'analyse. Je n'ai pas encore beaucoup travaillé avec cela, alors je vais voir comment ça se passe. J'aime bien Sweet et les macros me manquent donc je vais essayer de rester avec elle!

11
Chris Prince

Si votre variable n'est ni déclarée ni définie:

if ( typeof query !== 'undefined' ) { ... }

Si votre variable est déclarée mais non définie. (en supposant que ce soit le cas ici, c'est que la variable pourrait ne pas être définie, mais il peut s'agir d'une autre valeur falsy comme false ou "")

if ( query ) { ... }

Si votre variable est déclarée mais peut être undefined ou null:

if ( query != null ) { ... } // undefined == null
5
elclanrs

Pour des tâches faciles, je le fais souvent simplement comme:

var undef;

// Fails on undefined variables
if (query !== undef) {
    // variable is defined
} else {
    // else do this
}

Ou si vous voulez simplement vérifier une valeur nulled aussi ..

var undef;

// Fails on undefined variables
// And even fails on null values
if (query != undef) {
    // variable is defined and not null
} else {
    // else do this
}
0
JackFuchs

On dirait que vous effectuez une vérification de propriété sur un objet! Si vous souhaitez vérifier qu'une propriété existe (mais que vous pouvez utiliser des valeurs telles que null ou 0 en plus des valeurs de vérité), l'opérateur in peut créer une syntaxe de Nice.

var foo = { bar: 1234, baz: null };
console.log("bar in foo:", "bar" in foo); // true
console.log("baz in foo:", "baz" in foo); // true
console.log("otherProp in foo:", "otherProp" in foo) // false
console.log("__proto__ in foo:", "__proto__" in foo) // true

Comme vous pouvez le constater, la propriété _PROTO_ sera jetée ici. Cela est vrai pour toutes les propriétés héritées. Pour en savoir plus, je recommanderais la page MDN:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/in

0
MrToad