Gdy strona ładuje się po raz pierwszy, muszę sprawdzić, czy jest tam obraz image_arrayi załadować ostatni obraz.

W przeciwnym razie wyłączam przyciski podglądu, ostrzegam użytkownika, aby nacisnął nowy przycisk obrazu i utworzyłem pustą tablicę, aby umieścić obrazy;

Problem polega na tym, że image_arrayw elsepożarach cały czas. Jeśli tablica istnieje - po prostu ją zastępuje, ale alert nie działa.

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

AKTUALIZACJA Przed załadowaniem html mam coś takiego:

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

Twój problem może występować z powodu połączenia niejawnych zmiennych globalnych i podnoszenia zmiennych. Upewnij się, że używasz varza każdym razem, gdy deklarujesz zmienną:

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

A potem upewnij się, że nigdy później przypadkowo nie zmienisz tej zmiennej:

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

Aby sprawdzić, czy tablica jest pusta, czy nie

Nowoczesny sposób, ES5 +:

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

Oldschoolowy sposób:

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

Kompaktowy sposób:

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

Sposób na CoffeeScript:

if array?.length > 0

Dlaczego?

Case Undefined
Niezdefiniowana zmienna to zmienna, do której jeszcze jej nie przypisałeś.

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

Przypadek Null
Ogólnie mówiąc, null to stan braku wartości. Na przykład zmienna ma wartość NULL, gdy niektóre dane zostały pominięte lub nie powiodło się.

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

Case Not an Array
JavaScript ma dynamiczny system typów. Oznacza to, że nie możemy zagwarantować, jaki typ obiektu posiada zmienna. Istnieje szansa, że ​​nie rozmawiamy z żadnym przypadkiem Array.

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

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

Case Empty Array
Teraz, odkąd przetestowaliśmy wszystkie inne możliwości, rozmawiamy o instancji Array. Aby upewnić się, że nie jest pusty, pytamy o liczbę elementów, które zawiera i upewniając się, że ma więcej niż zero elementów.

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

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

Co powiesz na (ECMA 5.1):

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

Tego używam. Pierwszy warunek obejmuje prawdę, która ma zarówno wartość zerową, jak i niezdefiniowaną. Drugi warunek sprawdza pustą tablicę.

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

lub dzięki komentarzowi tsemera dodałem drugą wersję

if(arrayName && arrayName.length)

Następnie wykonałem test dla drugiego warunku, używając Scratchpad w 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!");
}

co również to potwierdza if(array2 && array2.length)i if(array2 && array2.length > 0)robią dokładnie to samo

Powinieneś użyć:

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

Jeśli chcesz sprawdzić, czy zmienna tablicy obrazów została zdefiniowana, możesz to zrobić w ten sposób

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 i podkreślenie

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

Za pomocą jQuery isEmptyObject()można sprawdzić, czy tablica zawiera elementy, czy nie.

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

Źródło: https://api.jquery.com/jQuery.isEmptyObject/

Prosty sposób, który nie powoduje wyjątków, jeśli nie istnieje, i konwersję na wartość logiczną:

!!array

Przykład:

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

Co powiesz na to ? sprawdzenie długości niezdefiniowanej tablicy może spowodować wyjątek.

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

Dla mnie na pewno niektóre z wysoko ocenianych odpowiedzi „działają”, kiedy umieszczam je w jsfiddle, ale kiedy mam dynamicznie generowaną listę tablic, wiele tego kodu w odpowiedziach po prostu nie działa dla MNIE.

To właśnie dla mnie działa.

var from = [];

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

Zauważ, ŻADNE cytaty nie są zdefiniowane i nie przejmuję się długością.

opcjonalne łączenie

Ponieważ opcjonalna propozycja łączenia osiągnęła etap 4 i zyskuje szersze poparcie, istnieje bardzo elegancki sposób, aby to zrobić

if(image_array?.length){

  // image_array is defined and has at least one element

}

Często spotykam się z tym problemem w Javascript. Dla mnie najlepszym sposobem na to jest sprawdzenie bardzo szerokiej kratki przed sprawdzeniem długości. Widziałem kilka innych rozwiązań w tym Q & A, ale chciałem być w stanie sprawdzić na obu nulllub undefinedlub jakiejkolwiek innej fałszywej wartości.

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

Będzie to pierwszy sprawdzić undefined, nullczy inne fałszywe wartości. Jeśli którakolwiek z tych prawd jest prawdą, dopełni boolean, ponieważ jest to OR. Następnie można sprawdzić bardziej ryzykowne sprawdzenie array.length, które może nas pomylić, jeśli tablica jest niezdefiniowana. To nigdy nie zostanie osiągnięty, jeśli arrayjest undefinedlub null, więc kolejność warunków jest bardzo ważne.

Za pomocą undescore lub lodash :

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

Poniżej znajduje się moje rozwiązanie opakowane w funkcję, która również generuje błędy w celu zarządzania kilkoma problemami z zakresem obiektu i wszystkimi możliwymi typami danych przekazywanymi do funkcji.

Oto moje skrzypce użyte do zbadania tego problemu ( źródło )

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

Jeśli nie masz zmiennej zadeklarowanej jako tablica, możesz utworzyć czek:

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

Sprawdza, czy zmienna x istnieje, a jeśli tak, sprawdza, czy jest to wypełniona tablica. w przeciwnym razie tworzy pustą tablicę (lub możesz robić inne rzeczy);

Jeśli masz pewność, że utworzono zmienną tablicową, następuje proste sprawdzenie:

var x = [];

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

Możesz sprawdzić moje skrzypce tutaj, pokazując najbardziej możliwe sposoby sprawdzenia tablicy.

Powinieneś to zrobić

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

w ts

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

w html

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

Kiedy tworzysz tablicę obrazków, jest ona pusta, dlatego twoja tablica obrazków ma długość 0

Jak stwierdzono w komentarzu poniżej, edytuję swoją odpowiedź na podstawie odpowiedzi na to pytanie ):

var image_array = []

w nawiasach klamrowych nic nie zmienia na obraz zdefiniowany wcześniej w kodzie