✔ Problem mit Rekursion

[prinzschleifer]

Hallo Community,

ich bin gerade eine Funktion zu schreiben, die ein multidimensionales Array runterwandern soll.

Mein Array:

$testarray[] = array( 'name' => 'LOL', 'subcat' => array( 'name' => 'LOL2', 'subcat' => ''));

So, nun möchte ich eine 'subcat' auf ein normales array (nicht multidimensional) bringen.

Also habe ich folgeden Funktion geschrieben:

function digdown($array) { 	
		 	 if(is_array($array)) {
		 		foreach($array as $key1 => $value1) {
		 			$test[] = array('name' => $value1['name'], 'num' => $value1['num'], 'sub' => 1 );
		 			digdown($value1['subcat']);
		 			
		 		}
		 		return $test;
		 	} 	
		 }

Und sie wird hier aufgerufen:

$test = digdown($testarray);

Es wir aber lediglich der erste Werte eingetragen, also nur eine Rekursion durchgeführt. Dann bleibts stehen. Was mach ich falsch?

Danke!

 

[deepthroat]

Hi.

Das Problem ist, das du das Rückgabe-Array innerhalb der Funktion überhaupt nicht verwendest. Da müßtest du die 2 Arrays zusammenhängen.

Gruß

 

[prinzschleifer]

So?

function digdown($array) {     
              if(is_array($array)) {
                 foreach($array as $key1 => $value1) {
                     $test[] = array('name' => $value1['name'], 'num' => $value1['num'], 'sub' => 1 );
                    $test[] = digdown($value1['subcat']);
                     
                 }
                 return $test;
             }     
         }

Dann bekomm ich das hier:

Array
(
    [0] => Array
        (
            [name] => LOL
            [num] => 
            [sub] => 1
        )

    [1] => Array
        (
            [0] => Array
                (
                    [name] => L
                    [num] => L
                    [sub] => 1
                )

            [1] => 
            [2] => Array
                (
                    [name] => 
                    [num] => 
                    [sub] => 1
                )

            [3] => 
        )

)

Sieht komisch aus
Wie müsste ich die Funktion abändern?

 

[deepthroat]

Hi.

So wie du es jetzt machst, fügst du ja wieder ein Array als Element in das Array ein. Du müßtest die Arrays aneinanderhängen.

Schau mal hier: http://www.faqts.com/knowledge_base/view.phtml/aid/343

Gruß

 

[Ork6]

Hi!

So funktioniert es, zumindest bei dem Beispielarray:

<?php
		$testarray[] = array( 'name' => 'LOL', 'subcat' => array( 'name' => 'LOL2', 'subcat' => ''));
		
		function digdown($array) {     
              if(is_array($array)) {
                 foreach($array as $key1 => $value1) {
                    
                 	$test[] = array('name' => $value1['name'], 'num' => $value1['num'], 'sub' => 1 );

                    if (is_array($value1['subcat'])){
                    	$quark = $value1['subcat'];
                 		$test[] = array('name' => $quark['name'], 'num' => $quark['num'], 'sub' => 2 );
                    }
                 }
                 return $test;
                 
             }
   
         }  
        $test = digdown($testarray);
		
        print_r ($test);
	?>

Grüße
Uwe

 

[prinzschleifer]

Vielen, vielen dank!

Trotzdem,
dass Ding ist ja nicht rekursiv gelöst, sprich es geht zwei Arrays runter und dann ist Schluss.

Mein Testarray hat sich übrigens geändert, wäre nett wenn da jemand mal einen blick drüber werfen könnte:

*/					$testarray[] = array( 'bla' => 'bla', 'subcat' => array(array('name' => 'Name9', 'subcat' => '')));		 			
		 			$testarray[] = array( 'name' => 'Nam1', 'subcat' => 
		 														array( 
		 																array('name' => 'Nam1', 'subcat' => 
		 																		array(
		 																				array('name' => 'Nam2', 'subcat' => array() 
		 																			 ),
		 															 
		 																array('name' => 'Nam3', 'subcat' => array())))));

Wie man sehen kann: Ich will beliebig tief gehen können!

Array
(
    [0] => Array
        (
            [bla] => bla
            [subcat] => Array
                (
                    [0] => Array
                        (
                            [name] => Name9
                            [subcat] => 
                        )

                )

        )

    [1] => Array
        (
            [name] => Nam1
            [subcat] => Array
                (
                    [0] => Array
                        (
                            [name] => Nam1
                            [subcat] => Array
                                (
                                    [0] => Array
                                        (
                                            [name] => Nam2
                                            [subcat] => Array
                                                (
                                                )

                                        )

                                    [1] => Array
                                        (
                                            [name] => Nam3
                                            [subcat] => Array
                                                (
                                                )

                                        )

                                )

                        )

                )

        )

)

 

[DeluXe]

Zwar nicht gerade schön, aber funktionell.

$testarray[] = array( 
	'name' => 'Nam',
	'subcat' => array(
		'name' => 'Nam1',
		'subcat' => array(
			'name' => 'Nam2',
			'subcat' => array()
		), 
	),
	array(
		'name' => 'Nam3',
		'subcat' => array()
	)
);

function digdown( $array, $list = array() ) {
	if( !is_array( $array ) ) return false;
	
	foreach( $array as $k => $value ) {
        if ( !is_array( $value ) || empty( $value ) ) continue;
        
		$list[] = array( 'name' => $value['name'], 'num' => $k );

		if ( is_array( $value['subcat'] ) ) {
            $list = digdown( $value, $list );
	    }
    }
    return $list;
}

Mehr ist beim ersten Kaffee eben noch nicht drinne.

 

[ZodiacXP]

So, nun möchte ich eine 'subcat' auf ein normales array (nicht multidimensional) bringen.

Das rekursiv zu lösen ginge ganz einfach, indem du den Ausgabewert als zweites Argument referentiell mitgibst und das Ursprungsarray selbstverständlich rekursiv aufbaust. Die Funktion soll dazu nur einen Return Wert haben, wenn sie kein zweites Argument hat, also muss dieses nur noch optional sein und fertig is der Schuh:

function array_flat($arr, &$return = NULL)
{
  foreach ($arr as $val)
  {
    if ($val["name"])
    {
      $return[] = array(
        "name" => $val["name"]
      );
    }
    if(is_array($val["subcat"]))
    {
      array_flat($val, $return);
    }
  }
  if (!$return)
  {
    return $return;
  }
}

So oder so ähnlich. Vor dem ersten Kaffee ist mehr nicht drin. Hoffe der Sinn ist klar geworden. Vorher noch auf Fehler prüfen, hab gerade nichts zum Parsen. Und ich blick noch nich ganz bei deinem Testarray durch, vor allem weil dazu die gewünschte Ausgabe fehlt. Sonst wär es garkein Problem das sauber umzusetzen.

Noch zwe eventuell hilfreiche Funktionen:
http://de.php.net/manual/de/function.array-reduce.php
http://de.php.net/manual/de/function.array-map.php

 

[prinzschleifer]

Hi,

ich hatte leider noch keine Zeit an dem Algorithmus weiterzuarbeiten, aber ich kann euch ja mal das Zielarray geben, dann wird die Sache doch recht einfach.

Ursprungsarray:

Array
(
    [0] => Array
        (
            [name] => bla
            [subcat] => Array
                (
                    [0] => Array
                        (
                            [name] => Name9
                            [subcat] => 
                        )

                )

        )

    [1] => Array
        (
            [name] => Nam1
            [subcat] => Array
                (
                    [0] => Array
                        (
                            [name] => Nam1
                            [subcat] => Array
                                (
                                    [0] => Array
                                        (
                                            [name] => Nam2
                                            [subcat] => Array
                                                (
                                                )

                                        )

                                    [1] => Array
                                        (
                                            [name] => Nam3
                                            [subcat] => Array
                                                (
                                                )

                                        )

                                )

                        )

                )

        )

)

Zielarray

Array 
( 
[0] => bla
[1] => Nam9
[2] => Nam1
[3] => Nam1
[4] => Nam2
[5] => Nam3
)

Das Skript soll einfach den Namen jeder Subkategorie finden und in ein Array packen.

 

[Sven Mintel]

Moin,

Willst du jetzt Hilfe oder etwas erledigt haben?

Es wurden mehrere Lösungsvorschläge gepostet, wenn es dich zuviel Zeit kostet(und du nichtmal den Anstand besitzt) dir diese anzusehen, dann wende dich mit deinem Problem vielleicht besser an die Jobbörse