Como faço para verificar no JavaScript se existe um valor em um determinado índice de matriz?

Isso funcionará para testar se um valor na posição "índice" existe ou não ou se existe uma maneira melhor:

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

Conceitualmente, matrizes em JavaScript contêm array.lengthelementos, começando com array[0]até array[array.length - 1]. Um elemento da matriz com índice ié definido para fazer parte da matriz, se iestiver entre 0e array.length - 1inclusive. Se eu não estiver nesse intervalo, não está no array.

Portanto, por conceito, as matrizes são lineares, começando com zero e indo ao máximo, sem nenhum mecanismo para ter "lacunas" dentro desse intervalo em que não existem entradas. Para descobrir se existe um valor em um determinado índice de posição (onde o índice é 0 ou um número inteiro positivo), você literalmente apenas usa

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

Agora, os mecanismos JavaScript quase certamente não alocam o espaço da matriz de maneira linear e contígua assim, pois não faria muito sentido em uma linguagem dinâmica e seria ineficiente para determinado código. Provavelmente são tabelas de hash ou alguma mistura híbrida de estratégias, e intervalos indefinidos da matriz provavelmente não recebem sua própria memória. No entanto, JavaScript, a linguagem deseja apresentar matrizes de array.length n como tendo n membros e elas são nomeadas de 0 a n-1 , e qualquer coisa nesse intervalo faz parte da matriz.

O que você provavelmente deseja, no entanto, é saber se um valor em uma matriz é realmente algo definido - ou seja, não é undefined. Talvez você queira saber se está definido e nãonull . É possível adicionar membros a uma matriz sem nunca definir seu valor: por exemplo, se você adicionar valores de matriz aumentando a array.lengthpropriedade, quaisquer novos valores serão undefined.

Para determinar se um determinado valor é significativo ou foi definido. Ou seja, não undefined , ou null:

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

ou

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

Curiosamente, por causa das regras de comparação do JavaScript, meu último exemplo pode ser otimizado para isso:

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

Não podemos simplesmente fazer isso:

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

Usar apenas .lengthnão é seguro e causará um erro em alguns navegadores. Aqui está uma solução melhor:

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

ou, podemos usar:

Object.keys(__array__).length

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

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

Abordagem curta e universal

Se você deseja verificar qualquer matriz se ela tiver valores falsos (como cadeias de caracteres falsas, indefinidas, nulas ou vazias), basta usar todos os métodos () como este:

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

Por exemplo:

['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

Se você precisar obter um primeiro índice de valor falso, poderá fazer o seguinte:

let falsyIndex; 

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

Se você só precisa verificar um valor falso de uma matriz para um determinado índice, basta fazer o seguinte:

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'
}

Se você quer dizer com 'Nulo' -> Seus elementos são nulos ou iguais a '', neste caso: Verifique se a matriz está vazia depois de filtrar todos os elementos 'nulos'

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

Obviamente, adicione o método Clean antes:

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

Eu recomendaria criar uma função como esta:

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

Você poderia chamar assim:

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

Forçar o desenvolvedor a aderir à interface isEmptyEl detectará erros de entrada, como variáveis ​​indefinidas arrayName ou indexVal.

Geralmente, é uma boa prática programar defensivamente ao programar em Javascript.

Você receberia um erro como este se arrayName não estivesse definido:

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 semelhantes para um indexVal indefinido.

Você receberá um erro se os valores da matriz ou do índice não existirem.

Para entrada válida, você só obterá um valor verdadeiro se arrayName [indexVal] for um dos seguintes:

• nulo
• Indefinido
• NaN
• seqüência vazia
• 0 0
• falso

Depende do que você quer dizer com "vazio".

Quando você tenta obter o valor de uma propriedade em um objeto que não possui nenhuma propriedade com esse nome, você obtém o valor undefined .

É o que acontece com matrizes esparsas: nem todos os índices entre 0e array.length-1existem.

Então você pode verificar se array[index] === undefined.

No entanto, a propriedade indexpoderia existir com um undefinedvalor. Se você deseja filtrar esse caso, pode usar o inoperador ou hasOwnProperty, conforme descrito em Como verifico se um objeto tem uma propriedade em JavaScript?

index in array;
array.hasOwnProperty(index);

Se você quiser considerar uma propriedade existente com um valor undefinedou nullinexistente, poderá usar a comparação livre array[index] == undefinedou array[index] == null.

Se você souber que a matriz não é esparsa, você pode comparar indexcom array.length. Mas, para estar seguro, convém garantir que indexrealmente seja um índice de matriz, consulte Verificar se o nome da propriedade é índice de matriz

OK, vamos primeiro ver o que aconteceria se um valor de matriz não existisse em JavaScript, portanto, se tivermos uma matriz como a seguir:

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

e agora verificamos se 6 existe no índice 5 ou não:

arr[5];

e nós temos undefined...

Então isso é basicamente a resposta, a melhor maneira de verificar se não está definido, algo assim:

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

É melhor NÃO fazer isso neste caso:

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

Porque imagine que temos essa matriz:

const arr = [0, 1, 2];

e fazemos:

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

Então, como você vê, mesmo o 0 está lá, ele não é reconhecido, existem poucas outras coisas que podem fazer o mesmo e torná-lo um buggy de aplicativo; portanto, tenha cuidado, listo todos eles:

1. indefinido : se o valor não estiver definido e forundefined
2. null : se for nulo, por exemplo, se um elemento DOM não existir ...
3. seqüência vazia :''
4. 0 0 : número zero
5. NaN : não é um número
6. falso

Gostaria de salientar algo que alguns parecem ter perdido: ou seja, é possível ter uma posição de matriz "vazia" no meio da matriz. Considere o seguinte:

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

A maneira natural de verificar seria então ver se o membro da matriz é indefinido. Não tenho certeza se existem outras maneiras.

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

tente isso se o array [index] for nulo

if (array[index] != null) 

Com o Lodash, você pode fazer:

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

if(_.has(req,'documents'))é verificar se nosso objeto de solicitação tem uma propriedade nomeada documentse se possui esse suporte, o próximo if (req.documents.length)é validar se não é uma matriz vazia, para que outras coisas forEachpossam ser prosseguidas.

Para verificar se ele nunca foi definido ou se foi excluído:

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

também funciona com matrizes associativas e matrizes nas quais você excluiu algum índice

Para verificar se ele nunca foi definido, foi excluído OU é um valor vazio nulo ou lógico (NaN, sequência vazia, false):

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

Corri para esse problema usando tabelas de dados laravel. Eu estava armazenando um valor JSON chamadoproperties em um log de atividades e queria mostrar um botão com base nesse valor vazio ou não.

Bem, as tabelas de dados estavam interpretando isso como uma matriz, se estivesse vazia, e um objeto, se não estivesse, portanto, a seguinte solução funcionou para mim:

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

Um objeto não possui uma propriedade length.

Penso que esta decisão é apropriada para indivíduos que preferem a programação funcional declarativa ao invés da OOP imperativa ou do procedimento. Se sua pergunta for " Existe algum valor interno? (Um valor verdadeiro ou falso)", você pode usar o .somemétodo para validar os valores internos.

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

• Não é perfeito, mas não requer a aplicação de nenhuma função extra que contenha a mesma lógica function isEmpty(arr) { ... }.
• Ainda soa melhor que "Tem comprimento zero?" quando fazemos isso, [].lengthresultando em0 o que é perigoso em alguns casos.
• Ou até mesmo esse [].length > 0ditado "Seu comprimento é maior que zero?"

Exemplos avançados:

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

Você pode usar a biblioteca Loadsh para fazer isso de forma mais eficiente, como:

se você tiver uma matriz chamada "animais de estimação", por exemplo:

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 os valores da matriz para valores nulos ou 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>

Veja mais exemplos em http://underscorejs.org/