Come sumre tutti i valori delle colonne nell’array multidimensionale?

Come posso aggiungere tutti i valori colonnari per chiave associativa? Nota che la chiave [gozhi] è dynamic .

Array di input:

 Array ( [0] => Array ( [gozhi] => 2 [uzorong] => 1 [ngangla] => 4 [langthel] => 5 ) [1] => Array ( [gozhi] => 5 [uzorong] => 0 [ngangla] => 3 [langthel] => 2 ) [2] => Array ( [gozhi] => 3 [uzorong] => 0 [ngangla] => 1 [langthel] => 3 ) ) 

Risultato desiderato :

 Array ( [gozhi] => 10 [uzorong] => 1 [ngangla] => 8 [langthel] => 10 ) 

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

È ansible utilizzare array_walk_recursive() per ottenere una soluzione generica per il problema ( quella in cui ogni array interno può eventualmente avere chiavi univoche ).

 $final = array(); array_walk_recursive($input, function($item, $key) use (&$final){ $final[$key] = isset($final[$key]) ? $item + $final[$key] : $item; }); 

Esempio con array_walk_recursive() per il caso generale

Inoltre, dal momento che PHP 5.5 è ansible utilizzare la funzione array_column() per ottenere il risultato desiderato per la chiave esatta , [gozhi] , ad esempio:

 array_sum(array_column($input, 'gozhi')); 

Esempio con array_column() per la chiave specificata

Se vuoi ottenere la sum totale di tutti gli array interni con gli stessi tasti ( il risultato desiderato che hai postato ), puoi fare qualcosa di simile ( tenendo presente che il primo array interno deve avere la stessa struttura degli altri ):

 $final = array_shift($input); foreach ($final as $key => &$value){ $value += array_sum(array_column($input, $key)); } unset($value); 

Esempio con array_column() nel caso in cui tutti gli array interni abbiano le stesse chiavi

Se si desidera una soluzione array_column() con array_column() in un primo momento si può prendere in considerazione l’ array_column() tutte le chiavi univoche e quindi ottenere la sum per ogni chiave:

 $final = array(); foreach($input as $value) $final = array_merge($final, $value); foreach($final as $key => &$value) $value = array_sum(array_column($input, $key)); unset($value); 

Esempio con array_column() per il caso generale

Ecco una soluzione simile alle altre due:

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

Ma questo non ha bisogno di controllare se le chiavi dell’array esistono già e non lancia le notifiche neanche.

Può anche essere fatto usando array_map :

 $rArray = array( 0 => array( 'gozhi' => 2, 'uzorong' => 1, 'ngangla' => 4, 'langthel' => 5 ), 1 => array( 'gozhi' => 5, 'uzorong' => 0, 'ngangla' => 3, 'langthel' => 2 ), 2 => array( 'gozhi' => 3, 'uzorong' => 0, 'ngangla' => 1, 'langthel' => 3 ), ); $sumResult = call_user_func_array('array_map', array_merge(['sum'], $rArray)); function sum() { return array_sum(func_get_args()); } 
 $newarr=array(); foreach($arrs as $value) { foreach($value as $key=>$secondValue) { if(!isset($newarr[$key])) { $newarr[$key]=0; } $newarr[$key]+=$secondValue; } } 

Un’altra versione, con alcuni vantaggi di seguito.

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

Volevo combinare la migliore risposta di Gumbo’s, Graviton’s e Chris J con i seguenti obiettivi, quindi ho potuto utilizzarla nella mia app:

a) Inizializza le chiavi dell’array ‘sum’ al di fuori del loop (Gumbo). Dovrebbe aiutare con le prestazioni su array molto grandi (non ancora testati!). Elimina le notifiche.

b) La logica principale è facile da capire senza toccare i manuali. (Gravitone, Chris J).

c) Risolvere il problema più generale di aggiungere i valori di qualsiasi array con le stesse chiavi e renderlo meno dipendente dalla struttura dell’array secondario.

Diversamente dalla soluzione di Gumbo, è ansible riutilizzarla nei casi in cui i valori non sono in sotto-array. Immagina nell’esempio seguente che $arr1 e $arr2 non sono codificati, ma vengono restituiti come risultato del richiamo di una funzione all’interno di un ciclo.

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

Può anche essere fatto usando array_walk :

 function array_sum_values(array $input, $key) { $sum = 0; array_walk($input, function($item, $index, $params) { if (!empty($item[$params[1]])) $params[0] += $item[$params[1]]; }, array(&$sum, $key) ); return $sum; } var_dump(array_sum_values($arr, 'gozhi')); 

Non è così leggibile come le soluzioni precedenti ma funziona 🙂

Usa questo snippet:

 $key = 'gozhi'; $sum = array_sum(array_column($array,$key)); 

Ecco una versione in cui le chiavi dell’array potrebbero non essere le stesse per entrambi gli array, ma si desidera che siano tutti lì nell’array finale.

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

Dobbiamo prima controllare se la chiave dell’array esiste.

CODICE:

 $sum = array(); foreach ($array as $key => $sub_array) { foreach ($sub_array as $sub_key => $value) { //If array key doesn't exists then create and initize first before we add a value. //Without this we will have an Undefined index error. if( ! array_key_exists($sub_key, $sum)) $sum[$sub_key] = 0; //Add Value $sum[$sub_key]+=$value; } } print_r($sum); 

OUTPUT con convalida della chiave della matrice:

 Array ( [gozhi] => 10 [uzorong] => 1 [ngangla] => 8 [langthel] => 10 ) 

OUTPUT senza convalida della chiave di array:

 Notice: Undefined index: gozhi in F:\web\index.php on line 37 Notice: Undefined index: uzorong in F:\web\index.php on line 37 Notice: Undefined index: ngangla in F:\web\index.php on line 37 Notice: Undefined index: langthel in F:\web\index.php on line 37 Array ( [gozhi] => 10 [uzorong] => 1 [ngangla] => 8 [langthel] => 10 ) 

Questa è una ctriggers pratica anche se stampa l’output. Controlla sempre prima se la chiave esiste.

Puoi provare questo:

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

e infine:

 print_r($c); 

Per chi è atterrato qui e sta cercando una soluzione che unisce N array e sum anche i valori delle chiavi identiche trovate negli array N, ho scritto questa funzione che funziona anche ricorsivamente. (Vedi: https://gist.github.com/Nickology/f700e319cbafab5eaedc )

Esempio:

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

Risulterà in:

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

Ecco il codice:

  * @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; } ?> 

Ecco come faccio di solito questo tipo di operazioni.

 // We declare an empty array in wich we will store the results $sumArray = array(); // We loop through all the key-value pairs in $myArray foreach ($myArray as $k=>$subArray) { // Each value is an array, we loop through it foreach ($subArray as $id=>$value) { // If $sumArray has not $id as key we initialize it to zero if(!isset($sumArray[$id])){ $sumArray[$id] = 0; } // If the array already has a key named $id, we increment its value $sumArray[$id]+=$value; } } print_r($sumArray); 

questo funziona benissimo sul mio progetto laravel

 print_r($Array); // your original array $_SUM = []; // count($Array[0]) => if the number of keys are equall in all arrays then do a count of index 0 etc. for ($i=0; $i < count($Array[0]); $i++) { $_SUM[] = $Array[0][$i] + $Array[1][$i]; // do a for loop on the count } print_r($_SUM); // get a sumed up array 
 $sumArray = array(); foreach ($myArray as $k => $subArray) { foreach ($subArray as $id => $value) { if (!isset($sumArray[$id])) { $sumArray[$id] = 0; } $sumArray[$id]+=$value; } } 
 $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); `