Quando a página está carregando pela primeira vez, preciso verificar se há uma imagem image_arraye carregar a última imagem.

Caso contrário, desabilito os botões de visualização, alerta o usuário a pressionar o botão de nova imagem e cria uma matriz vazia para colocar as imagens;

O problema é que image_arraynos elseincêndios o tempo todo. Se existe uma matriz - ela simplesmente a substitui, mas o alerta não 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 = [];
}

ATUALIZAÇÃO Antes de carregar o html, tenho algo parecido com isto:

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

Seu problema pode estar acontecendo devido a uma mistura de variáveis ​​globais implícitas e içamento de variáveis. Certifique-se de usar varsempre que declarar uma variável:

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

E certifique-se de nunca redeclarar acidentalmente essa variável mais tarde:

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

Para verificar se uma matriz está vazia ou não

Uma maneira moderna, ES5 +:

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

Uma maneira antiga:

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

Uma maneira compacta:

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

Uma maneira do CoffeeScript:

if array?.length > 0

Por quê?

Caso Indefinido A
variável indefinida é uma variável que você ainda não atribuiu a ela.

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

Nulo do caso
Em geral, nulo é o estado em que falta um valor. Por exemplo, uma variável é nula quando você perdeu ou não conseguiu recuperar alguns dados.

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

Caso Não é uma matriz
Javascript possui um sistema de tipos dinâmicos. Isso significa que não podemos garantir que tipo de objeto uma variável contém. Há uma chance de que não estamos falando com uma instância do Array.

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

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

Case Empty Array
Agora que testamos todas as outras possibilidades, estamos falando de uma instância de Array. Para garantir que não esteja vazio, perguntamos sobre o número de elementos que ele contém e certificando-se de que ele possui mais de zero elementos.

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

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

Que tal (ECMA 5.1):

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

É isso que eu uso. A primeira condição abrange a verdade, que é nula e indefinida. A segunda condição verifica se há uma matriz vazia.

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

ou, graças ao comentário do tsemer, adicionei uma segunda versão

if(arrayName && arrayName.length)

Então eu fiz um teste para a segunda condição, usando o Scratchpad no 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!");
}

o que também prova isso if(array2 && array2.length)e if(array2 && array2.length > 0)está fazendo exatamente o mesmo

Você deveria usar:

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

Se você quiser testar se a variável de matriz de imagem foi definida, faça-o desta maneira

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 & Sublinhado

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

Você pode usar o jQuery isEmptyObject()para verificar se a matriz contém elementos ou não.

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/

Uma maneira simples que não resulta em exceções, se não existir, e converta para booleano:

!!array

Exemplo:

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

Que tal agora ? a verificação do comprimento da matriz indefinida pode gerar uma exceção.

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

Para mim, algumas das respostas mais bem classificadas "funcionam" quando eu as coloco no jsfiddle, mas quando tenho uma quantidade gerada dinamicamente de uma lista de arrays, muito desse código nas respostas simplesmente não funciona para mim.

É isso que está funcionando para mim.

var from = [];

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

Observe, sem aspas indefinidas e não estou me incomodando com o comprimento.

encadeamento opcional

Como a proposta de encadeamento opcional chegou ao estágio 4 e está recebendo um suporte mais amplo, há uma maneira muito elegante de fazer isso

if(image_array?.length){

  // image_array is defined and has at least one element

}

Me deparei com esse problema bastante em Javascript. Para mim, a melhor maneira de fazer isso é fazer uma verificação muito ampla antes de verificar o comprimento. Vi algumas outras soluções nesta sessão de perguntas e respostas, mas queria poder verificar se havia um nullou undefinedoutro valor falso.

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

Isto irá primeiro verificar se há undefined, nullou outros valores falsos. Se algum deles for verdadeiro, ele completará o booleano, pois é um OR. Em seguida, a verificação mais arriscada array.length, que pode causar erros se a matriz for indefinida, pode ser verificada. Isso nunca será alcançado se arrayfor undefinedou null, portanto, a ordenação das condições é muito importante.

Usando undescore ou lodash :

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

A seguir, minha solução envolve uma função que também gera erros para gerenciar alguns problemas com o escopo do objeto e todos os tipos de possíveis tipos de dados passados ​​para a função.

Aqui está o meu violino usado para examinar este 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 você não tiver uma variável declarada como matriz, poderá criar uma verificação:

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

Isso verifica se a variável x existe e, se existe, verifica se é uma matriz preenchida. caso contrário, ele cria uma matriz vazia (ou você pode fazer outras coisas);

Se você tem certeza de que existe uma variável de matriz criada, há uma verificação simples:

var x = [];

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

Você pode verificar meu violino aqui com as maneiras mais possíveis de verificar a matriz.

Você deve fazer isso

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

Eu acho que esse código simples funcionaria:

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

em st

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

em html

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

Quando você cria seu image_array, ele está vazio; portanto, o image_array.length é 0

Conforme declarado no comentário abaixo, edito minha resposta com base na resposta desta pergunta ):

var image_array = []

dentro dos colchetes else não muda nada para o image_array definido anteriormente no código