Come verificare se l'elemento array esiste o no in JavaScript?

Sto lavorando con Titanium, il mio codice è simile al seguente:

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

Sto passando un indice all'array currentData. Non riesco ancora a rilevare un elemento inesistente usando il codice sopra.

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

vale a 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");
}

Qualcuno, per favore, mi corregga se sbaglio, ma AFAIK è vero quanto segue:

1. Gli array sono davvero solo oggetti sotto il cofano di JS
2. Pertanto, hanno il metodo prototipo hasOwnProperty"ereditato" daObject
3. nel mio test, hasOwnPropertyposso verificare se esiste qualcosa in un indice di array.

Quindi, fintanto che quanto sopra è vero, puoi semplicemente:

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

utilizzo:

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

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

Ho dovuto racchiudere la risposta di techfoobar in un blocco try.. catch, in questo modo:

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

... è così che ha funzionato in Chrome, comunque (altrimenti, il codice si è fermato con un errore).

Se gli elementi dell'array sono anche semplici oggetti o array, è possibile utilizzare alcune funzioni:

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

Considera l'array a:

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

Se vuoi verificare se 'nome1' esiste in a, prova semplicemente con in:

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

Se si utilizza underscore.js, questo tipo di controllo null e indefinito viene nascosto dalla libreria.

Quindi il tuo codice sarà simile a questo:

var currentData = new Array();

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

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

return true;

Sembra molto più leggibile ora.

Un modo semplice per verificare la presenza o meno dell'elemento

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")

Questo è il modo più semplice secondo me.

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

E forse un altro modo per farlo è.

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
}

Se stai cercando qualcosa del genere.

Ecco il seguente frammento

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
}

puoi semplicemente usare questo:

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

Controllare se il secondo elemento dell'array non è definito utilizzando typeofe controllandoundefined

Quando si cerca di scoprire se esiste un indice di array in JS, il modo più semplice e veloce per farlo è attraverso la doppia negazione.

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

Questo è esattamente ciò inche serve all'operatore. Usalo in questo modo:

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

La risposta accettata è errata, darà un falso negativo se il valore in indexè 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

Se espressione booleana

typeof arr[0] !== typeof undefined

è vero quindi 0 è contenuto in arr

Funziona anche bene, testando per tipo contro undefined.

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

Test:

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

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