Saltar al contenido

JavaScript isset () equivalente

Marcos, miembro de nuestro staff, nos hizo el favor de redactar esta sección ya que domina a la perfección dicho tema.

Solución:

Generalmente uso el typeof operador:

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

Volverá "undefined" ya sea si la propiedad no existe o su valor es undefined.

(Ver también: Diferencia entre undefined y no estar definido.)

Hay otras formas de averiguar si una propiedad existe en un objeto, como la hasOwnProperty método:

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

Y el in operador:

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

La diferencia entre los dos últimos es que el hasOwnProperty El método comprobará si la propiedad existe. físicamente en el objeto (la propiedad no se hereda).

los in El operador comprobará todas las propiedades accesibles en la cadena de prototipos, por ejemplo:

var obj =  foo: 'bar';

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

Como se puede ver, hasOwnProperty devoluciones false y el in devoluciones del operador true al comprobar el toString método, este método se define en la cadena de prototipos, porque obj hereda la forma Object.prototype.

Hilo antiguo, pero hay nuevas formas de ejecutar un equivalente isset().

ESNext (Etapa 4 de diciembre de 2019)

Dos nuevas sintaxis nos permiten simplificar enormemente el uso de isset() funcionalidad:

  • Encadenamiento opcional (?.)
  • Operador coalescente nulo (??)

Lea los documentos y tenga en cuenta la compatibilidad del navegador.

Respuesta

Consulte a continuación para obtener una explicación. Tenga en cuenta que uso 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
 * @returns Boolean           Value is not undefined or null
 */
function isset (accessor) 
  try 
    // Note we're seeing if the returned value of our function is not
    // undefined or null
    return accessor() !== undefined && accessor() !== null
   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 intentando acceder a unaarray como un array 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 está intentando acceder inmediatamente al valor de deeper
antes de que podamos envolverlo en nuestro isset() funciona tan …

// 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.call(some.nested.deeper, 'value') // Error
//                              ^^^^^^ undefined

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

Y algunas alternativas de trabajo que pueden volverse redundantes rápidamente:

// Wrap everything in try...catch
try 
  if (isset(some.nested.deeper)) 
    // ...
  
 catch (e) 

try 
  if (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 …

  1. Suponga que solo está verificando si la variable no está indefinida, lo cual está bien para algunos casos de uso, pero aún puede arrojar un error
  2. Suponga que solo está intentando acceder a una propiedad de nivel superior, lo que nuevamente está bien para algunos casos de uso
  3. Obligarlo a usar un enfoque menos que ideal en relación con PHP isset()

    p.ej isset(some, 'nested.deeper.value')

  4. Usar eval() que funciona pero yo personalmente evito

Creo que cubrí mucho de eso. Hay algunos puntos que hago en mi respuesta que no menciono porque, aunque relevantes, no son parte de la pregunta (por ejemplo, cortocircuitos). Sin embargo, si es necesario, puedo actualizar mi respuesta con enlaces a algunos de los aspectos más técnicos según la demanda.

Pasé mucho tiempo en esto, así que espero que ayude a la gente.

¡Gracias por leer!

Referencia a FUENTE

    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 

  return true

phpjs.org se ha retirado en su mayoría a favor de locutus Aquí está el nuevo enlace http://locutus.io/php/var/isset

No se te olvide dar difusión a esta crónica si lograste el éxito.

¡Haz clic para puntuar esta entrada!
(Votos: 0 Promedio: 0)



Utiliza Nuestro Buscador

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *