Comment vérifier si l'élément de tableau existe ou non en javascript?

Je travaille avec Titanium, mon code ressemble à ceci:

var currentData = new Array();

if(currentData[index]!==""||currentData[index]!==null||currentData[index]!=='null')
{
    Ti.API.info("is exists  " + currentData[index]);
    return true;
}
else
{   
    return false;
}

Je passe un index au tableau currentData. Je ne parviens toujours pas à détecter un élément inexistant à l'aide du code ci-dessus.

Utilisation typeof arrayName[index] === 'undefined'

c'est à dire

if(typeof arrayName[index] === 'undefined') {
    // does not exist
}
else {
    // does exist
}

var myArray = ["Banana", "Orange", "Apple", "Mango"];

if (myArray.indexOf(searchTerm) === -1) {
  console.log("element doesn't exist");
}
else {
  console.log("element found");
}

Quelqu'un, s'il vous plaît, corrigez-moi si je me trompe, mais AFAIK, ce qui suit est vrai:

1. Les tableaux ne sont vraiment que des objets sous le capot de JS
2. Ainsi, ils ont la méthode prototype hasOwnProperty"héritée" deObject
3. dans mes tests, hasOwnPropertypeut vérifier si quelque chose existe à un index de tableau.

Donc, tant que ce qui précède est vrai, vous pouvez simplement:

const arrayHasIndex = (array, index) => Array.isArray(array) && array.hasOwnProperty(index);

usage:

arrayHasIndex([1,2,3,4],4); les sorties: false

arrayHasIndex([1,2,3,4],2); les sorties: true

J'ai dû envelopper la réponse de techfoobar dans un bloc try.. catch, comme ceci:

try {
  if(typeof arrayName[index] == 'undefined') {
    // does not exist
  }
  else {
  // does exist
  }
} 
catch (error){ /* ignore */ }

... c'est de cette façon que cela fonctionnait dans le chrome (sinon, le code s'est arrêté avec une erreur).

Si les éléments du tableau sont également des objets ou des tableaux simples, vous pouvez utiliser une fonction:

// search object
var element = { item:'book', title:'javasrcipt'};

[{ item:'handbook', title:'c++'}, { item:'book', title:'javasrcipt'}].some(function(el){
    if( el.item === element.item && el.title === element.title ){
        return true; 
     } 
});

[['handbook', 'c++'], ['book', 'javasrcipt']].some(function(el){
    if(el[0] == element.item && el[1] == element.title){
        return true;
    }
});

Considérez le tableau a:

var a ={'name1':1, 'name2':2}

Si vous voulez vérifier si 'name1' existe dans a, testez-le simplement avec in:

if('name1' in a){
console.log('name1 exists in a')
}else
console.log('name1 is not in a')

Si vous utilisez underscore.js, ce type de vérification nulle et non définie est masqué par la bibliothèque.

Donc, votre code ressemblera à ceci -

var currentData = new Array();

if (_.isEmpty(currentData)) return false;

Ti.API.info("is exists  " + currentData[index]);

return true;

Cela semble beaucoup plus lisible maintenant.

Un moyen simple de vérifier que l'article existe ou non

Array.prototype.contains = function(obj) {
    var i = this.length;
    while (i--)
       if (this[i] == obj)
       return true;
    return false;
}

var myArray= ["Banana", "Orange", "Apple", "Mango"];

myArray.contains("Apple")

À mon avis, cette méthode est la plus simple.

var nameList = new Array('item1','item2','item3','item4');

// Using for loop to loop through each item to check if item exist.

for (var i = 0; i < nameList.length; i++) {
if (nameList[i] === 'item1') 
{   
   alert('Value exist');
}else{
   alert('Value doesn\'t exist');
}

Et peut-être une autre façon de le faire est.

nameList.forEach(function(ItemList)
 {
   if(ItemList.name == 'item1')
        {
          alert('Item Exist');
        }
 }

var demoArray = ['A','B','C','D'];
var ArrayIndexValue = 2;
if(ArrayIndexValue in demoArray){
   //Array index exists
}else{
   //Array Index does not Exists
}

Si vous cherchez quelque chose comme ça.

Voici l'extrait suivant

var demoArray = ['A','B','C','D'];
var ArrayIndexValue = 2;
if(demoArray.includes(ArrayIndexValue)){
alert("value exists");
   //Array index exists
}else{
alert("does not exist");
   //Array Index does not Exists
}

vous pouvez simplement utiliser ceci:

var tmp = ['a', 'b'];
index = 3 ;
if( tmp[index]){
    console.log(tmp[index] + '\n');
}else{
    console.log(' does not exist');
}

(typeof files[1] === undefined)?
            this.props.upload({file: files}):
            this.props.postMultipleUpload({file: files widgetIndex: 0, id})

Vérifiez si le deuxième élément du tableau n'est pas défini à l'aide de typeofet en vérifiantundefined

Lorsque vous essayez de savoir si un index de tableau existe dans JS, le moyen le plus simple et le plus court de le faire consiste à effectuer une double négation.

let a = [];
a[1] = 'foo';
console.log(!!a[0])   // false
console.log(!!a[1])   // true

C'est exactement à cela que insert l' opérateur. Utilisez-le comme ceci:

if (index in currentData) 
{ 
    Ti.API.info(index + " exists: " + currentData[index]);
}

La réponse acceptée est fausse, elle donnera un faux négatif si la valeur à indexest undefined:

const currentData = ['a', undefined], index = 1;

if (index in currentData) {
  console.info('exists');
}
// ...vs...
if (typeof currentData[index] !== 'undefined') {
  console.info('exists');
} else {
  console.info('does not exist'); // incorrect!
}

const arr = []

typeof arr[0] // "undefined"

arr[0] // undefined

Si expression booléenne

typeof arr[0] !== typeof undefined

est vrai alors 0 est contenu dans arr

Cela fonctionne également très bien, en testant par type contre undefined.

if (currentData[index] === undefined){return}

Tester:

const fruits = ["Banana", "Orange", "Apple", "Mango"];

if (fruits["Raspberry"] === undefined){
  console.log("No Raspberry entry in fruits!")
}