Detectando uma propriedade de objeto indefinida

https://stackoverflow.com/questions/27509

09-06-2019
|

Pergunta

Qual é a melhor maneira de verificar se uma propriedade de objeto em JavaScript está indefinida?

Solução

Usar:

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

Se for uma variável de objeto que possui 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
}

Outras dicas

Acredito que haja uma série 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é mesmo lidará 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!");
}

Adicionalmente, myVar === undefined gerará um erro na situação em que myVar não for declarado.

Apesar de ser veementemente recomendado por muitas outras respostas aqui, typeof é uma má escolha.Nunca deve ser usado para verificar se variáveis têm o valor undefined, porque atua como uma verificação combinada do valor undefined e para saber se existe uma variável.Na grande maioria dos casos, você sabe quando uma variável existe e typeof irá apenas introduzir o potencial para uma falha silenciosa se você cometer 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!
}

Portanto, a menos que você esteja fazendo detecção de recursos², onde há incerteza se um determinado nome estará no escopo (como verificar typeof module !== 'undefined' como uma etapa no código específico para um ambiente CommonJS), typeof é uma escolha prejudicial quando usada 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 a leitura de uma variável “não inicializada” (var foo) ou parâmetro (function bar(foo) { … }, chamado como bar()) vai falhar.Isso simplesmente não é verdade – variáveis sem inicialização explícita e parâmetros aos quais não foram dados 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 objeto global com o valor Indefinido.No entanto, desde ES5, esta propriedade tem sido somente leitura e não configurável.Nenhum navegador moderno permitirá o undefined propriedade a ser alterada, e a partir de 2017 isso já acontece há muito tempo.A falta do modo estrito não afeta undefinedtambém - ele apenas faz declarações como undefined = 5 não faça nada em vez de jogar.Como não é uma palavra-chave, você pode declarar variáveis com o nome undefined, e essas variáveis poderiam ser alteradas, criando este padrão antes comum:
```
(function (undefined) {
    // …
})()
```
mais perigoso do que usar o global undefined.Se você precisar ser compatível com ES3, substitua undefined com void 0 – não recorra a typeof. (void sempre foi um operador unário que avalia o valor Indefinido para qualquer operando.)

Com a forma como as variáveis funcionam, é hora de abordar a questão real:propriedades do objeto.Não há razão para usar typeof para propriedades do objeto.A exceção anterior em relação à detecção de recursos não se aplica aqui – typeof só tem comportamento especial em variáveis, e expressões que fazem referência a propriedades de objetos não são variáveis.

Esse:

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

é sempre exatamente equivalente para isto³:

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

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

Outra coisa a considerar quando se trata de propriedades de objetos é se você realmente deseja verificar undefined de forma alguma.Um determinado nome de propriedade pode estar ausente em um objeto (produzindo o valor undefined quando lido), presente no próprio objeto com o valor undefined, presente no protótipo do objeto com o valor undefined, ou presente em qualquer um daqueles com um não-undefined valor. 'key' in obj dirá se uma chave está em algum lugar na cadeia de protótipos de um objeto, e Object.prototype.hasOwnProperty.call(obj, 'key') dirá se está diretamente no objeto.Não entrarei em detalhes nesta resposta sobre protótipos e uso de objetos como mapas codificados por strings, porque o objetivo principal é contrariar todos os conselhos ruins em outras respostas, independentemente das possíveis interpretações da pergunta original.Leia em protótipos de objetos no MDN para mais!

_{¹ escolha incomum de nome de variável de exemplo?este é um código morto real da extensão NoScript para Firefox.}
_{² não presuma que não saber o que está no escopo é aceitável em geral.vulnerabilidade de bônus causada por abuso de escopo dinâmico: Projeto Zero 1225}
_{³ assumindo mais uma vez um ambiente ES5+ e que undefined refere-se a undefined propriedade do objeto global.substituto void 0 de outra forma.}

Em JavaScript existe nulo e aqui está indefinido.Eles têm significados diferentes.

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

Marijn Haverbeke afirma, em seu livro online gratuito "JavaScript eloquente" (ênfase minha):

Existe também um valor semelhante, nulo, cujo significado é ‘este valor está definido, mas não tem 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, pois, mesmo que não sejam exatamente o mesmo valor, nulo == indefinido produzirá verdadeiro.

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

if (something == undefined)

Espero que isto ajude!

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

var person = {
    name: "John",
    age: 28,
    sex: "male"
};

alert(person.name); // "John"
alert(person.fakeVariable); // undefined

O que isto significa: "propriedade de objeto indefinida"?

Na verdade, pode significar duas coisas bem diferentes!Primeiro, pode significar a propriedade que nunca foi definida no objeto e, em segundo lugar, pode significar o propriedade que tem um valor indefinido.Vejamos este código:

var o = { a: undefined }

É o.a indefinido?Sim!Seu valor é indefinido.É o.b indefinido?Claro!Não existe propriedade 'b'!OK, veja agora como diferentes abordagens se comportam em ambas as situações:

typeof o.a == 'undefined' // true
typeof o.b == 'undefined' // true
o.a === undefined // true
o.b === 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 em que uma propriedade não foi definida e não presta atenção ao valor da propriedade que pode estar indefinido.

Então o que fazer?

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

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

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

'prop' in obj

Notas:

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

Luta final: `obj.prop === undefined` contra `typeof obj.prop == 'undefined'`

Vantagens de obj.prop === undefined:

É um pouco mais curto e parece um pouco mais bonito
O mecanismo JavaScript apresentará um erro se você digitar incorretamente undefined

Desvantagens de obj.prop === undefined:

undefined pode ser substituído em navegadores antigos

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

É realmente universal!Funciona em navegadores novos e antigos.

Desvantagens de typeof obj.prop == 'undefined':

'undefned' (com erros ortográficos) aqui é apenas uma constante de string, então o mecanismo JavaScript não pode ajudá-lo se você digitou incorretamente como eu fiz.

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

Node.js suporta a variável global undefined como global.undefined (também pode ser usado sem o prefixo 'global').Não conheço outras implementações de JavaScript do lado do servidor.

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

O objeto tem a propriedade e seu valor não é undefined.
O objeto possui a propriedade e seu valor é undefined.
O objeto 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 typeof obj.foo não nos diz qual dos três casos 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 ressaltar que esses testes são os mesmos para null entradas 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 é indefinida, e o único caso em que esta verificação será diferente é o caso 2, o caso raro de uma entrada real no objeto com um valor indefinido.

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

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

O que ficou mais claro quando escrito sem verificação de indefinido.

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

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

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

Isso funcionou para mim enquanto os outros não.

Não tenho certeza de onde a origem do uso === com typeof veio e, como convenção, vejo que é usado em muitas bibliotecas, mas o operador typeof retorna uma string literal, e sabemos disso de antemão, então por que você também desejaria digitar check 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

Postando meu responder da pergunta relacionada Como verificar “indefinido” em JavaScript?

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

Alguns cenários que ilustram os resultados das diversas respostas:http://jsfiddle.net/drzaus/UVjM4/

(Observe que o uso de var para in os testes fazem a diferença quando estão em um wrapper com escopo definido)

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');
}

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

Como o objeto janela tem um escopo global (objeto padrão) fora de uma função, uma declaração será 'anexada' ao objeto janela.

Por exemplo:

var myvar = 'test';

A variável global minhavar é o mesmo que janela.myvar ou janela['minhavar']

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

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

A questão se uma variável realmente existe não importa, seu valor está incorreto.Caso contrário, é bobagem inicializar variáveis com indefinido, e é melhor usar o valor false para inicializar.Quando você sabe que todas as variáveis que você declara são inicializadas com false, você pode simplesmente verificar seu tipo ou confiar em !window.myvar para verificar se tem um valor adequado/válido.Então, 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 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 for verdadeira, o interpretador pula os próximos testes.

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

(s)

Não vi (espero não ter perdido) ninguém verificando o objeto antes da propriedade.Portanto, este é o mais curto e eficaz (embora não necessariamente o mais claro):

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

Se obj ou obj.prop for indefinido, nulo ou "falsy", a instrução if não executará o bloco de código.Isso é geralmente o comportamento desejado na maioria das instruções de bloco de código (em JavaScript).

No artigo Explorando o abismo do nulo e do indefinido em JavaScript Eu li que frameworks como Sublinhado.js use esta função:

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

'se (janela.x) { }'é seguro contra erros

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 gera um erro.

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

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

Como isso funciona:

janela é um objeto que contém todas as variáveis globais como seus membros e é legal tentar acessar um membro inexistente.Se x não foi declarado ou não foi definido então window.x retorna indefinido. indefinido leva a falso quando se() avalia isso.

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

Lendo isso, estou surpreso por não ter visto isso.Encontrei vários algoritmos que funcionariam para isso.

Nunca definido

Se o valor de um objeto nunca foi definido, isso impedirá o retorno true se for definido como null ou undefined.Isso é útil se você deseja que true 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 resulte como 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.

Geralmente, as pessoas me pedem 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");
}

Você pode obter um array totalmente indefinido com caminho usando o código a seguir.

 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

Simplesmente qualquer coisa que não esteja definida em JavaScript, é indefinido, não importa se é uma propriedade dentro de um Objeto/Array ou apenas uma simples variável...

JavaScript tem typeof o que torna muito fácil detectar uma variável indefinida.

Basta verificar se typeof whatever === 'undefined' e retornará um booleano.

É assim que a famosa função isUndefined() em AngularJs v.1x está escrito:

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

Então, como você vê a função receber um valor, se esse valor for definido, ela retornará false, caso contrário, para valores indefinidos, retorne true.

Então vamos dar uma olhada em quais serão os resultados quando passarmos valores, incluindo propriedades de objetos como abaixo, esta é a lista de variáveis que temos:

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

e nós os verificamos abaixo, você pode ver os resultados na frente deles como um comentário:

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

Como você pode ver, podemos verificar qualquer coisa usando algo assim em nosso código, como mencionado, você pode simplesmente usar typeof em seu código, mas se você estiver usando-o repetidamente, crie uma função como a amostra angular que compartilho e continuo reutilizando conforme o padrão de código DRY.

Além disso, mais uma coisa: para verificar a propriedade de um objeto em um aplicativo real que você não tem certeza se o objeto existe ou não, verifique primeiro se o objeto existe.

Se você verificar uma propriedade em um objeto e o objeto não existir, gerará um erro e interromperá a execução de todo o aplicativo.

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

Tão simples que você pode envolver uma instrução if como abaixo:

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

Que também é igual a isDefined em Angular 1.x...

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

Além disso, outras estruturas javascript, como sublinhado, têm verificação de definição semelhante, mas eu recomendo que você use typeof se você ainda não usa nenhum framework.

Também adiciono esta seção do MDN que contém informações úteis sobre typeof, undefined e void(0).

Igualdade estrita e indefinida
Você pode usar indefinidos e os operadores estritos de igualdade e desigualdade para determinar se uma variável tem um valor.No código a seguir, a variável x não é definida e a instrução IF é avaliada como true.

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

Observação:O operador estrito da igualdade em vez do operador de igualdade padrão deve ser usado aqui, porque x == indefinido também verifica se X é nulo, enquanto a igualdade estrita não.Nulo não é equivalente a indefinido.Consulte operadores de comparação para obter detalhes.

Operador Typeof e indefinido
Alternativamente, typeof pode ser usado:

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

Um motivo para usar o tipo OOF é que ele não lança um erro se a variável não tiver sido declarada.

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

if (x === undefined) { // throws a ReferenceError

}

Porém, esse tipo de técnica deve ser evitado.O JavaScript é um idioma estaticamente escopo, portanto, saber se uma variável é declarada pode ser lida, vendo se é declarada em um contexto de anexo.A única exceção é o escopo global, mas o escopo global está ligado ao objeto global, portanto, verificar a existência de uma variável no contexto global pode ser feita, verificando a existência de uma propriedade no objeto global (usando o operador, por exemplo).

Operador vazio e indefinido

O operador void é uma terceira alternativa.

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`)
}

mais > aqui

Compare com void 0, por concisão.

if (foo !== void 0)

Não é tão detalhado quanto if (typeof foo !== 'undefined')

A solução está incorreta.Em JavaScript,

null == undefined

retornará verdadeiro, porque ambos são "convertidos" para um booleano e são falsos.A maneira correta seria verificar

if (something === undefined)

qual é o operador de identidade...

Aqui está minha situação:

Estou usando o resultado de uma chamada REST.O resultado deve ser analisado de JSON para um objeto JavaScript.

Há um erro que preciso defender.Se os argumentos para a chamada rest estiverem incorretos na medida em que o usuário especificou os argumentos errados, a chamada rest retornará basicamente vazia.

Ao usar esta postagem para me ajudar a me defender contra isso, tentei isso.

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

Para minha situação, se restResult.data[0] === "object", posso começar a inspecionar com segurança o restante dos membros.Se indefinido, lance o erro como acima.

O que estou dizendo é que para a minha situação todas as sugestões acima neste post não funcionaram.Não estou dizendo que estou certo e que todos estão errados.Não sou um mestre em JavaScript, mas espero que isso ajude alguém.

Existe uma maneira agradável e elegante de atribuir uma propriedade definida a uma nova variável, se ela estiver definida, ou atribuir um valor padrão a ela como substituto, se for indefinida.

var a = obj.prop || defaultValue;

É adequado se você tiver uma função que receba uma propriedade de configuração adicional:

var yourFunction = function(config){

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

}

Agora executando

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

yourFunction();
//=> 1

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

Todas as respostas estão incompletas.Esta é a maneira correta de saber que existe uma propriedade 'definida como indefinida':

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

Exemplo:

var a = { b : 1, e : null } ;
a.c = a.d ;

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 a.c ;
hasUndefinedProperty(a, 'c') ; // false : c is undefined

Pena que esta foi a resposta certa e está enterrada em respostas erradas >_<

Então, para quem passar por aqui, vou te dar indefinidos de graça!!

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

Percorrendo os comentários, para quem quiser verificar ambos é indefinido ou seu valor é nulo:

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

Se você estiver usando a biblioteca jQuery, então jQuery.isEmptyObject() será suficiente para ambos os casos,

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;

Se você estiver usando Angular:

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

Sublinhado.js:

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

eu uso if (this.variable) para testar se está definido.Simples if (variable), recomendado acima, falha para mim.Acontece que funciona apenas quando a variável é um campo de algum objeto, obj.someField para verificar se está definido no dicionário.Mas podemos usar this ou window como objeto de dicionário, já que qualquer variável é um campo na janela atual, pelo que entendi.Portanto aqui está um teste

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

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

Ele primeiro detecta aquela variável abc é indefinido e é definido após a inicialização.

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

Retorna falso se a variável estiver definida e verdadeiro se for indefinido.

Então use:

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

Além disso, as mesmas coisas podem ser escritas de forma mais curta:

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

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

Eu gostaria de mostrar algo que estou usando para proteger o undefined variável:

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

Isto proíbe qualquer pessoa de alterar o window.undefined valor, portanto, destruindo o código baseado nessa variável.Se estiver usando "use strict", qualquer coisa que tente alterar seu valor terminará em erro, caso contrário, será silenciosamente ignorado.

De lodash.js.

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

Ele cria uma variável LOCAL chamada undefined que é inicializado com o valor padrão - o real undefined, então compara value com a variável undefined.

Apresento aqui três maneiras para quem espera respostas estranhas:

function isUndefined1(val) {
    try {
        val.a;
    } catch (e) {
        return /undefined/.test(e.message);
    }
    return false;
}
function isUndefined2(val) {
    return !val && val+'' === 'undefined';
}
function isUndefined3(val) {
    const defaultVal={};
    return ((input=defaultVal)=>input===defaultVal)(val);
}
function test(func){
    console.group(`test start :`+func.name);
    console.log(func(undefined));
    console.log(func(null));
    console.log(func(1));
    console.log(func("1"));
    console.log(func(0));
    console.log(func({}));
    console.log(func(function () { }));
    console.groupEnd();
}
test(isUndefined1);
test(isUndefined2);
test(isUndefined3);

éIndefinido1:

Tente obter uma propriedade do valor de entrada, verifique a mensagem de erro se existir.Se o valor de entrada for indefinido, a mensagem de erro seria Erro de tipo não detectado:Não é possível ler a propriedade 'b' de indefinido

éIndefinido2:

Converta o valor de entrada em string para comparar com "undefined" e certifique-se de que seja um valor negativo.

éIndefinido3:

Em js, o parâmetro opcional funciona quando o valor de entrada é exatamente undefined.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow