[dsxs]

Hi Leute

Ich habe ein Array, welches viele weitere Arrays enthält. Jedes dieser Arrays enthält wiederum viele Arrays und irgendwann komme ich dann zu der Dimension, in welcher nur noch Einträge sind.

Die Anzahl dieser Einträge im gesamten, grossen Array möchte ich nun auszählen.

Ich bin sicher, dass dies mit einer Callback Funktion möglich sein muss, bringe es mit array_map einfach nicht hin.

Hat mir jemand eine einfache Lösung?

Danke im Voraus

[Ben]

Hm,
ohne mir jetzt wirklich Gedanken gemacht zu haben, würde ich das rekursiv so lösen, dass ich in das Array "reingehe" und es durchlaufe und immer, wenn ein Element ein Array ist, gehe ich eine Dimension tiefer. Muss man dann den aktuellen Schlüssel mitgeben, um beim Rücksprung wieder an der richtigen Stelle weitermachen zu können.

Hmmm ..

[Corvin]

Zitat von http://de.php.net/manual/en/function.count.php

If the optional mode parameter is set to COUNT_RECURSIVE (or 1), count() will recursively count the array. This is particularly useful for counting all the elements of a multidimensional array. The default value for mode is 0. count() does not detect infinite recursion.

Also:

PHP-Code:

echo count($arr, 1); 


// edit:
Mouhaha. Just RTFM!

[WarrenFaith]

PHP-Code:

function countArray($arr) {
  foreach($arr as $key => $value) {
    if (is_array($value) {
      countArray($arr);
    } else {
      $i++;
    }
  }
}

$i = 0;
countArray($deinArray);
echo "Größe: ".$i; 


sollte doch reichen oder?

PS: für fehler übernehm ich keine Haftung, hab momentan nur noch in Java zu tun

//nachtrag:
tjo das nennt man wohl owned

[dsxs]

Danke für eure raschen Antworten.

@Ben und Warren: so habe ich mir das eben auch gedacht, aber ich war mir sicher, dass es auch einfacher geht als dutzende von foreach Schlaufen zu generieren.

Super Corvin, den kannte ich nicht. Owned, jep *rofl*

Danke an alle

[Ben]

Oh fein. Das kannte ich auch nicht.
Definitiv einfacher, als da selbst rumzu"rekursieren"

[dejan_spasic]

Zitat von Corvin

Also:

PHP-Code:

echo count($arr, 1); 


Dazu sage ich nur

Wenn ich eine Oper hundertmal dirigiert habe, dann ist es Zeit, sie wieder zu lernen.– Arturo Toscanini (1867–1957)

Nur, die Funkition gibt be einem Array wie diesem hier

PHP-Code:

$arr = array(
    array(
        array('eins', 'zwei'),
        array('drei', 'vier'),
    ),
    array(
        array(
            array('fünf', 'sechs')
        ),
        array('sieben', 'acht', 'neun'),
        array(
            array(
                array('zehn')
            ),
        ),
    ),
    'elf'   
); 


21 zurück. Was auch eigentlich richtig ist, da es auch die "Knotenpunkte"
bei Zählung mit einbezieht. Doch wie ich dsxs verstanden habe, benötigt er
eine Funktion die 11 zurück gibt. Wenn es so sein sollte, dann ist der
Lösungsweg von WarrenFaith der richtige.

[dsxs]

Danke noch für den Input Dejan... Habe dies auch soeben bemerkt -> count zusammen mit dem Flag, den Corvin vorschlug, zählt mir auch die Arrays selber, welche ich eigentlich nicht dabei haben wollte...

Dementsprechend habe ich jetzt Warrens Idee eingebaut.

[WarrenFaith]

Yeah doch nicht geowned

[Waq]

PHP-Code:

function countRecursive ($x) {
    if (is_array($x))
        return array_sum(array_map('countRecursive',$x));
    else 
        return 1;
} 


funktionale Programmierung ownz
Auch wenn das in einer funktionalen Sprache besser lesbar wäre, und deklarativ ein Zweizeiler ohne If-Gerücke.

[WarrenFaith]

doch geowned - wie fies! :-P

[dejan_spasic]

Zitat von Waq

PHP-Code:

function countRecursive ($x) {
    if (is_array($x))
        return array_sum(array_map('countRecursive',$x));
    else 
        return 1;
} 


funktionale Programmierung ownz
Auch wenn das in einer funktionalen Sprache besser lesbar wäre, und deklarativ ein Zweizeiler ohne If-Gerücke.

Nice

Doch die rekursive Variante von WarrenFaith ist von der Perfomence um einiges besser und zwar im Durchschnitt um 45-50%.

PHP-Code:

$arr = array(
    array(
        array('eins', 'zwei'),
        array('drei', 'vier'),
    ),
    array(
        array(
            array('fünf', 'sechs')
        ),
        array('sieben', 'acht', 'neun'),
        array(
            array(
                array('zehn')
            ),
        ),
    ),
    'elf',
);

function countRecursive ($x) 
{
    if (is_array($x))
        return array_sum(array_map('countRecursive',$x));
    else 
        return 1;
}

function count_deep_values(array $a)
{
    $c = 0;
    foreach ($a as $v) {
        if (is_array($v)) 
            $c += count_deep_values($v);
        else  
            ++$c;
    }
    return $c;
}

require_once 'Benchmark/Iterate.php';

$benchmark = new Benchmark_Iterate();

$benchmark->run(1000, 'countRecursive', $arr);
$result = $benchmark->get();
$first = $result['mean'];

$benchmark = new Benchmark_Iterate();

$benchmark->run(1000, 'count_deep_values', $arr);
$result = $benchmark->get();
$second = $result['mean'];

print "countRecursive: " . $first . PHP_EOL; //~0.000118
print "count_deep_values: " . $second . PHP_EOL; //~0.00079 


[JumperII]

Wundert mich nicht wirklich, da die verschachtelten Prozeßaufrufe inkl. Callback-funktionalität mehr overhead in der Verwaltung bedeuten.

Gruß,
Jumper, the II.

[Ben]

Sehr interessanter Thread.
Die unterschiedlichen Methoden sind wirklich nett und der Benchmark von waq's Lösung rundet das eigentlich gut ab.

Zum Anschauen ist countRecursive() aber wirklich klasse.