Come utilizzare Assert.isUndefined () e Assert.isNotUndefined () in YUI3?

Question

sto cercando di test per la presenza di una dichiarata, funzione definita utilizzando il framework YUI3 test. In Safari e Firefox, cercando di utilizzare isNotUndefined, isUndefined o isfunction fallisce. Mi aspetto che coloro un'eccezione che può essere gestito dal framework di test.

 Y
 Object
 Y.Assert
 Object
 Y.Assert.isNotUndefined(x, "fail message")
 ReferenceError: Can't find variable: x
 Y.Assert.isUndefined(x, "fail message")
 ReferenceError: Can't find variable: x
 Y.Assert.isFunction(x, "fail message")
 ReferenceError: Can't find variable: x

Ma, invece, non ho mai arrivare a vedere i messaggi di errore, e il resto dei test non correre, a causa del l'interprete intralcio ... Non che minano lo scopo di queste funzioni, o am ho fraintendendo il quadro?

Il mio intuito mi dice che, dato il codice di cui sopra e solo il codice di cui sopra,

  Y.Assert.isUndefined(x, "fail message")

dovrebbe proseguire senza un errore (perché x è sommerso) e

  Y.Assert.isNotUndefined(x, "fail message")

dovrebbe registrare il messaggio "fail messaggio" (perché x è sommerso).

Tuttavia, a causa della ReferenceError, non c'è modo (usando quei metodi YUI3) per verificare gli oggetti non dichiarati. Invece, mi sono lasciato con un po 'di codice affermazione piuttosto brutto. Non posso usare

 Y.Assert.isNotUndefined(x)
 ReferenceError: Can't find variable: x

o

 Y.assert( x !== undefined )
 ReferenceError: Can't find variable: x

che mi lascia con

 Y.assert( typeof(x) !== "undefined" ) // the only working option I've found
 Assert Error: Assertion failed.

che è molto meno leggibile di

 Y.Assert.isNotUndefined(x)

Ancora una volta, chiedo: Non fa che minano lo scopo di queste funzioni, o sto fraintendendo il quadro?

 x

è sommerso, e quindi non direttamente verificabile, mentre

 var x;

lo dichiara, ma lo lascia indefinito. Infine

 var x = function() {};

si sia dichiarata e definita.

Credo che quello che manca per me è la capacità di facilmente dire

 Y.Assert.isNotUndeclared(x);

-Wil

Answer 1

CONTESTO: Voglio essere in grado di distinguere tra:

x // undeclared && undefined
var x; // declared && undefined
var x = 5; // declared && defined

Quindi, la sfida qui è che JavaScript non è in grado di distinguere tra i primi 2 casi, che volevo essere in grado di fare per scopi didattici. Dopo un sacco di gioco e la lettura, ci sembra essere un modo per farlo, almeno nel contesto di un browser web e per le variabili globali (non eccezionale restrizioni, ma ...):

function isDeclared(objName) {
  return ( window.hasOwnProperty(objName) ) ? true : false;
}

function isDefined(objName) {
  return ( isDeclared(objName) && ("undefined" !== typeof eval(objName)) ) ? true : false;
}

Mi rendo conto che l'uso di eval potrebbe essere pericoloso, ma per il contesto strettamente controllato in cui vorrei utilizzare queste funzioni, è ok. Tutti gli altri, attenzione e vedere http://www.jslint.com/lint.html

isDeclared("x")  // false
isDefined("x")   // false

var x;
isDeclared("x")  // true
isDefined("x")   // false

var x = 5;
isDeclared("x")  // true
isDefined("x")   // true

Answer 2

OK, era un po 'tardi di ieri indovinare Capisco che domanda ora, ciò che si vuole fare è quello di verificare se una variabile è stata definita a tutti, giusto?

L'unico modo per farlo è typeof x === 'undefined'.

L'operatore typeof consente per le variabili non esistenti da utilizzare con esso.

Quindi, al fine di farlo funzionare, è necessario l'espressione e la spina sopra che in una normale affermare true/false.

Per esempio (non hanno usato YUI3):

Y.Assert.isTrue(typeof x === 'undefined', "fail message"); // isUndefined
Y.Assert.isFalse(typeof x === 'undefined', "fail message"); // isNotUndefined