Wie überprüfe ich in JavaScript, ob an einem bestimmten Array-Index ein Wert vorhanden ist?

Funktioniert dies, um zu testen, ob ein Wert an Position "Index" vorhanden ist oder nicht, oder gibt es einen besseren Weg:

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

Konzeptionell enthalten Arrays in JavaScript array.lengthElemente, beginnend mit array[0]bis array[array.length - 1]. Ein Array-Element mit Index iwird als Teil des Arrays definiert, wenn ies zwischen 0und array.length - 1einschließlich liegt. Wenn ich nicht in diesem Bereich bin, ist es nicht im Array.

Konzeptionell sind Arrays linear, beginnend mit Null und bis zum Maximum, ohne einen Mechanismus für "Lücken" innerhalb des Bereichs, in dem keine Einträge vorhanden sind. Um herauszufinden, ob an einem bestimmten Positionsindex ein Wert vorhanden ist (wobei der Index 0 oder eine positive Ganzzahl ist), verwenden Sie buchstäblich nur

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

Unter der Haube weisen JavaScript-Engines den Array-Speicherplatz mit ziemlicher Sicherheit nicht linear und zusammenhängend zu, da dies in einer dynamischen Sprache nicht viel Sinn macht und für bestimmten Code ineffizient wäre. Es handelt sich wahrscheinlich um Hash-Tabellen oder eine hybride Mischung von Strategien, und undefinierten Bereichen des Arrays wird wahrscheinlich kein eigener Speicher zugewiesen. In JavaScript möchte die Sprache jedoch Arrays von array.length n mit n Mitgliedern darstellen, und sie werden mit 0 bis n - 1 bezeichnet , und alles in diesem Bereich ist Teil des Arrays.

Was Sie jedoch wahrscheinlich wollen, ist zu wissen, ob ein Wert in einem Array tatsächlich etwas Definiertes ist - das heißt, es ist nicht undefined. Vielleicht möchten Sie sogar wissen, ob es definiert ist und nichtnull . Es ist möglich, Mitglieder zu einem Array hinzuzufügen, ohne jemals ihren Wert festzulegen. Wenn Sie beispielsweise Array-Werte durch Erhöhen der array.lengthEigenschaft hinzufügen , werden alle neuen Werte angezeigt undefined.

Feststellen, ob ein bestimmter Wert etwas Sinnvolles ist oder definiert wurde. Das heißt nicht undefined oder null:

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

oder

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

Interessanterweise kann mein letztes Beispiel aufgrund der Vergleichsregeln von JavaScript auf Folgendes optimiert werden:

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

Können wir das nicht einfach so machen:

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

Nur zu verwenden .lengthist nicht sicher und führt in einigen Browsern zu einem Fehler. Hier ist eine bessere Lösung:

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

oder wir können verwenden:

Object.keys(__array__).length

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

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

Kurzer und universeller Ansatz

Wenn Sie ein Array überprüfen möchten, ob es falsche Werte enthält (wie falsche, undefinierte, null oder leere Zeichenfolgen), können Sie einfach jede () Methode wie folgt verwenden :

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

Zum Beispiel:

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

Wenn Sie einen ersten Index für den falschen Wert benötigen, können Sie dies folgendermaßen tun:

let falsyIndex; 

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

Wenn Sie nur einen falschen Wert eines Arrays für einen bestimmten Index überprüfen müssen, können Sie dies folgendermaßen tun:

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

Wenn Sie mit 'Null' meinen -> Die Elemente sind null oder gleich '', in diesem Fall: Überprüfen Sie, ob das Array leer ist, nachdem Sie alle 'null'-Elemente gefiltert haben

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

Natürlich vorher die Clean- Methode hinzufügen:

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

Ich würde empfehlen, eine Funktion wie diese zu erstellen:

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

Man könnte es so nennen:

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

Wenn der Entwickler gezwungen wird, sich an die isEmptyEl-Schnittstelle zu halten, werden Eingabefehler wie undefinierte arrayName- oder indexVal-Variablen abgefangen.

(Es ist im Allgemeinen eine gute Praxis, beim Programmieren in Javascript defensiv zu programmieren.)

Sie würden einen solchen Fehler erhalten, wenn arrayName nicht definiert wäre:

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)

Ähnliche Ergebnisse für ein undefiniertes indexVal.

Sie erhalten eine Fehlermeldung, wenn die Array- oder Indexwerte nicht vorhanden sind.

Für eine gültige Eingabe erhalten Sie nur dann ein true, wenn arrayName [indexVal] eine der folgenden Angaben ist:

• Null
• nicht definiert
• NaN
• leerer String
• 0
• falsch

Es kommt darauf an, was du mit "leer" meinst.

Wenn Sie versuchen, den Wert einer Eigenschaft für ein Objekt abzurufen, das keine Eigenschaft mit diesem Namen hat, erhalten Sie den Wert undefined.

Das passiert mit spärlichen Arrays: Nicht alle Indizes zwischen 0und array.length-1existieren.

Sie können also überprüfen, ob array[index] === undefined.

Die Eigenschaft kann indexjedoch mit einem undefinedWert vorhanden sein. Wenn Sie diesen Fall herausfiltern möchten, können Sie den inOperator verwenden oder hasOwnProperty, wie unter Wie überprüfe ich, ob ein Objekt eine Eigenschaft in JavaScript hat?

index in array;
array.hasOwnProperty(index);

Wenn Sie möchten, dass eine vorhandene Eigenschaft mit einem undefinedoder null-Wert nicht vorhanden ist, können Sie den losen Vergleich array[index] == undefinedoder verwenden array[index] == null.

Wenn Sie wissen , das Array nicht spärlich ist, könnte man vergleichen indexmit array.length. Um jedoch sicher zu gehen, möchten Sie möglicherweise sicherstellen, dass es sich indextatsächlich um einen Array-Index handelt. Überprüfen Sie, ob der Eigenschaftsname ein Array-Index ist

OK, lassen Sie uns zuerst sehen, was passieren würde, wenn ein Array-Wert in JavaScript nicht vorhanden wäre. Wenn wir also ein Array wie das folgende haben:

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

und jetzt prüfen wir, ob 6 bei Index 5 vorhanden ist oder nicht:

arr[5];

und wir bekommen undefined...

Das gibt uns also im Grunde die Antwort, den besten Weg , um zu überprüfen, ob undefiniert, also so etwas:

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

In diesem Fall ist es besser , dies NICHT zu tun:

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

Stellen Sie sich vor, wir haben dieses Array:

const arr = [0, 1, 2];

und wir tun:

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

Wie Sie sehen, ist sogar 0 vorhanden, es wird nicht erkannt, es gibt nur wenige andere Dinge, die das Gleiche bewirken und Ihre Anwendung fehlerhaft machen können. Seien Sie also vorsichtig, ich liste sie alle auf:

1. undefined : wenn der Wert nicht definiert ist und es istundefined
2. null : wenn es null ist, zum Beispiel wenn ein DOM-Element nicht existiert ...
3. leere Zeichenfolge :''
4. 0 : Nummer Null
5. NaN : keine Nummer
6. falsch

Ich möchte auf etwas hinweisen, das einige vermisst zu haben scheinen: Es ist nämlich möglich, eine "leere" Array-Position in der Mitte Ihres Arrays zu haben. Folgendes berücksichtigen:

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

Der natürliche Weg zu überprüfen wäre dann zu sehen, ob das Array-Mitglied undefiniert ist. Ich bin mir nicht sicher, ob es andere Wege gibt

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

Versuchen Sie dies, wenn Array [Index] null ist

if (array[index] != null) 

Mit Lodash können Sie Folgendes tun:

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

if(_.has(req,'documents'))ist zu überprüfen, ob unser Anforderungsobjekt eine Eigenschaft mit dem Namen hat documentsund ob es diese Requisite hat, das nächste ist zu überprüfen, ob if (req.documents.length)es kein leeres Array ist, damit die anderen Dinge wie forEachfortgesetzt werden können.

So überprüfen Sie, ob es noch nie definiert oder gelöscht wurde:

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

Funktioniert auch mit assoziativen Arrays und Arrays, bei denen Sie einen Index gelöscht haben

Um zu überprüfen, ob es nie definiert wurde, wurde gelöscht ODER ist ein null oder logischer leerer Wert (NaN, leere Zeichenfolge, false):

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

Ich bin auf dieses Problem mit Laravel-Datentabellen gestoßen. Ich habe einen JSON-Wert gespeichert, der propertiesin einem Aktivitätsprotokoll aufgerufen wurde, und wollte eine Schaltfläche anzeigen, die darauf basiert, ob dieser Wert leer ist oder nicht.

Nun, datatables interpretierte dies als Array, wenn es leer war, und als Objekt, wenn es nicht war. Daher funktionierte die folgende Lösung für mich:

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

Ein Objekt hat keine Längeneigenschaft.

Ich denke, diese Entscheidung ist für Leute geeignet, die die deklarative funktionale Programmierung der imperativen OOP oder der prozeduralen vorziehen. Wenn Ihre Frage lautet " Gibt es einige Werte im Inneren? (Ein wahrer oder ein falscher Wert)" , können Sie .somedie darin enthaltenen Werte mithilfe der Methode validieren.

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

• Es ist nicht perfekt, aber es erfordert keine zusätzliche Funktion, die dieselbe Logik enthält, wie z function isEmpty(arr) { ... }.
• Es klingt immer noch besser als "Ist es Null Länge?" Wenn wir dies tun ist [].lengthErgebnis 0davon ist in einigen Fällen gefährlich.
• Oder sogar dieses [].length > 0Sprichwort "Ist seine Länge größer als Null?"

Fortgeschrittene Beispiele:

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

Sie können die Loadsh-Bibliothek verwenden, um dies effizienter zu erledigen, z.

Wenn Sie ein Array mit dem Namen "Haustiere" haben, zum Beispiel:

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

So überprüfen Sie alle Array-Werte auf null oder undefinierte Werte:

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>

Weitere Beispiele finden Sie unter http://underscorejs.org/.