|
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
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[3].
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.
<?
$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 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
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.
<?
?>
|
 |
