it-swarm.com.de

Wie summieren Sie alle Spaltenwerte in einem mehrdimensionalen Array?

Wie kann ich alle Spaltenwerte über den assoziativen Schlüssel hinzufügen? Beachten Sie, dass[gozhi]key dynamic ist. 

Eingabefeld:

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

Erwünschtes Ergebnis :

Array
(
    [gozhi] => 10
    [uzorong] => 1
    [ngangla] => 8
    [langthel] => 10
)
96
marknt15
$sumArray = array();

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

print_r($sumArray);
82
Chris J

Sie können array_walk_recursive() verwenden, um eine generelle Lösung für Ihr Problem zu erhalten (die, wenn jedes innere Array möglicherweise eindeutige Schlüssel haben kann).

$final = array();

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

Beispiel mit array_walk_recursive() für den allgemeinen Fall

Seit PHP 5.5 können Sie auch die Funktion array_column() verwenden, um das gewünschte Ergebnis für den genauen Schlüssel, [gozhi] zu erhalten. zum Beispiel :

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

Beispiel mit array_column() für den angegebenen Schlüssel

Wenn Sie die Gesamtsumme aller inneren Arrays mit den gleichen Schlüsseln erhalten möchten (das gewünschte Ergebnis, das Sie gepostet haben), können Sie Folgendes tun (unter Berücksichtigung des ersten inneren Arrays) Array muss die gleiche Struktur haben wie die anderen):

$final = array_shift($input);

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

unset($value);

Beispiel mit array_column() für den Fall, dass alle inneren Arrays die gleichen Schlüssel haben

Wenn Sie eine allgemeine Lösung mit array_column() suchen, können Sie zunächst alle eindeutigen Schlüssel abrufen und dann die Summe für jeden Schlüssel abrufen:

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

Beispiel mit array_column() für den allgemeinen Fall

148
potashin

Hier ist eine Lösung, die den beiden anderen ähnlich ist:

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

Es muss jedoch nicht geprüft werden, ob die Array-Schlüssel bereits vorhanden sind, und es werden auch keine Benachrichtigungen ausgegeben.

27
Gumbo

Es kann auch mit array_map durchgeführt werden:

$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());
}
21
npcoda
$newarr=array();
foreach($arrs as $value)
{
  foreach($value as $key=>$secondValue)
   {
       if(!isset($newarr[$key]))
        {
           $newarr[$key]=0;
        }
       $newarr[$key]+=$secondValue;
   }
}
12
Graviton

Verwenden Sie dieses Snippet: 

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

Eine andere Version mit einigen Vorteilen.

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

}

Ich wollte das Beste aus Gumbos, Gravitons und Chris Js Antwort mit den folgenden Zielen kombinieren, damit ich dies in meiner App verwenden kann:

a) Initialisieren Sie die 'sum' Array-Schlüssel außerhalb der Schleife (Gumbo). Sollte bei sehr großen Arrays mit der Leistung helfen (noch nicht getestet!). Beseitigt Benachrichtigungen.

b) Die Hauptlogik ist leicht zu verstehen, ohne die Handbücher zu treffen. (Graviton, Chris J).

c) Lösen Sie das allgemeinere Problem des Addierens der Werte von zwei beliebigen Arrays mit denselben Schlüsseln, und machen Sie sie weniger abhängig von der Subarray-Struktur.

Im Gegensatz zur Lösung von Gumbo können Sie dies in Fällen verwenden, in denen die Werte nicht in Sub-Arrays liegen. Stellen Sie sich im nachstehenden Beispiel vor, dass $arr1 und $arr2 nicht hartcodiert sind, sondern als Ergebnis des Aufrufs einer Funktion innerhalb einer Schleife zurückgegeben werden.

$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);
5
Todd Chaffee

Es kann auch mit array_walk durchgeführt werden:

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

Nicht so lesbar wie bisherige Lösungen, aber es funktioniert :)

4

Hier ist eine Version, bei der die Array-Schlüssel für beide Arrays nicht identisch sind, Sie möchten jedoch, dass sie alle im endgültigen Array vorhanden sind.

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

Wir müssen zuerst prüfen, ob der Array-Schlüssel vorhanden ist.

CODE:

$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 mit Array-Schlüsselüberprüfung:

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

OUTPUT ohne Array-Schlüsselüberprüfung:

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
)

Dies ist eine schlechte Vorgehensweise, obwohl die Ausgabe gedruckt wird. Prüfen Sie immer zuerst, ob der Schlüssel existiert.

2
Bluetree

das funktioniert gut bei meinem Laravel-Projekt

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
0
Maurice Wagura

Sie können dies versuchen:

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

und schlussendlich:

print_r($c);
0
Rohan Katkar

Hier haben Sie, wie ich normalerweise solche Operationen mache.

// 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);
0
Luis González

Durchlaufen Sie jedes Element des Arrays und summieren Sie die Werte zu den vorherigen Werten, falls sie vorhanden sind, wenn Sie nicht nur den Wert zuweisen.

<?php
$array = 
[
    [
        'a'=>1,
        'b'=>1,
        'c'=>1,
    ],
    [
        'a'=>2,
        'b'=>2,
    ],
    [
        'a'=>3,
        'd'=>3,
    ]
];

$result = array_reduce($array, function($carry, $item) {
    foreach($item as $k => $v)
        $carry[$k] = isset($carry[$k]) ? $carry[$k] + $v : $v;

    return $carry;
}, []);

print_r($result);

Ausgabe:

Array
(
    [a] => 6
    [b] => 3
    [c] => 1
    [d] => 3
)
0
Progrock

Für diejenigen, die hier gelandet sind und nach einer Lösung suchen, die N-Arrays AND zusammenführt und die Werte identischer Schlüssel in den N-Arrays summiert, habe ich diese Funktion geschrieben, die auch rekursiv funktioniert. (Siehe: https://Gist.github.com/Nickology/f700e319cbafab5eaedc )

Beispiel:

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

Wird darin enden, dass:

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

)

Hier ist der 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;

}

?>
0
Nick