Comment puis-je vérifier en JavaScript si une valeur existe à un certain index du tableau?

Question

Est-ce que cela fonctionnera pour tester si une valeur à la position index existe ou non, ou y a-t-il une meilleure façon de le faire :

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

Answer 1

Approche courte et universelle

Si vous voulez vérifier si un tableau a des valeurs fausses (comme false, undefined, null ou des chaînes vides), vous pouvez simplement utiliser la méthode every() de cette façon :

array.every(function(element) {return !!element;}); // retourne true ou false

Par exemple :

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

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

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

Si vous avez besoin d'obtenir le premier index de la valeur fausse, vous pouvez le faire comme ceci :

let falsyIndex; 

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

Si vous avez juste besoin de vérifier si une valeur fausse d'un tableau pour un index donné, vous pouvez le faire ainsi :

if (!!array[index]) {
  // array[index] est une valeur correcte
}
else {
  // array[index] est une valeur fausse
}

Answer 2

if(typeof arr ==='object' && arr instanceof Array ){
   if(!arr.length){
      println 'vide'
   }else{
      printn 'non vide'
   }

}else{
   println 'Null'
}

If you mean by 'Null' -> Ses éléments sont nuls ou égaux à '' , dans ce cas : Vérifiez si le tableau est vide après avoir filtré tous les éléments 'null'

if(!arr.clean().length){return 'est nul'}

Bien sûr, ajoutez la méthode Clean avant :

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

Answer 3

Cela dépend de ce que vous entendez par "vide".

Lorsque vous essayez de récupérer la valeur d'une propriété sur un objet qui n'a pas de propriété portant ce nom, vous obtenez la valeur undefined.

C'est ce qui se passe avec les tableaux clairsemés : tous les indices entre 0 et array.length-1 n'existent pas.

Vous pourriez donc vérifier si array[index] === undefined.

Cependant, la propriété index pourrait exister avec une valeur undefined. Si vous voulez filtrer ce cas, vous pouvez utiliser l'opérateur in ou hasOwnProperty, comme décrit dans Comment vérifier si un objet possède une propriété en JavaScript?

index in array;
array.hasOwnProperty(index);

Si vous voulez considérer qu'une propriété existante avec une valeur undefined ou null n'existe pas, vous pouvez utiliser la comparaison lâche array[index] == undefined ou array[index] == null.

Si vous savez que le tableau n'est pas clairsemé, vous pouvez comparer index avec array.length. Mais pour être sûr, vous voudrez peut-être vérifier que index est vraiment un index de tableau, voir Vérifier si le nom de la propriété est un index de tableau

Answer 4

Je recommanderais de créer une fonction comme ceci :

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

Vous pourriez l'appeler comme ceci :

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

Forcer le développeur à respecter l'interface de isEmptyEl permettra de détecter les erreurs de saisie telles que des variables arrayName ou indexVal non définies.

(Il est généralement recommandé de programmer de manière défensive lors de la programmation en Javascript.)

Vous obtiendriez une erreur jetée comme ceci si arrayName n'était pas défini :

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)

Résultats similaires pour un indexVal non défini.

Vous obtiendrez une erreur si les valeurs de tableau ou d'index n'existent pas.

Pour une entrée valide, vous n'obtiendrez un vrai que si arrayName[indexVal] est l'une des suivantes :

• null
• undefined
• NaN
• chaîne vide
• 0
• false

Answer 5

Je voudrais souligner quelque chose que quelques-uns semblent avoir manqué : il est en effet possible d'avoir une position "vide" dans votre tableau. Considérez ce qui suit :

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

delete arr[3]

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

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

La façon naturelle de vérifier serait alors de voir si le membre du tableau est indéfini, je ne suis pas sûr si d'autres moyens existent

if (arr[index] === undefined) {
  // le membre n'existe pas
}