Cum pot verifica în JavaScript dacă există o valoare la un anumit indice matrice?

Toate tablouri în JavaScript conțin matrice.lungime elemente, începând cu matrice[0]pânăarray[matrice.length - 1]. Prin definiție, o matrice, elementul cu indicele " i "este declarat a fi o parte din matrice dacă" eu "este între0" și " matrice.lungime - 1` inclusiv.

Asta este, JavaScript vectorii sunt liniar, începând cu zero și de a merge la un maxim, și tablouri don't au un mecanism de excludere a anumitor valori sau intervale de matrice. Pentru a afla dacă există o valoare, la o anumită poziție index (în cazul în care indicele este 0 sau un număr întreg pozitiv), ai folosi

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

Cu toate acestea, este posibil ca unele matrice de valori să fie null, nedefinit, "NaN", "Infinity", 0, sau o întreagă serie de valori diferite. De exemplu, dacă adăugați matrice de valori prin creșterea `matrice.lungimea de proprietate, noile valori vor fi "nedefinit".

Pentru a determina dacă o anumită valoare este ceva semnificativ, sau a fost definit. Asta este, nu nedefinit, sau null:

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

sau

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

Interesant, pentru că de JavaScript's comparație reguli, ultimul meu exemplu poate fi optimizat reduce la asta:

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

Poate't ne-am face acest lucru:

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

Folosind doar .lungime nu este sigur și va provoca o eroare în unele browsere. Aici este o soluție mai bună:

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

sau, putem folosi:

Object.keys(__array__).length

Scurt și abordare universală

Dacă doriți să verificați orice matrice dacă are falsy valori (cum ar fi false, nedefinit, nul sau gol siruri de caractere) puteți folosi doar fiecare() metoda de genul asta:

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

De exemplu:

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

Dacă aveți nevoie pentru a obține un indice de falsy valoare, o poti face astfel:

let falsyIndex; 

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

Dacă aveți nevoie doar pentru a verifica un falsy valoare de o matrice pentru un anumit index puteți face doar ca aceasta:

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

Dacă vrei să spui prin 'Nul' -> elementele Sale sunt nule sau este egal cu '' , în acest caz : Verificați dacă matricea este goală după filtrare toate 'nul' elemente

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

Desigur ,se Adaugă Curat metoda înainte :

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

Aceasta depinde de ceea ce vrei să spui cu "gol".

Când încercarea de a obține valoarea unei proprietăți a unui obiect care nu are nici o proprietate cu numele asta, vei primi valoarea "nedefinit".

Ca's ce se întâmplă cu tablouri rare: nu toate indici între 0 " și " matrice.lungime-1 exista.

Deci, ai putea verifica dacă array[index] === nedefinit.

Cu toate acestea, proprietatea "index" ar putea exista un "nedefinit" valoare. Dacă doriți pentru a filtra acest caz, puteți folosi " în "operator" sau " hasOwnProperty`, așa cum este descris în https://stackoverflow.com/q/135448/1529630

index in array;
array.hasOwnProperty(index);

Dacă doriți ia în considerare o proprietate imobiliară existentă cu un "nedefinit" sau null valoare nu există, puteți utiliza liber comparație array[index] == nedefinit " sau " matrice[index] == null.

Dacă știi matrice nu este rară, ai putea compara index " cu " matrice.lungime. Dar pentru a fi în siguranță, poate doriți să se asigure că "index" este într-adevăr o serie de index, a se vedea https://stackoverflow.com/q/38163612/1529630

Mi-ar recomanda crearea unei funcții de genul asta:

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

Ai putea spune ca aceasta:

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

Obligă pe producător să adere la isEmptyEl interfață va prinde erori de intrare, cum ar fi un nedefinit arrayName sau indexVal variabile.

(It's, în general, bună practică pentru programul defensiv atunci când programare în Javascript.)

V-ar obține o eroare aruncat așa, dacă arrayName nu a fost definit:

Uncaught ReferenceError: arrayName is not defined
    at :2:15
    at Object.InjectedScript._evaluateOn (:895:140)
    at Object.InjectedScript._evaluateAndWrap (:828:34)
    at Object.InjectedScript.evaluate (:694:21)

Rezultate similare pentru un nedefinit indexVal.

Veți obține o eroare în cazul în matrice sau valorile indicelui nu există.

De intrare valabil, te'll obține doar o adevărată dacă arrayName[indexVal] este oricare din următoarele:

• null
• nedefinit
• NaN
• șir gol
• 0
• false

OK să's vedem mai întâi ce s-ar întâmpla dacă o matrice valoarea nu există în JavaScript, deci, dacă avem o matrice de genul de mai jos:

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

și acum vom verifica dacă 6 este acolo, la index 5 sau nu:

arr[5];

și vom obține "nedefinit"...

Așa că's, practic, să ne dea răspunsul, cel mai bun mod de pentru a verifica dacă nedefinit, ceva de genul asta:

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

L's mai bine NU a face acest lucru în acest caz:

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

Pentru că ne imaginăm că avem această matrice:

const arr = [0, 1, 2];

și vom face:

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

Deci, după cum vedeți, chiar și 0 este acolo, nu't recunoscut, există alte câteva lucruri care pot face același lucru și face aplicarea buggy, astfel încât să fie atent, am lista-le pe toate în jos:

1. nedefinit: dacă valoarea nu este definit și it's "nedefinit"
2. null: dacă-l's nulă, de exemplu, dacă un element DOM nu există...
3. șir gol: ''
4. 0: numărul zero
5. NaN: nu un număr
6. fals

Cred că această decizie este potrivit pentru cei care prefera declarativ de programare funcționale de-a lungul imperativ OOP sau procedurale. Dacă întrebarea dvs. este "există unele valori în interiorul? (o sinceră sau o falsy valoare)" puteți utiliza `.unele metoda de a valida valorile interior. [].unele(el => el || !el);

• E't perfect, dar nu't nevoie pentru a aplica orice funcție suplimentară care conțin aceeași logică, cum ar fi funcția isEmpty(arr) { ... } `.
• Încă sună mai bine decât "Este de lungime zero?" atunci când vom face acest lucru [].lungime rezultate la " 0 " care este periculos în unele cazuri.
• Sau chiar și această [].lungime > 0 spun "Este lungimea mai mare decât zero?"

Avansate exemple: [ ].unele(el => el || !el); // false [nul].unele(el => el || !el); // true [1, 3].unele(el => el || !el); // true

Aș dori să subliniez ceva, câteva par să fi ratat: și anume că este posibil să aibă un "gol" matrice poziția în mijlocul de matrice. Luați în considerare următoarele:

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

Modul natural de a verifica ar fi atunci să văd dacă vectorul membru este nedefinit, nu sunt sigur dacă există și alte modalități de

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

încercați acest lucru dacă array[index] este nul

if (array[index] != null) 

Cu Lodash, puteți face:

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

dacă(_.a(req,'documente')) este de a verifica dacă cererea noastră obiect are o proprietate numită "acte" și dacă are cardanic, următoarea `dacă (req.documente.lungime) este de a valida dacă nu este un array gol, astfel încât alte umpluturi de genul "forEach" pot fi procedat.

Pentru a verifica dacă acesta nu a fost niciodată definit sau dacă acesta a fost șters:

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

de asemenea, funcționează cu tablouri asociative și tablouri în cazul în care ați șters unele index

Pentru a verifica dacă acesta nu a fost niciodată definit, a fost șters SAU este null sau logice valoare gol (NaN, șir gol, false):

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

Am întâlnit această problemă folosind laravel datatables. Am fost stocarea unui JSON valoare numită "proprietăți" într-un jurnal de activitate și a vrut să arate un buton pe baza acestei valori fiind gol sau nu.

Ei bine, datatables a fost de a interpreta acest lucru ca o matrice, dacă a fost gol, și un obiect dacă acesta nu a fost, prin urmare, următoarea soluție a lucrat pentru mine:

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

Un obiect nu are o lungime de proprietate.

Puteți utiliza Loadsh bibliotecă pentru a face acest lucru mai eficient, cum ar fi:

dacă aveți o matrice numit "animale de companie", de exemplu:

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

Pentru a verifica toate matrice de valori de null sau valori nedefinite:

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>

Verifica mai multe exemple în http://underscorejs.org/