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

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

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

Conceptuellement, les tableaux en JavaScript contiennent des array.lengthéléments, en commençant array[0]par jusqu'à array[array.length - 1]. Un élément de tableau avec index iest défini pour faire partie du tableau s'il iest compris entre 0et array.length - 1inclus. Si i n'est pas dans cette plage, ce n'est pas dans le tableau.

Donc, par concept, les tableaux sont linéaires, commençant par zéro et allant au maximum, sans aucun mécanisme pour avoir des "espaces" à l'intérieur de cette plage où aucune entrée n'existe. Pour savoir si une valeur existe à un index de position donné (où index est 0 ou un entier positif), vous utilisez littéralement

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

Maintenant, sous le capot, les moteurs JavaScript n'alloueront certainement pas l'espace de tableau de manière linéaire et contiguë comme ceci, car cela n'aurait pas beaucoup de sens dans un langage dynamique et serait inefficace pour certains codes. Ce sont probablement des tables de hachage ou un mélange hybride de stratégies, et les plages non définies du tableau ne sont probablement pas affectées à leur propre mémoire. Néanmoins, JavaScript, le langage veut présenter les tableaux de array.length n comme ayant n membres et ils sont nommés de 0 à n - 1 , et tout ce qui se trouve dans cette plage fait partie du tableau.

Ce que vous voulez probablement, cependant, c'est de savoir si une valeur dans un tableau est réellement quelque chose de défini - c'est-à-dire que ce n'est pas le cas undefined. Peut-être que vous voulez même savoir si c'est défini et nonnull . Il est possible d'ajouter des membres à un tableau sans jamais définir leur valeur: par exemple, si vous ajoutez des valeurs de tableau en augmentant la array.lengthpropriété, toutes les nouvelles valeurs le seront undefined.

Déterminer si une valeur donnée est significative ou a été définie. Ce n'est pas undefined , ou null:

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

ou

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

Fait intéressant, en raison des règles de comparaison de JavaScript, mon dernier exemple peut être optimisé jusqu'à ceci:

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

Ne pouvons-nous pas simplement faire ceci:

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

Utiliser uniquement .lengthn'est pas sûr et provoquera 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

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

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

Approche courte et universelle

Si vous souhaitez vérifier un tableau s'il contient des valeurs fausses (comme des chaînes fausses, non définies, nulles ou vides), vous pouvez simplement utiliser la méthode every () 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 devez obtenir un premier indice de valeur de falsification, 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 la valeur falsifiée d'un tableau pour un index donné, vous pouvez le faire comme ceci:

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 vous entendez 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 sûr, ajoutez la méthode Clean avant:

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

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

Forcer le développeur à adhérer à l'interface isEmptyEl interceptera les erreurs d'entrée telles que les 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 comme celle-ci 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)

Des résultats similaires pour un indexVal non défini.

Vous obtenez 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'un des éléments suivants:

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

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 pas de propriété avec ce nom, vous obtiendrez la valeur undefined .

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

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

Cependant, la propriété indexpeut exister avec une undefinedvaleur. Si vous souhaitez filtrer ce cas, vous pouvez utiliser l' inopérateur ou hasOwnProperty, comme décrit dans Comment vérifier si un objet a une propriété en JavaScript?

index in array;
array.hasOwnProperty(index);

Si vous souhaitez considérer qu'une propriété existante avec une valeur undefinedou nulln'existe pas, vous pouvez utiliser la comparaison lâche array[index] == undefinedouarray[index] == null .

Si vous savez que le tableau n'est pas rare, vous pouvez comparer indexavec array.length. Mais pour être sûr, vous pouvez vous assurer qu'il indexs'agit bien d'un index de tableau, voir Vérifier si le nom de la propriété est un index de tableau

OK, voyons d'abord ce qui se passerait si une valeur de tableau n'existe pas en JavaScript, donc si nous avons un tableau comme ci-dessous:

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

et maintenant on vérifie si 6 est là ou non à l'indice 5 :

arr[5];

et nous obtenons undefined...

Donc, c'est essentiellement nous donner la réponse, la meilleure façon de vérifier si non défini, donc quelque chose comme ceci:

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

Il vaut mieux NE PAS faire cela dans ce cas:

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

Imaginez que nous ayons ce tableau:

const arr = [0, 1, 2];

et nous faisons:

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

Donc, comme vous le voyez, même 0 est là, il n'est pas reconnu, il y a peu d'autres choses qui peuvent faire la même chose et vous rendre bogué, alors faites attention, je les énumère toutes:

1. non défini : si la valeur n'est pas définie et qu'il estundefined
2. null : s'il est nul, par exemple si un élément DOM n'existe pas ...
3. chaîne vide :''
4. 0 : numéro zéro
5. NaN : pas un nombre
6. faux

Je voudrais souligner quelque chose que quelques-uns semblent avoir manqué: à savoir qu'il est possible d'avoir une position de tableau "vide" au milieu de votre tableau. Considérer ce qui suit:

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

Le moyen naturel de vérifier serait alors de voir si le membre du tableau n'est pas défini, je ne suis pas sûr qu'il existe d'autres moyens

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

essayez ceci si le tableau [index] est nul

if (array[index] != null) 

Avec Lodash, vous pouvez faire:

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

if(_.has(req,'documents'))est de vérifier si notre objet de demande a une propriété nommée documentset s'il a cet accessoire, le prochain if (req.documents.length)est de valider s'il ne s'agit pas d'un tableau vide, afin que les autres éléments comme forEachpuissent être poursuivis.

Pour vérifier s'il n'a jamais été défini ou s'il a été supprimé:

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

fonctionne également avec les tableaux associatifs et les tableaux où vous avez supprimé certains index

Pour vérifier si elle n'a jamais été définie, a été supprimée OU est une valeur vide nulle ou logique (NaN, chaîne vide, false):

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

J'ai rencontré ce problème en utilisant des tables de données laravel. Je stockais une valeur JSON appelée propertiesdans un journal d'activité et je voulais afficher un bouton basé sur cette valeur étant vide ou non.

Eh bien, les tables de données interprétaient cela comme un tableau s'il était vide et un objet s'il ne l'était pas, par conséquent, la solution suivante a fonctionné pour moi:

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

Un objet n'a pas de propriété length.

Je pense que cette décision est appropriée pour les gars qui préfèrent la programmation fonctionnelle déclarative à la POO impérative ou à la procédure. Si votre question est " Y a-t-il des valeurs à l'intérieur? (Une valeur véridique ou fausse)", vous pouvez utiliser la .someméthode pour valider les valeurs à l'intérieur.

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

• Ce n'est pas parfait mais il ne nécessite pas d'appliquer de fonction supplémentaire contenant la même logique, comme function isEmpty(arr) { ... }.
• Cela sonne toujours mieux que "Est-ce une longueur nulle?" lorsque nous faisons cela [].lengthrésultant 0qui est dangereux dans certains cas.
• Ou même ce [].length > 0dicton "sa longueur est-elle supérieure à zéro?"

Exemples avancés:

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

Vous pouvez utiliser la bibliothèque Loadsh pour le faire plus efficacement, comme:

si vous avez un tableau nommé "pets", par exemple:

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

Pour vérifier toutes les valeurs de tableau pour les valeurs nulles ou non définies:

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>

Consultez d'autres exemples sur http://underscorejs.org/