Überprüfen, ob Array mehrdimensional ist oder nicht?

Question

1. Was ist der effizienteste Weg ist, zu überprüfen, ob ein Array ein flaches Array primitiver Werte oder wenn es ein mehrdimensionales Array ?
2. Gibt es eine Möglichkeit, dies zu tun, ohne tatsächlich Schleife durch eine Array und läuft is_array() auf jedes seiner Elemente?

Answer 1

Die kurze Antwort ist nein Sie es nicht tun, ohne zumindest Looping implizit, wenn die ‚zweite Dimension‘ könnte überall sein. Wenn es in dem ersten Element sein muss, dann würden Sie gerade tun

is_array($arr[0]);

Aber das effizienteste allgemein die ich finden konnte ist eine foreach-Schleife auf dem Array zu verwenden, zu, wenn ein Treffer gefunden wird (zumindest die implizite Schleife ist besser als die gerade für ()):

$ 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

Implizite Looping, aber wir können nicht so schnell kurzzuschließen als eine Übereinstimmung gefunden wird ...

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

Answer 2

Verwenden count () zweimal; einmal im Standardmodus und eine Zeit im rekursiven Modus. Wenn die Werte übereinstimmen, das Array nicht mehrdimensional, wie ein mehrdimensionales Array würde eine höhere rekursive Anzahl haben.

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

Diese Option zweiter Wert mode wurde in PHP 4.2.0 hinzugefügt. Aus dem PHP Docs :

  

Wenn die optionale Modus Parameter auf COUNT_RECURSIVE (oder 1), count () rekursiv das Array zählen. Dies ist besonders nützlich für alle Elemente eines mehrdimensionalen Array zählen. count () erkennt keine unendliche Rekursion.

Doch diese Methode nicht erkennt array(array()).

Answer 3

Für PHP 4.2.0 oder neuer:

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

Answer 4

Ich denke, das der direkteste Weg ist, und es ist state-of-the-art:

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

Answer 5

Sie können dies einfach ausführen:

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

Wenn die optionale Modus Parameter auf COUNT_RECURSIVE (oder 1), count () rekursiv das Array zählen. Dies ist besonders nützlich für alle Elemente eines mehrdimensionalen Arrays gezählt wird.

Wenn es das gleiche, bedeutet, es gibt überall keine Unterebenen. Einfach und schnell!

Answer 6

Sie könnten sehen is_array() auf dem ersten Elemente überprüfen, unter der Annahme, dass, wenn das erste Element eines Arrays ein Array ist, dann der Rest von ihnen ist es auch.

Answer 7

Alle großen Antworten ... hier ist meine drei Linien, die ich immer bin mit

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

Answer 8

Diese Funktion int Anzahl der Array-Dimensionen zurückkehren (bestohlen hier ).

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

   return $return;
}

Answer 9

Ich glaube, Sie werden feststellen, dass diese Funktion die einfachste, effizienteste und schnellste Weg.

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

Sie können es wie folgt testen:

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

Answer 10

Sie können auch eine einfache Prüfung wie folgt tun:

$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

Answer 11

Versuchen Sie wie folgt

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

}else{

  echo 'arrayList is no multidimensional';
}

Answer 12

Verwenden Sie keine COUNT_RECURSIVE

Diese Website klicken für, warum

Verwendung rsort und verwenden Sie dann isset

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

Answer 13

Ich denke, das eine noble ist (Requisiten zu einem anderen Benutzer Ich weiß nicht, seine Benutzername):

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

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

Answer 14

Alle oben genannten Methoden sind zu komplex für eine schnelle Ausrollen. Wenn ein Array flach ist, sollte das erste Element zurück Testen ein primitives z.B int, string e.t.c. Wenn es mehrdimensional ist, sollte es ein Array zurück. Durch die Erweiterung, können Sie diesen Einzeiler schnell und ordentlich verwenden.

echo is_array(array_shift($myArray));

Wenn das wahr zurückgibt, ist das Array mehrdimensional. Else ist es flach. Just zu beachten, es ist sehr selten für Arrays unterschiedliche Abmessungen aufweisen, um z wenn Sie Daten von einem Modell generieren, wird es immer die gleiche Art von mehrdimensionalen oder flacher Struktur, die durch Schleifen durchlaufen werden kann. Wenn dies nicht der Fall, dann haben Sie benutzerdefinierte es von Hand gebaut, was bedeutet, dass Sie wissen, wo alles sein wird, und es funktioniert, ohne dass ein Looping-Algorithmus schreiben

Answer 15

Zusätzlich zu den bisherigen Antworten und je nach dem Schema des Arrays Sie überprüfen mögen:

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

Answer 16

Auch das funktioniert

is_array(current($array));

Wenn false its a eindimensionale Array, wenn true its a Multi Dimension Array.

Strom werden Ihnen das erste Element des Arrays geben und prüfen, ob das erste Element ein Array ist oder nicht von is_array Funktion.

Answer 17

In meinem Fall. Ich steckte in variieren seltsamen Zustand.
1. Fall = array("data"=> "name");
2. Fall = array("data"=> array("name"=>"username","fname"=>"fname"));
Aber wenn data Array statt Wert dann sizeof () oder count () Funktion nicht für diesen Zustand arbeiten. Dann erstelle ich benutzerdefinierte Funktion zu überprüfen.
Wenn der erste Indexwert des Arrays haben, dann schicken Sie es „nur Wert“
Aber wenn Index des Wertes Array stattdessen dann zurückgeben „hat Array“
Ich benutze diese Art und Weise

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

Besonderer Dank geht an Vinko Vrsalovic

Answer 18

Seine so einfach wie

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

Answer 19

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

Answer 20

if ( array_key_exists(0,$array) ) {

// multidimensional array

}  else {

// not a multidimensional array

}

* Nur auf diese Arrays mit numerischem Index

Answer 21

Die native print_r Funktion gibt einen Menschen lesbaren String. Zählen Sie die "Array" Instanzen.

versuchen ...

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)

Auf dem Feld "is_multi nahm ,83681297302246 Sekunden in 500000 mal"

Mit freundlicher Genehmigung: Ruach HaKodesh

Answer 22

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

Answer 23

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

Keine Schleifen, schlicht und einfach.

Funktioniert auch mit Associate-Arrays nicht nur numerischer Arrays, die nicht 0 enthalten könnte (wie im vorherigen Beispiel würde eine Warnung aus, wenn das Array nicht über ein 0)