Array
Was sind eigentlich Arrays?
Übersicht
* Grundlagen: Anlegen und Füllen von Arrays, Zugriff auf Arrayinhalte
* assoziative Arrays
* mehrdimensionale Arrays
* Ausführliches Anwendungsbeispiel
* Weiterführende Informationen
1. Grundlagen: Anlegen und Füllen von Arrays, Zugriff auf Arrayinhalte
Ein Array, auch Feld genannt, kann als Variablenmenge angesehen werden.
Nehmen wir als Beispiel eine Liste von Mitgliedern eines Vereins. Es wäre natürlich möglich für jedes Mitglied eine Variable zu erstellen, aber solch eine Konstruktion
PHP-Code:
01
02
03
04
05
06
<?php
$mitglied1 = 'Peter';
$mitglied2 = 'Manuela';
$mitglied3 = 'Bernd';
$mitglied4 = 'Gunther';
?>
ist doch eher umständlich, vor allem bei großen Variablenzahlen. Aus diesem Grunde verwendet man für diese Ansammlung von Variablen ein Array.
Es gibt mehrere Möglichkeiten ein Array zu initialisieren / anzulegen und mit Inhalt zu füllen.
Ich stelle hier nur die Wege vor, die ich bisher als praxisnah empfunden habe.
Ich persönlich verwende in all meinen Scripten spezielle Variablenbezeichnungen. Das kann jeder machen, wie er das möchte, sofern die Bezeichnungen syntaktisch korrekt sind.
Kommen wir aber wieder zurück zu den Initialisierungsmöglichkeiten.
Möglichkeit 1
PHP-Code:
01
02
03
04
05
06
<?php
$_mitglieder = array('Peter',
'Manuela',
'Bernd',
'Gunther');
?>
PHP stellt die Funktion
array() zur Verfügung, um ein Array anzulegen. Optional können auch direkt bei der Initialisierung Elemente hinzugefügt werden.So kommen wir dann zur
Möglichkeit 2
PHP-Code:
01
02
03
04
05
06
07
08
<?php
$_mitglieder = array();
$_mitglieder[] = 'Peter';
$_mitglieder[] = 'Manuela';
$_mitglieder[] = 'Bernd';
$_mitglieder[] = 'Gunther';
?>
Die beiden Wege führen exakt zum selben Ergebnis.
Um die dritte Möglichkeit zu erklären müssen wir einen kleinen Ausflug machen. Nämlich zu der Frage, wie denn die Daten in dem Array eigentlich wieder zu verwenden sind?
Konkret: Wie greife ich auf die einzelnen Daten zu?
Man spricht von Elementen eines Arrays.
Wir haben oben jeweils ein indiziertes Array angelegt. Das ist ein Array, welches die Daten in der folgenden Struktur speichert.
Code:
1. Wert: Peter
2. Wert: Manuela
3. Wert: bernd
4. Wert: Gunther
Wichtig dabei ist, dass die Indizierung eines Arrays immer bei 0 anfängt.
Das erste Element ist also nicht über den Index 1, sondern über den Index 0 ansprechbar.
Indizes sind immer postive Ganzzahlen.
Der Zugriff auf der erste Element erfolgt dann z.B so
Code:
$_mitglieder[0]
Im folgenden Beispiel werden nun die Namen des ersten und des dritten Mitglieds ausgegeben.
PHP-Code:
01
02
03
04
05
06
07
08
09
10
11
<?php
$_mitglieder = array('Peter',
'Manuela',
'Bernd',
'Gunther');
echo 'Mitglied 1 heißt ' . $_mitglieder[0];
echo '<br />';
echo 'Mitglied 3 heißt ' . $_mitglieder[2];
?>
So kommen wir also zur dritten Möglichkeit ein Array mit Inhalt zu füllen.
Möglichkeit 3
PHP-Code:
01
02
03
04
05
06
07
08
<?php
$_mitglieder = array();
$_mitglieder[0] = 'Peter';
$_mitglieder[1] = 'Manuela';
$_mitglieder[2] = 'Bernd';
$_mitglieder[3] = 'Gunther';
?>
Selbstverständlich kann man die einzelnen Methoden jetzt beliebig mischen. Dies soll aber hier nicht weiter dokumentiert werden.
Enthält der Arrayelement, welches für die Zuweisung ausgewählt wurde bereits Inhalt, so wird dieser mit dem neu zugewiesenen Wert überschrieben.
Die einzelnen Elemente eines Arrays verhalten sich exakt so, wie normale Variablen.
2. Assoziative Arrays
Neben den indizierten Arrays gibt es noch eine andere Form, die assoziativen Arrays.
Die Daten werden hierbei durch eine Schlüssel-Wert-Beziehung (daher 'assoziativ') gespeichert. Die Schlüssel können numerisch oder als String vorliegen.
Die Grundstruktur sieht folgendermaßen aus:
Code:
$_array = array( Schlüssel => Wert )
Ein kleines Beispiel:
PHP-Code:
01
02
03
04
05
Die Zuweisung erfolgt mit Hilfe des ' => ' - Operators.
Da beim indizierten Array der Index natürlich auch als Schlüssel aufgefasst werden kann erfolgt der Zugriff wie erwartet:
PHP-Code:
01
02
03
<?php
echo $_mitglied['Name'];
?>
Um ein assoziatives Array dynamisch auszulesen gibt es sogar eine eigene Schleifenkonstruktion, die for-each-Schleife.
Ein Anwendungsbeispiel für die "for-each"-Schleife findest du im FAQ-Beitrag über Kontrollstrukturen. Folge einfach dem obigen Link ;-)
3. Mehrdimensionale Arrays
Wie zu Beginn schon beschrieben, kann ein Array unterschiedliche Typen beinhalten und somit auch weitere Arrays.
Bisher haben wir nur Arrays in der ersten Dimension kennengelernt.
Wenn wir nun als Arrayelement wieder eine Element angeben, so erhalten wir eine zweite Dimension.
Ich möchte mit Hilfe eines kleinen Beispiels verdeutlichen, wie man mit mehrdimensionalen Arrays arbeiten kann.
Im Abschnitt über assoziative Arrays haben wir ein Array folgender Struktur angelegt.
PHP-Code:
01
02
03
04
05
Nehmen wir an, dass wir nun nicht nur ein Mitglied haben, sondern mehrere. Ein mehrdimensionales Array wäre dann in der Lage alle Informationen über die Mitglieder in nur einer Variable zu verwalten.
Ein Beispiel.
PHP-Code:
01
02
03
04
05
06
07
08
09
10
11
12
13
Im Browser wird folgende Arraystruktur dargestellt:
Code:
Array
(
[0] => Array
(
[Name] => Peter
[Alter] => 22
[aktiv] => 1
)
[1] => Array
(
[Name] => Manuela
[Alter] => 34
[aktiv] => 0
)
)
Diese Verschachtelungen lassen sich natürlich beliebig dimensional vertiefen, allerdings sollte man sich früh Gedanken über die Übersichtlichkeit solcher Konstrukte machen.
Meiner persönlichen Erfahrung nach kann man mit zweidimensionalen Arrays noch sehr gut arbeiten, die dritte Dimension wird schon etwas unübersichtlicher. Alles was darüber ist, ist meines Erachtens nicht überschaubar.
Das ist allerdings jedem selbst überlassen.
4. Anwendungsbeispiel
Ich möchte mit diesem kleinen Beispiel zeigen, wie einfach es sein kann, mit einem einzigen Array große Datenmengen zu verwalten.
In dem Array legen wir zunächst einmal per Hand ein mehrdimensionales Array an. In der Praxis bezieht man diese Daten aus einer Datenbnak bzw. aus anderen Speichermedien.
Nach einer Testausgabe wird jedem Mitglied eine Mitglieds-ID zugewiesen.
Danach wird das aktualisierte Array mittels einer Schleifenkonstruktion wieder ausgegeben.
PHP-Code:
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
<?php
$_mitglieder = array(array('ID' => null,
'Name' => 'Peter',
'Alter' => 22,
'aktiv' => true ),
array( 'ID' => null,
'Name' => 'Manuela',
'Alter' => 34,
'aktiv' => false),
array( 'ID' => null,
'Name' => 'Bernd',
'Alter' => 28,
'aktiv' => true));
// Testausgabe
echo '<pre>';
print_r($_mitglieder);
echo '</pre>'; //*/
// Jedem Mitglieder automatisch eine eindeutige Mitglieds-ID zuweisen.
$id = 1000;
for( $i = 0; $i < count($_mitglieder); $i++ )
{
$_mitglieder[$i]['ID'] = ++$id;
}
echo 'Mitglieder-ID wurde hinzugefügt.';
// Testausgabe
echo '<pre>';
print_r($_mitglieder);
echo '</pre>'; //*/
// Arrayinhalt zum Test ausgeben lassen, dieses Mal 'manuell'.
for( $i = 0; $i < count($_mitglieder); $i++ )
{
foreach( $_mitglieder[$i] as $schluessel => $wert )
{
echo $schluessel . ': ' . $wert;
echo '<br />';
}
echo '##### <br />';
}
?>
Eine Ausgabe dieser Art wir man höchstwahrscheinlich in späteren praktischen Anwendungen nicht finden, da diese Konstruktion hier sicherlich komfortabler ist.
PHP-Code:
01
02
03
04
05
06
07
08
09
10
11
12
13
14
In dieser Ausgabe verwende ich einen ternären Operator. Bitte nicht erschrecken. Es ist leichter, als man denkt ;-)
Nun liegt es an Euch dieses Beispiel auszutesten, es nachzuprogrammieren und es somit zu verstehen.