validar - JavaScript isset() equivalente
validar undefined jquery (17)
En PHP puede hacer if(isset($array[''foo''])) { ... } . En JavaScript, a menudo usas if(array.foo) { ... } para hacer lo mismo, pero esta no es exactamente la misma declaración. La condición también se evaluará como falsa si array.foo existe pero es false o 0 (y probablemente también otros valores).
¿Cuál es el equivalente perfecto de la isset de PHP en JavaScript?
En un sentido más amplio, una guía general y completa sobre el manejo de JavaScript de variables que no existen, variables sin un valor, etc. sería conveniente.
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á mayormente retirado a favor de locutus. Aquí está el nuevo enlace http://locutus.io/php/var/isset
Esta es una solución bastante a prueba de balas para probar si existe una variable:
var setOrNot = typeof variable !== typeof undefined ? true : false;
Desafortunadamente, no puedes simplemente encapsularlo en una función.
Podrías pensar en hacer algo como esto:
function isset(variable) {
return typeof variable !== typeof undefined ? true : false;
}
Sin embargo, esto producirá un error de referencia si la variable variable no se ha definido, porque no puede pasar una variable no existente a una función:
Error de referencia no detectado: foo no está definido
Por otro lado, le permite probar si los parámetros de la función no están definidos:
var a = ''5'';
var test = function(x, y) {
console.log(isset(x));
console.log(isset(y));
};
test(a);
// OUTPUT :
// ------------
// TRUE
// FALSE
Aunque no se pasa ningún valor para y a la test función, nuestra función de isset funciona perfectamente en este contexto, ya que y en la test función se conoce como un valor undefined .
Esta solución funcionó para mí.
function isset(object){
return (typeof object !==''undefined'');
}
Esta solución simple funciona, pero no para la verificación profunda de objetos.
function isset(str) {
return window[str] !== undefined;
}
Generalmente uso el operador typeof :
if (typeof obj.foo !== ''undefined'') {
// your code here
}
"undefined" si la propiedad no existe o si su valor undefined está undefined .
(Ver también: Diferencia entre undefined y no definido ) .
Hay otras formas de averiguar si una propiedad existe en un objeto, como el método hasOwnProperty :
if (obj.hasOwnProperty(''foo'')) {
// your code here
}
Y in operador:
if (''foo'' in obj) {
// your code here
}
La diferencia entre los dos últimos es que el método hasOwnProperty comprobará si la propiedad existe físicamente en el objeto (la propiedad no se hereda).
El operador in verificará todas las propiedades alcanzables en la cadena del prototipo, por ejemplo:
var obj = { foo: ''bar''};
obj.hasOwnProperty(''foo''); // true
obj.hasOwnProperty(''toString''); // false
''toString'' in obj; // true
Como puede ver, hasOwnProperty devuelve false y el operador in devuelve true al verificar el método toString , este método se define en la cadena de prototipo, porque obj hereda la forma Object.prototype .
Hilo antiguo, pero aquí hay una nueva forma de ejecutar un isset() equivalente.
Responder
Vea a continuación la explicación. Nota utilizo la sintaxis StandardJS
Ejemplo 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
Función de respuesta
/**
* 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
}
}
Explicación
PHP
Tenga en cuenta que en PHP puede hacer referencia a cualquier variable a cualquier profundidad, incluso si intenta acceder a una no-matriz como una matriz devolverá un simple true o 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, no tenemos esa libertad, siempre obtendremos un error si hacemos lo mismo porque JS intenta inmediatamente acceder al valor de isset() antes de que podamos isset() en nuestra función isset() , así que ...
// 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
Más alternativas fallidas:
// 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
Y algunas alternativas de trabajo que pueden ser redundantes rápidamente:
// 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
Conclusión
Todas las otras respuestas, aunque la mayoría son viables ...
- Supongamos que solo está comprobando si la variable no está indefinida, lo que está bien para algunos casos de uso, pero aún puede generar un error
- Supongamos que solo está intentando acceder a una propiedad de nivel superior, lo que de nuevo está bien para algunos casos de uso
-
isset()a usar un enfoque menos que ideal en relación con elisset()de PHPisset()
por ejemplo,isset(some, ''nested.deeper.value'') - Usa
eval()que funciona pero yo personalmente evito
Creo que cubrí mucho de eso. En mi respuesta, señalo algunos puntos que no menciono porque, aunque son relevantes, no forman parte de la pregunta. Sin embargo, si es necesario, puedo actualizar mi respuesta con enlaces a algunos de los aspectos más técnicos basados en la demanda.
Pasé mucho tiempo en esto, así que espero que ayude a la gente.
¡Gracias por leer!
Manual de PHP decir:
isset - Determine si una variable está establecida y no es NULL
Y la interfaz de algo como esto:
bool isset ( mixed $var [, mixed $... ] )
El parámetro $var es la variable a verificar. Sin embargo, puede tener cualquier número de parámetro.
isset () devuelve TRUE si var existe y tiene un valor distinto de NULL . FALSE contrario.
Algunos ejemplos:
$foo = ''bar'';
var_dump(isset($foo)); -> true
$baz = null;
var_dump(isset($baz)); -> false
var_dump(isset($undefined)); -> false
Como esto en mente, aparentemente, no es posible escribir el equivalente exacto de la función php isset() . Por ejemplo cuando llamamos así:
if (isset(some_var)) {
}
function issset() {
// function definition
}
Uncaught ReferenceError: some_var is not defined at (file_name):line_number JavaScript Sin Uncaught ReferenceError: some_var is not defined at (file_name):line_number . Lo importante y notable de este comportamiento es que al intentar pasar variables no existentes a funciones normales, se desencadena un error.
Pero en PHP, isset() no son en realidad funciones regulares sino construcciones de lenguaje. Eso significa que son parte del lenguaje PHP en sí mismo, no cumplen con las reglas normales de las funciones y, por lo tanto, pueden evitar que se genere un error para las variables que no existen. Esto es importante cuando se trata de averiguar si una variable existe o no. Pero en javscript, se desencadena un error en primer lugar, digamos, función call con variables inexistentes.
Mi punto es que no podemos escribirlo como una función javscript equivalente pero podemos hacer algo como esto
if (typeof some_var !== ''undefined'') {
// your code here
}
Si desea exactamente el mismo efecto PHP también verifique que varable no es NULL
Por ejemplo
$baz = null;
var_dump(isset($baz)); -> false
Por lo tanto, podemos incorporar esto en javascript, entonces se verá así:
if (typeof some_var !== ''undefined'' && some_var !== null) {
// your code here
}
Para verificar si el bloque html existe o no, estoy usando este código:
if (typeof($(''selector'').html()) != ''undefined'') {
// $(''selector'') is existing
// your code here
}
Proporcione la ruta del objeto como una cadena, luego puede dividir esta cadena en una ruta y resolver hasOwnProperty en cada paso mientras sobrescribe el objeto en sí con cada iteración.
Si está codificando en el entorno ES6, eche un vistazo a este Ques .
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
);
Si estás usando Underscore.js siempre uso
if (!_.isUndefined(data) && !_.isNull(data)) {
//your stuff
}
Siempre uso esta función genérica para evitar errores en las variables primitivas, así como matrices y 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
(typeof SOMETHING) !== ''undefined''
Es demasiado largo para escribir cuando se usa. Pero no podemos empaquetar la typeof clave typeof en una función, porque se generará un error antes de llamar a la función, como esto:
function isdef($var) {
return (typeof $var) !== ''undefined'';
}
isdef(SOMETHING); ///// thrown error: SOMETHING is not defined
Así que descubrí una manera:
function isdef($type) {
return $type !== ''undefined'';
}
isdef(typeof SOMETHING);
Puede funcionar tanto con variables individuales (variables que no existen en absoluto) como con propiedades de objetos (propiedades no existentes). Y solo 7 caracteres más que el PHP isset .
//
// 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;
}
//
//
function isset(variable) {
try {
return typeof eval(variable) !== ''undefined'';
} catch (err) {
return false;
}
}
if (!(''foo'' in obj)) {
// not set.
}
if (var) {
// This is the most concise equivalent of Php''s 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; }
};
más pruebas:
https://gist.github.com/daylik/24acc318b6abdcdd63b46607513ae073