Sprawdzanie, czy tablica jest wielowymiarowa, czy nie?

1. Jaki jest najskuteczniejszy sposób sprawdzenia, czy tablica jest płaską tablicą wartości pierwotnych, czy też tablicą wielowymiarową ?
2. Czy istnieje sposób, aby to zrobić bez faktycznego przeglądania tablicy i uruchamiania is_array()na każdym z jej elementów?

Krótka odpowiedź brzmi: nie, nie możesz tego zrobić bez przynajmniej niejawnego zapętlenia, jeśli „drugi wymiar” może być gdziekolwiek. Jeśli ma być w pierwszej pozycji, po prostu zrób

is_array($arr[0]);

Ale najbardziej wydajnym sposobem, jaki mogłem znaleźć, jest użycie pętli foreach w tablicy, skracając za każdym razem, gdy zostanie znalezione trafienie (przynajmniej niejawna pętla jest lepsza niż prosta for ()):

$ more multi.php
<?php

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

function is_multi($a) {
    $rv = array_filter($a,'is_array');
    if(count($rv)>0) return true;
    return false;
}

function is_multi2($a) {
    foreach ($a as $v) {
        if (is_array($v)) return true;
    }
    return false;
}

function is_multi3($a) {
    $c = count($a);
    for ($i=0;$i<$c;$i++) {
        if (is_array($a[$i])) return true;
    }
    return false;
}
$iters = 500000;
$time = microtime(true);
for ($i = 0; $i < $iters; $i++) {
    is_multi($a);
    is_multi($b);
    is_multi($c);
}
$end = microtime(true);
echo "is_multi  took ".($end-$time)." seconds in $iters times\n";

$time = microtime(true);
for ($i = 0; $i < $iters; $i++) {
    is_multi2($a);
    is_multi2($b);
    is_multi2($c);
}
$end = microtime(true);
echo "is_multi2 took ".($end-$time)." seconds in $iters times\n";
$time = microtime(true);
for ($i = 0; $i < $iters; $i++) {
    is_multi3($a);
    is_multi3($b);
    is_multi3($c);
}
$end = microtime(true);
echo "is_multi3 took ".($end-$time)." seconds in $iters times\n";
?>

$ php multi.php
is_multi  took 7.53565130424 seconds in 500000 times
is_multi2 took 4.56964588165 seconds in 500000 times
is_multi3 took 9.01706600189 seconds in 500000 times

Niejawne zapętlenie, ale nie możemy zwierać, gdy tylko zostanie znalezione dopasowanie ...

$ more multi.php
<?php

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

function is_multi($a) {
    $rv = array_filter($a,'is_array');
    if(count($rv)>0) return true;
    return false;
}

var_dump(is_multi($a));
var_dump(is_multi($b));
?>

$ php multi.php
bool(true)
bool(false)

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

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

Ta druga wartość opcji modezostała dodana w PHP 4.2.0. Z dokumentów PHP :

Jeśli opcjonalny parametr trybu jest ustawiony na COUNT_RECURSIVE (lub 1), funkcja count () będzie rekurencyjnie zliczać tablicę. Jest to szczególnie przydatne do liczenia wszystkich elementów tablicy wielowymiarowej. 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));
}

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

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

Możesz po prostu wykonać to:

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

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

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

Możesz sprawdzić is_array()pierwszy element, zakładając, że jeśli pierwszy element tablicy jest tablicą, to reszta też jest.

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 liczbę int wymiarów tablicy (skradzionych stąd ).

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ć w ten sposób:

$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';

Po PHP 7 możesz po prostu zrobić:

public function is_multi(array $array):bool
{
    return is_array($array[array_key_first($array)]);
}

Możesz również wykonać prostą kontrolę, taką jak ta:

$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';
}

Nawet to działa

is_array(current($array));

Jeśli fałsz jest to tablica jednowymiarowa, jeśli prawda, to tablica wielowymiarowa .

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

Nie używaj COUNT_RECURSIVE

kliknij tę witrynę, 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 różnych dziwnych warunkach.
Pierwszy przypadek = array("data"=> "name");
Drugi przypadek = array("data"=> array("name"=>"username","fname"=>"fname"));
Ale jeśli datama tablicę zamiast wartości, to funkcja sizeof () lub count () nie będzie działać dla tego warunku. Następnie tworzę funkcję niestandardową do sprawdzenia.
Jeśli pierwszy indeks tablicy ma wartość to zwraca "jedyną wartość"
Ale jeśli indeks ma tablicę zamiast wartości to zwraca "ma tablicę"
Używam w ten sposób

 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 Vrsalovica

Myślę, że ten jest elegancki (rekwizyty dla innego użytkownika, którego nie znam):

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, aby można je było szybko wdrożyć. Jeśli tablica jest płaska, testowanie pierwszego elementu powinno zwrócić prymityw, np. Int, string, itp. Jeśli jest wielowymiarowy, powinien 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 zwraca prawdę, tablica jest wielowymiarowa. W przeciwnym razie jest płaski. Warto zauważyć, że bardzo rzadko tablice mają różne wymiary, np. Jeśli generujesz dane z modelu, zawsze będzie on miał ten sam typ wielowymiarowej lub płaskiej struktury, przez którą można przechodzić przez pętle. Jeśli tak nie jest, to zbudowałeś go ręcznie, co oznacza, że ​​wiesz, gdzie wszystko będzie, i po prostu działa bez konieczności pisania algorytmu zapętlenia

Oprócz wcześniejszych odpowiedzi iw 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;
}

To jest tak proste, jak

$isMulti = !empty(array_filter($array, function($e) {
                    return is_array($e);
                }));

$is_multi_array = array_reduce(array_keys($arr), function ($carry, $key) use ($arr) { return $carry && is_array($arr[$key]); }, true);

Oto ładna jedna wkładka. Iteruje po każdym kluczu, aby sprawdzić, czy wartość w tym kluczu jest tablicą. To zapewni prawdę

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

if ( array_key_exists(0,$array) ) {

// multidimensional array

}  else {

// not a multidimensional array

}

* tylko do tych tablic z indeksem numerycznym

Natywna funkcja print_r zwraca ciąg czytelny dla człowieka. Po prostu policz instancje „Array”.

próbować...

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 zajęło 0,83681297302246 sekund 500000 razy”

Dzięki uprzejmości: Ruach HaKodesh

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

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

Bez pętli, jasne i proste.

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