php - recorrer - ¿Comprobar si la matriz es multidimensional o no?

matrices multidimensionales

Question

1. ¿Cuál es la forma más eficiente de verificar si una matriz es una matriz plana de valores primitivos o si es una matriz multidimensional ?
2. ¿Hay alguna manera de hacerlo sin tener que recorrer un array y ejecutar is_array() en cada uno de sus elementos?

Answer 1

Además de las respuestas anteriores y según el esquema de la matriz que desea verificar:

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 2

Creo que encontrará que esta función es la más simple, la más eficiente y la más rápida.

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

Puedes probarlo así:

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

Creo que esta es la manera más directa y es lo último en tecnología:

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

Answer 4

Creo que este es elegante (accesorios para otro usuario, no conozco su nombre de usuario):

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

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

Answer 5

En mi caso. Me quedé en variar la condición extraña.
Primer caso = array("data"=> "name");
2 ° caso = array("data"=> array("name"=>"username","fname"=>"fname"));
Pero si los data tienen matriz en lugar de valor, la función sizeof () o count () no funciona para esta condición. Luego creo una función personalizada para verificar.
Si el primer índice de matriz tiene valor, entonces devuelve "solo valor"
Pero si el índice tiene matriz en lugar de valor, entonces devuelve "tiene matriz"
Yo uso de esta manera

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

Un agradecimiento especial a Vinko Vrsalovic

Answer 6

Esta función devolverá el número entero de dimensiones de la matriz (robado desde here ).

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

   return $return;
}

Answer 7

Incluso esto funciona

is_array(current($array));

Si es falso, una matriz de una dimensión si es verdadera es una matriz de múltiples dimensiones .

actual le dará el primer elemento de su matriz y comprobar si el primer elemento es una matriz o no por la función is_array .

Answer 8

La respuesta corta es no, no puedes hacerlo sin al menos iterar implícitamente si la ''segunda dimensión'' puede estar en cualquier parte. Si tiene que estar en el primer elemento, simplemente lo harías

is_array($arr[0]);

Pero, la manera general más eficiente que pude encontrar es utilizar un bucle foreach en la matriz, cortocircuitando cada vez que se encuentra un golpe (al menos el bucle implícito es mejor que el recto para ()):

$ 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

Bucle implícito, pero no podemos cortocircuitar tan pronto como se encuentre un partido ...

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

No use COUNT_RECURSIVE

haga clic en este sitio para saber por qué

use rsort y luego use 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 10

Para PHP 4.2.0 o posterior:

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

Answer 11

Podría mirar check is_array() en el primer elemento, bajo el supuesto de que si el primer elemento de una matriz es una matriz, el resto también lo es.

Answer 12

Pruebe de la siguiente manera

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

}else{

  echo ''arrayList is no multidimensional'';
}

Answer 13

Simplemente puede ejecutar esto:

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

Si el parámetro del modo opcional está configurado en COUNT_RECURSIVE (o 1), count () contará recursivamente la matriz. Esto es particularmente útil para contar todos los elementos de una matriz multidimensional.

Si es lo mismo, significa que no hay subniveles en ninguna parte. ¡Fácil y rápido!

Answer 14

También puede hacer una verificación simple como esta:

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

Todas las respuestas excelentes ... aquí están mis tres líneas que siempre uso

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

Answer 16

Todos los métodos anteriores son demasiado complejos para un despliegue rápido. Si una matriz es plana, la prueba del primer elemento debe devolver una primitiva, por ejemplo, int, cadena, etc. Si es multidimensional, debe devolver una matriz. Por extensión, puedes usar este trazador de líneas rápido y limpio.

echo is_array(array_shift($myArray));

si esto devuelve verdadero, la matriz es multidimensional. De lo contrario, es plano. Solo para observar, es muy raro que las matrices tengan diferentes dimensiones, por ejemplo, si está generando datos de un modelo, siempre tendrá el mismo tipo de estructura plana o multidimensional que puede atravesar mediante bucles. Si no es así, entonces usted lo ha creado a mano, lo que significa que sabe dónde estará todo y simplemente funciona sin necesidad de escribir un algoritmo de bucle.

Answer 17

Use count () dos veces; una vez en modo predeterminado y una vez en modo recursivo. Si los valores coinciden, la matriz no es multidimensional, ya que una matriz multidimensional tendría una cuenta recursiva más alta.

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

Esta opción del segundo mode valor se agregó en PHP 4.2.0. De los documentos de PHP :

Si el parámetro del modo opcional está configurado en COUNT_RECURSIVE (o 1), count () contará recursivamente la matriz. Esto es particularmente útil para contar todos los elementos de una matriz multidimensional. count () no detecta la recursión infinita.

Sin embargo, este método no detecta array(array()) .

Answer 18

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

Answer 19

if ( array_key_exists(0,$array) ) {

// multidimensional array

}  else {

// not a multidimensional array

}

* solo para aquellas matrices con índice numérico

Answer 20

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

Answer 21

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

No hay bucles, simple y llanamente

Funciona también con matrices asociadas no solo con matrices numéricas, que no podrían contener 0 (como en el ejemplo anterior, se lanzaría una advertencia si la matriz no tiene un 0).