web-dev-qa-db-de.com

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

  1. Was ist der effizienteste Weg, um zu überprüfen, ob ein Array ein flaches Array Von Grundwerten ist oder ob es sich um ein multidimensionales Array handelt?
  2. Gibt es eine Möglichkeit, dies zu tun, ohne tatsächlich ein -Array zu durchlaufen und is_array() für jedes seiner Elemente auszuführen?
124
Wilco

Die kurze Antwort lautet: Nein, Sie können es nicht tun, ohne zumindest implizit zu schleifen, wenn die "zweite Dimension" irgendwo sein könnte. Wenn es im ersten Artikel sein muss, tun Sie es einfach 

is_array($arr[0]);

Die effizienteste Methode, die ich finden kann, ist die Verwendung einer foreach-Schleife für das Array, die bei jedem Treffer einen Kurzschluss darstellt (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 Schleife, aber sobald eine Übereinstimmung gefunden wird, können wir keine Kurzschlüsse bilden ...

$ 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)
121
Vinko Vrsalovic

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

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

Dieser optionale zweite Wert mode wurde in PHP 4.2.0 hinzugefügt. Aus dem PHP Docs :

Wenn der optionale Modusparameter auf COUNT_RECURSIVE (oder 1) gesetzt ist, zählt count () das Array rekursiv. Dies ist besonders nützlich, um alle Elemente eines mehrdimensionalen Arrays zu zählen. count () erkennt keine unendliche Rekursion.

Diese Methode erkennt array(array()) jedoch nicht.

177
zash

Für PHP 4.2.0 oder neuer:

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

Sie können dies einfach ausführen: 

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

Wenn der optionale Modusparameter auf COUNT_RECURSIVE (oder 1) gesetzt ist, zählt count () das Array rekursiv. Dies ist besonders nützlich, um alle Elemente eines mehrdimensionalen Arrays zu zählen.

Wenn es das gleiche ist, bedeutet das, dass es nirgendwo Unterebenen gibt. Einfach und schnell!

9
Pian0_M4n

Ich denke, das ist der einfachste Weg und es ist Stand der Technik:

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

Sie könnten check is_array() auf das erste Element überprüfen, wobei davon ausgegangen wird, dass das erste Element eines Arrays ein Array ist, der Rest ebenfalls.

7
Greg Hewgill

Alles gute Antworten ... hier sind meine drei Zeilen, die ich immer verwende

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

Ich denke, Sie werden feststellen, dass diese Funktion der einfachste, effizienteste und schnellste Weg ist.

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

Sie können es so 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';
2
RoboTamer

Diese Funktion gibt die Anzahl der Array-Dimensionen zurück (von hier gestohlen).

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

   return $return;
}

Versuchen Sie es wie folgt 

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

}else{

  echo 'arrayList is no multidimensional';
}
1
Arshid KV

Sie können auch eine einfache Überprüfung wie folgt durchführen:

$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
1
Prashant

Alle oben genannten Methoden sind zu komplex für ein schnelles Ausrollen. Wenn ein Array flach ist, sollte das Testen des ersten Elements ein Grundelement zurückgeben, z. B. int, string e.t.c. Wenn es mehrdimensional ist, sollte es ein Array zurückgeben. Als Erweiterung können Sie diesen einen Liner schnell und ordentlich verwenden.

echo is_array(array_shift($myArray));

wenn dies true zurückgibt, ist das Array mehrdimensional. Sonst ist es flach. Zu beachten ist, dass Arrays sehr selten unterschiedliche Abmessungen haben, z. Wenn Sie Daten aus einem Modell generieren, hat dieses immer dieselbe Art von mehrdimensionaler oder flacher Struktur, die von Schleifen durchlaufen werden kann. machine made loops Wenn dies nicht der Fall ist, haben Sie es von Hand erstellt, was bedeutet, dass Sie wissen, wo sich alles befinden wird und es einfach funktioniert, ohne einen Schleifenalgorithmus schreiben zu müssen enter image description here

0

In meinem Fall. Ich verharrte in unterschiedlichem seltsamen Zustand.
Erster Fall = array("data"=> "name");
2. Fall = array("data"=> array("name"=>"username","fname"=>"fname"));
Wenn data ein Array anstelle eines Werts hat, funktioniert die Funktion sizeof () oder count () für diese Bedingung nicht. Dann erstelle ich eine benutzerdefinierte Funktion zur Überprüfung .
Wenn der erste Index des Arrays einen Wert hat, wird "nur Wert" zurückgegeben. 
Aber wenn index Array anstelle von value hat, dann gibt es "Array" zurück. 
Ich benutze diesen Weg

 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

0
Darkcoder

Sogar das funktioniert

is_array(current($array));

Wenn false sein Array single dimension ist, wenn true ein Array multi dimension ist.

current gibt Ihnen das erste Element Ihres Arrays und prüft anhand der Funktion is_array, ob das erste Element ein Array ist oder nicht.

0
Priyank

Verwenden Sie nicht COUNT_RECURSIVE

klicken Sie auf diese Website, um zu erfahren, warum

verwenden Sie Rsort und 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 ) );
0
hendra1

Ich denke, das ist klassisch (Requisiten für einen anderen Benutzer, dessen Benutzernamen ich nicht kenne)

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

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

Es ist so einfach wie 

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

Zusätzlich zu den vorherigen Antworten und abhängig vom Schema des Arrays, das Sie überprüfen möchten:

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