Comment la somme de toutes les valeurs de colonne dans un tableau multi-dimensionnel?

$sumArray = array();

foreach ($myArray as $k=>$subArray) {
  foreach ($subArray as $id=>$value) {
    $sumArray[$id]+=$value;
  }
}

print_r($sumArray);

Voici une solution similaire pour les deux autres:

$acc = array_shift($arr);
foreach ($arr as $val) {
    foreach ($val as $key => $val) {
        $acc[$key] += $val;
    }
}

Mais ce n'est pas nécessaire de vérifier si le tableau de clés existent déjà et ne jette pas d'avis non plus.

$newarr=array();
foreach($arrs as $value)
{
  foreach($value as $key=>$secondValue)
   {
       if(!isset($newarr[$key]))
        {
           $newarr[$key]=0;
        }
       $newarr[$key]+=$secondValue;
   }
}

Une autre version, avec quelques avantages ci-dessous.

$sum = ArrayHelper::copyKeys($arr[0]);

foreach ($arr as $item) {
    ArrayHelper::addArrays($sum, $item);
}


class ArrayHelper {

    public function addArrays(Array &$to, Array $from) {
        foreach ($from as $key=>$value) {
            $to[$key] += $value;
        }
    }

    public function copyKeys(Array $from, $init=0) {
        return array_fill_keys(array_keys($from), $init);
    }

}

J'ai voulu combiner le meilleur de Gumbo, de Graviton, et Chris J de réponse, avec les objectifs suivants afin que je puisse l'utiliser dans mon application:

a) Initialiser la "somme" de la matrice de touches à l'extérieur de la boucle (Gumbo). Devrait aider avec des performances sur de très grands tableaux (pas encore testé!). Élimine les avis.

b) les Principaux logique est facile à comprendre sans heurter les manuels. (Le Graviton, Chris J).

c) Résoudre le problème plus général de l'ajout des valeurs des deux tableaux avec la même clé et la rendre moins dépendante de la sous-structure du tableau.

Contrairement à Gumbo de la solution, il est possible de réutiliser ce dans les cas où les valeurs ne sont pas dans des sous-tableaux. Imaginez dans l'exemple ci-dessous que $arr1 et $arr2 ne sont pas codées en dur, mais sont retournés comme le résultat de l'appel d'une fonction à l'intérieur d'une boucle.

$arr1 = array(
    'gozhi' => 2,
    'uzorong' => 1,
    'ngangla' => 4,
    'langthel' => 5
);

$arr2 = array(
   'gozhi' => 5,
   'uzorong' => 0,
   'ngangla' => 3,
   'langthel' => 2
);

$sum = ArrayHelper::copyKeys($arr1);

ArrayHelper::addArrays($sum, $arr1);
ArrayHelper::addArrays($sum, $arr2);

Voici une version où la matrice de touches peuvent ne pas être les mêmes pour les deux tableaux, mais vous veux tous à être là, dans le tableau final.

function array_add_by_key( $array1, $array2 ) {
    foreach ( $array2 as $k => $a ) {
        if ( array_key_exists( $k, $array1 ) ) {
            $array1[$k] += $a;
        } else {
            $array1[$k] = $a;
        }
    }
    return $array1;
}

Pour ceux qui ont débarqué ici et sont à la recherche d'une solution qui fusionne N tableaux ET également à la somme des valeurs de clés identiques trouvés dans le N tableaux, j'ai écrit cette fonction qui fonctionne de manière récursive ainsi. (Voir: https://gist.github.com/Nickology/f700e319cbafab5eaedc)

Exemple:

$a = array( "A" => "bob", "sum" => 10, "C" => array("x","y","z" => 50) );
$b = array( "A" => "max", "sum" => 12, "C" => array("x","y","z" => 45) );
$c = array( "A" => "tom", "sum" =>  8, "C" => array("x","y","z" => 50, "w" => 1) );

print_r(array_merge_recursive_numeric($a,$b,$c));

Permettra:

Array
(
    [A] => tom
    [sum] => 30
    [C] => Array
        (
            [0] => x
            [1] => y
            [z] => 145
            [w] => 1
        )

)

Voici le code:

<?php 
/**
* array_merge_recursive_numeric function.  Merges N arrays into one array AND sums the values of identical keys.
* WARNING: If keys have values of different types, the latter values replace the previous ones.
* 
* Source: https://gist.github.com/Nickology/f700e319cbafab5eaedc
* @params N arrays (all parameters must be arrays)
* @author Nick Jouannem <[email protected]>
* @access public
* @return void
*/
function array_merge_recursive_numeric() {
//Gather all arrays
$arrays = func_get_args();
//If there's only one array, it's already merged
if (count($arrays)==1) {
return $arrays[0];
}
//Remove any items in $arrays that are NOT arrays
foreach($arrays as $key => $array) {
if (!is_array($array)) {
unset($arrays[$key]);
}
}
//We start by setting the first array as our final array.
//We will merge all other arrays with this one.
$final = array_shift($arrays);
foreach($arrays as $b) {
foreach($final as $key => $value) {
//If $key does not exist in $b, then it is unique and can be safely merged
if (!isset($b[$key])) {
$final[$key] = $value;
} else {
//If $key is present in $b, then we need to merge and sum numeric values in both
if ( is_numeric($value) && is_numeric($b[$key]) ) {
//If both values for these keys are numeric, we sum them
$final[$key] = $value + $b[$key];
} else if (is_array($value) && is_array($b[$key])) {
//If both values are arrays, we recursively call ourself
$final[$key] = array_merge_recursive_numeric($value, $b[$key]);
} else {
//If both keys exist but differ in type, then we cannot merge them.
//In this scenario, we will $b's value for $key is used
$final[$key] = $b[$key];
}
}
}
//Finally, we need to merge any keys that exist only in $b
foreach($b as $key => $value) {
if (!isset($final[$key])) {
$final[$key] = $value;
}
}
}
return $final;
}
?>

Vous pouvez essayer ceci:

$c = array_map(function () {
return array_sum(func_get_args());
},$a, $b);

et enfin:

print_r($c);

$sumArray = array();
foreach ($myArray as $k=>$subArray) {
foreach ($subArray as $id=>$value) {
if(!isset($sumArray[$id])){
$sumArray[$id] =$value;
}else {
$sumArray[$id]+=$value;
}
}
}
print_r($sumArray);
`