Quando la pagina viene caricata per la prima volta, devo verificare se è presente un'immagine image_arraye caricare l'ultima immagine.

Altrimenti, disabilito i pulsanti di anteprima, avvisare l'utente di premere il nuovo pulsante immagine e creare un array vuoto per mettere le immagini;

Il problema è che image_arraynei elsefuochi sempre. Se esiste un array, lo sovrascrive, ma l'avviso non funziona.

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 = [];
}

AGGIORNAMENTO Prima di caricare HTML, ho qualcosa del genere:

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

Il problema potrebbe verificarsi a causa di un mix di variabili globali implicite e sollevamento di variabili. Assicurati di usare varogni volta che dichiari una variabile:

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

E quindi assicurati di non dichiarare mai più accidentalmente quella variabile in seguito:

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

Per verificare se un array è vuoto o meno

Un modo moderno, ES5 +:

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

Un modo vecchio stile:

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

Un modo compatto:

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

Un modo CoffeeScript:

if array?.length > 0

Perché?

Case Undefined Una
variabile non definita è una variabile che non le è stata ancora assegnata.

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

Case Null
In generale, null è lo stato in cui manca un valore. Ad esempio, una variabile è nulla in caso di mancato recupero o mancato recupero di alcuni dati.

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

Caso non un array
Javascript ha un sistema di tipo dinamico. Ciò significa che non possiamo garantire il tipo di oggetto contenuto in una variabile. È possibile che non stiamo parlando di un'istanza di Array.

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

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

Case Empty Array
Ora da quando abbiamo provato tutte le altre possibilità, stiamo parlando di un'istanza di Array. Per assicurarci che non sia vuoto, chiediamo il numero di elementi che contiene e assicurandoci che abbia più di zero elementi.

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

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

Che ne dici (ECMA 5.1):

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

Questo è quello che uso. La prima condizione riguarda la verità, che ha sia null che indefinito. La seconda condizione controlla un array vuoto.

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

o grazie al commento di Tsemer ho aggiunto una seconda versione

if(arrayName && arrayName.length)

Quindi ho fatto un test per la seconda condizione, usando Scratchpad in Firefox:

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

che lo dimostra anche if(array2 && array2.length)e if(array2 && array2.length > 0)stanno facendo esattamente lo stesso

Dovresti usare:

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

Se si desidera verificare se la variabile dell'array di immagini è stata definita, è possibile farlo in questo modo

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 e Underscore

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

È possibile utilizzare jQuery isEmptyObject()per verificare se l'array contiene elementi o meno.

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

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

Un modo semplice che non comporta eccezioni se non esiste e converti in booleano:

!!array

Esempio:

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

Cosa ne pensi di questo ? il controllo della lunghezza dell'array non definito può generare eccezioni.

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

Per me alcune delle risposte più votate "funzionano" quando le inserisco in jsfiddle, ma quando ho una quantità di elenco di array generata dinamicamente un sacco di questo codice nelle risposte non funziona per ME.

Questo è ciò che funziona per me.

var from = [];

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

Notate, NESSUNA virgoletta non definita e non mi sto preoccupando della lunghezza.

concatenamento opzionale

Poiché la proposta di concatenazione opzionale ha raggiunto la fase 4 e sta ottenendo un sostegno più ampio, esiste un modo molto elegante per farlo

if(image_array?.length){

  // image_array is defined and has at least one element

}

Mi imbatto molto in questo problema in Javascript. Per me il modo migliore per farlo è quello di effettuare un controllo molto ampio prima di verificare la lunghezza. Ho visto alcune altre soluzioni in queste domande e risposte, ma volevo essere in grado di verificare uno nullo undefinedaltri valori falsi.

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

Questo sarà prima verificare la presenza undefined, nullo altri valori falsi. Se uno di questi è vero, completerà il booleano in quanto questo è un OR. Quindi array.lengthpuò essere verificato il controllo più rischioso di , che potrebbe errarci se l'array non è definito. Questo non sarà mai raggiunto se lo arrayè undefinedo null, quindi l'ordine delle condizioni è molto importante.

Utilizzando undescore o lodash :

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

La seguente è la mia soluzione racchiusa in una funzione che genera anche errori per gestire un paio di problemi con l'ambito dell'oggetto e tutti i tipi di possibili tipi di dati passati alla funzione.

Ecco il mio violino usato per esaminare questo problema ( fonte )

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

Se non hai una variabile dichiarata come matrice, puoi creare un segno di spunta:

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

Controlla se esiste la variabile x e se lo è, controlla se si tratta di un array pieno. altrimenti crea un array vuoto (oppure puoi fare altre cose);

Se si è certi che sia stata creata una variabile di matrice, è presente un semplice controllo:

var x = [];

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

Puoi controllare il mio violino qui con mostra i modi più possibili per controllare l'array.

Dovresti farlo

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

Penso che questo semplice codice funzionerebbe:

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

Quando crei image_array, è vuoto, quindi image_array.length è 0

Come indicato nel commento qui sotto, modifico la mia risposta in base alla risposta di questa domanda ):

var image_array = []

all'interno delle parentesi else non cambia nulla in image_array definito in precedenza nel codice