La transposition de tableaux multidimensionnels en PHP

function transpose($array) {
    array_unshift($array, null);
    return call_user_func_array('array_map', $array);
}

Ou si vous utilisez PHP 5.6 ou plus tard:

function transpose($array) {
    return array_map(null, ...$array);
}

Je pense que vous faites référence à la matrice transposer (colonnes deviennent les lignes, les lignes deviennent des colonnes).

Voici une fonction qui le fait pour vous (source):

function array_transpose($array, $selectKey = false) {
    if (!is_array($array)) return false;
    $return = array();
    foreach($array as $key => $value) {
        if (!is_array($value)) return $array;
        if ($selectKey) {
            if (isset($value[$selectKey])) $return[] = $value[$selectKey];
        } else {
            foreach ($value as $key2 => $value2) {
                $return[$key2][$key] = $value2;
            }
        }
    }
    return $return;
} 

Je suis confronté au même problème. Voici ce que j'ai trouvé:

function array_transpose(array $arr)
{
    $keys    = array_keys($arr);
    $sum     = array_values(array_map('count', $arr));

    $transposed = array();

    for ($i = 0; $i < max($sum); $i ++)
    {
        $item = array();
        foreach ($keys as $key)
        {
            $item[$key] = array_key_exists($i, $arr[$key]) ? $arr[$key][$i] : NULL;
        }
        $transposed[] = $item;
    }
    return $transposed;
}

Voici une variante de Codler/Andreas solution qui travaille avec des tableaux associatifs. Un peu plus de temps mais boucle-moins:

<?php
function transpose($array) {
    $keys = array_keys($array);
    return array_map(function($array) use ($keys) {
        return array_combine($keys, $array);
    }, array_map(null, ...array_values($array)));
}

Exemple:

<?php
$foo = array(
    "fooA" => [ "a1", "a2", "a3"],
    "fooB" => [ "b1", "b2", "b3"],
    "fooC" => [ "c1", "c2", "c3"]
);

print_r( $transpose( $foo ));
//Output like this:
Array (
    [0] => Array (
        [fooA] => a1
        [fooB] => b1
        [fooC] => c1
    )

    [1] => Array (
        [fooA] => a2
        [fooB] => b2
        [fooC] => c2
    )

    [2] => Array (
        [fooA] => a3
        [fooB] => b3
        [fooC] => c3
    )
);

<?php

$tableau_init = [
    [
        "prenom" => "med",
        "age" => 1
    ],
    [
        "prenom" => "hassan",
        "age" => 2
    ],
    [
        "prenom" => "ali",
        "age" => 3
    ]
];

function transpose($tableau){
    $out = array();

    foreach ($tableau as $key => $value){
        foreach ($value as $subKey => $subValue){
            $out[$subKey][$key] = $subValue;
        }
    }

    echo json_encode($out);
}

transpose($tableau_init);

Essayez Comme Ceci

C'est une autre façon de faire exactement la même chose que @codler s réponse ne. J'ai eu pour vider quelques tableaux au format csv j'ai donc utilisé la fonction suivante:

function transposeCsvData($data)
{
    $ct=0;
    foreach($data as $key => $val)
    {
        //echo count($val);
        if($ct< count($val))
            $ct=count($val);
        }
    //echo $ct;
    $blank=array_fill(0,$ct,array_fill(0,count($data),null));
    //print_r($blank);

    $retData = array();
    foreach ($data as $row => $columns)
    {
        foreach ($columns as $row2 => $column2) 
        {
            $retData[$row2][$row] = $column2;
            }
        }
    $final=array();
    foreach($retData as $k=>$aval)
    { 
        $final[]=array_replace($blank[$k], $aval);
       }
    return $final;
    }

De Test et de sortie de référence: https://tutes.in/how-to-transpose-an-array-in-php-with-irregular-subarray-size/

Si vous essayez de décompresser l'OP de l'échantillon de données avec le dossier de l'exploitant (...), vous allez générer:

Fatal error: Uncaught Error: Impossible de décompresser un tableau avec les clés de chaîne

La preuve

À surmonter cette erreur, appelez array_values() à l'index de la première clés au niveau de l'avant de déballer.

var_export(array_map(null, ...array_values($foo)));

De sortie:

array (
  0 => 
  array (
    0 => 'a1',
    1 => 'b1',
    2 => 'c1',
  ),
  1 => 
  array (
    0 => 'a2',
    1 => 'b2',
    2 => 'c2',
  ),
  2 => 
  array (
    0 => 'a3',
    1 => 'b3',
    2 => 'c3',
  ),
)

Une fonctionnalité supplémentaire/surprise concernant la transposition de cette technique est que null éléments seront générées lorsque les modules sont de différentes tailles ...mais peut-être pas où vous pourriez vous attendre.

À partir de l'échantillon de données comme ceci:

$foo = array(
    'a' => array(
       1 => 'a1',
       2 => 'a2'
    ),
    'b' => array(
       1 => 'b1',
       3 => 'b3' 
    ),
    'c' => array(
       1 => 'c1',
       2 => 'c2',
       3 => 'c3' 
    )
);

La sortie est:

array (
  0 => 
  array (
    0 => 'a1',
    1 => 'b1',
    2 => 'c1',
  ),
  1 => 
  array (
    0 => 'a2',
    1 => 'b3',
    2 => 'c2',
  ),
  2 => 
  array (
    0 => NULL,
    1 => NULL,
    2 => 'c3',
  ),
)

Avis le niveau de soins présenté par la fonction (comparable à la bagagistes qui porte vos bagages hors du ventre de l'avion). Il n'y a aucune attention à l'origine subarray valeurs de l'id (et ce ne serait pas grave si 1, 2, & 3 ont été x, y, & z); tout ce qui vient au large de la tapis roulant obtient jeté le plus bas de l'emplacement disponible.

Ce comportement est cohérent et fiable dans la prestation d'une matrice complète. Un foreach() boucle de remplacement ne sera pas nativement livrer null élément de sous-tableaux de tailles différentes, et dans la plupart des implémentations de sa capacité à accéder à tous les subarray valeurs dépend de la longueur de la première subarray.

$foo = array(
    'a' => array(
       1 => 'a1',
       2 => 'a2'
    ),
    'b' => array(
       1 => 'b1',
    ),
    'c' => array(
       1 => 'c1',
       2 => 'c2',
       3 => 'c3' 
    )
);

foreach (current($foo) as $column => $not_used) {
    $result[] = array_column($foo, $column);
}
var_export($result);

De sortie:

array (
  0 => 
  array (
    0 => 'a1',
    1 => 'b1',
    2 => 'c1',
  ),
  1 => 
  array (
    0 => 'a2',
    1 => 'c2',
  ),
)

Comme indiqué ci-dessus, si vous voulez être sûr que vous avez extrait TOUTES les données du tableau input, vous devriez écrire plus logique de livrer tous les unique de la colonne id de la boucle foreach.

---

p.s. avant que j'ai appris de cette abréviation de la transposition de la syntaxe, j'ai écrit un plus laid, plus détaillé fonctionnelle transpositeur que attrapé quelques critiques.