¿Cómo verifico en JavaScript si existe un valor en un determinado índice de matriz?

¿Funcionará para probar si un valor en la posición "índice" existe o no, o hay una mejor manera?

if(arrayName[index]==""){
     // do stuff
}

Conceptualmente, las matrices en JavaScript contienen array.lengthelementos, comenzando array[0]por hasta array[array.length - 1]. Un elemento de matriz con índice ise define como parte de la matriz si iestá entre 0e array.length - 1incluye. Si no estoy en este rango, no está en la matriz.

Entonces, por concepto, las matrices son lineales, comenzando con cero y llegando a un máximo, sin ningún mecanismo para tener "espacios" dentro de ese rango donde no existen entradas. Para averiguar si existe un valor en un índice de posición dado (donde el índice es 0 o un entero positivo), literalmente solo usa

if (i >= 0 && i < array.length) {
  // it is in array
}

Ahora, bajo el capó, los motores de JavaScript casi seguramente no asignarán espacio de matriz de forma lineal y contigua de esta manera, ya que no tendría mucho sentido en un lenguaje dinámico y sería ineficiente para cierto código. Probablemente sean tablas hash o alguna combinación híbrida de estrategias, y los rangos indefinidos de la matriz probablemente no tengan asignada su propia memoria. Sin embargo, JavaScript, el lenguaje, quiere presentar matrices de array.length n que tengan n miembros y se denominen 0 a n - 1 , y cualquier cosa en este rango es parte de la matriz.

Sin embargo, lo que probablemente desee es saber si un valor en una matriz es realmente algo definido , es decir, no lo es undefined. Tal vez incluso quieras saber si está definido y nonull . Es posible agregar miembros a una matriz sin establecer su valor: por ejemplo, si agrega valores de matriz al aumentar la array.lengthpropiedad, se mostrarán los valores nuevos undefined.

Para determinar si un valor dado es algo significativo o si se ha definido. Es decir, no undefined , o null:

if (typeof array[index] !== 'undefined') {

o

if (typeof array[index] !== 'undefined' && array[index] !== null) {

Curiosamente, debido a las reglas de comparación de JavaScript, mi último ejemplo puede optimizarse para esto:

if (array[index] != null) {
  // The == and != operators consider null equal to only null or undefined
}  

¿No podemos hacer esto?

if(arrayName.length > 0){   
    //or **if(arrayName.length)**
    //this array is not empty 
}else{
   //this array is empty
}

Usar solo .lengthno es seguro y provocará un error en algunos navegadores. Aquí hay una mejor solución:

if(array && array.length){   
   // not empty 
} else {
   // empty
}

o podemos usar:

Object.keys(__array__).length

if(!arrayName[index]){
     // do stuff
}

if(arrayName.length > index && arrayName[index] !== null) {
    //arrayName[index] has a value
}

Enfoque corto y universal

Si desea verificar cualquier matriz si tiene valores falsos (como cadenas falsas, indefinidas, nulas o vacías), puede usar cada método () de esta manera:

array.every(function(element) {return !!element;}); // returns true or false

Por ejemplo:

['23', null, 2, {key: 'value'}].every(function(element) {return !!element;}); // returns false

['23', '', 2, {key: 'value'}].every(function(element) {return !!element;}); // returns false

['23', true, 2, {key: 'value'}].every(function(element) {return !!element;}); // returns true

Si necesita obtener un primer índice de valor falso, puede hacerlo así:

let falsyIndex; 

if(!['23', true, 2, null, {key: 'value'}].every(function(element, index) {falsyIndex = index; return !!element;})) {
  console.log(falsyIndex);
} // logs 3

Si solo necesita verificar un valor falso de una matriz para un índice dado, puede hacerlo así:

if (!!array[index]) {
  // array[index] is a correct value
}
else {
  // array[index] is a falsy value
}

if(typeof arr ==='object' && arr instanceof Array ){
   if(!arr.length){
      println 'empty'
   }else{
      printn 'not Empty'
   }

}else{
   println 'Null'
}

Si quiere decir con 'Nulo' -> Sus elementos son nulos o iguales a '', en este caso: Verifique si la matriz está vacía después de filtrar todos los elementos 'nulos'

if(!arr.clean().length){return 'is null'}

Por supuesto, agregue el método Clean antes:

Array.prototype.clean=function(){return this.filter(function(e){return (typeof  e !=='undefined')&&(e!= null)&&(e!='')})}

Recomendaría crear una función como esta:

function isEmptyEl(array, i) {
   return !(array[i]);
}

Podrías llamarlo así:

if (isEmptyEl(arrayName, indexVal)) {
   console.log('arrayName[' + indexVal + '] is empty');
}

Obligar al desarrollador a adherirse a la interfaz isEmptyEl detectará errores de entrada como un arrayName indefinido o variables indexVal.

(Generalmente es una buena práctica programar a la defensiva cuando se programa en Javascript).

Se generaría un error como este si no se definiera arrayName:

Uncaught ReferenceError: arrayName is not defined
    at <anonymous>:2:15
    at Object.InjectedScript._evaluateOn (<anonymous>:895:140)
    at Object.InjectedScript._evaluateAndWrap (<anonymous>:828:34)
    at Object.InjectedScript.evaluate (<anonymous>:694:21)

Resultados similares para un indexVal indefinido.

Obtiene un error si la matriz o los valores de índice no existen.

Para una entrada válida, solo obtendrá un verdadero si arrayName [indexVal] es cualquiera de los siguientes:

• nulo
• indefinido
• Yaya
• cuerda vacía
• 0 0
• falso

Depende de lo que quieras decir con "vacío".

Cuando intente obtener el valor de una propiedad en un objeto que no tiene propiedades con ese nombre, obtendrá el valor undefined.

Eso es lo que sucede con matrices dispersas: no todos los índices existen 0y array.length-1existen.

Para que puedas comprobar si array[index] === undefined.

Sin embargo, la propiedad indexpodría existir con un undefinedvalor. Si desea filtrar este caso, puede usar el inoperador o hasOwnProperty, como se describe en ¿Cómo verifico si un objeto tiene una propiedad en JavaScript?

index in array;
array.hasOwnProperty(index);

Si desea considerar que una propiedad existente con un valor undefinedo nullno existe, puede usar la comparación suelta array[index] == undefinedo array[index] == null.

Si sabe que la matriz no es escasa, puede comparar indexcon array.length. Pero para estar seguro, es posible que desee asegurarse de que indexrealmente sea un índice de matriz, consulte Verificar si el nombre de la propiedad es un índice de matriz

OK, primero veamos qué sucedería si no existiera un valor de matriz en JavaScript, así que si tenemos una matriz como la siguiente:

const arr = [1, 2, 3, 4, 5];

y ahora verificamos si 6 está en el índice 5 o no:

arr[5];

y obtenemos undefined...

Así que básicamente nos da la respuesta, la mejor manera de verificar si no está definida, así que algo como esto:

if("undefined" === typeof arrayName[index]) {
  //array value is not there...
}

Es mejor NO hacer esto en este caso:

if(!arrayName[index]) {
  //Don't check like this..
}

Porque imagina que tenemos esta matriz:

const arr = [0, 1, 2];

y hacemos:

if(!arr[0]) {
  //This get passed, because in JavaScript 0 is falsy
}

Entonces, como puede ver, incluso 0 está allí, no se reconoce, hay algunas otras cosas que pueden hacer lo mismo y hacer que la aplicación tenga errores, así que tenga cuidado, los enumero todos:

1. indefinido : si el valor no está definido y esundefined
2. nulo : si es nulo, por ejemplo, si no existe un elemento DOM ...
3. cadena vacía :''
4. 0 : número cero
5. NaN : no es un número
6. falso

Me gustaría señalar algo que algunos parecen haber pasado por alto: a saber, es posible tener una posición de matriz "vacía" en el medio de la matriz. Considera lo siguiente:

let arr = [0, 1, 2, 3, 4, 5]

delete arr[3]

console.log(arr)      // [0, 1, 2, empty, 4, 5]

console.log(arr[3])   // undefined

La forma natural de verificar sería ver si el miembro de la matriz no está definido, no estoy seguro si existen otras formas

if (arr[index] === undefined) {
  // member does not exist
}

intente esto si la matriz [índice] es nula

if (array[index] != null) 

Con Lodash, puedes hacer:

if(_.has(req,'documents')){
      if (req.documents.length)
      _.forEach(req.documents, function(document){
        records.push(document);
      });
} else {
}

if(_.has(req,'documents'))es verificar si nuestro objeto de solicitud tiene una propiedad llamada documentsy si tiene ese accesorio, el siguiente if (req.documents.length)es validar si no es una matriz vacía, para que forEachse puedan continuar con las otras cosas .

Para verificar si nunca se ha definido o si se eliminó:

if(typeof arrayName[index]==="undefined"){
     //the index is not in the array
}

también funciona con matrices asociativas y matrices donde eliminó algún índice

Para verificar si nunca se definió, se eliminó O es un valor vacío nulo o lógico (NaN, cadena vacía, falso):

if(typeof arrayName[index]==="undefined"||arrayName[index]){
     //the index is not defined or the value an empty value
}

Me encontré con este problema usando tablas de datos laravel. Estaba almacenando un valor JSON llamado propertiesen un registro de actividad y quería mostrar un botón basado en este valor vacío o no.

Bueno, datatables estaba interpretando esto como una matriz si estaba vacía, y un objeto si no lo estaba, por lo tanto, la siguiente solución funcionó para mí:

render: function (data, type, full) {
    if (full.properties.length !== 0) {
        // do stuff
    }
}

Un objeto no tiene una propiedad de longitud.

Creo que esta decisión es apropiada para los chicos que prefieren la programación funcional declarativa sobre la OOP imperativa o la procesal. Si su pregunta es " ¿Hay algunos valores dentro? (Un valor verdadero o falso)" puede usar el .somemétodo para validar los valores internos.

[].some(el => el || !el);

• No es perfecto, pero no requiere aplicar ninguna función adicional que contenga la misma lógica, como function isEmpty(arr) { ... }.
• Todavía suena mejor que "¿Es de longitud cero?" cuando hacemos esto, [].lengthlo 0que resulta peligroso en algunos casos.
• O incluso este [].length > 0dicho "¿Su longitud es mayor que cero?"

Ejemplos avanzados:

[    ].some(el => el || !el); // false
[null].some(el => el || !el); // true
[1, 3].some(el => el || !el); // true

Puede usar la biblioteca Loadsh para hacer esto de manera más eficiente, como:

si tiene una matriz llamada "mascotas", por ejemplo:

var pets = ['dog', undefined, 'cat', null];

console.log(_.isEmpty(pets[1])); // true
console.log(_.isEmpty(pets[3])); // true
console.log(_.isEmpty(pets[4])); // false

_.map( pets, (pet, index) => { console.log(index + ': ' + _.isEmpty(pet) ) });

Para verificar todos los valores de matriz para valores nulos o indefinidos:

var pets = ['dog', undefined, 'cat', null];

console.log(_.isEmpty(pets[1])); // true
console.log(_.isEmpty(pets[3])); // true
console.log(_.isEmpty(pets[4])); // false

_.map( pets, (pet, index) => { console.log(index + ': ' + _.isEmpty(pet) ) });

<script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min.js"></script>

Vea más ejemplos en http://underscorejs.org/