Wie kann ich überprüfen, ob in Node.js eine Variable definiert ist?

Ich arbeite an einem Programm in node.js, das eigentlich js ist.

Ich habe eine Variable:

var query = azure.TableQuery...

Es sieht so aus, als würde diese Codezeile einige Male nicht ausgeführt.

meine Frage ist :

Wie kann ich eine Bedingung wie:

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

Ich kann nicht in js tun (query!= null)

Ich möchte sehen, ob diese Variable definiert ist. Wie macht man das

if ( typeof query !== 'undefined' && query )
{
  //do stuff if query is defined and not null
}
else
{

}

Bestimmen Sie, ob eine Eigenschaft vorhanden ist (aber kein falscher Wert ist):

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

Normalerweise mit

if (query){
   doStuff();
}

ist genügend. Bitte beachte, dass:

if (!query){
   doStuff();
}

doStuff () wird auch dann ausgeführt, wenn die Abfrage eine vorhandene Variable mit einem falschen Wert war (0, false, undefined oder null).

Übrigens gibt es eine sexy Coffeescript-Methode, um dies zu tun:

if object?.property? then doStuff()

welches kompiliert zu:

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

{
  doStuff();
}

Für mich ein Ausdruck wie

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

ist komplizierter als ich möchte, wie oft ich es verwenden möchte. Das heißt, ich teste häufig, ob eine Variable / null definiert ist. Ich möchte, dass ein solcher Test einfach ist. Um dies zu beheben, habe ich zuerst versucht, den obigen Code als Funktion zu definieren, aber der Knoten gibt mir nur einen Syntaxfehler aus und teilt mir mit, dass der Parameter für den Funktionsaufruf undefiniert ist. Nicht nützlich! Als ich nach diesem Bit suchte und daran arbeitete, fand ich eine Lösung. Vielleicht nicht für jedermann. Meine Lösung besteht darin, mit Sweet.js ein Makro zu definieren. So habe ich es gemacht:

Hier ist das Makro (Dateiname: 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;

Hier ist ein Beispiel für die Verwendung des Makros (in example.sjs):

function Foobar() {
    var self = this;

    self.x = 10;

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

module.exports = Foobar;

Und hier ist die Hauptknotendatei:

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();

Ein Nachteil davon ist, dass Sweet nicht nur installiert, das Makro eingerichtet und Sweet in Ihren Code geladen werden muss, sondern auch die Fehlerberichterstattung in Node erschweren kann. Es wird eine zweite Analyseebene hinzugefügt. Ich habe noch nicht so viel damit gearbeitet, also werde ich sehen, wie es aus erster Hand geht. Ich mag Sweet aber und ich vermisse Makros, also werde ich versuchen, dabei zu bleiben!

Wenn Ihre Variable weder deklariert noch definiert ist:

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

Wenn Ihre Variable deklariert, aber nicht definiert ist. (Unter der Annahme, dass hier die Variable möglicherweise nicht definiert ist, es sich jedoch um einen anderen falschen Wert wie falseoder handeln kann. "")

if ( query ) { ... }

Wenn Ihre Variable deklariert ist, aber sein kann undefinedoder null:

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

Für einfache Aufgaben mache ich es oft einfach so:

var undef;

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

Oder wenn Sie einfach auch nach einem Nullwert suchen möchten.

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
}

Es hört sich so an, als würden Sie ein Objekt auf Eigenschaften überprüfen! Wenn Sie eine Eigenschaft vorhanden überprüfen möchten (kann aber Werte wie null oder 0 zusätzlich zu truthy Werte), die in kann Operator für ein paar nette Syntax machen.

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

Wie Sie sehen können, wird die Eigenschaft __proto__ hier ausgelöst. Dies gilt für alle geerbten Eigenschaften. Für die weitere Lektüre würde ich die MDN-Seite empfehlen:

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