Cuando la página se carga por primera vez, necesito verificar si hay una imagen image_arrayy cargar la última imagen.

De lo contrario, deshabilito los botones de vista previa, alerta al usuario para que presione el botón de nueva imagen y creo una matriz vacía para colocar las imágenes;

El problema es que image_arrayen los elseincendios todo el tiempo. Si existe una matriz, simplemente la anula, pero la alerta no funciona.

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

ACTUALIZACIÓN Antes de cargar html, tengo algo como esto:

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

Su problema puede estar ocurriendo debido a una combinación de variables globales implícitas y elevación de variables. Asegúrese de usar varcada vez que declare una variable:

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

Y luego asegúrese de nunca volver a declarar accidentalmente esa variable más tarde:

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

Para verificar si una matriz está vacía o no

Una forma moderna, ES5 +:

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

Una manera de la vieja escuela:

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

Una forma compacta:

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

Una manera de CoffeeScript:

if array?.length > 0

¿Por qué?

Caso sin definir La
variable sin definir es una variable a la que todavía no se le ha asignado nada.

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

Caso nulo
En términos generales, nulo es el estado de falta de valor. Por ejemplo, una variable es nula cuando omitió o no pudo recuperar algunos datos.

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

Case Not an Array
Javascript tiene un sistema de tipo dinámico. Esto significa que no podemos garantizar qué tipo de objeto contiene una variable. Existe la posibilidad de que no estemos hablando de una instancia de Array.

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

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

Case Empty Array
Ahora, dado que probamos todas las demás posibilidades, estamos hablando de una instancia de Array. Para asegurarnos de que no esté vacío, preguntamos por el número de elementos que contiene y nos aseguramos de que tenga más de cero elementos.

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

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

¿Qué tal (ECMA 5.1):

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

Esto es lo que yo uso. La primera condición cubre la verdad, que tiene valores nulos e indefinidos. La segunda condición verifica si hay una matriz vacía.

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

o gracias al comentario de tsemer agregué una segunda versión

if(arrayName && arrayName.length)

Luego hice una prueba para la segunda condición, usando Scratchpad en 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!");
}

que también prueba eso if(array2 && array2.length)y if(array2 && array2.length > 0)están haciendo exactamente lo mismo

Deberías usar:

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

Si desea probar si se ha definido la variable de matriz de imagen, puede hacerlo así

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 y subrayado

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

Puede usar jQuery's isEmptyObject()para verificar si la matriz contiene elementos o no.

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

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

Una forma simple que no genera excepciones si no existe y se convierte a booleano:

!!array

Ejemplo:

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

Qué tal esto ? comprobar la longitud de la matriz indefinida puede generar una excepción.

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

Para mí, seguro que algunas de las respuestas mejor calificadas "funcionan" cuando las pongo en jsfiddle, pero cuando tengo una cantidad generada dinámicamente de la lista, mucho de este código en las respuestas simplemente no funciona para mí.

Esto es lo que ESTÁ trabajando para mí.

var from = [];

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

Tenga en cuenta que NO hay citas indefinidas y no me estoy molestando con la longitud.

encadenamiento opcional

Como la propuesta de encadenamiento opcional llegó a la etapa 4 y está obteniendo un soporte más amplio, hay una manera muy elegante de hacerlo

if(image_array?.length){

  // image_array is defined and has at least one element

}

Me encuentro con este problema bastante en Javascript. Para mí, la mejor manera de hacerlo es poner un control muy amplio antes de verificar la longitud. Vi algunas otras soluciones en este Q & A, pero quería ser capaz de verificar, ya sea para nullo undefinedo cualquier otro valor falso.

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

Esto primera comprobar undefined, nullu otros valores falsos. Si alguno de esos es verdadero, completará el booleano ya que es un OR. Luego array.length, se puede verificar la comprobación más arriesgada , que podría confundirnos si la matriz no está definida. Esto nunca se alcanzará si arrayes undefinedo null, por lo que el orden de las condiciones es muy importante.

Usando undescore o lodash :

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

La siguiente es mi solución envuelta en una función que también arroja errores para gestionar un par de problemas con el alcance del objeto y todos los tipos de tipos de datos posibles pasados ​​a la función.

Aquí está mi violín utilizado para examinar este problema ( fuente )

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

Si no tiene una variable declarada como matriz, puede crear una verificación:

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

Esto verifica si la variable x existe y si es así, verifica si es una matriz llena. de lo contrario, crea una matriz vacía (o puede hacer otras cosas);

Si está seguro de que hay una variable de matriz creada, hay una simple verificación:

var x = [];

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

Puede verificar mi violín aquí con la mayoría de las formas posibles de verificar la matriz.

Usted debe hacer esto

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

Creo que este código simple funcionaría:

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

en ts

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

en html

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

Cuando crea su image_array, está vacío, por lo tanto, su image_array.length es 0

Como se indica en el comentario a continuación, edito mi respuesta en función de la respuesta de esta pregunta ):

var image_array = []

dentro de los corchetes else no cambia nada al conjunto de imágenes definido anteriormente en el código