Wenn die Seite zum ersten Mal image_arraygeladen wird , muss ich überprüfen, ob ein Bild vorhanden ist, und das letzte Bild laden.

Andernfalls deaktiviere ich die Vorschau-Schaltflächen, warne den Benutzer, die Schaltfläche für neue Bilder zu drücken, und erstelle ein leeres Array, um die Bilder zu platzieren.

Das Problem ist, dass image_arrayin den elseBränden die ganze Zeit. Wenn ein Array vorhanden ist, wird es nur überschrieben, aber die Warnung funktioniert nicht.

if(image_array.length > 0)
    $('#images').append('<img src="'+image_array[image_array.length-1]+'" class="images" id="1" />');
else{
    $('#prev_image').attr('disabled', 'true');
    $('#next_image').attr('disabled', 'true');
    alert('Please get new image');
    var image_array = [];
}

UPDATE Vor dem Laden von HTML habe ich ungefähr Folgendes:

<?php if(count($images) != 0): ?>
<script type="text/javascript">
    <?php echo "image_array = ".json_encode($images);?>
</script>
<?php endif; ?>

if (typeof image_array !== 'undefined' && image_array.length > 0) {
    // the array is defined and has at least one element
}

Ihr Problem kann aufgrund einer Mischung aus impliziten globalen Variablen und variablem Heben auftreten. Stellen Sie sicher, dass Sie beim varDeklarieren einer Variablen Folgendes verwenden:

<?php echo "var image_array = ".json_encode($images);?>
// add var  ^^^ here

Und stellen Sie dann sicher, dass Sie diese Variable später nie versehentlich neu deklarieren:

else {
    ...
    image_array = []; // no var here
}

Um zu überprüfen, ob ein Array leer ist oder nicht

Ein moderner Weg, ES5 +:

if (Array.isArray(array) && array.length) {
    // array exists and is not empty
}

Ein Weg der alten Schule:

typeof array != "undefined"
    && array != null
    && array.length != null
    && array.length > 0

Ein kompakter Weg:

if (typeof array != "undefined" && array != null && array.length != null && array.length > 0) {
    // array exists and is not empty
}

Ein CoffeeScript-Weg:

if array?.length > 0

Warum?

Fall undefiniert
Undefinierte Variable ist eine Variable, der Sie noch nichts zugewiesen haben.

let array = new Array();     // "array" !== "array"
typeof array == "undefined"; // => true

Fall Null Im
Allgemeinen ist Null der Zustand, in dem ein Wert fehlt. Beispielsweise ist eine Variable null, wenn Sie einige Daten verpasst oder nicht abgerufen haben.

array = searchData();  // can't find anything
array == null;         // => true

Fall Kein Array
Javascript hat ein dynamisches Typsystem. Dies bedeutet, dass wir nicht garantieren können, welchen Objekttyp eine Variable enthält. Es besteht die Möglichkeit, dass wir nicht mit einer Instanz von sprechen Array.

supposedToBeArray =  new SomeObject();
typeof supposedToBeArray.length;       // => "undefined"

array = new Array();
typeof array.length;                   // => "number"

Case Empty Array
Da wir nun alle anderen Möglichkeiten getestet haben, sprechen wir mit einer Instanz von Array. Um sicherzustellen, dass es nicht leer ist, fragen wir nach der Anzahl der Elemente, die es enthält, und stellen sicher, dass es mehr als null Elemente enthält.

firstArray = [];
firstArray.length > 0;  // => false

secondArray = [1,2,3];
secondArray.length > 0; // => true

Wie wäre es mit (ECMA 5.1):

if(Array.isArray(image_array) && image_array.length){
  // array exists and is not empty
}

Das benutze ich. Die erste Bedingung betrifft die Wahrheit, die sowohl null als auch undefiniert ist. Die zweite Bedingung prüft auf ein leeres Array.

if(arrayName && arrayName.length > 0){
    //do something.
}

oder dank tsemers kommentar habe ich eine zweite version hinzugefügt

if(arrayName && arrayName.length)

Dann habe ich mit Scratchpad in Firefox einen Test für die zweite Bedingung durchgeführt:

var array1;
var array2 = [];
var array3 = ["one", "two", "three"];
var array4 = null;

console.log(array1);
console.log(array2);
console.log(array3);
console.log(array4);

if (array1 && array1.length) {
  console.log("array1! has a value!");
}

if (array2 && array2.length) {
  console.log("array2! has a value!");
}

if (array3 && array3.length) {
  console.log("array3! has a value!");
}

if (array4 && array4.length) {
  console.log("array4! has a value!");
}

das beweist auch das if(array2 && array2.length)und macht if(array2 && array2.length > 0)genau das gleiche

Du solltest benutzen:

  if (image_array !== undefined && image_array.length > 0)

Wenn Sie testen möchten, ob die Image-Array-Variable definiert wurde, können Sie dies folgendermaßen tun

if(typeof image_array === 'undefined') {
    // it is not defined yet
} else if (image_array.length > 0) {
    // you have a greater than zero length array
}

JavaScript

( typeof(myArray) !== 'undefined' && Array.isArray(myArray) && myArray.length > 0 )

Lodash & Unterstrich

( _.isArray(myArray) && myArray.length > 0 )

Mit jQuery's können Sie isEmptyObject()überprüfen, ob das Array Elemente enthält oder nicht.

var testArray=[1,2,3,4,5]; 
var testArray1=[];
console.log(jQuery.isEmptyObject(testArray)); //false
console.log(jQuery.isEmptyObject(testArray1)); //true 

Quelle: https://api.jquery.com/jQuery.isEmptyObject/

Ein einfacher Weg, der keine Ausnahmen zur Folge hat, wenn er nicht existiert und in einen Booleschen Wert konvertiert wird:

!!array

Beispiel:

if (!!arr) {
  // array exists
}

Wie wäre es damit ? Das Überprüfen der Länge eines undefinierten Arrays kann eine Ausnahme auslösen.

if(image_array){
//array exists
    if(image_array.length){
    //array has length greater than zero
    }
}

Für mich "funktionieren" sicher einige der hoch bewerteten Antworten, wenn ich sie in jsfiddle einfüge, aber wenn ich eine dynamisch generierte Menge an Array-Listen habe, funktioniert ein Großteil dieses Codes in den Antworten einfach nicht für MICH.

Das ist es, was für mich funktioniert.

var from = [];

if(typeof from[0] !== undefined) {
  //...
}

Beachten Sie, dass KEINE Anführungszeichen undefiniert sind und ich mich nicht um die Länge kümmere.

optionale Verkettung

Da der optionale Verkettungsvorschlag Stufe 4 erreicht hat und eine breitere Unterstützung erhält, gibt es eine sehr elegante Möglichkeit, dies zu tun

if(image_array?.length){

  // image_array is defined and has at least one element

}

Ich stoße in Javascript ziemlich oft auf dieses Problem. Für mich ist der beste Weg, dies zu tun, eine sehr breite Prüfung durchzuführen, bevor die Länge überprüft wird. Ich sah einige andere Lösungen in diesem Q & A, aber ich wollte entweder überprüfen können , nulloder undefinedoder anderen falschen Wert.

if(!array || array.length == 0){
    console.log("Array is either empty or does not exist")
}

Dies wird zunächst prüfen undefined, nulloder andere falsche Werte. Wenn einer dieser Punkte zutrifft, wird der Boolesche Wert vervollständigt, da dies ein ist OR. Dann kann die riskantere Überprüfung überprüft werden array.length, die uns Fehler machen kann, wenn das Array nicht definiert ist. Das wird nie erreicht werden , wenn arrayist undefinedoder null, so die Reihenfolge der Bedingungen sehr wichtig ist.

Verwenden von undescore oder lodash :

_.isArray(image_array) && !_.isEmpty(image_array)

Das Folgende ist meine Lösung, die in eine Funktion eingebunden ist, die auch Fehler auslöst, um einige Probleme mit dem Objektbereich und allen Arten möglicher Datentypen zu verwalten, die an die Funktion übergeben werden.

Hier ist meine Geige, mit der dieses Problem untersucht wurde ( Quelle )

var jill = [0];
var jack;
//"Uncaught ReferenceError: jack is not defined"

//if (typeof jack === 'undefined' || jack === null) {
//if (jack) {
//if (jack in window) {
//if (window.hasOwnP=roperty('jack')){
//if (jack in window){

function isemptyArray (arraynamed){
    //cam also check argument length
  if (arguments.length === 0) { 
    throw "No argument supplied";
  }

  //console.log(arguments.length, "number of arguments found");
  if (typeof arraynamed !== "undefined" && arraynamed !== null) {
      //console.log("found arraynamed has a value");
      if ((arraynamed instanceof Array) === true){
        //console.log("I'm an array");
        if (arraynamed.length === 0) {
            //console.log ("I'm empty");
            return true;
        } else {
          return false;
        }//end length check
      } else {
        //bad type
        throw "Argument is not an array";
      } //end type check
  } else {
    //bad argument
    throw "Argument is invalid, check initialization";;
  }//end argument check
}

try {
  console.log(isemptyArray(jill));
} catch (e) {
    console.log ("error caught:",e);
}

Wenn Sie keine Variable als Array deklariert haben, können Sie eine Prüfung erstellen:

if(x && x.constructor==Array && x.length){
   console.log("is array and filed");
}else{
    var x= [];
    console.log('x = empty array');
}

Dies prüft, ob die Variable x existiert und ob es sich um ein gefülltes Array handelt. Andernfalls wird ein leeres Array erstellt (oder Sie können andere Aufgaben ausführen).

Wenn Sie sicher sind , dass eine Array-Variable erstellt wurde, gibt es eine einfache Überprüfung:

var x = [];

if(!x.length){
    console.log('empty');
} else {
    console.log('full');
}

Sie können meine Geige hier mit den meisten Möglichkeiten überprüfen, um das Array zu überprüfen.

Du solltest das tun

    if (!image_array) {
      // image_array defined but not assigned automatically coerces to false
    } else if (!(0 in image_array)) {
      // empty array
      // doSomething
    }

Ich denke, dieser einfache Code würde funktionieren:

if(!(image_array<=0)){
//Specify function needed
}

in ts

 isArray(obj: any) 
{
    return Array.isArray(obj)
  }

in html

(photos == undefined ||! (isArray (photos) && photos.length> 0))

Wenn Sie Ihr image_array erstellen, ist es leer, daher ist Ihre image_array.length 0

Wie im Kommentar unten angegeben, bearbeite ich meine Antwort basierend auf der Antwort dieser Frage :

var image_array = []

In den else-Klammern ändert sich nichts an dem zuvor im Code definierten image_array