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


Cela fonctionnera-t-il pour tester si une valeur à la position "index" existe ou non, ou y a-t-il un meilleur moyen:

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

504
2018-04-20 03:41


origine


Réponses:


Tous les tableaux en JavaScript contiennent array.length éléments, en commençant par array[0] jusqu'à array[array.length - 1]. Par définition, un élément de tableau avec index i est dit faire partie du tableau si i est entre 0 et array.length - 1 compris.

Autrement dit, les tableaux JavaScript sont linéaires, commençant par zéro et allant jusqu'à un maximum, et les tableaux ne disposent pas d'un mécanisme permettant d'exclure certaines valeurs ou plages du tableau. Pour savoir si une valeur existe à un index de position donné (où index est 0 ou un entier positif), vous utilisez simplement

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

Cependant, il est possible pour certaines valeurs de tableau d'être nul, undefined, NaN, Infinity, 0, ou toute une série de valeurs différentes. Par exemple, si vous ajoutez des valeurs de tableau en augmentant le array.length propriété, toutes les nouvelles valeurs seront undefined.

Pour déterminer si une valeur donnée est significative ou a été définie. C'est, ne pas  undefined, ou null:

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

ou

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

Fait intéressant, grâce aux règles de comparaison de JavaScript, mon dernier exemple peut être optimisé pour:

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

713
2018-04-20 03:51



Ne pouvons-nous pas faire ceci:

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

351
2017-10-17 06:38



En utilisant seulement .length n'est pas sûr et causera une erreur dans certains navigateurs. Voici une meilleure solution:

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

ou, nous pouvons utiliser:

Object.keys(__array__).length

39
2017-08-18 08:18



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

20
2018-04-20 03:44



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

8
2018-04-20 03:44



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

}else{
   println 'Null'
}

Si vous voulez dire par '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 'is null'}

Bien sur, Ajouter Nettoyer  méthode avant:

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

6
2017-12-13 08:40



Approche courte et universelle

Si vous voulez vérifier n'importe quel tableau s'il a des valeurs falsifiées (comme les chaînes false, indéfinies, nulles ou vides), vous pouvez simplement utiliser chaque() méthode comme ceci:

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

Par exemple:

['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 vous avez besoin d'un premier indice de fausse valeur, 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);
} // logs 3

Si vous avez juste besoin de vérifier une valeur falsifiée d'un tableau pour un index donné, vous pouvez juste le faire comme ceci:

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

6
2018-01-19 08:41



Je recommanderais de créer une fonction comme celle-ci:

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

Vous pourriez l'appeler comme ceci:

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

En forçant le développeur à adhérer à l'interface isEmptyEl, les erreurs de saisie telles que les variables arrayName ou indexVal non définies seront interceptées.

(Il est généralement recommandé de programmer de façon défensive lors de la programmation en Javascript.)

Vous obtiendrez une erreur comme ceci si arrayName n'était pas défini:

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)

Résultats similaires pour un indexVal indéfini.

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

Pour une entrée valide, vous obtiendrez uniquement un vrai si arrayName [indexVal] est l'un des éléments suivants:

  • nul
  • indéfini
  • NaN
  • chaîne vide
  • 0
  • faux

5
2018-05-26 21:05



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

Lorsque vous essayez d'obtenir la valeur d'une propriété sur un objet qui n'a aucune propriété portant ce nom, vous obtiendrez la valeur undefined.

Voilà ce qui se passe avec les tableaux clairsemés: tous les indices entre 0 et array.length-1exister.

Donc, vous pouvez vérifier si array[index] === undefined.

Cependant, la propriété index pourrait exister avec un undefined valeur. Si vous souhaitez filtrer ce cas, vous pouvez utiliser le in opérateur ou hasOwnProperty, comme décrit dans Comment vérifier si un objet a une propriété dans JavaScript?

index in array;
array.hasOwnProperty(index);

Si vous voulez considérer une propriété existante avec un undefined ou null valeur pour ne pas exister, 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 pouvez vouloir vous assurer que index est vraiment un index de tableau, voir Vérifiez si le nom de la propriété est l'index du tableau


4
2017-08-26 17:20



essayez ceci si array [index] est null

if (array[index] != null) 

0
2018-03-04 12:51