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

¿Funcionará esto para probar si existe o no un valor en el “índice” de posición, o existe una mejor manera de hacerlo?

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

Todas las matrices en JavaScript contienen elementos array.length , comenzando con array[0] hasta array[array.length - 1] . Por definición, se dice que un elemento de matriz con índice i es parte de la matriz si i array.length - 1 entre 0 y array.length - 1 inclusive.

Es decir, las matrices de JavaScript son lineales, comenzando con cero y yendo a un máximo, y las matrices no tienen un mecanismo para excluir ciertos valores o rangos de la matriz. Para saber si existe un valor en un índice de posición dado (donde el índice es 0 o un entero positivo), simplemente utiliza literalmente

 if (index < array.length) { // do stuff } 

Sin embargo, es posible que algunos valores de matriz sean nulos, undefined , NaN , Infinity , 0 o una gran cantidad de valores diferentes. Por ejemplo, si agrega valores de matriz al boost la propiedad array.length , los valores nuevos no estarán undefined .

Para determinar si un valor dado es algo significativo, o ha sido definido. Es decir, no está 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 se puede optimizar hasta:

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

¿No podemos simplemente hacer esto?

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

Usar solo .length no 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 } 
 if(typeof arr ==='object' && arr instanceof Array ){ if(!arr.length){ println 'empty' }else{ printn 'not Empty' } }else{ println 'Null' } 

Si te refieres a ‘Nulo’ -> Sus elementos son nulos o iguales a ”, en este caso: Comprueba 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!='')})} 

Enfoque corto y universal

Si desea verificar cualquier matriz si tiene valores falsy (como false, undefined, null o cadenas vacías), puede simplemente 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 } 

Yo 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 tales como un undefined arrayName o variables indexVal.

(En general, es una buena práctica progtwigr defensivamente cuando se progtwig en Javascript).

Se obtendría un error como este si arrayName no se definió:

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

Resultados similares para un indexVal indefinido.

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

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

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

Depende de lo que quieras decir con “vacío”.

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

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

Entonces, puedes verificar si array[index] === undefined .

Sin embargo, el index propiedad podría existir con un valor undefined . Si desea filtrar este caso, puede usar el operador in o hasOwnProperty , tal como se describe en ¿Cómo hasOwnProperty si un objeto tiene una propiedad en JavaScript?

 index in array; array.hasOwnProperty(index); 

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

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

intente esto si array [index] es nulo

 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 para verificar si nuestro objeto de solicitud tiene una propiedad llamada documents y si tiene ese apoyo, el siguiente if (req.documents.length) es validar si no es un matriz vacía, por lo que las otras cosas como forEach se pueden continuar.

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 borraste algún índice

Para comprobar si nunca se ha definido, 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 las tablas de datos laravel. Estaba almacenando un valor JSON llamado properties en un registro de actividad y quería mostrar un botón basado en que este valor esté vacío o no.

Bueno, datatables interpretaba esto como una matriz si estaba vacía, y un objeto si no lo era, 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.

Bien, veamos primero qué pasarí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 comprobamos si 6 está en el índice 5 o no:

 arr[5]; 

y nos volvemos undefined

Así que básicamente eso nos da la respuesta, la mejor manera de verificar si no está definido, entonces 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 este conjunto:

 const arr = [0, 1, 2]; 

y lo hacemos:

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

Como ve, incluso 0 está allí, no se reconoce, hay algunas otras cosas que pueden hacer lo mismo y hacer que su aplicación falle, así que tenga cuidado, los anoté todos:

  1. indefinido : si el valor no está definido y no está undefined
  2. null : si es nulo, por ejemplo, si un elemento DOM no existe …
  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 haberse perdido: 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 } 

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