JavaScript équivalent à () équivalent
Dans PHP, vous pouvez faire if(isset($array['foo'])) { ... }. En JavaScript, vous utilisez souvent if(array.foo) { ... } pour faire la même chose, mais ce n'est pas exactement la même chose. La condition sera également évaluée à false si array.foo existe, mais est false ou 0 (et probablement aussi à d'autres valeurs).
Quel est l'équivalent parfait de isset en JavaScript de PHP?
Dans un sens plus large, un guide général complet sur le traitement par JavaScript des variables inexistantes, des variables sans valeur, etc. serait pratique.
J'utilise généralement l'opérateur typeof :
if (typeof obj.foo !== 'undefined') {
// your code here
}
Il renverra "undefined" si la propriété n'existe pas ou si sa valeur est undefined.
(Voir aussi: Différence entre undefined et ne pas être définie. )
Il existe d'autres moyens de déterminer si une propriété existe sur un objet, comme la méthode hasOwnProperty :
if (obj.hasOwnProperty('foo')) {
// your code here
}
Et l'opérateur in:
if ('foo' in obj) {
// your code here
}
La différence entre les deux derniers réside dans le fait que la méthode hasOwnProperty vérifie si la propriété existe physiquement sur l'objet (la propriété n'est pas héritée).
L’opérateur in vérifie toutes les propriétés pouvant être atteintes dans la chaîne de prototypes, par exemple:
var obj = { foo: 'bar'};
obj.hasOwnProperty('foo'); // true
obj.hasOwnProperty('toString'); // false
'toString' in obj; // true
Comme vous pouvez le constater, hasOwnProperty renvoie false et l'opérateur in renvoie true lors de la vérification de la méthode toString, cette méthode est définie dans la chaîne de prototypes, car obj hérite du formulaire Object.prototype.
L'ancien thread est ancien, mais voici une nouvelle façon d'exécuter un équivalent isset().
Répondre
Voir ci-dessous pour l'explication. Notez que j'utilise la syntaxe StandardJS
Exemple d'utilisation
// 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
Notez que dans PHP, vous pouvez référencer n'importe quelle variable à n'importe quelle profondeur - même essayer d'accéder à un non-tableau car 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
En JavaScript, nous n’avons pas cette liberté, nous aurons toujours une erreur si nous faisons la même chose car JS tente immédiatement d’accéder à la valeur de deeper avant de pouvoir l’envelopper dans notre fonction isset() afin .. .
// 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'alternatives défaillantes:
// 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 être rapidement redondantes:
// 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 ...
- Supposons que vous ne faites que vérifier si la variable n'est pas indéfinie, ce qui convient à certains cas d'utilisation, mais peut toujours générer une erreur.
- Supposons que vous essayez uniquement d'accéder à une propriété de niveau supérieur, ce qui est correct dans certains cas d'utilisation.
- Vous obliger à utiliser une approche moins qu'idéale par rapport à
isset()de PHP
par exemple.isset(some, 'nested.deeper.value') - Utilisez
eval()qui fonctionne mais que j’évite personnellement
Je pense que j'en ai couvert beaucoup. Dans ma réponse, il y a des points que je ne traite pas, car ils - bien que pertinents - ne font pas partie de la question. Cependant, si besoin est, je peux mettre à jour ma réponse avec des liens vers certains des aspects les plus techniques basés sur la demande.
J'ai passé beaucoup trop de temps là-dessus, alors j'espère que cela aidera les gens.
Merci pour la lecture!
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 retiré en faveur de locutus Voici le nouveau lien http://locutus.io/php/var/isset
if (!('foo' in obj)) {
// not set.
}
Cette solution simple fonctionne, mais pas pour la vérification d'objet en profondeur.
function isset(str) {
return window[str] !== undefined;
}
//
// 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;
}
//
//
J'utilise toujours cette fonction générique pour éviter les erreurs sur les variables primitives, ainsi que sur 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 nderscorejs j'utilise toujours
if (!_.isUndefined(data) && !_.isNull(data)) {
//your stuff
}
Cette solution a fonctionné pour moi.
function isset(object){
return (typeof object !=='undefined');
}
function isset(variable) {
try {
return typeof eval(variable) !== 'undefined';
} catch (err) {
return false;
}
}
C'est une jolie solution à l'épreuve des 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 à faire quelque chose comme ça:
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, car vous ne pouvez pas transmettre une variable non existante à une fonction:
Uncaught ReferenceError: foo n'est pas défini
Par contre, cela vous permet de vérifier si les paramètres de la fonction sont indé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, car y est connu dans la fonction test comme une valeur undefined.
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 pour écrire quand utilisé. Mais nous ne pouvons pas intégrer le mot clé typeof dans une fonction, car une erreur sera généré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 avec des propriétés d'objet (propriétés non existantes). Et seulement 7 caractères de plus que PHP isset.
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 des tests:
https://Gist.github.com/daylik/24acc318b6abdcdd63b46607513ae07
Indiquez le chemin d'accès à l'objet sous forme de chaîne. Vous pouvez ensuite diviser cette chaîne en chemin et résoudre hasOwnProperty à chaque étape tout en écrasant l'objet à chaque itération.
Si vous codez dans un environnement ES6, jetez un oeil à this Ques 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
);J'utilise une fonction qui peut vérifier les variables et les objets. très pratique pour travailler avec jQuery
function _isset (variable) {
if(typeof(variable) == "undefined" || variable == null)
return false;
else
if(typeof(variable) == "object" && !variable.length)
return false;
else
return true;
};
C'était vraiment un problème pour moi lorsque j'accédais à une propriété plus profonde d'un objet, j'ai donc créé une fonction qui renverra la valeur de la propriété si elle existe, sinon elle renverra false. Vous pouvez l’utiliser pour gagner du temps,
//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
Si vous voulez vérifier si un élément existe, utilisez simplement le code suivant:
if (object) {
//if isset, return true
} else {
//else return false
}
C'est échantillon:
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().
}
Manuel PHP dit:
isset - Détermine si une variable est définie et n'est pas NULL
Et interface quelque chose comme ça:
bool isset ( mixed $var [, mixed $... ] )
Le paramètre $var est la variable à vérifier. il peut cependant avoir un nombre quelconque de paramètres.
isset () retourne TRUE si la variable existe et a une valeur autre que NULL. FALSE sinon.
Quelques exemples:
$foo = 'bar';
var_dump(isset($foo)); -> true
$baz = null;
var_dump(isset($baz)); -> false
var_dump(isset($undefined)); -> false
Dans cet esprit, il est apparemment impossible d'écrire l'équivalent exact de la fonction php isset(). Par exemple quand on appelle comme ça:
if (isset(some_var)) {
}
function issset() {
// function definition
}
Déclencheur Javascript Uncaught ReferenceError: some_var is not defined at (file_name):line_number. Ce qui est important et remarquable à propos de ce comportement, c’est que lorsqu’on essaie de transmettre des variables inexistantes à des fonctions normales, une erreur est déclenchée.
Mais dans PHP isset() ne sont pas réellement des fonctions ordinaires mais des constructions de langage. Cela signifie qu’ils font partie du langage PHP lui-même, ne respectent pas les règles normales des fonctions et peuvent donc s’en tirer sans déclencher une erreur pour des variables inexistantes. Ceci est important lorsque vous essayez de déterminer si une variable existe ou non. Mais en javscript, il déclenche une erreur en premier lieu, appelez une fonction avec des variables inexistantes.
Mon point est que nous ne pouvons pas l'écrire en tant que fonction javscript équivalente, 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, vérifiez également que la variable n'est pas NULL
Par exemple
$baz = null;
var_dump(isset($baz)); -> false
Donc, nous pouvons incorporer cela dans javascript, alors ça ressemble à ça:
if (typeof some_var !== 'undefined' && some_var !== null) {
// your code here
}