Come posso controllare JavaScript se esiste un valore in un determinato indice di array?

Funzionerà per verificare se esiste o meno un valore nella posizione "indice" o esiste un modo migliore:

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

Concettualmente, le matrici in JavaScript contengono array.lengthelementi, a partire array[0]da fino a array[array.length - 1]. Un elemento array con indice iviene definito come parte dell'array se icompreso tra 0e array.length - 1compreso. Se non sono in questo intervallo non è nell'array.

Quindi, per concetto, le matrici sono lineari, iniziando da zero e andando al massimo, senza alcun meccanismo per avere "spazi vuoti" all'interno di quell'intervallo in cui non esistono voci. Per scoprire se esiste un valore in un determinato indice di posizione (dove l'indice è 0 o un numero intero positivo), letteralmente usi semplicemente

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

Ora, sotto il cofano, i motori JavaScript quasi sicuramente non alloteranno lo spazio dell'array in modo lineare e contiguo in questo modo, poiché non avrebbe molto senso in un linguaggio dinamico e sarebbe inefficiente per un determinato codice. Probabilmente sono tabelle hash o una combinazione ibrida di strategie, e gli intervalli indefiniti dell'array probabilmente non sono assegnati alla propria memoria. Tuttavia, JavaScript il linguaggio vuole presentare le matrici di array.length n come aventi n membri e sono nominate da 0 a n - 1 e qualsiasi cosa in questo intervallo fa parte dell'array.

Ciò che probabilmente vuoi, tuttavia, è sapere se un valore in un array è in realtà qualcosa di definito , cioè non lo è undefined. Forse vuoi anche sapere se è definito e nonull . È possibile aggiungere membri a un array senza mai impostarne il valore: ad esempio, se si aggiungono valori di array aumentando la array.lengthproprietà, tutti i nuovi valori saranno undefined.

Per determinare se un determinato valore è qualcosa di significativo o è stato definito. Cioè, no undefined o null:

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

o

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

È interessante notare che, a causa delle regole di confronto di JavaScript, il mio ultimo esempio può essere ottimizzato fino a questo:

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

Non possiamo semplicemente fare questo:

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

L'uso di solo .lengthnon è sicuro e causerà un errore in alcuni browser. Ecco una soluzione migliore:

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

oppure possiamo usare:

Object.keys(__array__).length

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

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

Approccio breve e universale

Se vuoi controllare qualsiasi array se ha valori falsy (come stringhe false, non definite, null o vuote) puoi semplicemente usare ogni metodo () come questo:

array.every(function(element) {return !!element;}); // returns true or false

Per esempio:

['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

Se hai bisogno di ottenere un primo indice di valore falso, puoi farlo in questo modo:

let falsyIndex; 

if(!['23', true, 2, null, {key: 'value'}].every(function(element, index) {falsyIndex = index; return !!element;})) {
  console.log(falsyIndex);
} // logs 3

Se hai solo bisogno di controllare un valore errato di un array per un dato indice, puoi farlo in questo modo:

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

Se intendi con "Null" -> I suoi elementi sono nulli o uguali a "", in questo caso: controlla se l'array è vuoto dopo aver filtrato tutti gli elementi "null"

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

Naturalmente, aggiungi il metodo Clean prima di:

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

Consiglierei di creare una funzione come questa:

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

Potresti chiamarlo così:

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

Forzare lo sviluppatore ad aderire all'interfaccia isEmptyEl rileverà errori di input come arrayName non definito o variabili indexVal.

(È generalmente buona norma programmare in modo difensivo durante la programmazione in Javascript.)

Si otterrebbe un errore generato in questo modo se arrayName non fosse definito:

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)

Risultati simili per un indexVal non definito.

Viene visualizzato un errore se i valori dell'array o dell'indice non esistono.

Per un input valido, otterrai un valore vero solo se arrayName [indexVal] è uno dei seguenti:

• nullo
• non definito
• NaN
• stringa vuota
• 0
• falso

Dipende da cosa intendi con "vuoto".

Quando si tenta di ottenere il valore di una proprietà su un oggetto che non ha proprietà con quel nome, si otterrà il valore undefined.

Questo è ciò che accade con gli array sparsi: non tutti gli indici tra 0ed array.length-1esistono.

Quindi puoi verificare se array[index] === undefined.

Tuttavia, la proprietà indexpotrebbe esistere con un undefinedvalore. Se si desidera filtrare questo caso, è possibile utilizzare l' inoperatore o hasOwnProperty, come descritto in Come posso verificare se un oggetto ha una proprietà in JavaScript?

index in array;
array.hasOwnProperty(index);

Se si desidera considerare una proprietà esistente con un valore undefinedo nullinesistente, è possibile utilizzare il confronto libero array[index] == undefinedo array[index] == null.

Se sai che l'array non è scarso, puoi confrontarlo indexcon array.length. Ma per sicurezza, potresti voler assicurarti che sia indexdavvero un indice di array, vedi Controlla se il nome della proprietà è indice di array

OK, vediamo prima cosa succederebbe se non esistesse un valore di array in JavaScript, quindi se abbiamo un array come di seguito:

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

e ora controlliamo se 6 è presente all'indice 5 oppure no:

arr[5];

e otteniamo undefined...

Quindi questo in sostanza ci dà la risposta, il modo migliore per verificare se non definito, quindi qualcosa del genere:

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

È meglio NON farlo in questo caso:

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

Perché immagina di avere questo array:

const arr = [0, 1, 2];

e facciamo:

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

Quindi, come vedi, anche 0 è lì, non viene riconosciuto, ci sono poche altre cose che possono fare lo stesso e renderti buggy dell'applicazione, quindi fai attenzione, li elenco tutti sotto:

1. undefined : se il valore non è definito ed èundefined
2. null : se è null, ad esempio se un elemento DOM non esiste ...
3. stringa vuota :''
4. 0 : numero zero
5. NaN : non un numero
6. falso

Vorrei sottolineare qualcosa che alcuni sembrano aver perso: vale a dire che è possibile avere una posizione "vuota" dell'array nel mezzo dell'array. Considera quanto segue:

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

Il modo naturale di verificare sarebbe quindi vedere se il membro dell'array non è definito, non sono sicuro che esistano altri modi

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

provare questo se l'array [indice] è nullo

if (array[index] != null) 

Con Lodash puoi fare:

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

if(_.has(req,'documents'))è verificare se il nostro oggetto richiesta ha una proprietà denominata documentse se ha quel prop, il prossimo if (req.documents.length)è di validare se non è un array vuoto, quindi le altre cose come forEachpossono essere proseguite.

Per verificare se non è mai stato definito o se è stato eliminato:

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

funziona anche con array associativi e array in cui è stato eliminato un certo indice

Per verificare se non è mai stato definito, è stato eliminato O è un valore nullo o logico vuoto (NaN, stringa vuota, falso):

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

Ho riscontrato questo problema utilizzando i database di laravel. Stavo memorizzando un valore JSON chiamato propertiesin un registro attività e volevo mostrare un pulsante basato sul fatto che questo valore era vuoto o meno.

Bene, i datatables lo interpretavano come un array se era vuoto e un oggetto se non fosse, quindi la seguente soluzione ha funzionato per me:

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

Un oggetto non ha una proprietà length.

Penso che questa decisione sia appropriata per i ragazzi che preferiscono la programmazione funzionale dichiarativa rispetto all'imperativo OOP o procedurale. Se la tua domanda è " Esistono dei valori all'interno? (Un valore di verità o di un falso)" puoi usare il .somemetodo per validare i valori al suo interno.

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

• Non è perfetto, ma non richiede di applicare alcuna funzione aggiuntiva contenente la stessa logica, come function isEmpty(arr) { ... }.
• Suona ancora meglio di "È lunghezza zero?" quando lo facciamo, il [].lengthrisultato 0è pericoloso in alcuni casi.
• O anche questo [].length > 0detto "La sua lunghezza è maggiore di zero?"

Esempi avanzati:

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

Puoi usare la libreria Loadsh per farlo in modo più efficiente, come:

se si dispone di un array denominato "animali domestici", ad esempio:

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

Per controllare tutti i valori di array per valori nulli o non definiti:

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>

Guarda altri esempi in http://underscorejs.org/