Lorsque la page se charge pour la première fois, je dois vérifier s'il y a une image dans image_array et charger la dernière image.

Sinon, je désactive les boutons de prévisualisation, alerte l'utilisateur de pousser le nouveau bouton d'image et crée un tableau vide pour mettre les images;

Le problème est que image_arraydans les elseincendies tout le temps. Si un tableau existe - il le remplace simplement, mais l'alerte ne fonctionne pas.

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

MISE À JOUR Avant de charger du HTML, j'ai quelque chose comme ceci:

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

Votre problème peut se produire en raison d'un mélange de variables globales implicites et de levage de variables. Assurez-vous d'utiliser varchaque fois que vous déclarez une variable:

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

Et puis assurez-vous de ne jamais redéclarer accidentellement cette variable plus tard:

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

Pour vérifier si un tableau est vide ou non

Une manière moderne, ES5 +:

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

Une façon old-school:

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

Une manière compacte:

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

Une façon CoffeeScript:

if array?.length > 0

Pourquoi?

Case Undefined
Undefined variable est une variable à laquelle vous ne lui avez encore rien attribué.

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

Case Null
D'une manière générale, null est l'état de manque de valeur. Par exemple, une variable est nulle lorsque vous avez manqué ou échoué à récupérer certaines données.

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

Case Not an Array
Javascript a un système de type dynamique. Cela signifie que nous ne pouvons pas garantir quel type d'objet contient une variable. Il est possible que nous ne parlions pas d'une instance de Array.

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

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

Case Empty Array
Maintenant que nous avons testé toutes les autres possibilités, nous parlons d'une instance de Array. Afin de nous assurer qu'il n'est pas vide, nous demandons le nombre d'éléments qu'il contient et nous assurons qu'il contient plus de zéro élément.

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

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

Que diriez-vous (ECMA 5.1):

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

C'est ce que j'utilise. La première condition couvre la vérité, qui est à la fois nulle et non définie. La deuxième condition vérifie la présence d'un tableau vide.

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

ou grâce au commentaire de tsemer j'ai ajouté une deuxième version

if(arrayName && arrayName.length)

Ensuite, j'ai fait un test pour la deuxième condition, en utilisant Scratchpad dans 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!");
}

ce qui prouve cela if(array2 && array2.length)et if(array2 && array2.length > 0)fait exactement la même chose

Tu devrais utiliser:

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

Si vous voulez tester si la variable du tableau d'images a été définie, vous pouvez le faire comme ceci

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

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

Vous pouvez utiliser jQuery isEmptyObject()pour vérifier si le tableau contient des éléments ou non.

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

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

Un moyen simple qui ne génère pas d'exceptions s'il n'existe pas et convertit en booléen:

!!array

Exemple:

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

Que dis-tu de ça ? la vérification de la longueur d'un tableau non défini peut générer une exception.

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

Pour moi, certaines des réponses les mieux notées "fonctionnent" lorsque je les mets dans jsfiddle, mais lorsque j'ai une quantité de liste de tableaux générée dynamiquement, une grande partie de ce code dans les réponses ne fonctionne tout simplement pas pour moi.

C'est ce qui fonctionne pour moi.

var from = [];

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

Remarquez, PAS de guillemets indéfinis et je ne me soucie pas de la longueur.

chaînage optionnel

Comme la proposition de chaînage facultative a atteint l'étape 4 et obtient un soutien plus large, il existe un moyen très élégant de le faire

if(image_array?.length){

  // image_array is defined and has at least one element

}

Je rencontre beaucoup ce problème en Javascript. Pour moi, la meilleure façon de le faire est de mettre un chèque très large avant de vérifier la longueur. J'ai vu d'autres solutions dans ce Q&R, mais je voulais pouvoir vérifier l'une nullou l' autre undefinedou toute autre valeur fausse.

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

Ce sera d' abord vérifier undefined, nullou d' autres valeurs fausses. Si l'une d'entre elles est vraie, cela complètera le booléen car c'est un OR. Ensuite, la vérification plus risquée de array.length, qui pourrait nous induire en erreur si le tableau n'est pas défini, peut être vérifiée. Cela ne sera jamais atteint si arrayest undefinedou null, donc l'ordre des conditions est très important.

Utilisation de Undescore ou Lodash :

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

Ce qui suit est ma solution enveloppée dans une fonction qui génère également des erreurs pour gérer quelques problèmes avec la portée de l'objet et tous les types de types de données possibles transmis à la fonction.

Voici mon violon utilisé pour examiner ce problème ( source )

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 vous n'avez pas de variable déclarée comme tableau, vous pouvez créer une vérification:

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

Cela vérifie si la variable x existe et si elle l'est, vérifie s'il s'agit d'un tableau rempli. sinon, il crée un tableau vide (ou vous pouvez faire d'autres choses);

Si vous êtes certain qu'une variable de tableau est créée, il suffit de vérifier:

var x = [];

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

Vous pouvez vérifier mon violon ici avec la plupart des façons possibles de vérifier le tableau.

Vous devriez faire ceci

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

Je pense que ce code simple fonctionnerait:

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

en ts

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

en html

(photos == non défini ||! (isArray (photos) && photos.length> 0))

Lorsque vous créez votre image_array, il est vide, donc votre image_array.length est 0

Comme indiqué dans le commentaire ci-dessous, je modifie ma réponse en fonction de la réponse à cette question ):

var image_array = []

à l'intérieur des parenthèses else ne change rien à l'image_array définie auparavant dans le code