Modul 295
Backend für Applikationen realisieren
04 - Arrays und Schleifen
Mehrere Werte verwalten und wiederholt verarbeiten
Lernziele dieser Lektion
- Erklären können, was ein Array ist und wozu es dient
- Indizierte und assoziative Arrays anlegen und verwenden können
- Elemente aus einem Array lesen, ändern, hinzufügen und entfernen können
- Häufig genutzte Array-Funktionen einsetzen können (Suchen, Sortieren, Zählen)
- Die verschiedenen Schleifenarten in PHP kennen und ihre Unterschiede erklären können
- Schleifen zur Verarbeitung von Arrays einsetzen können
Rückblick: Bedingungen
-
Mit
if/elseif/elsesteuern wir den Programmablauf abhängig von Bedingungen - Diese Bausteine brauchen wir gleich wieder - innerhalb von Schleifen
<?php
$points = 68;
if ($points >= 60) {
echo "Bestanden";
} else {
echo "Nicht bestanden";
}
Was ist ein Array?
- Ein Array ist eine Variable, die mehrere Werte auf einmal speichern kann
- Statt für jeden Wert eine eigene Variable anzulegen, fasst man zusammengehörige Werte in einem Array zusammen
- Jedes Element im Array hat einen Schlüssel (Index) und einen Wert
<?php
// Ohne Array - unpraktisch
$fruit1 = "Apfel";
$fruit2 = "Birne";
$fruit3 = "Kiwi";
// Mit Array - viel besser
$fruits = ["Apfel", "Birne", "Kiwi"];
Indizierte Arrays anlegen
-
Bei einem indizierten Array vergibt PHP automatisch
numerische Schlüssel, beginnend bei
0 -
Die eckige Klammer-Schreibweise
[]ist heute Standard, die alte Funktionarray()funktioniert weiterhin
<?php
$fruits = ["Apfel", "Birne", "Kiwi"];
// entspricht: $fruits = array("Apfel", "Birne", "Kiwi");
// Schlüssel: 0 => "Apfel", 1 => "Birne", 2 => "Kiwi"
echo $fruits[0]; // "Apfel"
echo $fruits[2]; // "Kiwi"
Elemente lesen und ändern
- Der Zugriff erfolgt über den Schlüssel in eckigen Klammern
- Ein neues Element wird einfach mit einem neuen Schlüssel zugewiesen - oder ohne Schlüssel angehängt
<?php
$fruits = ["Apfel", "Birne", "Kiwi"];
$fruits[1] = "Mango"; // Element ändern
echo $fruits[1]; // "Mango"
$fruits[] = "Orange"; // Element anhängen (Index 3)
echo $fruits[3]; // "Orange"
Assoziative Arrays
- Bei einem assoziativen Array definiert man die Schlüssel selbst - meist als String
- Damit lassen sich Werte inhaltlich beschriften statt sie über eine Position anzusprechen
<?php
$person = [
"firstname" => "Anna",
"lastname" => "Muster",
"age" => 23,
];
echo $person["firstname"]; // "Anna"
$person["age"] = 24; // Wert ändern
Mehrdimensionale Arrays
- Ein Array-Element kann selbst wieder ein Array sein - so entstehen verschachtelte Strukturen
- Häufig genutzt, um z.B. mehrere Datensätze (Personen, Produkte, ...) zu speichern
<?php
$persons = [
["firstname" => "Anna", "age" => 23],
["firstname" => "Bruno", "age" => 31],
];
echo $persons[0]["firstname"]; // "Anna"
echo $persons[1]["age"]; // 31
Verhalten von Arrays
- Arrays sind dynamisch - sie wachsen und schrumpfen automatisch, es gibt keine feste Grösse
- Ein Array kann Werte unterschiedlichen Typs enthalten (Strings, Zahlen, Booleans, sogar weitere Arrays)
-
Mit
count()ermittelt man die Anzahl Elemente
<?php
$mixed = ["Anna", 23, true, [1, 2, 3]];
echo count($mixed); // 4
Arrays ausgeben
-
echofunktioniert nicht direkt mit Arrays -
print_r()zeigt den Inhalt lesbar an,var_dump()zeigt zusätzlich die Datentypen
<?php
$fruits = ["Apfel", "Birne", "Kiwi"];
print_r($fruits);
// Array ( [0] => Apfel [1] => Birne [2] => Kiwi )
var_dump($fruits);
// array(3) { [0]=> string(5) "Apfel" ... }
Elemente hinzufügen und entfernen
array_push($arr, $val) |
Element am Ende hinzufügen |
array_pop($arr) |
Letztes Element entfernen und zurückgeben |
array_unshift($arr, $val) |
Element am Anfang hinzufügen |
array_shift($arr) |
Erstes Element entfernen und zurückgeben |
unset($arr[$key]) |
Element mit bestimmtem Schlüssel entfernen |
Im Array suchen
-
in_array()prüft, ob ein Wert im Array vorkommt -
array_search()liefert den Schlüssel eines gesuchten Werts (oderfalse) -
array_key_exists()prüft, ob ein bestimmter Schlüssel existiert
<?php
$fruits = ["Apfel", "Birne", "Kiwi"];
var_dump(in_array("Kiwi", $fruits)); // bool(true)
var_dump(array_search("Kiwi", $fruits)); // int(2)
var_dump(array_key_exists(5, $fruits)); // bool(false)
Arrays sortieren
sort() |
Aufsteigend sortieren, Schlüssel neu vergeben |
rsort() |
Absteigend sortieren, Schlüssel neu vergeben |
asort() |
Nach Werten sortieren, Schlüssel bleiben erhalten |
ksort() |
Nach Schlüsseln sortieren |
<?php
$numbers = [5, 3, 8, 1];
sort($numbers);
print_r($numbers); // [1, 3, 5, 8]
Weitere nützliche Array-Funktionen
array_merge($a, $b) |
Zwei Arrays zusammenführen |
array_slice($arr, $off, $len) |
Ausschnitt aus einem Array holen |
array_reverse($arr) |
Reihenfolge umkehren |
array_unique($arr) |
Doppelte Werte entfernen |
array_sum($arr) |
Summe aller Werte berechnen |
Zweiter Teil: Schleifen
Code wiederholt ausführen
Wozu Schleifen?
- Schleifen (Loops) führen einen Codeblock mehrmals aus, solange eine Bedingung zutrifft
- Damit lässt sich Code wiederholen, ohne ihn mehrfach abzuschreiben - z.B. um alle Elemente eines Arrays zu verarbeiten
<?php
// Ohne Schleife - unpraktisch
echo $fruits[0];
echo $fruits[1];
echo $fruits[2];
// Mit Schleife - viel besser
foreach ($fruits as $fruit) {
echo $fruit;
}
Arten von Schleifen in PHP
while |
Solange eine Bedingung zutrifft (Prüfung vorher) |
do-while |
Wie while, aber Prüfung
erst nach dem ersten Durchlauf |
for |
Wenn die Anzahl Durchläufe bekannt ist (Zähler) |
foreach |
Um alle Elemente eines Arrays zu durchlaufen |
while-Schleife
Die Bedingung wird vor jedem Durchlauf geprüft. Ist sie
von Anfang an false, wird der
Codeblock kein einziges Mal ausgeführt.
<?php
$i = 1;
while ($i <= 5) {
echo $i;
$i++; // wichtig, sonst Endlosschleife!
}
// Ausgabe: 12345
do-while-Schleife
Der Codeblock wird zuerst einmal ausgeführt und die Bedingung erst danach geprüft - daher läuft er mindestens einmal.
<?php
$i = 10;
do {
echo $i;
$i++;
} while ($i <= 5);
// Ausgabe: 10 - obwohl die Bedingung nie zutrifft!
for-Schleife
Fasst Startwert, Bedingung und Schrittzähler in einer Zeile zusammen - ideal, wenn die Anzahl Durchläufe von Anfang an klar ist.
<?php
// Start; Bedingung; Schritt
for ($i = 1; $i <= 5; $i++) {
echo $i;
}
// Ausgabe: 12345
for mit Array-Index
Mit count() lässt sich auch ein
Array mit einer for-Schleife
durchlaufen - dabei hat man Zugriff auf den Index.
<?php
$fruits = ["Apfel", "Birne", "Kiwi"];
for ($i = 0; $i < count($fruits); $i++) {
echo $i . ": " . $fruits[$i];
}
foreach-Schleife
Durchläuft jedes Element eines Arrays automatisch - ohne Zähler und ohne Gefahr, sich beim Index zu vertun. Der Standardweg, um Arrays zu durchlaufen.
<?php
$fruits = ["Apfel", "Birne", "Kiwi"];
foreach ($fruits as $fruit) {
echo $fruit;
}
// Ausgabe: ApfelBirneKiwi
foreach mit Schlüssel und Wert
Mit as $key => $value erhält
man zusätzlich den Schlüssel - unerlässlich bei assoziativen
Arrays.
<?php
$person = [
"firstname" => "Anna",
"age" => 23,
];
foreach ($person as $key => $value) {
echo $key . ": " . $value;
}
// firstname: Anna
// age: 23
break und
continue
-
breakbeendet die Schleife sofort komplett -
continueüberspringt nur den aktuellen Durchlauf und macht beim nächsten weiter
<?php
for ($i = 1; $i <= 10; $i++) {
if ($i == 5) {
break; // Schleife stoppt bei 5
}
echo $i;
}
// Ausgabe: 1234
for ($i = 1; $i <= 5; $i++) {
if ($i % 2 == 0) {
continue; // gerade Zahlen überspringen
}
echo $i;
}
// Ausgabe: 135
Vorsicht: Endlosschleifen
-
Wird die Bedingung nie
false, läuft die Schleife für immer weiter und blockiert das Skript - Häufigste Ursache: der Zähler wird vergessen oder falsch verändert
<?php
$i = 1;
while ($i <= 5) {
echo $i;
// $i++; fehlt -> Endlosschleife!
}
Schleifen und Arrays kombiniert
Ein typisches Muster: mit einer Schleife alle Elemente durchgehen und dabei eine Bedingung prüfen.
<?php
$prices = [19.90, 45.00, 8.50, 120.00];
$total = 0;
foreach ($prices as $price) {
if ($price >= 20) {
$total += $price;
}
}
echo $total; // 165 (45 + 120)
TL;DR
- Ein Array speichert mehrere Werte in einer Variable - indiziert (automatische Nummerierung) oder assoziativ (eigene Schlüssel)
-
Häufige Funktionen:
count(),in_array(),array_search(),sort(),array_push()/array_pop() -
whileunddo-whilelaufen, solange eine Bedingung zutrifft -
foreignet sich für eine bekannte Anzahl Durchläufe,foreachfür das Durchlaufen von Arrays -
breakstoppt die Schleife,continueüberspringt nur den aktuellen Durchlauf