PHP lernen – Arrays – Link's Blog

Hi,

heute geht’s um Arrays. Du hast Variablen kennen gelernt und weißt, dass man in solchen Werte speichern kann. Und dass Variablen von verschiedenen Typen sein können (Text, Zahlen, Wahrheitswert). Arrays sind sowas ähnliches – sie tun im Grunde dasselbe, es lassen sich darin aber mehr als nur ein Wert abspeichern.

Was sind Arrays?

Arrays sind sog. Datenfelder, man spricht auch von Schlüssel-Werte-Paaren. Variablen kennst du ja schon. Eine Variable hat einen Namen und ihr wird ein Wert zugewiesen. Einem Array können hingegen viele Werte zugewiesen werden. Dabei legt man einen Wert im Array ab, auf den man über einen Schlüssel Zugriff erhält. Dieser Schlüssel ist quasi der Index innerhalb der Liste von Werten. Schlüssel klingt kompliziert, im Grunde werden die Werte abgelegt und der Index automatisch durchnummeriert wenn man selbst keinen angibt.

Arrays werden in eckigen Klammern deklariert, kommagetrennt werden die einzelnen Werte übergeben, zum Beispiel [ "Apfel", "Birne", "Banane" ].
Du kannst auch ein leeres Array das keine Werte hat und vielleicht erst später welche bekommt deklarieren, dann einfach mit einer öffnenden und schließenden eckigen Klammer ohne Werte darin, also [].

Zur Deklaration schreibst du dann einfach $meinArray = [ "Wert1", "Wert2" ]; Der Index („Schlüssel“) wird automatisch vergeben sodass das erste Element im Array an Index #0 liegt und das zweite an Index #1 und so weiter. In der Programmierung wird bei 0 angefangen zu zählen, nicht bei 1.

Testen wir das in der Praxis. Ich deklariere ein Array und gebe ihm 3 Werte, anschließend gebe ich den ersten und zweiten Wert aus:

<?php
	
	# Deklariere ein Array und gib ihm gleich 3 Werte
	$Obst = ["Apfel", "Banane", "Melone"];
	
	/**
	 * +++ WICHTIG +++
	 * Der Index (also die Schlüssel zu den Werten) wurde hier
	 * automatisch vergeben, weil wir selbst keinen angegeben haben.
	 */
	
	# Geben wir das ERSTE Element im Array aus:
	echo $Obst[0];
	
	# Und jetzt das zweite:
	echo $Obst[1];

?>

<?php

# Deklariere ein Array und gib ihm gleich 3 Werte

$Obst = ["Apfel", "Banane", "Melone"];

/**

* +++ WICHTIG +++

* Der Index (also die Schlüssel zu den Werten) wurde hier

* automatisch vergeben, weil wir selbst keinen angegeben haben.

# Geben wir das ERSTE Element im Array aus:

echo $Obst[0];

# Und jetzt das zweite:

echo $Obst[1];

Analog hierzu können wir nun auch noch das dritte und letzte Element ausgeben – du ahnst schon wie wir Zugriff darauf erhalten:

echo $Obst[2];

1	echo $Obst[2];

Fantastisch, ich denke das ist nicht so schwer – abgesehen davon dass es natürlich etwas wirr aussieht, wenn man vorher noch nie Programmcode gesehen hat 😉

Es gibt noch eine andere, veraltete Schreibweise zur Deklaration von Arrays:

<?php
	
	# Deklaration wie vorhin:
	$Obst = [ "Apfel", "Banane", "Melone" ];
	
	# Alternative (veraltete) Schreibweise:
	$Obst = array( "Apfel", "Banane", "Melone" );

?>

<?php

# Deklaration wie vorhin:

$Obst = [ "Apfel", "Banane", "Melone" ];

# Alternative (veraltete) Schreibweise:

$Obst = array( "Apfel", "Banane", "Melone" );

Warum zeig‘ ich dir das, will ich Verwirrung stiften? Nein, allerdings wirst du beim googlen vermutlich über beide Schreibweisen stolpern, besser du hast sie also gleich intus. Diese Schreibweise mit den eckigen Klammern ist durchweg zu empfehlen, nicht nur weil es intuitiver ist (den Zugriff auf Elemente des Array erhältst du ja auch, indem du den Schlüssel in eckigen Klammern angibst) sondern auch weil sie geläufiger ist. Möglich ist das ab PHP Version 5.4, aber da solltest du mit dem aktuellen XAMPP-Paket definitiv drüber liegen (PHP 5.6, sicherlich aber schon irgendwas über PHP 7). Falls du doch Bedenken hast, kannst du das mit folgender Code-Zeile ganz schnell herausfinden:

<?php
	
	echo phpversion();

?>

<?php

echo phpversion();

Numerische Indexierung

Wie du siehst, hat PHP also die Werte die zu in das Array gepackt hast, automatisch durchnummeriert – weniger zu tun für uns. Aber natürlich können wir aber auch selbst angeben, welcher Wert unter welchem Schlüssel gespeichert wird.

<?php
	
	# Array deklarieren und Schlüssel selbst angeben:
	$Obst = [ 12 => "Apfel", 900 => "Banane", 1 => "Melone" ];

?>

<?php

# Array deklarieren und Schlüssel selbst angeben:

$Obst = [ 12 => "Apfel", 900 => "Banane", 1 => "Melone" ];

Es ist also völlig egal, unter welchem Index du deine Werte speichern willst. Entsprechend erfolgt der Zugriff nun über die von dir angegebenen Schlüssel:

<?php
	
	# Array deklarieren und Schlüssel selbst angeben:
	$Obst = [ 12 => "Apfel", 900 => "Banane", 1 => "Melone" ];
	
	echo $Obst[12];
	echo $Obst[900];
	echo $Obst[1];

?>

<?php

# Array deklarieren und Schlüssel selbst angeben:

$Obst = [ 12 => "Apfel", 900 => "Banane", 1 => "Melone" ];

echo $Obst[12];

echo $Obst[900];

echo $Obst[1];

Die Ausgabe ist ein bisschen ätzend: ApfelBananeMelone . Das kriegen wir schöner hin, indem wir einfach einen HTML-Zeilenumbruch hinter jede ausgegebene Zeile setzen:

<?php
	
	# Array deklarieren und Schlüssel selbst angeben:
	$Obst = [ 12 => "Apfel", 900 => "Banane", 1 => "Melone" ];
	
	echo $Obst[12] . "<br>";
	echo $Obst[900] . "<br>";
	echo $Obst[1] . "<br>";

?>

<?php

# Array deklarieren und Schlüssel selbst angeben:

$Obst = [ 12 => "Apfel", 900 => "Banane", 1 => "Melone" ];

echo $Obst[12] . " ";

echo $Obst[900] . " ";

echo $Obst[1] . " ";

Und schon sieht es hübsch aus:

Apfel
Banane
Melone

Apfel

Banane

Melone

Manuelle und automatische Indexierung mischen

Du hast jetzt gesehen wie PHP die Nummerierung selbst vornimmt und wie du sie beeinflussen kannst. Bei der Deklaration können wir beide Varianten ganz einfach mischen. PHP arbeitet dabei so, dass es versucht, mit dem nächsthöheren, verfügbaren Zahlenwert zu nummerieren. Sehen wir uns das mal an:

<?php
	
	# Array deklarieren und Schlüssel selbst angeben bzw. automatisch vergeben lassen
	$Obst = [ 12 => "Apfel", "Banane", 2 => "Melone", "Birne" ];

?>

<?php

# Array deklarieren und Schlüssel selbst angeben bzw. automatisch vergeben lassen

$Obst = [ 12 => "Apfel", "Banane", 2 => "Melone", "Birne" ];

Und damit wir nicht wieder so viele Zeilen zur Ausgabe verschwenden müssen, gibt es zwei einfache Befehle, um Arrays auf die schnelle auszugeben, var_dump und print_r . Also dasselbe nochmal:

<?php
	
	# Array deklarieren und Schlüssel selbst angeben bzw. automatisch vergeben lassen
	$Obst = [ 12 => "Apfel", "Banane", 2 => "Melone", "Birne" ];
	
	# Ausgabe mit var_dump
	var_dump($Obst);
	
	# HTML Zeilenumbruch
	echo "<br>";
	
	# Ausgabe mit print_r
	print_r($Obst);

?>

<?php

# Array deklarieren und Schlüssel selbst angeben bzw. automatisch vergeben lassen

$Obst = [ 12 => "Apfel", "Banane", 2 => "Melone", "Birne" ];

# Ausgabe mit var_dump

var_dump($Obst);

# HTML Zeilenumbruch

echo " ";

# Ausgabe mit print_r

print_r($Obst);

Die Ausgabe sieht folgendermaßen aus:

array(4) { [12]=> string(5) "Apfel" [13]=> string(6) "Banane" [2]=> string(6) "Melone" [14]=> string(5) "Birne" }

Array ( [12] => Apfel [13] => Banane [2] => Melone [14] => Birne )

array(4) { [12]=> string(5) "Apfel" [13]=> string(6) "Banane" [2]=> string(6) "Melone" [14]=> string(5) "Birne" }

Array ( [12] => Apfel [13] => Banane [2] => Melone [14] => Birne )

So schnell kann’s gehen – aber so richtig schön ist es nicht. Ich persönlich verwende zur Ausgabe immer gern den HTML pre -Tag in Verbindung mit print_r, wobei ich an die print_r Funktion noch zusätzlich den zweiten Parameter true übergebe, der dafür sorgt, dass print_r nicht sofort eine Ausgabe macht – damit kann ich print_r mit echo verwenden. Machen wir’s diesmal richtig:

<?php
	
	# Array deklarieren und Schlüssel selbst angeben bzw. automatisch vergeben lassen
	$Obst = [ 12 => "Apfel", "Banane", 2 => "Melone", "Birne" ];
	
	# Ausgabe mit print_r
	echo "<pre>" . print_r($Obst, true) . "</pre>";

?>

<?php

# Array deklarieren und Schlüssel selbst angeben bzw. automatisch vergeben lassen

$Obst = [ 12 => "Apfel", "Banane", 2 => "Melone", "Birne" ];

# Ausgabe mit print_r

echo "<pre>" . print_r($Obst, true) . "</pre>";

Und die Ausgabe ist auch sehr hübsch und übersichtlich:

Array
(
    [12] => Apfel
    [13] => Banane
    [2] => Melone
    [14] => Birne
)

Array

(

[12] => Apfel

[13] => Banane

[2] => Melone

[14] => Birne

)

Für Banane und und Birne hat PHP den Index selbst bestimmt. Die Banane an Index 13 (weil der größte vorherige 12 ist, das haben wir selber so festgelegt) und die Birne an 14, weil es die nächstgrößere verfügbare Zahl ist.

Welche Fallstricke gibt es?

Man kann sich schonmal vertippen und zum Beispiel einen Wert aus dem Array holen, den es am angegebenen Index nicht gibt. Machen wir mal absichtlich einen Fehler:

<?php
	
	# Array deklarieren und Schlüssel selbst angeben bzw. automatisch vergeben lassen
	$Obst = ["Apfel"];
	
	# Es gibt nur ein Element (an Index 0), also kriegen wir
	# in der folgenden Zeile mit Sicherheit einen Fehler:
	echo $Obst[7];

?>

<?php

# Array deklarieren und Schlüssel selbst angeben bzw. automatisch vergeben lassen

$Obst = ["Apfel"];

# Es gibt nur ein Element (an Index 0), also kriegen wir

# in der folgenden Zeile mit Sicherheit einen Fehler:

echo $Obst[7];

So, und wenn du den Code jetzt ausführst, bekommst du entweder gar nix angezeigt (die Seite bleibt weiß und hat keine Ausgabe) oder du bekommst eine Fehlermeldung.

Fehlerausgabe aktivieren

Falls du nur eine weiße Seite bekommst, erweitere deinen Code am Anfang um die folgenden zwei Zeilen:

<?php
	
	ini_set('display_errors', 1);
	error_reporting(E_ALL);
	
	# Array deklarieren und Schlüssel selbst angeben bzw. automatisch vergeben lassen
	$Obst = [ "Apfel" ];
	
	# Es gibt nur ein Element (an Index 0), also kriegen wir mit
	# der folgenden Zeile einen Fehler:
	echo $Obst[7];

?>

<?php

ini_set('display_errors', 1);

error_reporting(E_ALL);

# Array deklarieren und Schlüssel selbst angeben bzw. automatisch vergeben lassen

$Obst = [ "Apfel" ];

# Es gibt nur ein Element (an Index 0), also kriegen wir mit

# der folgenden Zeile einen Fehler:

echo $Obst[7];

Vermutlich bekommst du also spätestens jetzt den Fehler ausgegeben:

Notice: Undefined offset: 7 in /pfad/zum/skript.php on line 11

1	Notice: Undefined offset: 7 in /pfad/zum/skript.php on line 11

Perfekt, ein Fehler, was machen wir jetzt damit? Nix, aber du hast eine neue Fehlermeldung kennengelernt. „Undefined offset“ bedeutet übersetzt in etwa soviel wie dass der Ableger nicht definiert ist. Der Wert der versucht wurde auszugeben, ist also nicht bei Index 7 abgelegt. Den Fehler wirst du am Anfang noch öfter machen, spätestens wenn du mit Formularen und Schleifen arbeitest.

Kann ich Werte auch nachträglich zum Array hinzufügen?

Sicher, nix leichter als das. Und zwar einfach, indem wir an den Variablennamen des Arrays ein Paar eckiger Klammern hängen und dann den Wert zuweisen. Außerdem siehst du, wie man ein leeres Array anlegen kann (jupp, das geht natürlich auch):

<?php
	
	ini_set('display_errors', 1);
	error_reporting(E_ALL);
	
	# Ein leeres Array deklarieren
	$Obst = [];
	
	# Werte mit Angabe des Index hinzufügen
	$Obst[12] = "Apfel";
	$Obst[900] = "Birne";
	
	# Werte ohne Angabe des Index hinzufügen:
	$Obst[] = "Banane";
	$Obst[] = "Melone";
	
	echo "<pre>" . print_r($Obst, true) . "</pre>";

?>

<?php

ini_set('display_errors', 1);

error_reporting(E_ALL);

# Ein leeres Array deklarieren

$Obst = [];

# Werte mit Angabe des Index hinzufügen

$Obst[12] = "Apfel";

$Obst[900] = "Birne";

# Werte ohne Angabe des Index hinzufügen:

$Obst[] = "Banane";

$Obst[] = "Melone";

echo "<pre>" . print_r($Obst, true) . "</pre>";

Die Ausgabe hierzu ist dementsprechend:

Array
(
    [12] => Apfel
    [900] => Birne
    [901] => Banane
    [902] => Melone
)

Array

(

[12] => Apfel

[900] => Birne

[901] => Banane

[902] => Melone

)

Und natürlich lassen sich vorhandene Werte in einem Array auch genausogut Überschreiben. Check das:

<?php
	
	ini_set('display_errors', 1);
	error_reporting(E_ALL);
	
	# Ein leeres Array deklarieren
	$Obst = [ "Apfel", "Birne", "Banane", "Melone" ];
	
	$Obst[2] = "Erdbeere";
	
	echo "<pre>" . print_r($Obst, true) . "</pre>";

?>

<?php

ini_set('display_errors', 1);

error_reporting(E_ALL);

# Ein leeres Array deklarieren

$Obst = [ "Apfel", "Birne", "Banane", "Melone" ];

$Obst[2] = "Erdbeere";

echo "<pre>" . print_r($Obst, true) . "</pre>";

Der Wert an Index 2 (Banane) wurde also ersetzt mit Erdbeere, daher auch die Ausgabe:

Array
(
    [0] => Apfel
    [1] => Birne
    [2] => Erdbeere
    [3] => Melone
)

Array

(

[0] => Apfel

[1] => Birne

[2] => Erdbeere

[3] => Melone

)

Assoziativer Index – Namen statt Zahlen

Wie schon gesagt, ein Element, also ein Wert im Array erhält automatisch einen Index, wenn man selber keinen angegeben hat. Über diesen Index kann ein Array-Element angesprochen werden. Es gibt 2 Arten, wie Werte in Arrays indexiert werden können:

Numerischer Index
Wenn man die Werte einfach an ein Array übergibt, nummeriert PHP den Index von 0 (Null) beginnend einfach durch. Das erste Element („Wert1“) ist an Index #0 des Arrays zu finden, „Wert2“ ist an Index #1 und so weiter. Du kannst den numerischen Index auch selbst festlegen. Beide Möglichkeiten habe ich dir oben gezeigt.
Assoziativer Index
So viele seltsame Begriffe auf einmal! Aber wir schaffen das schon, keine Panik. Assoziativ heißt nur, dass man Elemente eines Arrays nicht durch einen numerischen Index sondern stattdessen über einen Namen speichert und anspricht. Das ist wesentlich komfortabler wenn man im Vornherein weiß, welche Werte das Array enthält.

Funktionieren tut es genauso, nur dass man anstatt Zahlen eben Text für den Index angibt (somit also in Anführungszeichen). Und so läuft es:

<?php

	# Deklaration eines assoziativen Arrays
	$Person = [
		"name" => "Max Mustermann",
		"firma" => "Mustermann GmbH",
		"strasse" => "Musterweg 4",
		"plz" => "12345",
		"ort" => "Musterstadt"
	];


	echo "Array \"Person\" ausgeben:<br>";
	echo "<pre>" . print_r($Person, 1) . "</pre>";

	echo "<br>";
	echo "Die Person heisst " . $Person["name"] . " und wohnt in " . $Person["ort"] . ".<br>";

	# Erweitern wir die Angaben:
	$Person["alter"] = 32;
	$Person["email"] = "max.mustermann@example.com";

	echo "Die Person ist " . $Person['alter'] . " Jahre alt. Schreib ihr doch eine E-Mail an " . $Person['email'] . "<br>";

?>

<?php

# Deklaration eines assoziativen Arrays

$Person = [

"name" => "Max Mustermann",

"firma" => "Mustermann GmbH",

"strasse" => "Musterweg 4",

"plz" => "12345",

"ort" => "Musterstadt"

];

echo "Array \"Person\" ausgeben: ";

echo "<pre>" . print_r($Person, 1) . "</pre>";

echo " ";

echo "Die Person heisst " . $Person["name"] . " und wohnt in " . $Person["ort"] . ". ";

# Erweitern wir die Angaben:

$Person["alter"] = 32;

$Person["email"] = "max.mustermann@example.com";

echo "Die Person ist " . $Person['alter'] . " Jahre alt. Schreib ihr doch eine E-Mail an " . $Person['email'] . " ";

Das Beispiel erzeugt folgende Ausgabe:

Array "Person" ausgeben:

Array
(
    [name] => Max Mustermann
    [firma] => Mustermann GmbH
    [strasse] => Musterweg 4
    [plz] => 12345
    [ort] => Musterstadt
)


Die Person heisst Max Mustermann und wohnt in Musterstadt.
Die Person ist 32 Jahre alt. Schreib ihr doch eine E-Mail an max.mustermann@example.com

Array "Person" ausgeben:

Array

(

[name] => Max Mustermann

[firma] => Mustermann GmbH

[strasse] => Musterweg 4

[plz] => 12345

[ort] => Musterstadt

)

Die Person heisst Max Mustermann und wohnt in Musterstadt.

Die Person ist 32 Jahre alt. Schreib ihr doch eine E-Mail an max.mustermann@example.com

Ist doch deutlich komfortabler und auch intuitiver, als sich einen numerischen Index zu merken 🙂

Kann ich Elemente in einem Array numerisch UND assoziativ ablegen?

Auch das geht, wie folgendes Beispiel zeigt:

<?php
	
	$Arr = array(
		'eins' => 'Wert 1',
		8      => 'Wert 2',
		'Wert 3'
	);
	
	echo "<pre>" . print_r($Arr, 1) . "</pre>";

?>

<?php

$Arr = array(

'eins' => 'Wert 1',

8 => 'Wert 2',

'Wert 3'

);

echo "<pre>" . print_r($Arr, 1) . "</pre>";

Das Beispiel erzeugt folgende Ausgabe:

Array
(
    [eins] => Wert 1
    [8] => Wert 2
    [9] => Wert 3
)

Array

(

[eins] => Wert 1

[8] => Wert 2

[9] => Wert 3

)

Wir haben dem Array zuerst über einen assoziativen Index „eins“ den Wert „Wert 1“ zugewiesen, dann über einen numerischen Index den Wert „Wert 2“ und zum Schluss wieder PHP überlassen, an welchem Index er den dritten Wert „Wert 3“ ablegt – in dem Fall an Index #9, weil ja #8 vorher der höchste numerische Index war.

Ein Array kann also numerisch oder assoziativ oder von PHP automatisch indexiert werden – und das geht wenn wenn man will auch alles zugleich.

Kann der Wert eines Arrays selbst ein Array sein?

Klar, auch das ist möglich. Man spricht dabei von „verschachtelten“ Arrays (nested arrays). Ein Array kann also beliebig viele weitere Arrays als Werte haben, und auch die können wiederum weitere Arrays enthalten. Geschrieben wird es genauso. Hier ein Code zur Verdeutlichung:

<?php
	
	# Array Mitarbeiter - Mitarbeiter werden numerisch angesprochen, die einzelnen Personendaten assoziativ
	$Mitarbeiter = [
		[
			'Name'   => 'Max Mustermann',
			'Gehalt' => 2000,
		],
		[
			'Name'   => 'Sonja Meier',
			'Gehalt' => 1600,
		],
		[
			'Name'   => 'Tobias Weiss',
			'Gehalt' => 4500,
		],
	];
	
	echo "<pre>" . print_r($Mitarbeiter, 1) . "</pre>";
	
	# Wieviel Gehalt bekommt Frau Meier?
	echo "Sonja Meier bekommt " . $Mitarbeiter[1]['Gehalt'] . "&euro; im Monat.";
	
	echo "<br><br>";
	# Natürlich geht auch assoziativ
	$Lebensmittel = [
		'fastfood'  => [
			'Pizza',
			'Burger',
		],
		'obst'      => [
			'Apfel',
			'Banane',
			'Trauben',
			'Kirschen',
		],
		'gemuese'   => [
			'Salat',
			'Tomaten',
			'Gurken',
		],
		'suesskram' => [
			'Snickers',
			'Maoam',
			'Zuckerwatte',
			'Nutella',
		],
	];
	
	echo "<pre>" . print_r($Lebensmittel, 1) . "</pre>";
	
	# Gib mir OBST!!!
	echo "<strong>Iss mal etwas Obst:</strong><br>";
	echo "<pre>" . print_r($Lebensmittel['obst'], 1) . "</pre>";
	
	# Oder Zuckerwatte...
	echo "Wenn du aufgegessen hast kriegst du Nachtisch: ";
	echo $Lebensmittel['suesskram'][2];

<?php

# Array Mitarbeiter - Mitarbeiter werden numerisch angesprochen, die einzelnen Personendaten assoziativ

$Mitarbeiter = [

[

'Name' => 'Max Mustermann',

'Gehalt' => 2000,

[

'Name' => 'Sonja Meier',

'Gehalt' => 1600,

[

'Name' => 'Tobias Weiss',

'Gehalt' => 4500,

];

echo "<pre>" . print_r($Mitarbeiter, 1) . "</pre>";

# Wieviel Gehalt bekommt Frau Meier?

echo "Sonja Meier bekommt " . $Mitarbeiter[1]['Gehalt'] . "€ im Monat.";

echo " ";

# Natürlich geht auch assoziativ

$Lebensmittel = [

'fastfood' => [

'Pizza',

'Burger',

'obst' => [

'Apfel',

'Banane',

'Trauben',

'Kirschen',

'gemuese' => [

'Salat',

'Tomaten',

'Gurken',

'suesskram' => [

'Snickers',

'Maoam',

'Zuckerwatte',

'Nutella',

];

echo "<pre>" . print_r($Lebensmittel, 1) . "</pre>";

# Gib mir OBST!!!

echo "Iss mal etwas Obst: ";

echo "<pre>" . print_r($Lebensmittel['obst'], 1) . "</pre>";

# Oder Zuckerwatte...

echo "Wenn du aufgegessen hast kriegst du Nachtisch: ";

echo $Lebensmittel['suesskram'][2];

Das Beispiel erzeugt folgende Ausgabe:

Array
(
    [0] => Array
        (
            [Name] => Max Mustermann
            [Gehalt] => 2000
        )

    [1] => Array
        (
            [Name] => Sonja Meier
            [Gehalt] => 1600
        )

    [2] => Array
        (
            [Name] => Tobias Weiss
            [Gehalt] => 4500
        )

)

Sonja Meier bekommt 1600€ im Monat.

Array
(
    [fastfood] => Array
        (
            [0] => Pizza
            [1] => Burger
        )

    [obst] => Array
        (
            [0] => Apfel
            [1] => Banane
            [2] => Trauben
            [3] => Kirschen
        )

    [gemuese] => Array
        (
            [0] => Salat
            [1] => Tomaten
            [2] => Gurken
        )

    [suesskram] => Array
        (
            [0] => Snickers
            [1] => Maoam
            [2] => Zuckerwatte
            [3] => Nutella
        )

)

Iss mal etwas Obst:

Array
(
    [0] => Apfel
    [1] => Banane
    [2] => Trauben
    [3] => Kirschen
)

Wenn du aufgegessen hast kriegst du Nachtisch: Zuckerwatte

Array

(

[0] => Array

(

[Name] => Max Mustermann

[Gehalt] => 2000

)

[1] => Array

(

[Name] => Sonja Meier

[Gehalt] => 1600

)

[2] => Array

(

[Name] => Tobias Weiss

[Gehalt] => 4500

)

Sonja Meier bekommt 1600€ im Monat.

Array

(

[fastfood] => Array

(

[0] => Pizza

[1] => Burger

)

[obst] => Array

(

[0] => Apfel

[1] => Banane

[2] => Trauben

[3] => Kirschen

)

[gemuese] => Array

(

[0] => Salat

[1] => Tomaten

[2] => Gurken

)

[suesskram] => Array

(

[0] => Snickers

[1] => Maoam

[2] => Zuckerwatte

[3] => Nutella

)

Iss mal etwas Obst:

Array

(

[0] => Apfel

[1] => Banane

[2] => Trauben

[3] => Kirschen

)

Wenn du aufgegessen hast kriegst du Nachtisch: Zuckerwatte

Array-Funktionen

PHP stellt einige Funktionen speziell für Arrays zur Verfügung. Ich zeige dir im Folgenden einige davon.

Werte aus einem Array löschen

Aus einem Array können mit der Funktion unset Werte gelöscht werden. Schau her:

<?php
	
	$Arr = ['Wert1', 'Wert2', 'Wert3'];
	
	# Ein Element aus einem Array entfernen
	unset($Arr[1]);
	echo "<pre>" . print_r($Arr, 1) . "</pre>";

<?php

$Arr = ['Wert1', 'Wert2', 'Wert3'];

# Ein Element aus einem Array entfernen

unset($Arr[1]);

echo "<pre>" . print_r($Arr, 1) . "</pre>";

Die Ausgabe hierzu lautet dementsprechend:

Array
(
    [0] => Wert1
    [2] => Wert3
)

Array

(

[0] => Wert1

[2] => Wert3

)

Etwas hieran fällt ins Auge – das Array wird nicht neu indiziert. Der Wert wird einfach rausgelöscht. Wenn man an unset ein Array ohne Angabe des Index übergibt, ist anschließend das Array weg. Analog hierzu kann man an die Funktion unset anstatt eines Array-Wertes auch eine Variable übergeben – diese würde es anschließend einfach nicht mehr geben. Lass mich dir auch das kurz zeigen:

<?php
	
	$Arr = ['Wert1', 'Wert2', 'Wert3'];
	
	# Ein Element aus einem Array entfernen
	unset($Arr);
	echo "<pre>" . print_r($Arr, 1) . "</pre>";
	
	echo "<br>";
	
	# Mit Variablen:
	$Variable = 12;
	echo $Variable;
	unset($Variable);
	echo $Variable;

<?php

$Arr = ['Wert1', 'Wert2', 'Wert3'];

# Ein Element aus einem Array entfernen

unset($Arr);

echo "<pre>" . print_r($Arr, 1) . "</pre>";

echo " ";

# Mit Variablen:

$Variable = 12;

echo $Variable;

unset($Variable);

echo $Variable;

Die Ausgabe hierzu? Schwer zu sagen, entweder bei dir wird gar nichts angezeigt (weiße Seite) oder du erhältst folgende Fehlermeldungen:

Notice: Undefined variable: Arr in /dein/pfad/zu/xampp/htdocs/index.php on line 6

12
Notice: Undefined variable: Variable in /dein/pfad/zu/xampp/htdocs/index.php on line 14

Notice: Undefined variable: Arr in /dein/pfad/zu/xampp/htdocs/index.php on line 6

Notice: Undefined variable: Variable in /dein/pfad/zu/xampp/htdocs/index.php on line 14

Die Beschreibung des Fehlers ist recht eindeutig: „Undefined Variable“. Es wird also versucht, eine Variable (in dem Fall ja zuerst ein Array und danach eine Variable, PHP macht da von der Fehlermeldung her aber keinen Unterschied) auszugeben, die nicht deklariert ist. Warum nicht? Weil wir sie mit unset gelöscht haben.

Anzahl der Array-Elemente anzeigen

Hierfür gibt’s eine Funktion count . Man übergibt ihr das Array und sie spuckt aus, wieviele Werte es enthält:

$Arr = [1, 2, 3, "a", "b", "c"];
echo count($Arr);

1 2	$Arr = [1, 2, 3, "a", "b", "c"]; echo count($Arr);

Die Ausgabe ist

6

Werte im Array zufällig anordnen

Die Funktion shuffle tut genau das:

<?php
	
	$Arr = [1, 2, 3, "a", "b", "c"];
	echo "<pre>" . print_r($Arr, 1) . "</pre>";
	
	shuffle($Arr);
	echo "<pre>" . print_r($Arr, 1) . "</pre>";

<?php

$Arr = [1, 2, 3, "a", "b", "c"];

echo "<pre>" . print_r($Arr, 1) . "</pre>";

shuffle($Arr);

echo "<pre>" . print_r($Arr, 1) . "</pre>";

Folgende Ausgabe wird erzeugt (die natürlich jedes mal anders ist):

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => a
    [4] => b
    [5] => c
)

Array
(
    [0] => 1
    [1] => c
    [2] => a
    [3] => b
    [4] => 3
    [5] => 2
)

Array

(

[0] => 1

[1] => 2

[2] => 3

[3] => a

[4] => b

[5] => c

)

Array

(

[0] => 1

[1] => c

[2] => a

[3] => b

[4] => 3

[5] => 2

)

Implode und Explode

Klingt erstmal seltsam, aber diese beiden Funktionen wirst du lieben – und später sicher auch an einigen Stellen verwenden.

implode

Mit implode kannst du alle Elemente eines Arrays zu einem String zusammenfügen. Die Funktion erwartet zwei Werte die zu übergeben sind, 1) einen Verkettungs-String und 2) das Array mit den Werten. Schau selbst:

<?php
	
	$Namen = [
		"Bob",
		"Thomas",
		"Linda",
	];
	
	echo "Das sind alle Namen:<br>";
	echo implode(", ", $Namen);

?>

<?php

$Namen = [

"Bob",

"Thomas",

"Linda",

];

echo "Das sind alle Namen: ";

echo implode(", ", $Namen);

Du siehst folgende Ausgabe:

Das sind alle Namen:
Bob, Thomas, Linda

1 2	Das sind alle Namen: Bob, Thomas, Linda

Alle Elemente des Arrays wurden mit , zusammengefügt. Du kannst das natürlich dann auch einer Variable zuweisen, einfach mit $Text = implode(", ", $Namen); .

explode

Explode tut genau das Gegenteil – es splittet einen String anhand eines bestimmten gewünschten Zeichens in Array-Elemente. Check das:

<?php
	
	$Text = "Das ist ein ganz toller Text";
	
	$Array = explode(" ", $Text);
	
	echo "<pre>" . print_r($Array, 1) . "</pre>";

?>

<?php

$Text = "Das ist ein ganz toller Text";

$Array = explode(" ", $Text);

echo "<pre>" . print_r($Array, 1) . "</pre>";

Wir splitten den Text auf bei allen Leerzeichen, anschließend geben wir das Array mit print_r aus und sehen:

Array
(
    [0] => Das
    [1] => ist
    [2] => ein
    [3] => ganz
    [4] => toller
    [5] => Text
)

Array

(

[0] => Das

[1] => ist

[2] => ein

[3] => ganz

[4] => toller

[5] => Text

)

Die beiden Funktionen werden dir oft nützlich sein.

Funktion range()

Die Funktion range() kann dir automatisch ein Array mit Zahlen befüllen, sie erwartet 2 Pflichtargumente für kleinste und größte Zahl, optional kann als dritter Parameter die Schrittweise übergeben werden.

Der folgende Code füllt ein Array mit Zahlen von 8 bis 25 (jeweils einschließlich):

<?php
	
	$range = range(8, 25);
	
	echo "<pre>" . print_r($range, true) . "</pre>";

<?php

$range = range(8, 25);

echo "<pre>" . print_r($range, true) . "</pre>";

Das Ergebnis sieht folgendermaßen aus:

Array
(
    [0] => 8
    [1] => 9
    [2] => 10
    [3] => 11
    [4] => 12
    [5] => 13
    [6] => 14
    [7] => 15
    [8] => 16
    [9] => 17
    [10] => 18
    [11] => 19
    [12] => 20
    [13] => 21
    [14] => 22
    [15] => 23
    [16] => 24
    [17] => 25
)

Array

(

[0] => 8

[1] => 9

[2] => 10

[3] => 11

[4] => 12

[5] => 13

[6] => 14

[7] => 15

[8] => 16

[9] => 17

[10] => 18

[11] => 19

[12] => 20

[13] => 21

[14] => 22

[15] => 23

[16] => 24

[17] => 25

)

Praktisch wenn’s schnell gehen soll und man schon weiß was man im Array haben will. Und wenn wir jetzt den Code etwas verändern und eine Schrittweite von 5 einstellen:

<?php
	
	$range = range(0, 40, 5);
	
	echo "<pre>" . print_r($range, true) . "</pre>";

<?php

$range = range(0, 40, 5);

echo "<pre>" . print_r($range, true) . "</pre>";

dann erhalten wir als Ausgabe im Browser:

Array
(
    [0] => 0
    [1] => 5
    [2] => 10
    [3] => 15
    [4] => 20
    [5] => 25
    [6] => 30
    [7] => 35
    [8] => 40
)

Array

(

[0] => 0

[1] => 5

[2] => 10

[3] => 15

[4] => 20

[5] => 25

[6] => 30

[7] => 35

[8] => 40

)

Kann nützlich sein.

Zufälligen Wert aus dem Array holen

Dadurch dass du die Funktion mt_rand() bereits kennst und auch die Funktion count(), können wir ein zufälliges Element aus dem Array holen. Wie du schon kurz gesehen hast, übergeben wir Minimum und Maximum als Argumente, die Funktion spuckt uns dann einen zufälligen Wert aus der irgendwo zwischen diesen beiden Zahlen liegt. Das können wir nutzen um einen zufälligen Wert aus einem Array zu holen. Schau:

<?php
	
	# Array mit Werten füllen
	$arr = ["Hund", "Katze", "Maus", "Hamster", "Kuh", "Esel", "Ziege", "Ente", "Gans"];
	
	# Anzahl Werte im Array zählen und Variable zuweisen
	$anzahl_array_elemente = count($arr);
	
	# Zufallsindex auswählen
	# WICHTIG: die Schlüssel im Array wurden automatisch nummeriert wie du schon weißt.
	# Das Array hat 9 Elemente -> das heißt dass der Index des letzten Elements
	# 8 sein muss (von 0 bis 8 sind es 9 Elemente), deswegen ziehen wir von der 
	# Anzahl der Werte 1 ab, das ist der größte Index den es in diesem Array geben kann.
	$zufallsindex = mt_rand(0, $anzahl_array_elemente - 1);
	
	# Wert aus dem Array holen:
	$zufallswert = $arr[$zufallsindex];
	
	# Zufallswert ausgeben:
	echo "Ein zufälliges Tier: {$zufallswert}";

<?php

# Array mit Werten füllen

$arr = ["Hund", "Katze", "Maus", "Hamster", "Kuh", "Esel", "Ziege", "Ente", "Gans"];

# Anzahl Werte im Array zählen und Variable zuweisen

$anzahl_array_elemente = count($arr);

# Zufallsindex auswählen

# WICHTIG: die Schlüssel im Array wurden automatisch nummeriert wie du schon weißt.

# Das Array hat 9 Elemente -> das heißt dass der Index des letzten Elements

# 8 sein muss (von 0 bis 8 sind es 9 Elemente), deswegen ziehen wir von der

# Anzahl der Werte 1 ab, das ist der größte Index den es in diesem Array geben kann.

$zufallsindex = mt_rand(0, $anzahl_array_elemente - 1);

# Wert aus dem Array holen:

$zufallswert = $arr[$zufallsindex];

# Zufallswert ausgeben:

echo "Ein zufälliges Tier: {$zufallswert}";

Wenn du die Seite jetzt im Browser aktualisierst, werden dir immer unterschiedliche Tiere angezeigt.

Links & Infos

Dokumentation zu Arrays auf php.net lesen: http://php.net/manual/de/language.types.array.php.
Dokumentation zur Funktion print_r auf php.net lesen: http://php.net/manual/de/function.print-r.php.
Dokumentation zur Funktion var_dump auf php.net lesen: http://php.net/manual/de/function.var-dump.php.
Dokumentation zur Funktion count auf php.net lesen: http://php.net/manual/de/function.count.php.
Dokumentation zur Funktion shuffle auf php.net lesen: http://php.net/manual/de/function.shuffle.php.

FAQ

Assoziativer Index in einfachen oder doppelten Anführungszeichen?
Ah, da hat jemand aufgepasst. Ja, ich verwende oben im Code mal einfache ' und mal doppelte " Anführungszeichen. Welche du nimmst ist egal, das bleibt dir überlassen.

Indexiertes Array? Indiziertes Array? Assoziatives Array? Was denn nun??
Einen Index hat jedes Array – dies können Schlüssel vom Typ Integer (=numerisch) oder vom Typ String (=assoziativ) sein. Aber beim numerisch indexierten Array spricht man auch vom indizierten Array (auch wenn das eigentlich nicht ganz der korrekte Ausdruck dafür ist, indexiert ist eher richtig). In anderen Tutorials hast du das vielleicht wieder anders gelesen. Lass dich nicht verrückt machen, wichtig ist, dass der Zugriff numerisch oder assoziativ erfolgt. Fertig.

Fazit

„Deklaration von numerisch oder assoziativ indizierten Arrays“ … klingt ja richtig krass – und DU weißt jetzt sogar, was damit gemeint ist – sehr cool. Im nächsten Teil wird es richtig spannend, da kommt Interaktion in’s Spiel. Wir werden mit HTML-Formularen arbeiten, sodass man als Person vor dem Browser auch endlich mal was auf der Seite machen kann. Wir werden lernen, mit GET- und POST-Requests zu arbeiten (was viel schlimmer klingt als es ist) und Benutzereingaben zu verarbeiten. Außerdem werden Schleifen sich als äußerst praktisch erweisen, jetzt wo du Arrays kennengelernt hast.

Gruß
Marius

2 Gedanken zu „PHP lernen – Arrays“

Markus

4. August 2016 um 0:33 Uhr

Vielen Dank, hat mir echt weiter geholfen.
Antworten
- marius.gerum
  
  4. August 2016 um 0:51 Uhr
  
  Freut mich, danke 🙂
  
  Schönen Abend
  Marius
  Antworten

Schreibe einen Kommentar Antworten abbrechen

Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahre mehr darüber, wie deine Kommentardaten verarbeitet werden.