Sprawdzanie czy tablica jest wielowymiarowa czy nie?

Użyj count () dwa razy; jeden raz w trybie domyślnym i jeden raz w trybie rekurencyjnym. Jeśli wartości są zgodne, tablica jest , a nie wielowymiarowa, ponieważ tablica wielowymiarowa miałaby większą liczbę rekurencyjną.

if (count($array) == count($array, COUNT_RECURSIVE)) 
{
  echo 'array is not multidimensional';
}
else
{
  echo 'array is multidimensional';
}

Ta opcja druga wartość mode została dodana w PHP 4.2.0. Z PHP Docs:

Jeśli opcjonalny parametr mode jest ustawiony na COUNT_RECURSIVE (lub 1), count () policzy tablicę rekurencyjnie. Jest to szczególnie przydatne do liczenia wszystkich elementy wielowymiarowej tablicy. count() nie wykrywa nieskończonej rekurencji.

Jednak ta metoda nie wykrywa array(array()).

Dla PHP 4.2.0 lub nowszego:

function is_multi($array) {
    return (count($array) != count($array, 1));
}

Możesz po prostu wykonać to:

if (count($myarray) !== count($myarray, COUNT_RECURSIVE)) return true;
else return false;

Jeśli opcjonalny parametr mode jest ustawiony na COUNT_RECURSIVE (lub 1), count() policzy tablicę rekurencyjnie. Jest to szczególnie przydatne do liczenia wszystkich elementów tablicy wielowymiarowej.

Jeśli jest taki sam, oznacza to, że nie ma nigdzie podpoziomów. Łatwo i szybko!

Myślę, że jest to najbardziej prosta droga i jest najnowocześniejsza:

function is_multidimensional(array $array) {
    return count($array) !== count($array, COUNT_RECURSIVE);
}

Można sprawdzić is_array() Na pierwszym elemencie, przy założeniu, że jeśli pierwszy element tablicy jest tablicą, to reszta też.

Wszystkie świetne odpowiedzi... oto moje trzy linijki, których zawsze używam

function isMultiArray($a){
    foreach($a as $v) if(is_array($v)) return TRUE;
    return FALSE;
}

Ta funkcja zwróci int liczbę wymiarów tablicy (skradzionych z Tutaj ).

function countdim($array)
{
   if (is_array(reset($array))) 
     $return = countdim(reset($array)) + 1;
   else
     $return = 1;

   return $return;
}

Myślę, że przekonasz się, że ta funkcja jest najprostszym, najbardziej wydajnym i najszybszym sposobem.

function isMultiArray($a){
    foreach($a as $v) if(is_array($v)) return TRUE;
    return FALSE;
}

Możesz to przetestować TAK:

$a = array(1 => 'a',2 => 'b',3 => array(1,2,3));
$b = array(1 => 'a',2 => 'b');

echo isMultiArray($a) ? 'is multi':'is not multi';
echo '<br />';
echo isMultiArray($b) ? 'is multi':'is not multi';

Możesz również wykonać proste sprawdzenie w ten sposób:

$array = array('yo'=>'dream', 'mydear'=> array('anotherYo'=>'dream'));
$array1 = array('yo'=>'dream', 'mydear'=> 'not_array');

function is_multi_dimensional($array){
    $flag = 0;
    while(list($k,$value)=each($array)){
        if(is_array($value))
            $flag = 1;
    }
    return $flag;
}
echo is_multi_dimensional($array); // returns 1
echo is_multi_dimensional($array1); // returns 0

Spróbuj w następujący sposób

if (count($arrayList) != count($arrayList, COUNT_RECURSIVE)) 
{
  echo 'arrayList is multidimensional';

}else{

  echo 'arrayList is no multidimensional';
}

Myślę, że ten jest z klasą (rekwizyty do innego użytkownika nie znam jego nazwy użytkownika):

static public function isMulti($array)
{
    $result = array_unique(array_map("gettype",$array));

    return count($result) == 1 && array_shift($result) == "array";
}

Wszystkie powyższe metody są zbyt skomplikowane do szybkiego wdrożenia. Jeśli tablica jest płaska, testowanie pierwszego elementu powinno zwrócić prymitywną np. int, string e.T.c. jeśli jest wielowymiarowa, powinna zwrócić tablicę. Dzięki temu możesz używać tej jednej wkładki szybko i schludnie.

echo is_array(array_shift($myArray));

Jeśli to zwróci true, tablica jest wielowymiarowa. Inaczej jest płaski. Dla przypomnienia, bardzo rzadko tablice mają różne wymiary, np. jeśli generujesz dane z modelu, zawsze będą miały ten sam typ wielowymiarowej lub płaskiej struktury, którą można przemierzać za pomocą pętli. Jeśli tak nie jest, to masz niestandardowe zbudowanie go ręcznie, co oznacza, że wiesz, gdzie wszystko będzie i po prostu działa bez potrzeby pisania algorytmu pętli

Oprócz poprzednich odpowiedzi i w zależności od schematu tablicy, którą chcesz sprawdzić:

function is_multi_array($array=[],$mode='every_key'){

    $result = false;

    if(is_array($array)){

        if($mode=='first_key_only'){

            if(is_array(array_shift($array))){

                $result = true;
            }
        }
        elseif($mode=='every_key'){

            $result = true;

            foreach($array as $key => $value){

                if(!is_array($value)){

                    $result = false;
                    break;
                }
            }
        }
        elseif($mode=='at_least_one_key'){

            if(count($array)!==count($array, COUNT_RECURSIVE)){

                $result = true; 
            }
        }
    }

    return $result;
}

Nawet to działa

is_array(current($array));

If false its a single dimension array if true its a multi dimension array.

Current da ci pierwszy element tablicy i sprawdzi, czy pierwszy element jest tablicą, czy nie za pomocą funkcji is_array.

Nie używaj COUNT_RECURSIVE

Kliknij tutaj, aby dowiedzieć się dlaczego

Użyj rsort, a następnie użyj isset

function is_multi_array( $arr ) {
rsort( $arr );
return isset( $arr[0] ) && is_array( $arr[0] );
}
//Usage
var_dump( is_multi_array( $some_array ) );

W moim przypadku. Utknąłem w dziwnym stanie.
1. przypadek = array("data"=> "name");
2. przypadek = array("data"=> array("name"=>"username","fname"=>"fname"));
Ale jeśli data ma tablicę zamiast wartości, to funkcja sizeof() lub count () nie działa dla tego warunku. Następnie tworzę niestandardową funkcję do sprawdzenia.
Jeżeli pierwszy indeks tablicy ma wartość, wtedy zwraca "only value"
Ale jeśli indeks ma tablicę zamiast wartości, to zwraca "has array"
I use this way

 function is_multi($a) {
        foreach ($a as $v) {
          if (is_array($v)) 
          {
            return "has array";
            break;
          }
          break;
        }
        return 'only value';
    }

Specjalne podziękowania dla Vinko Vrsalovic

Natywna funkcja print_r zwraca czytelny dla człowieka łańcuch znaków. Wystarczy policzyć instancje "Array".

substr_count(print_r([...array...], true), 'Array') > 1;

$a = array(1 => 'a',2 => 'b',3 => array(1,2,3));
$b = array(1 => 'a',2 => 'b');
$c = array(1 => 'a',2 => 'b','foo' => array(1,array(2)));
$d = array(array());
$e = array(1, array());
$f = array(array(), array());
$g = array("hello", "hi" => "hi there");
$h[] = $g;

var_dump(substr_count(print_r($a, true), 'Array') > 1);
...

//a: bool(true)
//b: bool(false)
//c: bool(true)
//d: bool(true)
//e: bool(true)
//f: bool(true)
//g: bool(false)
//h: bool(true)

Na moim pudełku, "is_multi trwało 0.83681297302246 sekund w 500000 razy"

Dzięki Uprzejmości: Ruach HaKodesh

if($array[0]){
//enter your code 
}

if ( array_key_exists(0,$array) ) {

// multidimensional array

}  else {

// not a multidimensional array

}

*tylko do tablic z indeksem liczbowym

function isMultiArray(array $value)
{
    return is_array(reset($value));
}

is_array($arr[key($arr)]); 

Brak pętli, proste i proste.

Działa również z tablicami skojarzonymi, nie tylko numerycznymi, które nie mogą zawierać 0 ( jak w poprzednim przykładzie wyświetli ostrzeżenie, jeśli tablica nie ma 0. )