SELFPHP

SELFPHP-Druckversion
Original Adresse dieser Seite:
http://www.selfphp.de/praxisbuch/praxisbuchseite.php?site=164&group=28&page=2
© 2001-2017 E-Mail SELFPHP OHG, info@selfphp.de
© 2005-2017 E-Mail PHP5 Praxisbuch - Matthias Kannengiesser, m.kannengiesser@selfphp.de


Nützliche Arrayfunktionen


Wie Sie bereits erfahren haben, stellt Ihnen PHP eine Reihe Arrayfunktionen zur Verfügung. Wir werden uns einige dieser Funktionen näher betrachten und ihre Funktionsweise vorstellen.


Einsatz von array_unshift()

Mithilfe der Funktion array_unshift() haben Sie die Möglichkeit, einzelne Elemente am Anfang eines Arrays einzufügen.

Beispiel

<?php
$zahlen = array(10,20,30,40,50);
array_unshift($zahlen,"a","b","c");

foreach ($zahlen as $element) {
  echo "$element ";
}
?>

Ausgabe
a b c 10 20 30 40 50


Einsatz von array_push()

Die Funktion array_push() fügt ein oder mehrere Elemente an das Ende eines Arrays an.

Beispiel

<pre>
<?php
$werte = array('wagen', 'punkt', 'mutter');
$resultat = array_push($werte,"mama","papa");
print_r($werte);
echo $resultat;
?>
</pre>

Ausgabe
Array
(
    [0] => wagen
    [1] => punkt
    [2] => mutter
    [3] => mama
    [4] => papa
)
5


Einsatz von array_shift()

Die Methode array_shift() entfernt das erste Element eines Arrays.

Beispiel

<pre>
<?php
$werte = array('wagen', 'punkt', 'mutter');
$resultat = array_shift($werte);
print_r($werte);
echo $resultat;
?>
</pre>

Ausgabe
Array
(
    [0] => punkt
    [1] => mutter
)
wagen


Einsatz von array_pop()

Die Methode array_pop() entfernt das letzte Element eines Arrays.

Beispiel

<pre>
<?php
$werte = array('wagen', 'punkt', 'mutter');
$resultat = array_pop($werte);
print_r($werte);
echo $resultat;
?>
</pre>

Ausgabe
Array
(
    [0] => wagen
    [1] => punkt
)
mutter
{PSP}Einsatz von array_splice()

Die Funktion array_splice() eignet sich hervorragend, um Elemente aus einem Array zu entfernen und diese durch andere Elemente eines Arrays zu ersetzen. Hierbei können Sie selbst wählen, an welcher Position im Array dieser Eingriff durchgeführt werden soll.

Beispiel

<?php
$zahlen = array(10,20,30,40,50);
$buchstaben = array("a","b","c");

// $resultat = array_splice($array1, postion, anzahl, $array2);
$resultat = array_splice($zahlen, 2, 2,$buchstaben);

foreach ($zahlen as $element) {
  echo "$element ";
}
foreach ($resultat as $element) {
  echo "$element ";
}
?>

Ausgabe
10 20 a b c 50
30 40

Die ersetzten Elemente werden in dem Array $resultat abgelegt. Für die Angabe der Position eines Arrayelements gilt es immer zu beachten, dass das erste Arrayelement die Position 0 hat.

Einsatz von array_reverse()

Die Methode array_reverse() kehrt die Reihenfolge der Arrayelemente im Array selbst um. Ist der optionale zweite Parameter preserve_keys TRUE, bleibt die Reihenfolge der Schlüssel erhalten.

Beispiel

<pre>
<?php
$werte = array('wagen', 'punkt', 'mutter');
$resultat = array_reverse($werte);
print_r($resultat);
$resultat = array_reverse($werte,true);
print_r($resultat);
?>
</pre>

Ausgabe
Array
(
    [0] => mutter
    [1] => punkt
    [2] => wagen
)
Array
(
    [2] => mutter
    [1] => punkt
    [0] => wagen
)


Einsatz von array_keys()

Wie unter Verwendung der Funktion array_keys() die Schlüssel eines Arrays einem anderen Array zugewiesen werden können, sehen Sie im folgenden Beispiel:

<pre>
<?php
$array1 = array ("Zahl" => 100, "Farbe" => "rot");
print_r(array_keys ($array1));

$array2 = array ("Wert" => 100, "Eintrag" => "rot");
$array2 = array_keys($array1);
print_r($array2);
?>

Ausgabe
Array
(
    [0] => Zahl
    [1] => Farbe
)
Array
(
    [0] => Zahl
    [1] => Farbe
)

Ist der optionale Parameter search_value angegeben, werden nur die Schlüssel für diesen Wert zurückgegeben. Andernfalls werden sämtliche Schlüssel zurückgegeben.{PSP}Beispiel

<pre>
<?php
$array1 = array ("Zahl" => 100, "Farbe" => "rot");
print_r(array_keys ($array1));

$array2 = array ("Wert" => 100, "Eintrag" => "rot");
$array2 = array_keys($array1,"rot");
print_r($array2);
?>
</pre>

Ausgabe
Array
(
    [0] => Zahl
    [1] => Farbe
)
Array
(
    [0] => Farbe
)


Einsatz von array_map()

Mithilfe von array_map() wird eine sogenannte Callback-Funktion auf das vorhandene Array angewandt. Die Anzahl der Parameter, welche die Callback-Funktion zulässt, sollte der Anzahl der an array_map() übergebenen Arrays entsprechen.

Beispiel

<pre>
<?php
function multiplizieren($n) {
    return $n*$n;
}

$zahlen = array(1, 2, 3, 4, 5);
$multzahlen = array_map("multiplizieren", $zahlen);
print_r($multzahlen);
print_r($zahlen);
?>
</pre>

Ausgabe
Array
(
    [0] => 1
    [1] => 4
    [2] => 9
    [3] => 16
    [4] => 25
)
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
)

Wie man sieht, bleiben die Elemente des ursprünglichen Arrays erhalten!

Natürlich lassen sich mit array_map() auch mehrere Arrays verarbeiten. Hierzu müssen Sie lediglich berücksichtigen, dass die Anzahl Ihrer Funktionsparameter mit der Anzahl der übergebenen Arrays übereinstimmt.

Beispiel

<pre>
<?php
function verbinden($n, $m) {
  return array ($n => $m);
}

$vok_de = array("auto", "bus", "motorrad", "fahrrad");
$vok_en = array("car", "bus", "motorcycle", "bicycle");

$vokabelheft = array_map("verbinden", $vok_de, $vok_en);
print_r($vokabelheft);
?>
</pre>

Ausgabe
Array
(
    [0] => Array
    (
        [auto] => car
    )

    [1] => Array
    (
        [bus] => bus
    )

    [2] => Array
    (
        [motorrad] => motorcycle
    )

    [3] => Array
    (
        [fahrrad] => bicycle
    )

)
{PSP}oder so:
<pre>
<?php
function zeige_vokabeln($n, $m) {
  return "Vokabeln (Deutsch/Englisch): $n / $m";
}

$vok_de = array("auto", "bus", "motorrad", "fahrrad");
$vok_en = array("car", "bus", "motorcycle", "bicycle");

$vokabelheft = array_map("zeige_vokabeln", $vok_de, $vok_en);
print_r($vokabelheft);
?>
</pre>

Ausgabe
Array
(
  [0] => Vokabeln (Deutsch/Englisch): auto / car
  [1] => Vokabeln (Deutsch/Englisch): bus / bus
  [2] => Vokabeln (Deutsch/Englisch): motorrad / motorcycle
  [3] => Vokabeln (Deutsch/Englisch): fahrrad / bicycle
)

Bei Verwendung von zwei oder mehr Arrays sollten diese möglichst die gleiche Länge haben, da die Callback-Funktion parallel auf die entsprechenden Elemente angewandt wird. Haben die Arrays unterschiedliche Längen, wird das kürzeste um leere Elemente erweitert.

Eine weitere interessante Anwendung dieser Funktion ist die Konstruktion eines Arrays bestehend aus Arrays, was mit NULL als Name der Callback-Funktion leicht realisiert werden kann.

Beispiel

<pre>
<?php
$vok_de = array("auto", "bus", "motorrad", "fahrrad");
$vok_en = array("car", "bus", "motorcycle", "bicycle");
$vok_fr = array("voiture", "autobus", "motocyclette", "bicyclette");

$vokabelheft = array_map(null, $vok_de, $vok_en, $vok_fr);
print_r($vokabelheft);
?>
</pre>

Ausgabe

Array
(
    [0] => Array
    (
        [0] => auto
        [1] => car
        [2] => voiture
    )

    [1] => Array
    (
        [0] => bus
        [1] => bus
        [2] => autobus
    )

    [2] => Array
    (
        [0] => motorrad
        [1] => motorcycle
        [2] => motocyclette
    )

    [3] => Array
    (
        [0] => fahrrad
        [1] => bicycle
        [2] => bicyclette
    )
)


Einsatz von array_merge()

Wollen Sie zwei oder mehr Arrays miteinander verbinden, steht Ihnen die Funktion array_merge() zur Verfügung.

Beispiel

<pre>
<?php
$vok_de = array("auto", "bus", "motorrad");
$vok_fr = array(
    "W1"=>"voiture",
    "W2"=>"autobus",
    "W3"=>"motocyclette"
    );
$vok_en = array("car", "bus", "motorcycle");

$worte = array_merge ($vok_de, $vok_fr, $vok_en);
print_r($worte);
?>
</pre>
{PSP}Ausgabe
Array
(
    [0] => auto
    [1] => bus
    [2] => motorrad
    [W1] => voiture
    [W2] => autobus
    [W3] => motocyclette
    [3] => car
    [4] => bus
    [5] => motorcycle
)


Einsatz von array_pad()

Mithilfe der Funktion array_pad() kann ein Array um eine beliebige Anzahl von Elementen erweitert werden und entweder am Anfang oder am Ende mit einem angegebenen Wert, z. B. einem *, aufgefüllt werden.

Beispiel

<?php
$werte = array(10,20,30,40,50);
$anfang = array_pad($werte,-10,'*');
$ende = array_pad($werte,10,'*');
foreach ($anfang as $element) {
  echo "$element ";
}
echo "<br>";
foreach ($ende as $element) {
  echo "$element ";
}
?>

Ausgabe
* * * * * 10 20 30 40 50
10 20 30 40 50 * * * * *


Einsatz von array_slice()

Die Funktion array_slice() gibt aus einem Array eine angegebene Anzahl von Elementen, die ab einer Position gefunden werden, an ein zweites Array zurück. Ist die Positionsangabe positiv, beginnt die Sequenz am Anfang des Arrays, sonst am Ende des Arrays.

Beispiel

<?php
$werte = array(10,20,30,40,50);
$vomanfang = array_slice($werte,2,2);
$vomende = array_slice($werte,-2,2);
foreach ($vomanfang as $element) {
  echo "$element ";
}
echo "<br>";
foreach ($vomende as $element) {
  echo "$element ";
}
?>

Ausgabe
30 40
40 50

In diesem Fall

$resultat1 = array_slice($werte,0,2);
$ resultat1 = array_slice($werte,2);

erhalten Sie folgende Ausgabe:
10 20
30 40 50


Einsatz von array_values()

Mithilfe der Funktion array_values() können Sie auf einfache Weise sämtliche Werte eines assoziativen Arrays ermitteln.

Beispiel

<?php
$personen = array(
    "P1"=>"Matthias",
    "P2"=>"Caroline",
    "PX"=>"Gülten"
    );
$resultat = array_values($personen);
foreach ($resultat as $element) {
  echo "$element ";
}
?>

Ausgabe
Matthias Caroline Gülten
{PSP}Einsatz von in_array()

Mithilfe der Funktion in_array() kann ein Array nach einem bestimmten Wert durchsucht werden. Die Funktion liefert hierbei den Wahrheitswert TRUE zurück, wenn der gesuchte Wert gefunden wurde.

Beispiel

<?php
$personen = array(
    "P1"=>"Matthias",
    "P2"=>"Caroline",
    "PX"=>"Gülten"
    );
if (in_array("Caroline",$personen)) {
  echo "Gefunden";
} else {
  echo "Nicht gefunden";
}
?>

Ausgabe
Gefunden


Einsatz von compact()

Die Funktion compact() übergibt die Namen von Variablen als Indizes und deren Werte als zugehörige Elemente in ein Array. So lassen sich auf einfache Weise Variablen in ein assoziatives Array überführen.
Beispiel
<?php
$p1 = "Matthias";
$p2 = "Caroline";
$px = "Gülten";
$personen = compact("p1","p2","px");
foreach ($personen as $key=>$element) {
  echo "$key=>$element<br>";
}
?>

Ausgabe
p1=>Matthias
p2=>Caroline
px=>Gülten


Einsatz von array_combine()

Die Funktion array_combine() erzeugt ein Array mithilfe eines Arrays, welches die Schlüssel vorgibt, und eines Arrays, welches die Werte vorgibt. Die Funktion steht Ihnen erst ab PHP 5 zur Verfügung.

Beispiel

<pre>
<?php
$groessen = array('klein', 'mittel', 'gross');
$werte = array('wagen', 'punkt', 'mutter');
$resultat = array_combine($groessen, $werte);
print_r($resultat);
?>
</pre>

Ausgabe
Array
(
    [klein] => wagen
    [mittel] => punkt
    [groß] => mutter
)

Achtung: Die Anzahl der Elemente beider Arrays muss übereinstimmen, sonst wird FALSE zurückgegeben.


Einsatz von array_chunk()

Mithilfe der Funktion array_chunk() teilen Sie ein Array in einzelne Arrays auf, welche eine von Ihnen festgelegte Anzahl von Werten besitzen. Am Ende kann auch ein Array mit weniger Werten erzeugt werden. Die Arrays werden als Teile eines mehrdimensionalen Arrays erzeugt, welches numerisch indiziert ist. Sie können PHP dazu zwingen, die ursprünglichen Schlüssel des Arrays beizubehalten, indem Sie den optionalen dritten Parameter preserve_keys auf TRUE setzen. Geben Sie FALSE an, werden in jedem erzeugten Array neue numerische Indizes erzeugt, welche bei 0 beginnen, Standard ist FALSE.

Beispiel

<pre>
<?php
$werte = array('wagen', 'punkt', 'mutter');
print_r(array_chunk($werte, 2));
print_r(array_chunk($werte, 2, TRUE));
?>
</pre>
{PSP}Ausgabe
Array
(
    [0] => Array
    (
        [0] => wagen
        [1] => punkt
    )

    [1] => Array
    (
        [0] => mutter
    )
)

Array
(
    [0] => Array
    (
        [0] => wagen
        [1] => punkt
    )

    [1] => Array
    (
        [2] => mutter
    )
)


Einsatz von array_multisort()

Mithilfe von array_multisort() werden mehrere indizierte oder multidimensionale Arrays auf einmal sortiert. Bei der Sortierung werden die Schlüsselassoziationen beibehalten.

Die Struktur der Argumente ist etwas ungewöhnlich, aber flexibel. Das allererste Argument muss ein Array sein. Die nachfolgenden Argumente können entweder ein Array oder eines der folgenden Sortierflags sein.

Flags für Sortierreihenfolge:

Flags für Sortiertypen:

Hinweis: Gibt bei Erfolg TRUE zurück, im Fehlerfall FALSE.

Beispiel – Sortieren mehrerer Arrays

<pre>
<?php
$werte1 = array ("10", 100, 100, "a");
$werte2 = array (1, 3, "2", 1);
array_multisort ($werte1, $werte2);
print_r($werte1);
print_r($werte2);
?>
</pre>

Ausgabe
Array
(
    [0] => 10
    [1] => a
    [2] => 100
    [3] => 100
)
Array
(
    [0] => 1
    [1] => 1
    [2] => 2
    [3] => 3
)

Beispiel – Sortieren eines mehrdimensionalen Arrays

<pre>
<?php
$werte = array (
  array ("10", 100, 100, "a"),
  array (1, 3, "2", 1)
);
array_multisort ($werte[0], SORT_ASC, SORT_STRING,
        $werte[1], SORT_DESC, SORT_NUMERIC);
print_r($werte);
?>
</pre>
{PSP}Ausgabe
Array
(
    [0] => Array
    (
        [0] => 10
        [1] => 100
        [2] => 100
        [3] => a
    )

    [1] => Array
    (
        [0] => 1
        [1] => 3
        [2] => 2
        [3] => 1
    )
)


Einsatz von array_rand()

Mithilfe der Funktion array_rand() erhalten Sie einen oder mehrere zufällige Einträge eines Arrays. Die Funktion übernimmt das Array und ein optionales Argument num_req, welches die gewünschte Anzahl Einträge spezifiziert. Ist num_req nicht angegeben, wird auf 1 gesetzt.

Beispiel

<pre>
<?php
$personen = array (
    "Matthias",
    "Caroline",
    "Gülten",
    "Toni",
    "Saban"
    );
$rand_keys = array_rand ($personen, 2);
print $personen[$rand_keys[0]] . "<br>";
print $personen[$rand_keys[1]] . "<br>";;
?>
</pre>

Ausgabe
Caroline
Toni

Sie haben bereits nahezu sämtliche Arrayfunktionen kennengelernt. Es warten jedoch noch mehr auf Sie! Wie Sie sicher bereits bemerkt haben, sind Arrays ein recht interessantes Thema und können Ihnen die Arbeit an Ihren Programmen vereinfachen, vor allem dort, wo es eine Vielzahl von Daten zu bearbeiten oder verwalten gibt. Dies ist besonders heute im Zeitalter der Datenbanken einer der Schwerpunkte!


Einsatz von array_search()

Mithilfe der Funktion array_search() erhalten Sie entweder den gefundenen Schlüssel oder FALSE zurück. Zusätzlich liefert die Funktion die Position des gesuchten Elements.

Beispiel

<?php
$personen = array("Matthias", "Caroline", "Gülten");
$suchwort = "Caroline";
$position = array_search($suchwort,$personen);

if ($position !== false) {
  echo "$suchwort liegt auf Position $position";
} else {
  echo "Person $suchwort nicht enthalten";
}
?>

Ausgabe
Caroline liegt auf Position 1

Bitte achten Sie darauf, den Vergleich mit !== durchzuführen, denn sollte Ihr gesuchtes Element im Array an der Position 0 gefunden werden, ergibt die if-Anweisung ein logisches FALSE, und dies würde zu einem falschen Resultat führen.

Beispiel

<?php
$personen = array("Matthias", "Caroline", "Gülten");
$suchwort = "Matthias";
$position = array_search($suchwort,$personen);
if ($position != false) {
  echo "$suchwort liegt auf Position $position";
} else {
  echo "Person $suchwort nicht enthalten";
}
?>

Ausgabe
Person Matthias nicht enthalten
{PSP}Doppelgänger aus einem Array entfernen

Sie haben ein Array und würden gerne Duplikate entfernen. Dafür nutzen Sie die Funktion array_unique(). Sie gibt ein neues Array zurück, welches keine doppelten Werte enthält.

Beispiel

<pre>
<?php
$zahlen = array(10,1,10,20,30,10,5);
$neuesarray = array_unique($zahlen);
print_r($neuesarray);
?>
</pre>

Ausgabe
Array
(
    [0] => 10
    [1] => 1
    [3] => 20
    [4] => 30
    [6] => 5
)

Hinweis: Wie Sie sehen, bleiben die Indizes erhalten.


Kleinstes und größtes Arrayelement ausgeben

Sollten Sie das kleinste und das größte Element eines Arrays ermitteln wollen, können Sie hierfür die Funktionen min() und max() verwenden. Dies ist vor allem bei Zeittafeln oder chronlogischen Abfolgen äußerst wichtig.

Beispiel – max()

<?php
$personen = array("Matthias", "Caroline", "Gülten");
// Ausgabe – Caroline
echo $kleinstes = min($personen);
?>

Beispiel – min()

<?php
$personen = array("Matthias", "Caroline", "Gülten");
// Ausgabe – Matthias
echo $groesstes = max($personen);
?>


Array in eine Zeichenkette umwandeln

Sie haben ein Array, welches Sie in eine Zeichenkette (String) umwandeln wollen. Hierfür könnten Sie z. B. eine foreach-Schleife verwenden.

Beispiel

<?php
$personen = array("matthias", "caroline", "gülten");
foreach ($personen as $element) {
  $zeichen .= $element;
}
// Ausgabe – matthiascarolinegülten
echo $zeichen;
?>

Das hat recht gut funktioniert. Doch wie kommen wir an die einzelnen Bestandteile der Zeichenkette heran? Die aktuell vorliegende Variable $zeichen enthält eine zusammenhängende Zeichenkette, in der wir keine Unterscheidungsmöglichkeit haben, wann welcher Teilstring beginnt und wann er endet. In diesem Fall könnten wir unsere Schleife optimieren, indem wir ein Trennzeichen hinzufügen.

Beispiel

<?php
$personen = array("matthias", "caroline", "gülten");
foreach ($personen as $element) {
  $zeichen .= ",$element";
}
// Ausgabe – ,matthias,caroline,gülten
echo $zeichen;
// Führendes Trennzeichen entfernen
// Ausgabe – matthias,caroline,gülten
echo $zeichen = substr($zeichen,1);
?>

Anhand der Ausgabe ist zu erkennen, dass nach dem Schleifendurchlauf noch eine Bearbeitung der Zeichenkette durch die Stringfunktion substr() stattgefunden hat, um das erste Trennzeichen (,) zu entfernen.

Hinweis: In PHP stehen Ihnen eine Reihe von Stringfunktionen zur Verfügung. Auf die Stringfunktionen werde ich im Abschnitt 3.13 dieses Kapitels eingehen.
{PSP}Vereinigung, Schnitt- oder Differenzmengen zweier Arrays

Nehmen wir an, Sie haben zwei Arrays und wollen diese miteinander vergleichen. Hierbei sollen folgende Schwerpunkte gesetzt werden:

Als Vorlage dienen die folgenden beiden Arrays:

$vok_a = array("ein","zwei","drei","vier");
$vok_b = array("ein","zwei","vier");


Ermitteln der Vereinigungsmenge

<pre>
<?php
$vok_a = array("ein","zwei","drei","vier");
$vok_b = array("ein","zwei","vier");
$vereinen = array_unique(array_merge($vok_a,$vok_b));
print_r($vereinen );
?>
</pre>

Ausgabe
Array
(
    [0] => ein
    [1] => zwei
    [2] => drei
    [3] => vier
)

Um die Vereinigungsmenge zu finden, mischen Sie die beiden Arrays mithilfe der Funktion array_merge() und erhalten damit ein größeres Array mit sämtlichen Werten. Leider lässt die Funktion jedoch doppelte Werte zu, wenn sie zwei indizierte Arrays miteinander mischt, daher rufen Sie zusätzlich noch die Funktion array_unique() auf, um diese herauszufiltern.


Ermitteln der Schnittmenge

<pre>
<?php
$vok_a = array("ein","zwei","drei","vier");
$vok_b = array("ein","zwei","vier");
$schnitt = array_intersect($vok_a,$vok_b);
print_r($schnitt);
?>
</pre>

Ausgabe
Array
(
    [0] => ein
    [1] => zwei
    [3] => vier
)

Bei der Bildung der Schnittmenge ist Ihnen die Funktion array_intersect() behilflich.


Ermitteln der Differenzmenge

<pre>
<?php
$vok_a = array("ein","zwei","drei","vier");
$vok_b = array("ein","zwei","vier");
$differenz = array_diff($vok_a,$vok_b);
print_r($differenz );
?>
</pre>

Ausgabe
Array
(
    [2] => drei
)

Die Funktion array_diff() gibt ein Array zurück, welches sämtliche Elemente in $vok_a enthält, die nicht in $vok_b vorkommen.{PSP}Elementkombination eines Arrays ermitteln

Sie wollen sämtliche Elementkombinationen eines Arrays ermitteln, die einige oder alle Elemente des Arrays enthalten, sprich die Potenzmenge. Hier die zuständige Funktion:

function set_potenz($liste) {
  // Initialisierung durch ein leeres Array
  $resultate = array(array());
  foreach ($liste as $element) {
    foreach($resultate as $kombination) {
      array_push($resultate, array_merge(array($element), $kombination));
    }
  }
  return $resultate;
}

Diese Funktion gibt ein Array aus Arrays zurück, das sämtliche Kombination von Elementen beinhaltet, einschließlich der leeren Menge.

Beispiel

$werte = array("A","B","C");
$potenzmenge = set_potenz($werte);
print_r($potenzmenge);

Ausgabe
Array
(
    [0] => Array
      ( )

    [1] => Array
      ( [0] => A )

    [2] => Array
      ( [0] => B )

    [3] => Array
      ( [0] => B [1] => A )

    [4] => Array
      ( [0] => C )

    [5] => Array
      ( [0] => C [1] => A )

    [6] => Array
      ( [0] => C [1] => B )

    [7] => Array
      ( [0] => C [1] => B [2] => A )
)

$potenzmenge enthält anschließend acht Arrays, sprich acht mögliche Kombinationen. Die erste foreach-Schleife arbeitet sämtliche Elemente des Arrays ab, während die innere foreach-Schleife sämtliche vorhandenen, aus den vorherigen Elementen erzeugten Kombinationen durchläuft. Dies ist auch der schwierige Teil innerhalb der Funktion. Sie müssen genau wissen, wie sich PHP während der Schleifendurchläufe verhält.

Die Funktion array_merge() kombiniert das Element mit den vorherigen Kombinationen. Beachten Sie jedoch, dass das Array $resultate, dem das neue Array mit array_push() hinzugefügt wird, dasjenige ist, das in dem foreach durchlaufen wird. Normalerweise würde dies zu einer Endlosschleife führen, wenn Sie Einträge zu $resultate hinzufügen. In PHP ist dies jedoch nicht der Fall, denn PHP arbeitet mit einer Kopie des ursprünglichen Arrays. Wenn Sie aber eine Ebene höher in die äußere Schleife zurückspringen und das foreach mit dem nächsten $element erneut ausführen, wird es zurückgesetzt. Daher können Sie direkt mit $resultate arbeiten und das Array als Stapelspeicher für Ihre Kombinationen verwenden. Indem Sie alles als Array speichern, erhalten Sie zusätzliche Flexibilität bei der Bearbeitung der einzelnen Arrays bzw. Kombinationen.

Um die Ergebnisse formatiert zwischen den Elementen innerhalb der Kombinationen und Zeilenwechsel zwischen den Kombinationen auszugeben, können Sie folgende Codezeilen einsetzen:

$werte = array("A","B","C");
echo "<table border=1>";
foreach (set_potenz($werte) as $element) {
  print "<tr><td> " . join(" ", $element) . "</td></tr>";
}
echo "</table>";

Und hier die Kombinationen mit jeweils zwei Elementen:

$werte = array("A","B","C");
echo "<table border=1>";
foreach (set_potenz($werte) as $element) {
  if (2 == count($element)) {
    print "<tr><td> " . join(" ", $element) . "</td></tr>";
  }
}
echo "</table>";

Achtung: Der Durchlauf dauert bei einer großen Menge von Elementen sehr lange. Aus einer Menge mit n Elementen entstehen 2n+1 Mengen. Mit anderen Woren, wenn n um 1 erhöht wird, verdoppelt sich die Anzahl der Elemente.
{PSP}Permutationen und Arrays

Abschließend noch ein Beispiel zum Thema Permutation. Sie haben ein Array mit Elementen und wollen sämtliche Möglichkeiten berechnen, wie diese unterschiedlich angeordnet werden können.

$begriffe = array("ich","bin","dort");

Beispiel

<?php
// Permutationen ermitteln (Rekursiv)
function setze_permutation($liste, $permliste = array()) {
  if (empty($liste)) {
    print join(' ', $permliste) . "<br>";
  } else {
    for ($i = count($liste) – 1; $i >= 0; --$i) {
      $neueliste = $liste;
      $neuepermliste = $permliste;
      list($werte) = array_splice($neueliste, $i, 1);
      array_unshift($neuepermliste, $werte);
      setze_permutation($neueliste, $neuepermliste);
    }
  }
}

// Entspricht – array("ich","bin","dort");
$begriffe = split(" ","ich bin dort");
setze_permutation($begriffe);
?>

Ausgabe
ich bin dort
bin ich dort
ich dort bin
dort ich bin
bin dort ich
dort bin ich