Vérifier si array est multidimensionnel ou non?

utiliser count() deux fois; une fois en mode par défaut et une fois en mode récursif. Si les valeurs correspondent, le tableau est et non multidimensionnel, car un tableau multidimensionnel aurait un nombre récursif plus élevé.

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

cette deuxième valeur d'option mode a été ajoutée dans PHP 4.2.0. De la PHP Docs :

si le paramètre mode optionnel est défini à COUNT_RECURSIVE (ou 1), count () va recursivement compter le tableau. Ceci est particulièrement utile pour compter tous les éléments d'un tableau multidimensionnel. count () ne détecte pas la récursion infinie.

Toutefois, cette méthode ne détecte pas array(array()) .

pour PHP 4.2.0 ou plus récent:

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

vous pouvez simplement exécuter ceci:

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

si le paramètre de mode optionnel est défini à COUNT_RECURSIVE (ou 1), count() va recursively count le tableau. Ceci est particulièrement utile pour compter tous les éléments d'un tableau multidimensionnel.

si c'est le même, ça veut dire qu'il n'y a pas de sous-niveaux nulle part. Facile et rapide!

je pense que c'est le plus simple et c'est l'état de l'art:

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

on pourrait voir la case is_array() sur le premier élément, sous l'hypothèse que si le premier élément d'un tableau est un tableau, alors le reste d'entre eux sont trop.

toutes les bonnes réponses... voici mes trois lignes que j'utilise toujours

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

cette fonction retournera en nombre de dimensions du tableau (volé de ici ).

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

   return $return;
}

je pense que vous trouverez que cette fonction est la plus simple, la plus efficace et la plus rapide.

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

vous pouvez le tester comme ceci:

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

vous pouvez aussi faire une simple vérification comme celle-ci:

$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

Essayer comme suit:

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

}else{

  echo 'arrayList is no multidimensional';
}

je pense que celui-ci est classe (accessoires pour un autre utilisateur Je ne sais pas son nom d'utilisateur):

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

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

Toutes les méthodes ci-dessus sont trop complexes pour un déroulement rapide. Si un tableau est plat, tester le premier élément devrait retourner un e primitif.G int, string E. T. C. S'il est multidimensionnel, il devrait retourner un tableau. Par extension, vous pouvez utiliser ce liner rapide et soigné.

echo is_array(array_shift($myArray));

si cela est vrai, le tableau est multidimensionnel. Sinon, il est plat. Juste pour noter, Il est très rare que les tableaux aient des dimensions différentes, par exemple si vous générez des données d'un modèle, il aura toujours le même type de structure multidimensionnelle ou plate qui peut être traversé par des boucles. Si ce n'est pas le cas, alors vous avez personnalisé construit à la main, ce qui signifie que vous savez où tout sera Et il fonctionne tout simplement sans avoir besoin d'écrire un algorithme de boucle

en plus des réponses précédentes et en fonction du schéma du tableau que vous voulez vérifier:

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

Même cela fonctionne

is_array(current($array));

Si false son seule dimension tableau vrai son multi dimension "151950920 tableau.