Detectando uma propriedade de object indefinida

Qual é a melhor maneira de verificar se uma propriedade de object em JavaScript é indefinida?

Usar:

if (typeof something === "undefined") { alert("something is undefined"); } 

Se uma variável de object que tem algumas propriedades você pode usar a mesma coisa assim:

 if (typeof my_obj.someproperties === "undefined"){ console.log('the property is not available...'); // print into console } 

Como o ECMAScript 5, undefined não pode ser sobrescrito, então my_obj === undefined também funcionaria, mas somente se my_obj existir. Isso pode ou não ser desejado porque você também pode usar null se precisar dessa semântica (consulte Qual é a diferença entre null e undefined em JavaScript? ). No entanto, para propriedades de object, ele funciona independentemente de a propriedade existir.

Eu acredito que há um número de respostas incorretas para este tópico. Ao contrário da crença comum, “indefinido” não é uma palavra-chave em JavaScript e pode, de fato, ter um valor atribuído a ela.

Código correto

A maneira mais robusta de realizar este teste é:

 if (typeof myVar === "undefined") 

Isso sempre retornará o resultado correto e até myVar com a situação em que myVar não é declarado.

Código degenerado. NÃO USE.

 var undefined = false; // Shockingly, this is completely legal! if (myVar === undefined) { alert("You have been misled. Run away!"); } 

Além disso, myVar === undefined irá gerar um erro na situação em que myVar não é declarado.

Em JavaScript há nulo e não está definido . Eles têm significados diferentes.

  • undefined significa que o valor da variável não foi definido; não se sabe qual é o valor.
  • null significa que o valor da variável é definido e definido como nulo (não tem valor).

Marijn Haverbeke afirma, em seu livro on-line gratuito ” Eloquent JavaScript ” (ênfase minha):

Há também um valor similar, null, cujo significado é ‘esse valor é definido, mas não possui um valor’. A diferença de significado entre indefinido e nulo é principalmente acadêmica e geralmente não é muito interessante. Em programas práticos, muitas vezes é necessário verificar se algo ‘tem valor’. Nestes casos, a expressão algo == indefinido pode ser usada, porque, mesmo que eles não sejam exatamente o mesmo valor, null == undefined produzirá true.

Então, eu acho que a melhor maneira de verificar se algo estava indefinido seria:

 if (something == undefined) 

Espero que isto ajude!

Edit: Em resposta à sua edição, as propriedades do object devem funcionar da mesma maneira.

 var person = { name: "John", age: 28, sex: "male" }; alert(person.name); // "John" alert(person.fakeVariable); // undefined 

Apesar de ser veementemente recomendado por muitas outras respostas aqui, o typeof é uma má escolha . Ele nunca deve ser usado para verificar se as variables ​​têm o valor undefined , porque ele age como uma verificação combinada para o valor undefined e para a existência de uma variável. Na grande maioria dos casos, você sabe quando existe uma variável, e o typeof apenas introduzirá o potencial para uma falha silenciosa se você digitar um erro de digitação no nome da variável ou na string literal 'undefined' .

 var snapshot = …; if (typeof snaposhot === 'undefined') { // ^ // misspelled¹ – this will never run, but it won't throw an error! } 
 var foo = …; if (typeof foo === 'undefned') { // ^ // misspelled – this will never run, but it won't throw an error! } 

Então, a menos que você esteja fazendo a detecção de resources², onde há incerteza se um determinado nome estará no escopo (como verificar o typeof module !== 'undefined' como uma etapa no código específico para um ambiente CommonJS), typeof é uma escolha prejudicial quando usado em uma variável, e a opção correta é comparar o valor diretamente:

 var foo = …; if (foo === undefined) { ⋮ } 

Alguns equívocos comuns sobre isso incluem:

  • que ler uma variável “não inicializada” ( var foo ) ou parâmetro ( function bar(foo) { … } , chamada como bar() ) falhará. Isso simplesmente não é verdade – variables ​​sem boot explícita e parâmetros que não receberam valores sempre se tornam undefined e estão sempre no escopo.

  • que undefined pode ser substituído. Há muito mais nisso. undefined não é uma palavra-chave em JavaScript. Em vez disso, é uma propriedade no object global com o valor indefinido. No entanto, desde ES5, essa propriedade foi somente leitura e não configurável . Nenhum navegador moderno permitirá que a propriedade undefined seja alterada e, a partir de 2017, esse é o caso há muito tempo. A falta do modo estrito também não afeta o comportamento do undefined – apenas faz declarações como undefined = 5 não fazer nada ao invés de jogar. Como não é uma palavra-chave, no entanto, é possível declarar variables ​​com o nome undefined , e essas variables ​​podem ser alteradas, tornando esse padrão uma vez comum:

     (function (undefined) { // … })() 

    mais perigoso do que usar o global undefined . Se você tiver que ser compatível com ES3, substitua undefined por void 0 – não recorra ao typeof . ( void sempre foi um operador unário que avalia o valor Indefinido para qualquer operando.)

Com o modo como as variables ​​funcionam, é hora de abordar a questão real: propriedades do object. Não há razão para usar o typeof para propriedades de objects. A exceção anterior em relação à detecção de resources não se aplica aqui – o typeof tem apenas um comportamento especial nas variables ​​e as expressões que fazem referência às propriedades do object não são variables.

Este:

 if (typeof foo.bar === 'undefined') { ⋮ } 

é sempre exatamente equivalente a isso³:

 if (foo.bar === undefined) { ⋮ } 

e levando em consideração os conselhos acima, para evitar confundir os leitores sobre o motivo pelo qual você está usando typeof , porque faz mais sentido usar === para verificar a igualdade, porque ela poderia ser refatorada para verificar o valor de uma variável mais tarde, e porque simplesmente parece melhor, você deve sempre usar === undefined aqui também .

Outra coisa a ser considerada quando se trata de propriedades de objects é se você realmente quer verificar se está undefined . Um determinado nome de propriedade pode estar ausente em um object (produzindo o valor undefined quando lido), presente no próprio object com o valor undefined , presente no protótipo do object com o valor undefined , ou presente em qualquer um com um não undefined valor. 'key' in obj lhe dirá se uma chave está em qualquer lugar na cadeia de protótipos de um object, e Object.prototype.hasOwnProperty.call(obj, 'key') dirá se está diretamente no object. Eu não vou entrar em detalhes nesta resposta sobre protótipos e usar objects como mapas com chave de seqüência de caracteres, porque é principalmente destinado a contrariar todos os maus conselhos em outras respostas, independentemente das possíveis interpretações da questão original. Leia sobre protótipos de objects no MDN para mais!

¹ escolha incomum do nome da variável de exemplo? Este é um verdadeiro código morto da extensão NoScript para o Firefox.
² não assuma que não saber o que está no escopo é bom em geral, no entanto. vulnerabilidade de bônus causada por abuso de escopo dynamic: Projeto Zero 1225
³ mais uma vez assumindo um ambiente ES5 + e que undefined se refere à propriedade undefined do object global. substitua void 0 caso contrário.

O que isso significa: “propriedade de object indefinida” ?

Na verdade, isso pode significar duas coisas bem diferentes! Primeiro, pode significar a propriedade que nunca foi definida no object e, segundo, pode significar a propriedade que possui um valor indefinido . Vamos ver este código:

 var o = { a: undefined } 

É oa indefinido? Sim! Seu valor é indefinido. É ob indefinido? Certo! Não há propriedade ‘b’ em tudo! OK, veja agora como diferentes abordagens se comportam em ambas as situações:

 typeof oa == 'undefined' // true typeof ob == 'undefined' // true oa === undefined // true ob === undefined // true 'a' in o // true 'b' in o // false 

Podemos ver claramente que typeof obj.prop == 'undefined' e obj.prop === undefined são equivalentes e não distinguem essas diferentes situações. E 'prop' in obj pode detectar a situação quando uma propriedade não foi definida e não presta atenção ao valor da propriedade que pode ser indefinido.

Então o que fazer?

1) Você quer saber se uma propriedade é indefinida pelo primeiro ou segundo significado (a situação mais típica).

 obj.prop === undefined // IMHO, see "final fight" below 

2) Você quer apenas saber se o object tem alguma propriedade e não se importa com o seu valor.

 'prop' in obj 

Notas:

  • Você não pode verificar um object e sua propriedade ao mesmo tempo. Por exemplo, este xa === undefined ou este typeof xa == 'undefined' gera ReferenceError: x is not defined se x não estiver definido.
  • Variável undefined é uma variável global (então, na verdade, é window.undefined nos navegadores). Ele tem sido suportado desde a primeira edição do ECMAScript e, como o ECMAScript 5, é somente leitura . Portanto, em navegadores modernos, não pode ser redefinido como verdadeiro, como muitos autores adoram nos assustar, mas isso ainda é verdade para navegadores mais antigos.

Luta Final: obj.prop === undefined vs typeof obj.prop == 'undefined'

Vantagens de obj.prop === undefined :

  • É um pouco mais curto e parece um pouco mais bonito
  • O mecanismo de JavaScript fornecerá um erro se você tiver typescript incorretamente

Minuses de obj.prop === undefined :

  • undefined pode ser substituído em navegadores antigos

Vantagens do typeof obj.prop == 'undefined' :

  • É realmente universal! Funciona em navegadores novos e antigos.

Minuses do typeof obj.prop == 'undefined' :

  • 'undefned' ( escrito incorretamente ) aqui é apenas uma constante de string, então o mecanismo de JavaScript não pode ajudá-lo se você tiver typescript errado como acabei de fazer.

Atualização (para JavaScript do lado do servidor):

O Node.js suporta a variável global undefined como global.undefined (também pode ser usada sem o prefixo ‘global’). Eu não sei sobre outras implementações de JavaScript do lado do servidor.

A questão resume-se a três casos:

  1. O object tem a propriedade e seu valor não é undefined .
  2. O object tem a propriedade e seu valor é undefined .
  3. O object não possui a propriedade.

Isso nos diz algo que considero importante:

Há uma diferença entre um membro indefinido e um membro definido com um valor indefinido.

Mas, infelizmente, o typeof obj.foo não nos diz qual dos três casos que temos. No entanto, podemos combinar isso com "foo" in obj para distinguir os casos.

  | typeof obj.x === 'undefined' | !("x" in obj) 1. { x:1 } | false | false 2. { x : (function(){})() } | true | false 3. {} | true | true 

Vale a pena notar que estes testes são os mesmos para inputs null também

  | typeof obj.x === 'undefined' | !("x" in obj) { x:null } | false | false 

Eu diria que, em alguns casos, faz mais sentido (e é mais claro) verificar se a propriedade está lá, do que verificar se ela está indefinida, e o único caso em que essa verificação será diferente é o caso 2, o caso raro de uma input real no object com um valor indefinido.

Por exemplo: Acabei de refatorar um monte de código que tinha um monte de verificações se um object tinha uma determinada propriedade.

 if( typeof blob.x != 'undefined' ) { fn(blob.x); } 

Qual foi mais claro quando escrito sem um cheque para indefinido.

 if( "x" in blob ) { fn(blob.x); } 

Mas, como foi mencionado, estes não são exatamente os mesmos (mas são mais do que suficientes para as minhas necessidades).

 if ( typeof( something ) == "undefined") 

Isso funcionou para mim enquanto os outros não.

Eu não tenho certeza de onde a origem de usar === com typeof veio, e como uma convenção eu vejo isso usado em muitas bibliotecas, mas o operador typeof retorna uma string literal, e nós sabemos disso na frente, então por que você também quer digitar verificá-lo também?

 typeof x; // some string literal "string", "object", "undefined" if (typeof x === "string") { // === is redundant because we already know typeof returns a string literal if (typeof x == "string") { // sufficient 

Crossposting my answer from related question Como verificar se há “indefinido” em JavaScript?

Específico para esta questão, veja casos de teste com someObject. .


Alguns cenários ilustrando os resultados das várias respostas: http://jsfiddle.net/drzaus/UVjM4/

(Observe que o uso de var in testes faz diferença quando em um wrapper com escopo)

Código para referência:

 (function(undefined) { var definedButNotInitialized; definedAndInitialized = 3; someObject = { firstProp: "1" , secondProp: false // , undefinedProp not defined } // var notDefined; var tests = [ 'definedButNotInitialized in window', 'definedAndInitialized in window', 'someObject.firstProp in window', 'someObject.secondProp in window', 'someObject.undefinedProp in window', 'notDefined in window', '"definedButNotInitialized" in window', '"definedAndInitialized" in window', '"someObject.firstProp" in window', '"someObject.secondProp" in window', '"someObject.undefinedProp" in window', '"notDefined" in window', 'typeof definedButNotInitialized == "undefined"', 'typeof definedButNotInitialized === typeof undefined', 'definedButNotInitialized === undefined', '! definedButNotInitialized', '!! definedButNotInitialized', 'typeof definedAndInitialized == "undefined"', 'typeof definedAndInitialized === typeof undefined', 'definedAndInitialized === undefined', '! definedAndInitialized', '!! definedAndInitialized', 'typeof someObject.firstProp == "undefined"', 'typeof someObject.firstProp === typeof undefined', 'someObject.firstProp === undefined', '! someObject.firstProp', '!! someObject.firstProp', 'typeof someObject.secondProp == "undefined"', 'typeof someObject.secondProp === typeof undefined', 'someObject.secondProp === undefined', '! someObject.secondProp', '!! someObject.secondProp', 'typeof someObject.undefinedProp == "undefined"', 'typeof someObject.undefinedProp === typeof undefined', 'someObject.undefinedProp === undefined', '! someObject.undefinedProp', '!! someObject.undefinedProp', 'typeof notDefined == "undefined"', 'typeof notDefined === typeof undefined', 'notDefined === undefined', '! notDefined', '!! notDefined' ]; var output = document.getElementById('results'); var result = ''; for(var t in tests) { if( !tests.hasOwnProperty(t) ) continue; // bleh try { result = eval(tests[t]); } catch(ex) { result = 'Exception--' + ex; } console.log(tests[t], result); output.innerHTML += "\n" + tests[t] + ": " + result; } })(); 

E resultados:

 definedButNotInitialized in window: true definedAndInitialized in window: false someObject.firstProp in window: false someObject.secondProp in window: false someObject.undefinedProp in window: true notDefined in window: Exception--ReferenceError: notDefined is not defined "definedButNotInitialized" in window: false "definedAndInitialized" in window: true "someObject.firstProp" in window: false "someObject.secondProp" in window: false "someObject.undefinedProp" in window: false "notDefined" in window: false typeof definedButNotInitialized == "undefined": true typeof definedButNotInitialized === typeof undefined: true definedButNotInitialized === undefined: true ! definedButNotInitialized: true !! definedButNotInitialized: false typeof definedAndInitialized == "undefined": false typeof definedAndInitialized === typeof undefined: false definedAndInitialized === undefined: false ! definedAndInitialized: false !! definedAndInitialized: true typeof someObject.firstProp == "undefined": false typeof someObject.firstProp === typeof undefined: false someObject.firstProp === undefined: false ! someObject.firstProp: false !! someObject.firstProp: true typeof someObject.secondProp == "undefined": false typeof someObject.secondProp === typeof undefined: false someObject.secondProp === undefined: false ! someObject.secondProp: true !! someObject.secondProp: false typeof someObject.undefinedProp == "undefined": true typeof someObject.undefinedProp === typeof undefined: true someObject.undefinedProp === undefined: true ! someObject.undefinedProp: true !! someObject.undefinedProp: false typeof notDefined == "undefined": true typeof notDefined === typeof undefined: true notDefined === undefined: Exception--ReferenceError: notDefined is not defined ! notDefined: Exception--ReferenceError: notDefined is not defined !! notDefined: Exception--ReferenceError: notDefined is not defined 

Se você fizer

 if (myvar == undefined ) { alert('var does not exists or is not initialized'); } 

ele falhará quando a variável myvar não existir, porque myvar não está definido, então o script está quebrado e o teste não tem efeito.

Como o object window possui um escopo global (object padrão) fora de uma function, uma declaração será ‘anexada’ ao object window.

Por exemplo:

 var myvar = 'test'; 

A variável global myvar é a mesma que window.myvar ou window [‘myvar’]

Para evitar erros para testar quando existe uma variável global, é melhor você usar:

 if(window.myvar == undefined ) { alert('var does not exists or is not initialized'); } 

A questão se realmente existe uma variável não importa, seu valor está incorreto. Caso contrário, é bobagem inicializar as variables ​​com undefined, e é melhor usar o valor false para inicializar. Quando você sabe que todas as variables ​​que você declara são inicializadas com false, você pode simplesmente verificar seu tipo ou confiar em !window.myvar para verificar se ele possui um valor válido. Portanto, mesmo quando a variável não está definida, então !window.myvar é o mesmo para myvar = undefined ou myvar = false ou myvar = 0 .

Quando você espera um tipo específico, teste o tipo da variável. Para acelerar o teste de uma condição, é melhor você fazer:

 if( !window.myvar || typeof window.myvar != 'string' ) { alert('var does not exists or is not type of string'); } 

Quando a primeira e simples condição é verdadeira, o intérprete pula os próximos testes.

É sempre melhor usar a instância / object da variável para verificar se ela tem um valor válido. É mais estável e é uma maneira melhor de programar.

(y)

Eu não vi (espero não ter perdido) alguém verificando o object antes da propriedade. Então, isso é o mais curto e mais eficaz (embora não necessariamente o mais claro):

 if (obj && obj.prop) { // Do something; } 

Se obj ou obj.prop estiver indefinido, nulo ou “falso”, a instrução if não executará o bloco de códigos. Este é geralmente o comportamento desejado na maioria das instruções de bloco de código (em JavaScript).

No artigo Explorando o abismo de nulo e indefinido em JavaScript , li que frameworks como Underscore.js usam essa function:

 function isUndefined(obj){ return obj === void 0; } 

if (window.x) {} ‘ é um erro seguro

Muito provavelmente você quer if (window.x) . Esta verificação é segura mesmo que x não tenha sido declarado ( var x; ) – o navegador não lança um erro.

Exemplo: quero saber se meu navegador suporta a API de histórico

 if (window.history) { history.call_some_function(); } 

Como isso funciona:

window é um object que contém todas as variables ​​globais como seus membros, e é legal tentar acessar um membro não existente. Se x não foi declarado ou não foi definido, window.x retorna indefinido . indefinido leva a falso quando if () o avalia.

 "propertyName" in obj //-> true | false 

Lendo por isso, eu estou espantado por não ter visto isso. Eu encontrei vários algoritmos que funcionariam para isso.

Nunca definido

Se o valor de um object nunca foi definido, isso impedirá de retornar true se estiver definido como null ou undefined . Isso é útil se você quiser que o verdadeiro seja retornado para valores definidos como undefined

 if(obj.prop === void 0) console.log("The value has never been defined"); 

Definido como indefinido ou nunca definido

Se você quiser que ele seja true para valores definidos com o valor de undefined , ou nunca definido, você pode simplesmente usar === undefined

 if(obj.prop === undefined) console.log("The value is defined as undefined, or never defined"); 

Definido como um valor falso, indefinido, nulo ou nunca definido.

Comumente, as pessoas me pediram um algoritmo para descobrir se um valor é falso, undefined ou null . Os seguintes trabalhos.

 if(obj.prop == false || obj.prop === null || obj.prop === undefined) { console.log("The value is falsy, null, or undefined"); } 

You can get an array all undefined with path using the following code.

  function getAllUndefined(object) { function convertPath(arr, key) { var path = ""; for (var i = 1; i < arr.length; i++) { path += arr[i] + "->"; } path += key; return path; } var stack = []; var saveUndefined= []; function getUndefiend(obj, key) { var t = typeof obj; switch (t) { case "object": if (t === null) { return false; } break; case "string": case "number": case "boolean": case "null": return false; default: return true; } stack.push(key); for (k in obj) { if (obj.hasOwnProperty(k)) { v = getUndefiend(obj[k], k); if (v) { saveUndefined.push(convertPath(stack, k)); } } } stack.pop(); } getUndefiend({ "": object }, ""); return saveUndefined; } 

jsFiddle link

Compare with void 0 , for terseness.

 if (foo !== void 0) 

It’s not as verbose as if (typeof foo !== 'undefined')

The solution is incorrect. Em JavaScript,

 null == undefined 

will return true, because they both are “casted” to a boolean and are false. The correct way would be to check

 if (something === undefined) 

which is the identity operator…

Here is my situation:

I am using the result of a REST call. The result should be parsed from JSON to a JavaScript object.

There is one error I need to defend. If the args to the rest call were incorrect as far as the user specifying the args wrong, the rest call comes back basically empty.

While using this post to help me defend against this, I tried this.

 if( typeof restResult.data[0] === "undefined" ) { throw "Some error"; } 

For my situation, if restResult.data[0] === “object”, then I can safely start inspecting the rest of the members. If undefined then throw the error as above.

What I am saying is that for my situation, all the suggestions above in this post did not work. I’m not saying I’m right and everyone is wrong. I am not a JavaScript master at all, but hopefully this will help someone.

There is a nice & elegant way to assign a defined property to a new variable if it is defined or assign a default value to it as a fallback if it´s undefined.

 var a = obj.prop || defaultValue; 

It’s suitable if you have a function, which receives an additional config property:

 var yourFunction = function(config){ this.config = config || {}; this.yourConfigValue = config.yourConfigValue || 1; console.log(this.yourConfigValue); } 

Now executing

 yourFunction({yourConfigValue:2}); //=> 2 yourFunction(); //=> 1 yourFunction({otherProperty:5}); //=> 1 

Simply anything is not defined in JavaScript, is undefined , doesn’t matter if it’s a property inside an Object/Array or as just a simple variable…

JavaScript has typeof which make it very easy to detect an undefined variable.

Simply check if typeof whatever === 'undefined' and it will return a boolean.

That’s how the famous function isUndefined() in AngularJs v.1x is written:

 function isUndefined(value) {return typeof value === 'undefined';} 

So as you see the function receive a value, if that value is defined, it will return false , otherwise for undefined values, return true .

So let’s have a look what gonna be the results when we passing values, including object properties like below, this is the list of variables we have:

 var stackoverflow = {}; stackoverflow.javascipt = 'javascript'; var today; var self = this; var num = 8; var list = [1, 2, 3, 4, 5]; var y = null; 

and we check them as below, you can see the results in front of them as a comment:

 isUndefined(stackoverflow); //false isUndefined(stackoverflow.javascipt); //false isUndefined(today); //true isUndefined(self); //false isUndefined(num); //false isUndefined(list); //false isUndefined(y); //false isUndefined(stackoverflow.java); //true isUndefined(stackoverflow.php); //true isUndefined(stackoverflow && stackoverflow.css); //true 

As you see we can check anything with using something like this in our code, as mentioned you can simply use typeof in your code, but if you are using it over and over, create a function like the angular sample which I share and keep reusing as following DRY code pattern.

Also one more thing, for checking property on an object in real application which you not sure even the object exists or not, check if the object exist first.

If you check a property on an object and the object doesn’t exist, will throw an error and stop the whole application running.

 isUndefined(x.css); VM808:2 Uncaught ReferenceError: x is not defined(…) 

So simple you can wrap inside an if statement like below:

 if(typeof x !== 'undefined') { //do something } 

Which also equal to isDefined in Angular 1.x…

 function isDefined(value) {return typeof value !== 'undefined';} 

Also other javascript frameworks like underscore has similar defining check, but I recommend you use typeof if you already not using any frameworks.

I also add this section from MDN which has got useful information about typeof, undefined and void(0).

Strict equality and undefined
You can use undefined and the strict equality and inequality operators to determine whether a variable has a value. In the following code, the variable x is not defined, and the if statement evaluates to true.

 var x; if (x === undefined) { // these statements execute } else { // these statements do not execute } 

Note: The strict equality operator rather than the standard equality operator must be used here, because x == undefined also checks whether x is null, while strict equality doesn’t. null is not equivalent to undefined. See comparison operators for details.


Typeof operator and undefined
Alternatively, typeof can be used:

 var x; if (typeof x === 'undefined') { // these statements execute } 

One reason to use typeof is that it does not throw an error if the variable has not been declared.

 // x has not been declared before if (typeof x === 'undefined') { // evaluates to true without errors // these statements execute } if (x === undefined) { // throws a ReferenceError } 

However, this kind of technique should be avoided. JavaScript is a statically scoped language, so knowing if a variable is declared can be read by seeing whether it is declared in an enclosing context. The only exception is the global scope, but the global scope is bound to the global object, so checking the existence of a variable in the global context can be done by checking the existence of a property on the global object (using the in operator, for instance).


Void operator and undefined

The void operator is a third alternative.

 var x; if (x === void 0) { // these statements execute } // y has not been declared before if (y === void 0) { // throws a ReferenceError (in contrast to `typeof`) } 

more > here

 function isUnset(inp) { return (typeof inp === 'undefined') } 

Returns false if variable is set, and true if is undefined.

Então use:

 if (isUnset(var)) { // initialize variable here } 

All the answers are incomplete. This is the right way of knowing that there is a property ‘defined as undefined’ :

 var hasUndefinedProperty = function hasUndefinedProperty(obj, prop){ return ((prop in obj) && (typeof obj[prop] == 'undefined')) ; } ; 

Exemplo:

 var a = { b : 1, e : null } ; ac = ad ; hasUndefinedProperty(a, 'b') ; // false : b is defined as 1 hasUndefinedProperty(a, 'c') ; // true : c is defined as undefined hasUndefinedProperty(a, 'd') ; // false : d is undefined hasUndefinedProperty(a, 'e') ; // false : e is defined as null // And now... delete ac ; hasUndefinedProperty(a, 'c') ; // false : c is undefined 

Too bad that this been the right answer is buried in wrong answers >_<

So, for anyone who pass by, I will give you undefineds for free!!

 var undefined ; undefined ; // undefined ({}).a ; // undefined [].a ; // undefined ''.a ; // undefined (function(){}()) ; // undefined void(0) ; // undefined eval() ; // undefined 1..a ; // undefined /a/.a ; // undefined (true).a ; // undefined 

Going through the comments, for those who want to check both is it undefined or its value is null:

 //Just in JavaScript var s; // Undefined if (typeof s == "undefined" || s === null){ alert('either it is undefined or value is null') } 

If you are using jQuery Library then jQuery.isEmptyObject() will suffice for both cases,

 var s; // Undefined jQuery.isEmptyObject(s); // Will return true; s = null; // Defined as null jQuery.isEmptyObject(s); // Will return true; //Usage if (jQuery.isEmptyObject(s)) { alert('Either variable:s is undefined or its value is null'); } else { alert('variable:s has value ' + s); } s = 'something'; // Defined with some value jQuery.isEmptyObject(s); // Will return false; 

If you are using Angular:

 angular.isUndefined(obj) angular.isUndefined(obj.prop) 

Underscore.js:

 _.isUndefined(obj) _.isUndefined(obj.prop) 

I use if (this.variable) to test if it is defined. Simple if (variable) , recommended above , fails for me. It turns out that it works only when variable is a field of some object, obj.someField to check if it is defined in the dictionary. But we can use this or window as the dictionary object since any variable is a field in current window, as I understand it. Therefore here is a test

 if (this.abc) alert("defined"); else alert("undefined"); abc = "abc"; if (this.abc) alert("defined"); else alert("undefined"); 

Also same things can be written shorter:

 if (!variable){ //do it if variable is Undefined } 

ou

 if (variable){ //do it if variable is Defined } 

I would like to show you something I’m using in order to protect the undefined variable:

 Object.defineProperty(window, 'undefined', {}); 

This forbids anyone to change the window.undefined value therefore destroying the code based on that variable. If using "use strict" , anything trying to change its value will end in error, otherwise it would be silently ignored.

Usar:

To check if property is undefined:

 if (typeof something === "undefined") { alert("undefined"); } 

To check if property is not undefined:

 if (typeof something !== "undefined") { alert("not undefined"); } 

From lodash.js.

 var undefined; function isUndefined(value) { return value === undefined; } 

It creates an variable named undefined which is initialized with the default value — the real undefined , then compares value with the variable undefined .