Jak sprawdzić w JavaScript, czy wartość ma określony indeks tablicy?

Czy to zadziała do testowania, czy istnieje wartość w pozycji „index”, czy też istnieje lepszy sposób:

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

Pod względem koncepcyjnym tablice w JavaScript zawierają array.lengthelementy, zaczynając od array[0]aż do array[array.length - 1]. Element tablicy z indeksem ijest zdefiniowany jako część tablicy, jeśli ijest pomiędzy 0i array.length - 1obejmuje. Jeśli i nie znajduje się w tym zakresie, nie ma go w tablicy.

Tak więc z założenia tablice są liniowe, zaczynając od zera i osiągając maksimum, bez żadnego mechanizmu mającego „przerwy” w tym zakresie, w którym nie ma żadnych wpisów. Aby dowiedzieć się, czy wartość istnieje przy danym indeksie pozycji (gdzie indeks wynosi 0 lub dodatnia liczba całkowita), dosłownie wystarczy użyć

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

Teraz, pod maską, silniki JavaScript prawie na pewno nie będą alokować przestrzeni tablic liniowo i przylegle w ten sposób, ponieważ nie miałoby to większego sensu w dynamicznym języku i byłoby nieefektywne dla pewnego kodu. Prawdopodobnie są to tabele skrótów lub hybrydowe połączenie strategii, a niezdefiniowanym zakresom tablicy prawdopodobnie nie przydzielono własnej pamięci. Niemniej jednak JavaScript język chce przedstawić tablice array.length n jako mające n członków i mają one nazwy od 0 do n - 1 , a wszystko w tym zakresie jest częścią tablicy.

Jednak prawdopodobnie chcesz wiedzieć, czy wartość w tablicy jest rzeczywiście czymś zdefiniowanym - to znaczy nie jest undefined. Może nawet chcesz wiedzieć, czy to jest zdefiniowane, czy nienull . Możliwe jest dodawanie członków do tablicy bez ustawiania ich wartości: na przykład, jeśli dodasz wartości tablicy przez zwiększenie array.lengthwłaściwości, będą to nowe wartości undefined.

Aby ustalić, czy dana wartość ma znaczenie, czy została zdefiniowana. To znaczy nie undefined lub null:

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

lub

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

Co ciekawe, ze względu na reguły porównywania JavaScript, mój ostatni przykład można zoptymalizować do tego stopnia:

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

Czy nie możemy tego po prostu zrobić:

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

Używanie tylko .lengthnie jest bezpieczne i spowoduje błąd w niektórych przeglądarkach. Oto lepsze rozwiązanie:

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

lub możemy użyć:

Object.keys(__array__).length

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

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

Krótkie i uniwersalne podejście

Jeśli chcesz sprawdzić dowolną tablicę, która ma wartości fałszowania (takie jak fałsz, niezdefiniowane, puste lub puste łańcuchy), możesz po prostu użyć każdej metody () :

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

Na przykład:

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

Jeśli potrzebujesz pierwszego indeksu wartości fałszowania, możesz to zrobić w następujący sposób:

let falsyIndex; 

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

Jeśli chcesz tylko sprawdzić wartość fałszowania tablicy dla danego indeksu, możesz to zrobić w następujący sposób:

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

Jeśli masz na myśli „Null” -> Jego elementy są zerowe lub równe „”, w tym przypadku: Sprawdź, czy tablica jest pusta po odfiltrowaniu wszystkich elementów „null”

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

Oczywiście, dodaj metodę Clean przed:

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

Poleciłbym utworzenie takiej funkcji:

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

Możesz to tak nazwać:

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

Zmuszenie programisty do przestrzegania interfejsu isEmptyEl spowoduje wyłapanie błędów wejściowych, takich jak niezdefiniowana nazwa tablicy lub zmienne indexVal.

(Ogólnie dobrą praktyką jest programowanie defensywne podczas programowania w JavaScript).

Wystąpiłby taki błąd, gdyby nie zdefiniowano arrayName:

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)

Podobne wyniki dla niezdefiniowanego indexVal.

Błąd pojawia się, jeśli wartości tablicy lub indeksu nie istnieją.

Prawidłowe dane wejściowe są prawdziwe tylko wtedy, gdy nazwa_kolekcji [indexVal] jest jedną z następujących czynności:

• zero
• nieokreślony
• NaN
• pusta struna
• 0
• fałszywe

To zależy od tego, co masz na myśli przez „pusty”.

Gdy spróbujesz uzyskać wartość właściwości obiektu, który nie ma właściwości o tej nazwie, otrzymasz wartość undefined.

Tak dzieje się z rzadkimi tablicami: nie wszystkie wskaźniki pomiędzy 0i array.length-1istnieją.

Więc możesz sprawdzić, czy array[index] === undefined.

Jednak właściwość indexmoże istnieć z undefinedwartością. Jeśli chcesz odfiltrować ten przypadek, możesz użyć inoperatora lub hasOwnProperty, jak opisano w Jak sprawdzić, czy obiekt ma właściwość w JavaScript?

index in array;
array.hasOwnProperty(index);

Jeśli chcesz uznać, że istniejąca właściwość z wartością undefinedlub nullnie istnieje, możesz użyć luźnego porównania array[index] == undefinedlub array[index] == null.

Jeśli wiesz, że tablica nie jest rzadki, można porównać indexz array.length. Ale dla bezpieczeństwa możesz chcieć upewnić się, że indextak naprawdę jest to indeks tablicy, zobacz Sprawdź, czy nazwa właściwości to indeks tablicy

OK, najpierw zobaczmy, co by się stało, gdyby wartość tablicy nie istniała w JavaScript, więc jeśli mamy tablicę jak poniżej:

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

a teraz sprawdzamy, czy 6 ma indeks 5, czy nie:

arr[5];

i dostajemy undefined...

To w zasadzie daje nam odpowiedź, najlepszy sposób sprawdzenia, czy jest niezdefiniowany, więc coś takiego:

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

Lepiej NIE rób tego w tym przypadku:

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

Wyobraź sobie, że mamy tę tablicę:

const arr = [0, 1, 2];

a my:

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

Jak widać, nawet 0 jest tam, nie można ich rozpoznać, jest kilka innych rzeczy, które mogą zrobić to samo i spowodować, że aplikacja będzie działać nieprawidłowo, więc bądź ostrożny, wymienię je wszystkie w dół:

1. undefined : jeśli wartość nie jest zdefiniowana i jestundefined
2. null : jeśli jest null, na przykład jeśli element DOM nie istnieje ...
3. pusty ciąg :''
4. 0 : liczba zero
5. NaN : brak liczby
6. fałszywe

Chciałbym zwrócić uwagę na coś, co niektórym wydaje się przeoczyć: mianowicie możliwe jest umieszczenie „pustej” pozycji tablicy na środku tablicy. Rozważ następujące:

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

Naturalnym sposobem sprawdzenia byłoby wtedy sprawdzenie, czy element tablicy nie jest zdefiniowany, nie jestem pewien, czy istnieją inne sposoby

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

spróbuj tego, jeśli tablica [indeks] ma wartość NULL

if (array[index] != null) 

Z Lodash możesz:

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

if(_.has(req,'documents'))jest sprawdzenie, czy nasz obiekt żądania ma właściwość o nazwie, documentsa jeśli ma tę prop, następną if (req.documents.length)jest sprawdzenie, czy nie jest to pusta tablica, aby forEachmożna było wykonać inne czynności.

Aby sprawdzić, czy nigdy nie został zdefiniowany lub czy został usunięty:

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

działa również z tablicami asocjacyjnymi i tablicami, w których usunięto niektóre indeksy

Aby sprawdzić, czy nigdy nie został zdefiniowany, został usunięty LUB jest pustą lub logicznie pustą wartością (NaN, pusty ciąg, fałsz):

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

Natknąłem się na ten problem przy użyciu danych laravel. Przechowywałem wartość JSON wywoływaną propertiesw dzienniku aktywności i chciałem wyświetlić przycisk oparty na tej wartości, która jest pusta lub nie.

Cóż, bazy danych interpretowały to jako tablicę, jeśli była pusta, a obiekt, jeśli nie był, dlatego następujące rozwiązanie działało dla mnie:

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

Obiekt nie ma właściwości length.

Myślę, że ta decyzja jest odpowiednia dla facetów, którzy wolą deklaratywne programowanie funkcjonalne niż imperatywny OOP lub proceduralny. Jeśli twoje pytanie brzmi: „ Czy w środku są jakieś wartości? (Prawda lub fałsz)?” Możesz użyć .somemetody, aby sprawdzić wartości w środku.

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

• Nie jest idealny, ale nie wymaga zastosowania żadnej dodatkowej funkcji zawierającej tę samą logikę, jak function isEmpty(arr) { ... }.
• Nadal brzmi lepiej niż „Czy ma zerową długość?” kiedy to robimy, [].lengthco 0w niektórych przypadkach jest niebezpieczne.
• Lub nawet to [].length > 0powiedzenie „Czy jego długość jest większa od zera?”

Zaawansowane przykłady:

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

Możesz użyć biblioteki Loadsh, aby zrobić to bardziej wydajnie, na przykład:

jeśli masz tablicę o nazwie „zwierzaki”, na przykład:

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

Aby sprawdzić wszystkie wartości tablic pod kątem wartości pustych lub niezdefiniowanych:

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>

Sprawdź więcej przykładów w http://underscorejs.org/