Em PHP você pode fazer if(isset($array['foo'])) { ... }. Em JavaScript, você costuma usar if(array.foo) { ... }o mesmo, mas essa não é exatamente a mesma declaração. A condição também será avaliada como falsa se array.fooexistir, mas é falseor 0(e provavelmente outros valores também).

Qual é o equivalente perfeito de PHP issetem JavaScript?

Em um sentido mais amplo, seria conveniente um guia geral e completo sobre o tratamento de variáveis ​​que não existem no JavaScript, variáveis ​​sem valor etc.

Eu geralmente uso o typeofoperador:

if (typeof obj.foo !== 'undefined') {
  // your code here
}

Ele retornará "undefined"se a propriedade não existir ou seu valor for undefined.

_{(Veja também: Diferença entre undefinede não sendo definido. )}

Existem outras maneiras de descobrir se existe uma propriedade em um objeto, como o hasOwnPropertymétodo:

if (obj.hasOwnProperty('foo')) {
  // your code here
}

E o inoperador:

if ('foo' in obj) {
  // your code here
}

A diferença entre os dois últimos é que o hasOwnPropertymétodo verifica se a propriedade existe fisicamente no objeto (a propriedade não é herdada).

O inoperador verificará todas as propriedades alcançáveis ​​na cadeia de protótipos, por exemplo:

var obj = { foo: 'bar'};

obj.hasOwnProperty('foo'); // true
obj.hasOwnProperty('toString'); // false
'toString' in obj; // true

Como você pode ver, hasOwnPropertyretorna falsee o inoperador retorna trueao verificar o toStringmétodo, esse método é definido na cadeia de protótipos, porque objherda o formulário Object.prototype.

Segmento antigo, mas há novas maneiras de executar um equivalente isset().

ESNext (Etapa 4 de dezembro de 2019)

Duas novas sintaxes nos permitem simplificar amplamente o uso da isset()funcionalidade:

• Encadeamento opcional ( ?.)
• Operador de coalescência nulo ( ??)

Leia os documentos e lembre-se da compatibilidade do navegador.

Resposta Anterior

Veja abaixo a explicação. Nota Eu uso a sintaxe StandardJS

Exemplo de uso

// IMPORTANT pass a function to our isset() that returns the value we're
// trying to test(ES6 arrow function)
isset(() => some) // false

// Defining objects
let some = { nested: { value: 'hello' } }

// More tests that never throw an error
isset(() => some) // true
isset(() => some.nested) // true
isset(() => some.nested.value) // true
isset(() => some.nested.deeper.value) // false

// Less compact but still viable except when trying to use `this` context
isset(function () { return some.nested.deeper.value }) // false

Função de resposta

/**
 * Checks to see if a value is set.
 *
 * @param {Function} accessor Function that returns our value
 */
function isset (accessor) {
  try {
    // Note we're seeing if the returned value of our function is not
    // undefined
    return typeof accessor() !== 'undefined'
  } catch (e) {
    // And we're able to catch the Error it would normally throw for
    // referencing a property of undefined
    return false
  }
}

Explicação

PHP

Observe que no PHP você pode fazer referência a qualquer variável a qualquer profundidade - mesmo tentando acessar um não array, pois um array retornará um simples trueou false:

// Referencing an undeclared variable
isset($some); // false

$some = 'hello';

// Declared but has no depth(not an array)
isset($some); // true
isset($some['nested']); // false

$some = ['nested' => 'hello'];

// Declared as an array but not with the depth we're testing for
isset($some['nested']); // true
isset($some['nested']['deeper']); // false

JS

Em JavaScript, não temos essa liberdade, sempre obteremos um erro se fizermos o mesmo, porque JS está tentando acessar imediatamente o valor de deeper antes de podermos envolvê-lo em nossa isset()função para ...

// Common pitfall answer(ES6 arrow function)
const isset = (ref) => typeof ref !== 'undefined'

// Same as above
function isset (ref) { return typeof ref !== 'undefined' }

// Referencing an undeclared variable will throw an error, so no luck here
isset(some) // Error: some is not defined

// Defining a simple object with no properties - so we aren't defining
// the property `nested`
let some = {}

// Simple checking if we have a declared variable
isset(some) // true

// Now trying to see if we have a top level property, still valid
isset(some.nested) // false

// But here is where things fall apart: trying to access a deep property
// of a complex object; it will throw an error
isset(some.nested.deeper) // Error: Cannot read property 'deeper' of undefined
//         ^^^^^^ undefined

Mais alternativas com falha:

// Any way we attempt to access the `deeper` property of `nested` will
// throw an error
some.nested.deeper.hasOwnProperty('value') // Error
//   ^^^^^^ undefined

Object.hasOwnProperty('value', some.nested.deeper) // Error
//                                  ^^^^^^ undefined

// Same goes for typeof
typeof some.nested.deeper !== 'undefined' // Error
//          ^^^^^^ undefined

E algumas alternativas de trabalho que podem ser redundantes rapidamente:

// Wrap everything in try...catch
try { isset(some.nested.deeper) } catch (e) {}
try { typeof some.nested.deeper !== 'undefined' } catch (e) {}

// Or by chaining all of the isset which can get long
isset(some) && isset(some.nested) && isset(some.nested.deeper) // false
//                        ^^^^^^ returns false so the next isset() is never run

Conclusão

Todas as outras respostas - embora a maioria seja viável ...

1. Suponha que você esteja apenas verificando se a variável não está indefinida, o que é bom para alguns casos de uso, mas ainda pode gerar um erro
2. Suponha que você esteja apenas tentando acessar uma propriedade de nível superior, o que novamente é bom para alguns casos de uso
3. Forçar você a usar uma abordagem abaixo do ideal em relação ao PHP, isset()
   por exemploisset(some, 'nested.deeper.value')
4. Uso eval()que funciona, mas eu pessoalmente evito

Eu acho que cobri muito disso. Há alguns pontos que afirmo em minha resposta que não menciono, porque eles - embora relevantes - não fazem parte da pergunta. Se necessário, posso atualizar minha resposta com links para alguns dos aspectos mais técnicos com base na demanda.

Passei muito tempo nisso, espero que ajude as pessoas.

Obrigado pela leitura!

Referência a SOURCE

    module.exports = function isset () {
  //  discuss at: http://locutus.io/php/isset/
  // original by: Kevin van Zonneveld (http://kvz.io)
  // improved by: FremyCompany
  // improved by: Onno Marsman (https://twitter.com/onnomarsman)
  // improved by: Rafał Kukawski (http://blog.kukawski.pl)
  //   example 1: isset( undefined, true)
  //   returns 1: false
  //   example 2: isset( 'Kevin van Zonneveld' )
  //   returns 2: true

  var a = arguments
  var l = a.length
  var i = 0
  var undef

  if (l === 0) {
    throw new Error('Empty isset')
  }

  while (i !== l) {
    if (a[i] === undef || a[i] === null) {
      return false
    }
    i++
  }

  return true
}

O phpjs.org é aposentado principalmente a favor do locutus. Aqui está o novo link http://locutus.io/php/var/isset

if (!('foo' in obj)) {
  // not set.
}

//
//  tring to reference non-existing variable throws ReferenceError 
//  before test function is even executed
//
//  example, if you do:
//    
//     if ( isset( someVar ) ) 
//        doStuff( someVar );
//   
//  you get a ReferenceError ( if there is no someVar... ) 
//  and isset fn doesn't get executed.
//
//  if you pass variable name as string, ex. isset( 'novar' );, 
//  this might work:
//
function isset ( strVariableName ) { 

    try { 
        eval( strVariableName );
    } catch( err ) { 
        if ( err instanceof ReferenceError ) 
           return false;
    }

    return true;

 } 
//
//

Essa solução simples funciona, mas não para verificação profunda de objetos.

function isset(str) {
    return window[str] !== undefined;
}

Eu sempre uso essa função genérica para evitar erros em variáveis ​​primitivas, bem como matrizes e objetos.

isset = function(obj) {
  var i, max_i;
  if(obj === undefined) return false;
  for (i = 1, max_i = arguments.length; i < max_i; i++) {
    if (obj[arguments[i]] === undefined) {
        return false;
    }
    obj = obj[arguments[i]];
  }
  return true;
};

console.log(isset(obj));                   // returns false
var obj = 'huhu';
console.log(isset(obj));                   // returns true
obj = {hallo:{hoi:'hoi'}};
console.log(isset(obj, 'niet'));           // returns false
console.log(isset(obj, 'hallo'));          // returns true
console.log(isset(obj, 'hallo', 'hallo')); // returns false
console.log(isset(obj, 'hallo', 'hoi'));   // returns true

Se você estiver usando underscorejs, eu sempre uso

if (!_.isUndefined(data) && !_.isNull(data)) {
     //your stuff
}

Esta é uma solução bastante à prova de balas para testar se existe uma variável:

var setOrNot = typeof variable !== typeof undefined ? true : false;

Infelizmente, você não pode simplesmente encapsulá-lo em uma função.

Você pode pensar em fazer algo assim:

function isset(variable) {
    return typeof variable !== typeof undefined ? true : false;
}

No entanto, isso produzirá um erro de referência se a variável variablenão tiver sido definida, porque você não pode passar uma variável inexistente para uma função:

Não detectado ReferenceError: foo não está definido

Por outro lado, permite testar se os parâmetros de função são indefinidos:

var a = '5';

var test = function(x, y) {
    console.log(isset(x));
    console.log(isset(y));
};

test(a);

// OUTPUT :
// ------------
// TRUE
// FALSE

Embora nenhum valor para yseja repassado para a função test, nossa issetfunção funciona perfeitamente nesse contexto, porque yé conhecida na função testcomo um undefinedvalor.

(typeof SOMETHING) !== 'undefined'

É muito longo para escrever quando usado. Mas não podemos empacotar a typeofpalavra-chave em uma função, porque um erro será gerado antes que a função seja chamada, assim:

function isdef($var) {
    return (typeof $var) !== 'undefined';
}

isdef(SOMETHING); ///// thrown error: SOMETHING is not defined

Então eu descobri uma maneira:

function isdef($type) {
    return $type !== 'undefined';
}

isdef(typeof SOMETHING);

Ele pode trabalhar tanto com variáveis ​​individuais (variáveis ​​que não existem) quanto com propriedades de objetos (propriedades inexistentes). E apenas 7 caracteres a mais que o PHP isset.

Esta solução funcionou para mim.

function isset(object){
    return (typeof object !=='undefined');
}

function isset(variable) {
    try {
        return typeof eval(variable) !== 'undefined';
    } catch (err) {
        return false;
    }
}

window.isset = function(v_var) {
    if(typeof(v_var) == 'number'){ if(isNaN(v_var)){ return false; }}
    if(typeof(v_var) == 'undefined' || v_var === null){ return false;   } else { return true; }
};

mais testes:

https://gist.github.com/daylik/24acc318b6abdcdd63b46607513ae073

Para verificar se o bloco html existe ou não, estou usando este código:

if (typeof($('selector').html()) != 'undefined') {
    // $('selector') is existing
    // your code here
}

Forneça o caminho do objeto como uma sequência e, em seguida, você poderá quebrá-la em um caminho e resolvê-lo hasOwnPropertya cada etapa enquanto sobrescreve o próprio objeto a cada iteração.

Se você estiver codificando no ambiente ES6, dê uma olhada neste Ques do stackoverflow .

var a;

a = {
    b: {
        c: 'e'
    }
};

function isset (obj, path) {
    var stone;

    path = path || '';

    if (path.indexOf('[') !== -1) {
        throw new Error('Unsupported object path notation.');
    }

    
    path = path.split('.');
    
    do {
        if (obj === undefined) {
            return false;
        }

        stone = path.shift();
        
        if (!obj.hasOwnProperty(stone)) {
            return false;
        }
        
        obj = obj[stone];
        
    } while (path.length);

    return true;
}

console.log(
    isset(a, 'b') == true,
    isset(a, 'b.c') == true,
    isset(a, 'b.c.d') == false,
    isset(a, 'b.c.d.e') == false,
    isset(a, 'b.c.d.e.f') == false
);

Eu uso uma função que pode verificar variáveis ​​e objetos. muito conveniente trabalhar com jQuery

    function _isset (variable) {
        if(typeof(variable) == "undefined" || variable == null)
            return false;
        else
            if(typeof(variable) == "object" && !variable.length) 
                return false;
            else
                return true;
    };

Foi realmente um problema para mim quando eu estava acessando uma propriedade mais profunda de um objeto, então criei uma função que retornará o valor da propriedade, se existir, caso contrário, retornará false. Você pode usá-lo para economizar seu tempo,

//Object on which we want to test
var foo = {
    bar: {
        bik: {
            baz: 'Hello world'
        }
    }
};


/*
USE: To get value from the object using it properties supplied (Deeper),
    if found it will return the property value if not found then will return false

You can use this function in two ways
WAY - 1:
Passing an object as parameter 1 and array of the properties as parameter 2
EG: getValueFromObject(foo, ['bar', 'bik', 'baz']);
WAY - 2: (This will work only if, your object available in window object)
Passing an STRING as parameter 1(Just similarly how we retrieve value form object using it's properties - difference is only the quote)
EG: getValueFromObject('foo.bar.bik.baz');
*/
function getValueFromObject(object, properties) {
    if(typeof(object) == 'string') {            //Here we extract our object and it's properties from the string
        properties = object.split('.');
        object = window[properties[0]];
        if(typeof(object) == 'undefined') {
            return false;
        }
        properties.shift();
    }
    var property = properties[0];
    properties.shift();
    if(object != null && typeof(object[property]) != 'undefined') {
        if(typeof(object[property]) == 'object') {
            if(properties.length != 0) {
                return getValueFromObject(object[property], properties);    //Recursive call to the function
            } else {
                return object[property];
            }
        } else {
            return object[property];
        }
    } else {
        return false;
    }
}
console.log(getValueFromObject('fooo.bar.bik.baz'));        //false
console.log(getValueFromObject('foo.bar.bik.baz'));         //Hello world
console.log(getValueFromObject('foo'));                     //false
console.log(getValueFromObject('foo.bar.bik'));             //returns an object { baz: 'Hello World' }
console.log(getValueFromObject(foo, ['bar', 'bik']));       //returns an object { baz: 'Hello World' }
console.log(getValueFromObject(foo, ['bar', 'bik', 'baz']));//Hello world

Se você deseja verificar se um elemento existe, basta usar o seguinte código:

if (object) {
  //if isset, return true
} else {
  //else return false
}

Esta é uma amostra:

function switchDiv() {
    if (document.querySelector("#divId")) {
        document.querySelector("#divId").remove();
    } else {
        var newDiv = document.createElement("div");
        newDiv.id = "divId";
        document.querySelector("body").appendChild(newDiv);
    }
}

document.querySelector("#btn").addEventListener("click", switchDiv);

#divId {
    background: red;
    height: 100px;
    width: 100px;
    position: relative;
    
}

<body>
  <button id="btn">Let's Diiiv!</button>
</body>

if (var) {
  // This is the most concise equivalent of Php's isset().
} 

O manual do PHP diz:

isset - Determina se uma variável está definida e não é NULL

E interface algo como isto:

bool isset ( mixed $var [, mixed $... ] )

O parâmetro $varé a variável a ser verificada. embora possa ter qualquer número de parâmetros.

isset () retorna TRUEse var existir e tiver um valor diferente de NULL. FALSEde outra forma.

Algum exemplo:

$foo = 'bar';
var_dump(isset($foo));        -> true

$baz = null;
var_dump(isset($baz));        -> false

var_dump(isset($undefined));  -> false

Como isso em mente, aparentemente, não é possível escrever o equivalente exato da isset()função php . Por exemplo, quando chamamos assim:

if (isset(some_var)) {

}

function issset() {
    // function definition
}

Gatilho Javascript Uncaught ReferenceError: some_var is not defined at (file_name):line_number. O importante e notável sobre esse comportamento é que, ao tentar passar variáveis ​​inexistentes para funções normais, um erro é acionado.

Mas no PHP isset()não são realmente funções regulares, mas construções de linguagem. Isso significa que eles fazem parte da própria linguagem PHP, não cumprem as regras normais de funções e, portanto, podem se safar por não desencadear um erro para variáveis ​​inexistentes. Isso é importante ao tentar descobrir se uma variável existe ou não. Mas em javscript, ele dispara um erro em primeiro lugar, digamos, chamada de função com variáveis ​​inexistentes.

Meu argumento é que não podemos escrevê-lo como função javscript equivalente, mas podemos fazer algo assim

if (typeof some_var !== 'undefined') {
   // your code here
}

Se você quiser exatamente o mesmo efeito, o PHP também verificará que varable não é NULL

Por exemplo

$baz = null;
var_dump(isset($baz));        -> false

Então, podemos incorporar isso no javascript, e fica assim:

if (typeof some_var !== 'undefined' && some_var !== null) {
   // your code here
}

isset javascript

let test = {
  a: {
    b: [0, 1]
  }
};

console.log(test.isset('a.b'))   // true
console.log(test.isset('a.b.1')) // true
console.log(test.isset('a.b.5')) // false
console.log(test.isset('a.c'))   // false
console.log('abv'.isset('0'))    // true

Tenha cuidado no ES6 , todas as soluções anteriores não funcionam se você deseja verificar uma declaração de uma variável let e declara-la, se não estiver

exemplo

let myTest = 'text';

if(typeof myTest === "undefined") {
    var myTest = 'new text'; // can't be a let because let declare in a scope
}

você verá um erro

Não detectado SyntaxError: o identificador 'myTest' já foi declarado

A solução foi alterá-lo por um var

var myTest = 'text'; // I replace let by a var

if(typeof myTest === "undefined") {
    var myTest = 'new text';
}

outra solução, se você puder alterar um let por um var, precisará remover seu var

let myTest = 'text';

if(typeof myTest === "undefined") {
    myTest = 'new text'; // I remove the var declaration
}

    isset('user.permissions.saveProject', args);

    function isset(string, context) {
        try {
            var arr = string.split('.');
            var checkObj = context || window;

            for (var i in arr) {
                if (checkObj[arr[i]] === undefined) return false;
                checkObj = checkObj[arr[i]];
            }

            return true;
        } catch (e) {
            return false;
        }
    }