Pour vérifier si un tableau est vide ou pas.

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

Version Compacte

  if(typeof array != "undefined" && array != null && array.length != null && array.length > 0){}

CoffeeScript Version

  if array?.length > 0

Remarque: Ne pas l'utiliser, il ya une meilleure façon de trouver des si un tableau existe et c'est non-vide .

pourquoi?

la variable non définie est une variable à laquelle vous n'avez encore rien assigné.

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

Case Null

Généralement parlant, nul est l'état de défaut d'une 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

Cas Pas un Tableau

Javascript a un système de type dynamique. Cela signifie que nous ne pouvons pas garantir quel type d'objet a variable contient.

Il y a une chance 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 Vide

depuis que nous avons testé toutes les autres possibilités, nous parlons d'une instance de Array .

afin de s'assurer qu'il n'est pas vide, nous demandons à un certain nombre d'éléments qu'il tient, et s'assurer qu'il a plus de zéro éléments.

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

que dire de (ECMA 5.1):

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

vous devez utiliser:

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

si vous voulez tester si la variable image array avait é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
}

C'est ce que j'utilise. La première condition couvre truthy, qui a à la fois nul et non défini. Seconde condition vérifie pour 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)

puis 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;

de la console.log(matrice1); console.log(tableau2); 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!");
}

puis les résultats:

Non défini

[]

["un", "deux", "trois"]

null

et le test final qui indique

if(array2 && array2.length){

est le même que

if(array2 && array2.length > 0){

array3! a une valeur!

L'utilisateur JQuery est EmptyObject 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 

pour moi sûr que certaines des réponses de haute qualité" fonctionnent " quand je les mets dans jsfiddle, mais quand j'ai une quantité générée dynamiquement de liste de tableau 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) {
  //...
}

avis, Pas de guillemets non définis et je ne m'occupe pas de la longueur.

JavaScript

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

Lodash Et Trait De Soulignement

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

si vous n'avez pas de variable déclarée comme tableau vous pouvez créer un contrôle:

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

ceci vérifie si la variable x existe et si elle existe, vérifie si c'est un tableau rempli. autre chose, elle crée un tableau vide (ou vous pouvez faire d'autres choses);

si vous êtes certain il y a une variable array créée il y a une simple vérification:

var x = [];

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

, Vous pouvez cocher la case mon violon ici avec plus de moyens possibles pour vérifier le tableau.

je suis tombé sur ce problème beaucoup dans Javascript. Pour moi, la meilleure façon de le faire est de mettre un très large vérifier avant de vérifier pour la longueur. J'ai vu d'autres solutions dans ce Q&r, mais je voulais être en mesure de vérifier soit null ou undefined ou toute autre fausse valeur.

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

ceci vérifiera d'abord undefined , null , ou d'autres valeurs fausses. Si l'un d'eux est vrai, il complétera le booléen comme ceci est un OR . Ensuite , le contrôle plus risqué de array.length , qui pourrait nous induire en erreur si le tableau n'est pas défini, peut être vérifié. Cela ne sera jamais atteint si array est undefined ou null , de sorte que l'ordre des conditions est très important.

utilisant undescore ou lodash :

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

et ça ? la vérification de la longueur du tableau non défini peut jeter l'exception.

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

quand vous créez votre image_array, il est vide, donc votre image_array.longueur est 0

comme indiqué dans le commentaire ci-dessous, je modifie ma réponse basée sur cette réponse de la question ):

var image_array = []

dans les crochets else ne change rien à l'image_array défini avant dans le code

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
    }

Essayez ci-dessous,

if(array.results != undefined) - specific to SharePoint

ou

if(array.length > 0)

une manière simple qui n'entraîne pas d'exceptions si elles n'existent pas et convertir en booléen:

!!array

exemple:

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

voici le mien pour ajouter à la longue liste de réponses:

d'abord, vérifier length n'est pas suffisant pour vérifier le type, car

const fakeArray1 = { length: "very long" };
const fakeArray2 = { length: "1337", data: {} };
if (fakeArray1.length) {...} // is true
if (fakeArray2.length > 0) {...} // is also true

donc vous devez vérifier pour le type réel, soit

image_array.constructor === Array ou Array.isArray(image_array)

Now the magic (note: utiliser la magie dans JS est dangereux et exige de la dextérité et de la responsabilité) , lors de l'utilisation de type de comparaison n'importe quelle paire de l'égalité ci-dessous est véridique

[] == false; [] == 0; [] == ''; [null] == false

So! c'est en train de sortir: p

MA RÉPONSE

if(Array.isArray(image_array) && image_array == false) {
  // handle the case where, either
  // - the array don't exist
  // - the array is empty
  // - it contains only one empty element
}

Note: (conseiller)

utiliser un contrôle non typé est considéré comme une mauvaise pratique dans JS et quelqu'un pourrait vouloir ajouter le troisième = , changer le comportement de votre code. Je conseille donc d'envelopper cette vérification dans une fonction util afin de ne pas entrer dans votre logique et manquer compris par les pairs.

dans ts

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

en html

(photos == indéterminé || !(isArray (photos) & & photos.Longueur > 0))