référence à la 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
}

phpjs.org est la plupart du temps à la retraite en faveur de locutus Voici le nouveau lien http://locutus.io/php/var/isset

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

vieux fil, Mais voici une nouvelle façon d'exécuter un équivalent isset() .

réponse

voir ci-dessous pour explication. Note-je utiliser StandardJS syntaxe

Exemple D'Usage

// 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

Fonction De Réponse

/**
 * 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
  }
}

explication

PHP

noter que en PHP vous pouvez faire référence à n'importe quelle variable à n'importe quelle profondeur - même en essayant de accéder à un non-tableau comme un tableau retournera un simple true ou 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

dans JavaScript, nous n'avons pas cette liberté, nous aurons toujours une erreur si nous faisons la même chose parce que JS tente immédiatement d'accéder à la valeur de deeper avant que nous puissions l'envelopper dans notre isset() fonction ainsi...

// 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

plus à défaut d'alternatives:

// 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

et quelques alternatives de travail qui peuvent devenir redondantes rapidement:

// 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

Conclusion

toutes les autres réponses-bien que la plupart soient viables...

1. supposons que vous vérifiez seulement pour voir si la variable n'est pas non défini qui est très bien pour certains cas d'utilisation, mais peut encore jeter une Erreur
2. supposez que vous essayez seulement accéder à une propriété de haut niveau, qui est encore amende pour certains cas d'utilisation
3. vous forcer à utiliser une approche moins qu'idéale par rapport à PHP isset()
   
   par exemple isset(some, 'nested.deeper.value')
4. Utiliser eval() qui fonctionne, mais personnellement, je l'éviter

je pense que j'en ai couvert beaucoup. Il y a quelques points que je fais dans ma réponse que je ne pas toucher parce qu'ils - mais - ne font pas partie de le question. Si besoin est, cependant, je peux mettre à jour ma réponse avec des liens vers certains des aspects plus techniques basés sur la demande.

j'ai passé beaucoup de temps là-dessus donc j'espère que ça aidera les gens.

Merci d'avoir lu!

//
//  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;

 } 
//
//

cette solution simple fonctionne, mais pas pour la vérification en profondeur de l'objet.

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

j'utilise toujours Cette fonction générique pour empêcher les erreurs sur les variables primitives aussi bien que les tableaux et les objets.

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

si vous utilisez sous-titres j'utilise toujours

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

Cette solution a fonctionné pour moi.

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

C'est une solution assez pare-balles pour tester si une variable existe:

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

Malheureusement, vous ne pouvez pas simplement l'encapsuler dans une fonction.

Vous pourriez penser, de faire quelque chose comme ceci :

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

cependant, cela produira une erreur de référence si la variable variable n'a pas été définie, parce que vous ne pouvez pas passer le long d'une variable non existante à une fonction:

Uncaught ReferenceError: foo n'est pas défini

d'un autre côté, il vous permet de vérifier si les paramètres de la fonction ne sont pas définis :

var a = '5';

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

test(a);

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

bien qu'aucune valeur pour y ne soit transmise à la fonction test , notre fonction isset fonctionne parfaitement dans ce contexte, parce que y est connu dans la fonction test comme une valeur undefined .

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

fournit le chemin de l'objet comme une chaîne, alors vous pouvez briser cette chaîne dans un chemin et résoudre hasOwnProperty à chaque étape tout en écrasant l'objet lui-même avec chaque itération.

si vous codez dans un environnement ES6, jetez un coup d'oeil à cette question de flux 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
);

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

plus les essais:

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

pour vérifier si le bloc html existe ou non, j'utilise ce code:

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

(typeof SOMETHING) !== 'undefined'

C'est trop long à écrire. Mais nous ne pouvons pas empaqueter le mot-clé typeof dans une fonction, parce qu'une erreur sera lancée avant que la fonction soit appelée, comme ceci:

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

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

alors j'ai trouvé un moyen:

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

isdef(typeof SOMETHING);

il peut fonctionner à la fois avec des variables individuelles (variables qui n'existent pas du tout), ou des propriétés d'objet (Propriétés inexistantes). Et seulement 7 caractères de plus que PHP isset .

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

manuel PHP dire:

isset - déterminer si une variable est définie et N'est pas nulle

et interface quelque chose comme ceci:

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

le paramètre $var est la variable à vérifier. il peut avoir un nombre quelconque de paramètres.

isset () retourne TRUE si var existe et a valeur autre que NULL . FALSE dans le cas contraire.

quelque exemple:

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

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

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

comme ceci à l'esprit, apparemment, il n'est pas possible d'écrire l'équivalent exact de la fonction php isset() . Par exemple quand nous appelons comme ceci:

if (isset(some_var)) {

}

function issset() {
    // function definition
}

Javascript déclencheur Uncaught ReferenceError: some_var is not defined at (file_name):line_number . Ce qui est important et remarquable dans ce comportement, c'est qu'en essayant de passer des variables inexistantes à des fonctions normales, un l'erreur est déclenchée.

mais en PHP isset() ne sont pas en fait des fonctions régulières mais des constructions linguistiques. Cela signifie qu'ils font partie du langage PHP lui-même, ne jouent pas selon les règles normales des fonctions et peuvent donc s'en tirer sans déclencher d'erreur pour les variables inexistantes. C'est important lorsqu'on essaie de déterminer si une variable existe ou non. Mais dans javscript, il déclenche une erreur en premier lieu disons appel de fonction avec des variables inexistantes.

mon point est que nous ne pouvons pas l'écrire comme la fonction javscript equivlent mais nous pouvons faire quelque chose comme ça

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

si vous voulez exactement le même effet PHP aussi vérifier varable n'est pas NULL

par exemple

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

donc, nous pouvons incorporer ceci dans javascript alors il ressemble à ceci:

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