web-dev-qa-db-fra.com

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

Cela fonctionnera-t-il pour vérifier si une valeur à la position "index" existe ou non, ou s'il existe un meilleur moyen:

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

Tous les tableaux en JavaScript contiennent des éléments array.length, commençant par array[0] jusqu'à array[array.length - 1]. Par définition, un élément de tableau d'indice i est considéré comme faisant partie du tableau si i est compris entre 0 et array.length - 1 inclus.

C'est-à-dire que les tableaux JavaScript sont linéaires, allant de zéro à maximum, et qu'ils 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 littéralement

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

Cependant il est possible que certaines valeurs de tableau soient nulles, undefined, NaN, Infinity, 0 , ou toute une foule de valeurs différentes. Par exemple, si vous ajoutez des valeurs de tableau en augmentant la propriété array.length, toutes les nouvelles valeurs seront undefined.

Déterminer si une valeur donnée a un sens ou si elle a été définie. C'est-à-dire notundefined 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é de la manière suivante:

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

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
}
350
madi

Utiliser uniquement .length n'est pas sans danger et entraînera une erreur de certains navigateurs. Voici une meilleure solution:

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

ou, nous pouvons utiliser:

Object.keys(__array__).length
40
Joni
if(!arrayName[index]){
     // do stuff
}
20
x2.
if(arrayName.length > index && arrayName[index] !== null) {
    //arrayName[index] has a value
}
8
Rex M

approche courte et universelle

Si vous voulez vérifier n'importe quel tableau s'il a des valeurs faussement (comme des chaînes fausses, non définies, nulles ou vides), vous pouvez simplement utiliser chaque méthode () comme cette:

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 index de valeur de fausseté, 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 falsy 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
}
8
indreed
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 sont égaux à '', dans ce cas: Vérifiez si le tableau est vide après avoir filtré tous les éléments 'nuls'

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

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

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

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

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

Vous pourriez l'appeler comme ça:

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

Forcer le développeur à adhérer à l'interface isEmptyEl interceptera les erreurs de saisie telles que les variables non définies arrayName ou indexVal.

(C'est généralement une bonne pratique de programmer de manière 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 du tableau ou de l'index n'existent pas.

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

  • nul
  • undefined
  • NaN
  • chaîne vide
  • false
5
l3x

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

Lorsque vous essayez d'obtenir 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 produit avec les tableaux épars: tous les index entre 0 et array.length-1 n'existent pas.

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

Cependant, la propriété index peut exister avec une valeur undefined. Si vous souhaitez filtrer ce cas, vous pouvez utiliser l'opérateur in 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 une propriété existante avec une valeur undefined ou null inexistante, vous pouvez utiliser la comparaison lâche array[index] == undefined ou array[index] == null.

Si vous savez que le tableau n'est pas fragmenté, vous pouvez comparer index avec array.length. Mais pour plus de sécurité, vous pouvez vous assurer que index est vraiment un index de tableau, voir Vérifier si le nom de la propriété est un index de tablea

5
Oriol

Pour vérifier si cela 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, si elle a été supprimée OR est une valeur vide ou vide (NaN, chaîne vide, false):

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

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

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

et maintenant nous vérifions si 6 est là à l'index 5 ou pas:

arr[5];

et nous obtenons undefined...

Donc, en gros, donnez-nous la réponse, la meilleure façon de vérifier si elle n'est pas définie, quelque chose comme ceci:

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

C'est mieux PAS faire ceci dans ce cas:

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

Car imaginons 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 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ée, alors faites attention, je les énumère toutes:

  1. non défini: si la valeur n'est pas définie et que c'est undefined
  2. null: si c'est null, par exemple si un élément DOM n'existe pas ...
  3. chaîne vide: ''
  4. : numéro zéro
  5. NaN: pas un nombre
  6. false
0
Alireza

Je pense que cette décision est appropriée pour les gars qui préfèrent la programmation fonctionnelle déclarative à l'impératif OOP ou à la procédure. Si votre question est "Y a-t-il des valeurs à l'intérieur? (une valeur de vérité ou de fausseté)" , vous pouvez utiliser .some mé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 "sa longueur est-elle nulle?" quand on fait ceci [].length résultant en 0 qui est dangereux en certains cas.
  • Ou même ceci [].length > 0 disant "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
0
Purkhalo Alex

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 requête a une propriété nommée documents et s'il a cette propriété, la prochaine if (req.documents.length) doit valider si ce n'est pas un tableau vide, donc les autres comme forEach peut être poursuivi.

0
Pristine Kallio

J'aimerais 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

La manière naturelle 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
}
0
Benoit Ranque

essayez ceci si array [index] est null

if (array[index] != null)
0
Kishan

J'ai rencontré ce problème en utilisant laravel datatables. Je stockais une valeur JSON appelée properties dans un journal d'activité et je voulais afficher un bouton basé sur le fait que cette valeur soit vide ou non.

Eh bien, datatables interprétait 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é de longueur.

0
kjdion84