¿Cómo verificar si el elemento de matriz existe o no en javascript?

Estoy trabajando con Titanium, mi código se ve así:

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

Estoy pasando un índice a la matriz currentData. Todavía no puedo detectar un elemento no existente usando el código anterior.

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

es decir

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

Alguien corríjame si estoy equivocado, pero AFAIK lo siguiente es cierto:

1. Las matrices son realmente solo objetos bajo el capó de JS
2. Por lo tanto, tienen el método prototipo hasOwnProperty"heredado" deObject
3. en mis pruebas, hasOwnPropertypuedo verificar si existe algo en un índice de matriz.

Entonces, siempre que lo anterior sea cierto, simplemente puede:

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

uso:

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

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

Tuve que ajustar la respuesta de techfoobar en un try.. catchbloque, así:

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

... así es como funcionaba en Chrome, de todos modos (de lo contrario, el código se detuvo con un error).

Si los elementos de la matriz también son objetos simples o matrices, puede usar alguna función:

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

Considere la matriz a:

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

Si desea verificar si 'name1' existe en a, simplemente pruébelo con in:

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

Si usa underscore.js, la biblioteca oculta este tipo de verificación nula e indefinida.

Entonces su código se verá así:

var currentData = new Array();

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

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

return true;

Parece mucho más legible ahora.

Manera simple de verificar si el artículo existe o no

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

Este camino es el más fácil en mi opinión.

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

Y tal vez otra forma de hacerlo es.

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 buscas algo como esto.

Aquí está el siguiente fragmento

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
}

simplemente puedes usar esto:

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

Compruebe si el segundo elemento de la matriz está indefinido utilizando typeofy comprobandoundefined

Al intentar averiguar si existe un índice de matriz en JS, la forma más fácil y más corta de hacerlo es a través de la doble negación.

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

Para esto es exactamente el inoperador. Úselo así:

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

La respuesta aceptada es incorrecta, dará un falso negativo si el valor en indexes 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 expresión booleana

typeof arr[0] !== typeof undefined

es cierto, entonces 0 está contenido en arr

Esto también funciona bien, probando por tipo contra undefined.

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

Prueba:

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

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