Werbung einblenden Werbung ausblenden


Home / Tutorials / PHP Handbuch / Arrays und Hashes


Arrays und hashes
Arrays initialisieren
Sortieren von Arrays
Die Funktion arsort: alphabetische, absteigende Sortierung
Die Funktion ksort: Aufsteigende, alphabetische Sortierung eines Hashs nach dem key
Die Funktion krsort: Absteigende, alphabetische Sortierung eines Hashs nach dem key
Die Funktion rsort: Sortierung und Reorganisation des Indexes
Die Funktion array_multisort: Mehrdimensionale Arrays sortieren
Arrays manipulieren
Funktionen array_shift() und array_pop(): Elemente am Anfang bzw. am Ende entfernen
Die Funktion array_reverse: Einen Array spiegeln
Die Funktion array_unique : Identische Elemente in einem Array finden
Die Funktionen array_slice und array_splice: Teile aus einem Array herausschneiden
Die Funktionen array_diff, array_intersect: Arrays vergleichen
Die Funtion array_implode: Mehrere Arrays zu einem Array zusammenfügen
Die Funktion implode: Die Elemente eines Arrays zu einem String verbinden
Die Funktionen in_array und array_search: Suchen in einem Array

Arrays und hashes

Ein Array ist vergleichbar mit einer Komode mit vielen Schubladen. Hat die Komode fünf Schubladen und in der vierten Schublade befinden sich die Handbücher, dann kann man auf die Handbücher zugreifen mit $schrank[2]. Wer keinerlei Programmiererfahrung hat, der fragt sich, wozu man das braucht. Wer Programmiererfahrung hat, weiss, dass sich ohne Arrays praktisch keine Programme schreiben lassen. Wem das so auf die Schnelle nicht einleuchtet, der sollte sich klarmachen, dass die ganze Welt ein einziger Array ist. Eine Adresse vom Typ

infos24 GmbH
Hallandstrasse 2
13189 Berlin

ist ein Array. Wir haben einen grossen Schrank, nämlich Berlin, in dem grossen Schrank Berlin, gibt es eine Schublade, die Hallandstrasse, da gibt es wiederum eine Schublade, nämlich die Hausnummer 2, und da gibt es wieder eine Schublade,das ist die infos24 GmbH. Wir haben also eine solche Struktur.

[Berlin] [Hallandstrasse][2][infos24 GmbH]
[Berlin] [Hallandstrasse][2][Müller]]
[Berlin][Hallandstrasse][4][Maier]
[Berlin][Kurfürstendamm][12]
[Berlin][Kurfürstendamm][22]
[Freiburg][Habsburger Strasse][1]
[Freiburg][Habsburger Strasse][2]
[Freiburg][Krozinger Strasse][12]
[Freiburg][Krozinger Strasse][34]


etc.

Die ganze Welt ist also ein ziemlicher Riesenarray, also ein mehrdimensionaler Array. Wenn dem nicht so wäre, hätten wir im Alltag Probleme mit der Orientierung. Praktisch alles, Unternehmen, Schulklassen, Käsesorten lassen sich über Arrays abbilden und werden in der Programmierung über Arrays abgebildet. Mehrdimensionale Array sind hierbei auch in einer Baumstruktur abbildbar. Von den Schränken gibt es zwei Sorten, nämlich Arrays und Hashs (anonymous arrays). Der erste ist der normale Array, den alle Programmiersprachen kennen. Hierbei ist der Index eine Zahl , während beim zweiten Typ, beim Hash, der Index eine Zeichenkette ist. Die Welt ist eigentlich eher über Hashs abbildbar, aber Arrays sind, wohl aus rein technischen Gründen, üblicher. Kommen wir mal zum rein technischen Teil.

Arrays initialisieren

<?
$banane=array("süss","gelb","tropisch","vitamreich");
print $banane[3];
?>


Es wurde also ein array mit 4 Elementen gebildet, wobei das höchste Element, vitaminreich, den Wert 3 hat. Innerhalb der eckigen Klammern steht der Index des Arrays, der anzeigt, auf welches Element des Arrays zugegriffen werden soll. Natürlich kann man auch direkt Werte an ein Element des Arrays übergeben.

<?
$banane=array("süss","gelb","tropisch","vitamreich");
$banane[4]="Guatemala";
print $banane[4];
?>

Bevor wir uns mit den sehr zahlreichen Funktionen zur Manipulation von Arrays befassen, schauen wir uns noch den anderen Typ von Array an, den Hash. Da beim Hash der Index selber eine beliebige Zeichenkette ist, ist es klar, dass die Initialisierung eines Hash, wie auch die Manipulation, davon später, komplizierter ist, als beim "normalen" Array. Beim normalen Array ist der Index eine Zahl, die einfach hochgezählt wird, wenn ein neues Element hinzugefügt wird. Beim Hash muss man aber den Index angeben.

<?
$banane=array("Geschmack"=>"süess","Farbe"=>"gelb","Klima"=>"tropisch",
"Nährwert"=>"vitaminreich");
print $banane['Farbe'];
?>

Wir sehen also, dass bei der Zuweisung, Paare gebildet werden nach dem Schema Index => Wert, wobei der Index eine Zeichenkette ist. Über den entsprechenden Index kann man den dazugehörigen Wert wieder rausfischen. Man beachte, dass der Index in Anführungsstrichen steht. So wird verhindert, dass der Wert, der als Schlüssel angegeben wird, irgendwann mal in Konflikt gerät mit Wörtern, die in PHP reserviert sind. Auch dem Hash Banane können direkt Werte zugewiesen werden.

<?
$banane=array("Geschmack"=>"süess","Farbe"=>"gelb","Klima"=>"tropisch",
"Nährwert"=>"vitaminreich");
$banane['Herkunftsland']="Guatemala";
print $banane['Herkunftsland'];
?>

So weit so nett. Bis jetzt haben wir aber nur eine Fruchtsorte, nämlich die Banane beschrieben. Was ist, wenn man auch Kirsche und Himbeere beschreiben will ? Man hat dann einen mehrdimensionalen Array. Beginnen wir mit dem einfachen Fall, wenn es sich um einen Array mit nummerischem Index handelt.

<?
$obst=array(
$banane=array("süess","gelb","tropisch","vitaminreich"),
$kirsche=array("sauer","rot","continental","kalorienreich"),
$himbeere=array("herb","rosa","überall","fett"));
print $obst[1][1];
?>

Läßt man den Skript ablaufen, setzt er rot auf den Schirm, weil $obst[1] der Array $kirsche und hiervon das erste Element rot ist. Auch hier, kann man Werte direkt zuweisen.

<?
$obst=array(
$banane=array("süess","gelb","tropisch","vitaminreich"),
$kirsche=array("sauer","rot","continental","kalorienreich"),
$himbeere=array("herb","rosa","überall","fett"));
$obst[1][4]="Guatemala";
print $obst[1][4];
?>

Komplizierter, wenn auch nur unwesentlich, wird die Sache, wenn es sich um einen Hash handelt.

<?
$obst=array(
"banane"=>array("Geschmack"=>"süess","Farbe"=>"gelb",
"Klima"=>"tropisch","Nährwert"=>"vitaminreich"),
"kirsche"=>array("Geschmack"=>"sauer","Farbe"=>"rot",
"Klima"=>"continental","Nährwert"=>"kalorienreich"),
"himbeere"=>array("Geschmack"=>"herb","Farbe"=>"rosa",
"Klima"=>"überall","Nährwert"=>"fett"));
print $obst["banane"]["Farbe"];
?>

Will man mehrdimensionale Array in einer foreach Schleife auslesen, kann man das so machen.

<?
$stadt=array(
"Berlin"=>array("Maier","Schmidt","Schulze","Erdmann"),
"Bonn"=>array("Lehmann","Martinez","Zumkeller","Fritsche"),
"Freiburg"=>array("Binsenteich","Knobloch","Erzengel","Dichter")
);

foreach ($stadt as $key=>$name)
{
print "<br><font color=red>In $key wohnen</font> <br>--------<br>";

foreach ($stadt[$key] as $index)
{
print "$index <br>";
}
}
?>

Das Ergebnis sieht dann so aus.

In Berlin wohnen
--------
Maier
Schmidt
Schulze
Erdmann

In Bonn wohnen
--------
Lehmann
Martinez
Zumkeller
Fritsche

In Freiburg wohnen
--------
Binsenteich
Knobloch
Erzengel
Dichter

$obst["banane"] hat als Wert selber wieder einen Hash. Auf diesen Hash können wir dann mit mit den entsprechenden Indizes zugreifen.
Nun sollte klar sein, was Arrays sind, was Hash sind und wie man Werte an das Array übergibt und wie man sie wieder ausliest. PHP stellt nun
fast 60 Funktionen zur Verfügung, um Arrays zu manipulieren. Bei den Funktionen muss dann jeweils unterschieden werden, ob sie nur auf
Hashs, nur auf Arrays oder für beide Typen gelten. Mit diesen Funktionen kann man Arrays sortieren, die Indices rausfischen, Elemente
hinzufügen, Elemente löschen, nach doppelten Einträgen suchen, die Anzahl der Elemente des Arrays ermitteln etc. etc. Die wichtigsten
werden hier im Detail vorgestellt. Eine vollständige List steht im Anhang.

Sortieren von Arrays

Sortieren kann nach unterschiedlichen Kriterien erfolgen, und der Suchalgorithmus kann auf unterschiedliche Bestandteile, auf den Index oder auf den
Wert angewendet werden. Bedingt durch diese Tatsache, gibt es insgesamt 9 Funktionen zum Sortieren von Arrays.
Die Funktion asort(): alphabetische, aufsteigende Sortierung des Wertes


<?
$namen=array("Hans","Peter","Martin","Andreas","Heinz","Maria");
$sort_namen=asort($namen);
foreach ($namen as $wert)
{
print "$wert <br>";
}
?>

Wir erhalten Andreas, Hans, Heinz, Maria, Martin, Peter. Für eine Erklärung der verwendeten foreach Schleife siehe Schleifen.
Für einen Hash ergibt sich folgendes Bild.


<?
$namen=array("Ehmann"=>"Andres","Landivar"=>"Maria",
"Bustamante"=>"Enrique","Nelson"=>"David");
$sort_namen=asort($namen);
foreach ($namen as $wert)
{
print "$wert <br>";
}
?>

Wir erhalten Andres, David, Enrique, Maria. Dies ist in der Regel nicht das was wir wollen, in der Regel will man in so einem
Fall nach dem Nachnamen, also dem Schlüssel sortieren und nicht nach dem Vornamen, dem Wert. Dazu gleich mehr. Will man
innerhalb einer foreach Schleife sowohl den Index als auch den Schlüssel drucken, kann man das zum Beispiel so machen.


<?
$namen=array("Ehmann"=>"Andres","Landivar"=>"Maria",
"Bustamante"=>"Enrique","Nelson"=>"David");
$sort_namen=asort($namen);
foreach ($namen as $index => $wert)
{
print "Index ist $index und der Wert $wert <br>";
}
?>

Zusammenfassung: asort() sortiert nach dem Wert und zwar sowohl beim Array, als auch beim Hash.

Die Funktion arsort: alphabetische, absteigende Sortierung

<?
$namen=array("Hans","Peter","Martin","Andreas","Heinz","Maria");
$sort_namen=arsort($namen);
foreach ($namen as $wert)
{
print "$wert <br>";
}
?>

Wir erhalten Peter, Martin, Maria, Heinz, Hans, Andreas. Die Funktion arsort ist mit der Funktion asort weitgehend identisch. Der einzige
Unterschied besteht darin, dass asort aufsteigend, arsort absteigend sortiert.

Die Funktion ksort: Aufsteigende, alphabetische Sortierung eines Hashs nach dem key

<?
$namen=array("Ehmann"=>"Andres","Landivar"=>"Maria",
"Bustamante"=>"Enrique","Nelson"=>"David");
$sort_namen=ksort($namen);
foreach ($namen as $index => $wert)
{
print "Index ist $index und der Wert $wert <br>";
}
?>

Wir erhalten

Index ist Bustamante und der Wert Enrique
Index ist Ehmann und der Wert Andres
Index ist Landivar und der Wert Maria
Index ist Nelson und der Wert David

Wie deutlich zu sehen, wurde jetzt nach dem Nachnamen, dem key sortiert.

Die Funktion krsort: Absteigende, alphabetische Sortierung eines Hashs nach dem key

<?
$namen=array("Ehmann"=>"Andres","Landivar"=>"Maria",
"Bustamante"=>"Enrique","Nelson"=>"David");
$sort_namen=krsort($namen);
foreach ($namen as $index => $wert)
{
print "Index ist $index und der Wert $wert <br>";
}
?>

Wir erhalten:

Index ist Nelson und der Wert David
Index ist Landivar und der Wert Maria
Index ist Ehmann und der Wert Andres
Index ist Bustamante und der Wert Enrique

Wir erhalten das gleiche Ergebnis wie oben, allerdings ist der Sortieralgorithmus jetzt absteigend.

Die Funktion rsort: Sortierung und Reorganisation des Indexes

Bei allen Beispielen bislang, wurde die Verknüpfung zwischen Index (bei Hashs heisst das key) und Wert (bei Hashs heisst das value) nicht
aufgelöst. Mit rsort wird diese Verknüpfung aufgebrochen. Man betrachte das Ergebnis dieser beiden Skripte.

arsort

<?
$namen=array("Hans","Peter","Martin","Andreas","Heinz","Maria");
$sort_namen=arsort($namen);
foreach ($namen as $index=>$wert)
{
print "Index ist $index und Wert ist $wert <br>";
}
?>

Das Ergebnis:

Index ist 1 und Wert ist Peter
Index ist 2 und Wert ist Martin
Index ist 5 und Wert ist Maria
Index ist 4 und Wert ist Heinz
Index ist 0 und Wert ist Hans
Index ist 3 und Wert ist Andreas

rsort

<?
$namen=array("Hans","Peter","Martin","Andreas","Heinz","Maria");
$sort_namen=rsort($namen);
foreach ($namen as $index=>$wert)
{
print "Index ist $index und Wert ist $wert <br>";
}
?>

Das Ergebnis:

Index ist 0 und Wert ist Peter
Index ist 1 und Wert ist Martin
Index ist 2 und Wert ist Maria
Index ist 3 und Wert ist Heinz
Index ist 4 und Wert ist Hans
Index ist 5 und Wert ist Andreas

Wie deutlich zu erkennen ist, wurden bei der Variante mit rsort der Index neu sortiert. Mit Hash kann man das auch machen, allerdings ist das Ergebnis
verblüffend, der key wird einfach ins Nirvana geschickt.

<?
$namen=array("Ehmann"=>"Andres","Landivar"=>"Maria",
"Bustamante"=>"Enrique","Nelson"=>"David");
$sort_namen=rsort($namen);
foreach ($namen as $index => $wert)
{
print "Index ist $index und der Wert $wert <br>";
}
?>

Das Ergebnis ist:

Index ist 0 und der Wert Maria
Index ist 1 und der Wert Enrique
Index ist 2 und der Wert David
Index ist 3 und der Wert Andres

Wie man sieht, wurden die Nachnamen schlicht eliminiert.

Die Funktion array_multisort: Mehrdimensionale Arrays sortieren

Man stelle sich vor, man hat mehrere Städte und in jeder Stadt leben eine bestimmte Anzahl Menschen. Etwa ein Verband, der in mehreren
Städten vertreten ist und da mehrere Mitglieder hat. Mit folgendem Skript kann man alle Städte auslesen und die Personen die dort wohnen
alphabetisch sortieren lassen.


<?
$stadt=array(
"Berlin"=>array("Maier","Schmidt","Schulze","Erdmann"),
"Bonn"=>array("Lehmann","Martinez","Zumkeller","Fritsche"),
"Freiburg"=>array("Binsenteich","Knobloch","Erzengel","Dichter")
);

array_multisort($stadt['Berlin'],$stadt['Bonn'],$stadt['Freiburg']);

foreach ($stadt as $key=>$name)
{
print "<br><font color=red>In $key wohnen</font> <br>--------<br>";

foreach ($stadt[$key] as $index)
{
print "$index <br>";
}
}
?>

Das Ergebnis sieht dann so aus.

In Berlin wohnen
--------
Erdmann
Maier
Schmidt
Schulze

In Bonn wohnen
--------
Fritsche
Lehmann
Martinez
Zumkeller

In Freiburg wohnen
--------
Dichter
Binsenteich
Knobloch
Erzengel

Arrays manipulieren

Die Funktionen array_unshift und array_push: Elemente am Anfang, bzw. am Ende hinzufügen

array_push fügt ein Element an das Ende des nummerischen Arrays an

<?
$banane=array("süss","gelb","tropisch","vitamreich");
array_push($banane,"Guatemala","United Fruit Company");
print $banane[4]." und ".$banane[5];
?>

array_unshift fügt ein Element an den Anfang des nummerischen Arrays

<?
$banane=array("süss","gelb","tropisch","vitamreich");
array_unshift($banane,"Guatemala","United Fruit Company");
print $banane[0]." und ".$banane[1];
?>

Funktionen array_shift() und array_pop(): Elemente am Anfang bzw. am Ende entfernen

<?
$banane=array("süss","gelb","tropisch","vitaminreich");
array_shift($banane);
print $banane[0];
# Wenn das erste Element entfernt wurde, muss gelb rauskommen
?>

<?
$banane=array("süss","gelb","tropisch","vitamreich");
array_pop($banane);
foreach($banane as $werte)
{
print "$werte \n";
}
# Die foreach Schleife darf vitaminreich nicht mehr zeigen
?>

Die Funktionen array_pop und array_shift funktionnieren auch mit Hashs

<?
$banane=array("Banane"=>"süss","Pfirsich"=>"gelb","Apfel"=>"vitamreich",
"Birne"=>"billig","Melone"=>"kernig");
array_pop($banane);
foreach ($banane as $key => $value)
{
print "Schlüssel ist $key und Wert ist $value <br>";
}
# Wenn das letzte Element entfernt wurde, darf Melone und billig nicht erscheinen
?>

Ergebnis:

Schlüssel ist Banane und Wert ist süss
Schlüssel ist Pfirsich und Wert ist gelb
Schlüssel ist Apfel und Wert ist vitamreich
Schlüssel ist Birne und Wert ist billig

<?
$banane=array("Banane"=>"süss","Pfirsich"=>"gelb","Apfel"=>"vitamreich",
"Birne"=>"billig","Melone"=>"kernig");
array_shift($banane);
foreach ($banane as $key => $value)
{
print "Schlüssel ist $key und Wert ist $value <br>";
}
# Wenn das erste Element entfernt wurde, darf Banane und süss nicht erscheinen
?>

Ergebnis:

Schlüssel ist Pfirsich und Wert ist gelb
Schlüssel ist Apfel und Wert ist vitamreich
Schlüssel ist Birne und Wert ist billig
Schlüssel ist Melone und Wert ist kernig

Das Gegenteil aber, array_push und array_unshift führen bei Hash zu merkwürdigen Ergebnissen.

Die Funktion array_reverse: Einen Array spiegeln

Es kann vorkommen, dass man den Array spiegeln will. Das ist zum Beispiel bei der Programmierung eines Gästebuches der Fall. Da in der Regel
der letzte Beitrag ganz hinten steht, er aber als erster erscheinen soll, wenn der User sich die Beiträge anschaut, muss der Array, der die Beiträge
hält, gespiegelt werden. Beispiel siehe Gästebuch.


<?
$obst=array("Banane","Kirsche","Himbeere","Zitrone","Kiwi","Melone");
$kompott=array_reverse($obst);
foreach($kompott as $wert)
{
print "$wert <br>";
}
?>

Das Ergebnis ist:

Melone
Kiwi
Zitrone
Himbeere
Kirsche
Banane

Wie man sieht, wurde der Array gespiegelt. Die Frage ist, ob das auch mit Hashs funktionniert.

<?
$obst=array("Guatemala"=>"Banane","Deutschland"=>"Kirsche","Italien"=>"Himbeere",
"Spanien"=>"Zitrone","Neuseeland"=>"Kiwi","Israel"=>"Melone");
$kompott=array_reverse($obst);
foreach($kompott as $index => $wert)
{
print "Der Schlüssel ist $index und der Wert ist $wert <br>";
}
?>


Das Ergebnis ist:

Der Schlüssel ist Israel und der Wert ist Melone
Der Schlüssel ist Neuseeland und der Wert ist Kiwi
Der Schlüssel ist Spanien und der Wert ist Zitrone
Der Schlüssel ist Italien und der Wert ist Himbeere
Der Schlüssel ist Deutschland und der Wert ist Kirsche
Der Schlüssel ist Guatemala und der Wert ist Banane

Wir sehen, dass der Befehl array_reverse auch auf Hashs angewendet werden kann.

Die Funktion array_unique : Identische Elemente in einem Array finden

<?
$frucht=("Birne","Orangen","Apfelsine","Nuss","Melone","Kirsche","Apfelsine");
$obst=array_unique($frucht);
foreach ($obst as $wert)
{
print "$wert <br>";
}
?>

Das Ergebnis ist:

Birne
Orangen
Nuss
Melone
Kirsche
Apfelsine

Wie man sieht, wurde die doppelte Apfelsine eliminiert.
Es stellt sich die Frage, wie dieser Befehl bei einem Hash wirkt.


<?
$ obst=array("Guatemala"=>"Banane",
"Deutschland"=>"Kirsche",
"Deutschland"=>"Himbeere",
"Spanien"=>"Banane",
"Neuseeland"=>"Kiwi",
"Israel"=>"Melone");
$kompott=array_unique($obst);
foreach($kompott as $index => $wert)
{
print "Der Schlüssel ist $index und der Wert ist $wert <br>";
}
?>

Das Ergebnis ist:

Der Schlüssel ist Guatemala und der Wert ist Banane
Der Schlüssel ist Deutschland und der Wert ist Himbeere
Der Schlüssel ist Neuseeland und der Wert ist Kiwi
Der Schlüssel ist Israel und der Wert ist Melone

Es wurde sowohl das doppelte Deutschland eliminiert, wie auch die doppelte Banane. array_unique entfernt also sowohl doppelte
keys wie auch doppelte values.

Die Funktion array_unique : Identische Elemente in einem Array finden

<?
$frucht=("Birne","Orangen","Apfelsine","Nuss","Melone","Kirsche","Apfelsine");
$obst=array_unique($frucht);
foreach ($obst as $wert)
{
print "$wert <br>";
}
?>

Das Ergebnis ist:

Birne
Orangen
Nuss
Melone
Kirsche
Apfelsine

Wie man sieht, wurde die doppelte Apfelsine eliminiert.
Es stellt sich die Frage, wie dieser Befehl bei einem Hash wirkt.


<?
$ obst=array("Guatemala"=>"Banane",
"Deutschland"=>"Kirsche",
"Deutschland"=>"Himbeere",
"Spanien"=>"Banane",
"Neuseeland"=>"Kiwi",
"Israel"=>"Melone");
$kompott=array_unique($obst);
foreach($kompott as $index => $wert)
{
print "Der Schlüssel ist $index und der Wert ist $wert <br>";
}
?>

Das Ergebnis ist:

Der Schlüssel ist Guatemala und der Wert ist Banane
Der Schlüssel ist Deutschland und der Wert ist Himbeere
Der Schlüssel ist Neuseeland und der Wert ist Kiwi
Der Schlüssel ist Israel und der Wert ist Melone

Es wurde sowohl das doppelte Deutschland eliminiert, wie auch die doppelte Banane. array_unique entfernt also sowohl doppelte
keys wie auch doppelte values.

Die Funktionen array_slice und array_splice: Teile aus einem Array herausschneiden

Arbeitet man mit Textdatenbanken, landen die Inhalte meistens in einem Array. Von dieser Textdatenbank will man aber meistens nur einen
Ausschnitt haben. In diesem Zusammenhang will man oft Teile aus Arrays herausschneiden, siehe Gästebuch. Der Unterschied
zwischen array_slice und array_splice besteht darin, dass man mit arrays_slice nur Teile aus einem Array herausschneiden kann, während man mit array_splice
die herausgeschnittenen Teile durch etwas anderes ersetzen kann.

array_splice

<?
$banane=array("süss","gelb","tropisch","vitamreich","nahrhaft","billig","anspruchslos");
$teile=array_slice($banane,2,3);
foreach ($teile as $wert)
{
print "$wert <br>";
}
?>

Das Ergebnis ist:

tropisch
vitamreich
nahrhaft

Die Funktion array_slice hat also drei Parameter. Den Array, aus dem herausgeschnitten wird, der Startpunkt und die Anzahl der Elemente, die herausgeschnitten werden.
Da der Array bei 0 anfängt, ist das 2 Element tropisch, zu tropisch noch drei Elemente mehr, wobei der Startpunkt mitzählt, ergibt dann tropisch, vitaminreich, nahrhaft.

array_splice

<?
$banane=array("süss","gelb","tropisch","vitamreich","nahrhaft","billig","anspruchslos");
$ersatz=array("tropical","lleno de vitaminas","alto valor nutritivo");
$teile=array_splice($banane,2,3,$ersatz);
foreach ($banane as $wert)
{
print "$wert <br>";
}
?>


Das Ergebnis ist dann:

süss
gelb
tropical
lleno de vitaminas
alto valor nutritivo
billig
anspruchslos

Wie deutlich zu erkennen, wurden die Elemente die herausgeschnitten wurden durch die Elemente des Arrays $ersatz ersetzt.

Die Funktionen array_diff, array_intersect: Arrays vergleichen

Mit array_div wird ein Abgleich durchgeführt zwischen einem Array einerseits und mehreren Arrays andererseits. Hierbei wird geprüft,
ob es Elemente gibt, die nur in dem Array vorkommen, mit dem alle anderen verglichen werden.


<?
$banane1=array("süss","gelb","subtropisch","vitamreich",
"nahrhaft","billig","anspruchslos");
$banane2=array("süss","gelb","tropisch","vitamreich",
"nahrhaft","billig","mehlig");
$banane3=array("süss","gelb","tropisch","vitamreich",
"nahrhaft","lustig","anspruchslos");
$teile=array_diff($banane1,$banane2,$banane3);
foreach ($teile as $wert)
{
print "$wert <br>";
}
?>

Als Ergebnis liefert der Skript subtropisch, da nur subtropisch in keinem anderen Array vorhanden ist. Der Array, der mit allen anderen verglichen wird,
ist der erste Parameter der Funktion.


<?
$banane1=array("süss","gelb","subtropisch","vitamreich",
"nahrhaft","billig","anspruchslos");
$banane2=array("süss","gelb","tropisch","kalorienreich",
"nahrhaft","billig","mehlig");
$banane3=array("süss","gelb","tropisch","vitamreich",
"nahrhaft","lustig","anspruchslos");
$teile=array_intersect($banane1,$banane2,$banane3);
foreach ($teile as $wert)
{
print "$wert <br>";
}
?>

Das Ergebnis ist:

süss
gelb
nahrhaft

da nur diese drei Werte in allen drei Arrays vorhanden sind.

Die Funtion array_implode: Mehrere Arrays zu einem Array zusammenfügen

Mit array_implode lassen sich mehrere Arrays zu einem Array zusammefügen.

<?
$banane1=array("süss","gelb","subtropisch","vitamreich",
"nahrhaft","billig","anspruchslos");
$banane2=array("süss","gelb","tropisch","kalorienreich",
"nahrhaft","billig","mehlig");
$banane3=array("süss","gelb","tropisch","vitamreich",
"nahrhaft","lustig","anspruchslos");
$teile=array_merge($banane1,$banane2,$banane3);
foreach ($teile as $wert)
{
print "$wert <br>";
}
?>

Das Ergebnis sieht dann so aus:

süss
gelb
subtropisch
vitamreich
nahrhaft
billig
anspruchslos
süss
gelb
tropisch
kalorienreich
nahrhaft
billig
mehlig
süss
gelb
tropisch
vitamreich
nahrhaft
lustig
anspruchslos

Die Funktion implode: Die Elemente eines Arrays zu einem String verbinden

Mit implode lassen sich die Elemente eines Arrays zu einer Zeichenkette zusammenfügen.

<?
$banane1=array("süss","gelb","subtropisch","vitamreich");
$teile=implode(" und ",$banane1);
print $teile;
?>

Das Ergebnis sieht dann so aus:

süss und gelb und subtropisch und vitamreich



Die Funktionen in_array und array_search: Suchen in einem Array

Mit in_array kann geprüft werden, ob ein bestimmtes Wort in einem Array enthalten ist

<?
$banane=array("süss","gelb","subtropisch","vitamreich");
$flag=in_array("gelb",$banane);
print $flag;
?>

Die Funktion gibt eins zurück, wenn das gesuchte Element, in diesem Falle "gelb" in dem Array enthalten ist.

Wenn man nicht nur wissen will, ob das Element enthalten ist, sondern auch wie der dazugehörige Schlüssel heisst, kann man die Funktion
array_search verwenden. Sowohl bei einem nummerischen Array als auch bei einem Hash geht die Funktion ausschliesslich auf den Wert.


<?
$banane=array("süss","gelb","subtropisch","vitamreich","subtropisch");
$flag=array_search("subtropisch",$banane);
print $flag;
?>

Das Ergebnis ist 2, weil subtropisch sich an zweiter Position befindet (Arrays starten mit 0).
Auf einen Hash angewendet

<?
$banane=array("Geschmack"=>"süss","Farbe"=>"gelb","Klima"=>"subtropisch",
"Nährwert"=>"vitamreich");
$flag=array_search("gelb",$banane);
print $flag;
?>

Das Ergebnis ist dann Farbe, weil gelb der Wert zu Farbe ist.

Hashes durchlaufen: each
Wem, aus welchen Gründen auch immer, die Konstruktion foreach ($name_des_hashs as $Index => $Wert) nicht gefällt, der kann einen
Hash auch mit each auslesen.

<?
$banane=array("Geschmack"=>"süss","Farbe"=>"gelb","Klima"=>"subtropisch",
"Nährwert"=>"vitamreich");
while(list($index,$wert)=each($banane))
{
print "Der Index ist $index und der Wert ist $wert <br>";
}
?>

Die Funktion each gibt einen Array mit zwei Elementen zurück (den Schlüssel und den Wert). Diese kann man dann mit list in
die Variable $index und $wert einlesen. Wer es so logischer findet, der kann es auch so machen.


<?
$banane=array("Geschmack"=>"süss","Farbe"=>"gelb","Klima"=>"subtropisch",
"Nährwert"=>"vitamreich");
while($miniarray=each($banane))
{
print "Der Index ist $miniarray[0] und der Wert ist $miniarray[1] <br>";
}
?>

Ermitten der Index eines arrays: key
Diese Funktion ist nicht mit der Funktion keys von Perl vergleichbar, sie gibt keinen Array mit allen Schlüsseln aus eines Hash aus, sondern
nur den Schlüssel des aktuellen key/value Paares. Wer will hat so eine dritte Möglichkeit, einen Hash zu durchlaufen.


<?
$banane=array("Geschmack"=>"süss","Farbe"=>"gelb","Klima"=>"subtropisch",
"Nährwert"=>"vitamreich");
$schluessel=key($banane);
for ($i=0;$i<count($banane);$i++)
{
$wert=key($banane);
print "Der Index ist $wert und der Wert ist $banane[$wert]<br>";
next($banane);
}
?>

Das Ergebnis ist:

Der Index ist Geschmack und der Wert ist süss
Der Index ist Farbe und der Wert ist gelb
Der Index ist Klima und der Wert ist subtropisch
Der Index ist Nährwert und der Wert ist vitamreich

key wird angewendet auf das aktuelle key/value Paar, wie dieses Beispiel deutlich zeigt.

<?
$banane=array("Geschmack"=>"süss","Farbe"=>"gelb","Klima"=>"subtropisch",
"Nährwert"=>"vitamreich");
$schluessel=key($banane);
print $schluessel;
?>

Das Ergebnis ist dann Geschmack, der erste key. Nachdem der key ausgelesen wurde, kann man mit next die Position eins weiter rücken und
sich dann beim nächsten Schleifendurchlauf den nächsten Schlüssel anzeigen lassen. So kann man dann durch den ganzen Array
durchmaschieren.

Die Summe der Arraywerte berechnen: array_sum

<?
$summe=array(3,7,11);
$ergebnis=array_sum($summe);
print $ergebnis;
?>

Als Ergebnis kommt 21 raus.

Elemente eines Arrays an eine Funktion übergeben: array_walk
Will man komplexere Operationen mit den Elementen eines Arrays machen, z.B. jedes Element formatieren, alle Elemente miteinander
multiplizieren, bei jedem Element prüfen, einen Abgleich machen mit einer regular expression etc. dann kann man mit array_walk nacheinander
jedes Element einer Funktion übergeben.


<?
function Zeichenkette($a)
{
global $kette;
$kette=" ".$kette." ".$a;
}
$Anfang=array("Das","ist","das","Haus","vom","Nikolaus");
array_walk($Anfang,"Zeichenkette");
print $kette;
?>

Wir erhalten als Ergebnis: Das ist das Haus vom Nikolaus. Für jedes Element des Arrays $Anfang wird die Funktion Zeichenkette aufgerufen. Die Art,
wie sie aufgerufen wird, ist gewöhnungsbedürftig. Die Funktion Zeichenkette fügt bei jedem Durchgang das Element des Arrays an die Variable Kette,
so dass wir am Schluss dann eben haben, "Das ist das Haus vom Nikolaus". Mehr zu Funktionen unter Funktionen.
Der Punkt in der Zeile $kette=" ".$kette." ".$a ist ein sogenannter Konkatenationsoperator. Mehr dazu unter
Arbeiten mit Zeichenketten. Besonders Aufmerksamen ist jetzt wahrscheinlich aufgefallen, dass
man dies auch hätte mit der Funktion implode errreichen können. Das ist richtig, war aber auch nur ein Beispiel für array_walk.

Die Anzahl der Elemente eines Arrays ermitteln: count
Die Anzahl der Elemente eines Arrays muss man sehr oft ermitteln, etwa wenn man bei einem Gästebuch aufblenden will, wieviele Einträge insgesamt schon
gemacht wurden, siehe Gästebuch.

<?

?>

vorhergehendes Kapitel