Grossmann-php_grund

Anführungszeichen?!
echo 'Apfel$atf';
echo "Apfel$atf";
echo "Apfel\$aft";
// ergibt: Apfel$aft
// ergibt: Apfel + Inhalt der Variable $aft
// ergibt: Apfel$aft
echo 'c:\temp';
echo "c:\temp";
echo "c:\\temp";
echo 'c:\\temp';
// ergibt: c:\temp
// ergibt: c: + Tabulator + emp
// ergibt: c:\temp
// ergibt: c:\temp
→ In PHP können Strings sowohl von normalen Anführungszeichen (")
als auch von Hochkommata (') eingefasst werden.
→ Der Bereich zwischen Anführungszeichen wird von PHP ausgewertet,
während alles, was zwischen Hochkommata steht, von PHP schnell
übergangen wird.
→ Strings in Hochkommata werden schneller verarbeitet, allerdings
werden dann Variablen nicht durch ihren Wert ersetzt.
Operatoren
Ermöglichen das Arbeiten mit Daten.
→ Variablenwerte vergleichen oder verändern.
Zuweisungsoperator: „=“
$a=5;
// Die Variable $a bekommt den Wert 5 zugewiesen
$b=$a; // $b erhält den Wert von $a.
Arithmetische Operatoren
Addition(+), Subtraktion(-), Multiplikation(*), Division(/),
Modulo(%).
$a=9;
$b=5;
$c=$a+$b;
$c=$a*$b;
$c=$a%$b;
// $c ist jetzt 14.
// $c ist jetzt 45.
// $c ist jetzt 4.
Vereinfachte Schreibweisen:
$a=5;
$a=$a*5;
$a*=5;
$a=$a+1;
$a++;
erhöht.
$a=$a-1;
// In beiden Zeilen wird $a=25.
// In beiden Zeilen wird der Wert von $a um 1
Die Inkrement-Operatoren (++, --) funktionieren auch mit
Buchstaben.
$Zeichen=A;
$Zeichen++;
echo ++$Zeichen
echo $Zeichen++
// $Zeichen ist jetzt B;
// Ausgabe ist C;
// Ausgabe bleibt C;
Sind beide Operanden Integer, so ist auch das Ergebnis ein
Integer.
Ist ein Operand eine Kommazahl, so ist auch das Ergebnis
eine Kommazahl.
Zeichenkettenoperatoren
Der einzige echte Zeichenketten Operator ist „.“.
→ Wird verwendet zum verknüpfen von Zeichenketten.
$string= “Guten “;
$string2= $string.“Tag!“;
echo $string2;
//Die Ausgabe hier ist „Guten Tag!“.
Auch hier ist eine verkürzte Schreibweise möglich:
$string = „Guten “;
$string .= „Tag!“;
// Ausgabe auch hier: „Guten Tag!“.
Vergleichsoperatoren
Werden zum Formulieren von Bedingungen verwendet, welche
z.B. bei der if-Funktion notwendig sind (später mehr dazu).
Ist eine Bedingung erfüllt, wird TRUE zurückgegeben,
ansonsten FALSE.
Zur Erinnerung:
„=“ ist Zuweisungsoperator und kein Vergleichsoperator!
Vergleichsoperatoren:
== Gleichheit (z.B. $a == 10)
=== Identität (z.B. $a === 10)
!= Ungleichheit (z.B. $a != 10)
> Größer als (z.B. $a > 10)
>= Größer als oder gleich (z.B. $a >= 10)
< Kleiner als (z.B. $a < 10)
<= Kleiner als oder gleich (z.B. $a <= 10)
Logische Operatoren
Bieten die Möglichkeit Vergleichsoperatoren zu komplexeren
Bedingungen zu verknüpfen.
Logische Operatoren:
&& (and)
|| (or)
xor
→ und
→ oder
→ ist TRUE, wenn eine der Bedingungen wahr ist,
nicht aber wenn beide wahr oder falsch sind.
Beispiele:
$a=5;
$b=10;
$c=15;
$a < $b
$a==$b
$c>$a
&&(and)
||(oder)
xor
$a<=$c
$a!=$c
$c>$b
→ TRUE
→ TRUE
→ FALSE
Kontrollstrukturen
If-Abfrage:
→ Eine der häufigstens Konstrukte in Programmcodes
→ Abfrage des Zustands von Variablen oder Konstanten in
Folge dessen Anweisungen ausgeführt werden.
if(Bedingung)
{
Anweisung;
}
else
{
andere Anweisung;
}
Beispiele:
$Vermoegen=100;
$Steuern=50;
$Vermoegen -= $Steuern;
if($Vermoegen<=0)
{
echo „Sie sind pleite!“;
}
else
{
echo „Ihr Vermögen beträgt $Vermoegen!“;
}
--------------------------------------------------------------------------------------------------if($Vermoegen<20) {
echo „Besser etwas sparen!“;
}
elseif
($Vermoegen>=20 && $Vermoegen < 50) {
echo „Ein Bier geht noch!“;
}
elseif
($Vermoegen>=50 && $Vermoegen < 75) {
echo „Eine Runde ausgeben!“;
}
elseif
($Vermoegen>=75 && „Vermoegen <100) {
echo „Auch morgen gibt’s ein warmes Essen!“;
} else {
echo „Sie sind reich!“;
}
Switch-Anweisung:
→ Ersetzt die Verwendung von mehreren elseif-Abfragen.
$Nachrichten=3;
switch($Nachrichten) {
case 0:
echo „Sie haben keine Nachrichten“;
break;
case 1:
echo „Sie haben $Nachrichten Nachricht“;
break;
case 2:
echo „Sie haben $Nachrichten Nachrichten“;
break;
case 3:
echo „Sie haben $Nachrichten Nachrichten“;
break;
case 4:
echo „Sie haben $Nachrichten Nachrichten“;
break;
default:
echo „Sie sind unglaublich beliebt!“;
break;
}
Schleifen
Schleifen werden immer dann genutzt, wenn man einen
Programmteil mehrfach ausführen will, ohne ihn im Code
mehrfach schreiben zu müssen.
Die Anzahl der Schleifendurchläufe wird durch eine Bedingung
kontrolliert.
Der Schleifenrumpf wird mehrfach mit (meist) unterschiedlichen
Variableninhalten durchlaufen.
PHP bietet vier Möglichkeiten zur Formulierung von Schleifen:
→ while-Schleife
→ do-while-Schleife
→ for-Schleife
→ foreach-Schleife
While-Schleife:
→ Einfachster Schleifentyp mit nur einer Bedingung im Schleifenkopf.
→ Wenn die Bedingung TRUE ergibt, so wird der Schleifenrumpf
ausgeführt und danach die Bedingung erneut überprüft.
→ Bei FALSE wird die Schleife beendet.
$a=0;
While ($a<5)
{
echo $a;
$a++;
}
→
Die Anweisungen werden hier solange wiederholt, bis die $a größer
als 4 wird.
→ Das Programmstück gibt also die Zahlen von 1 bis 4 aus.
Do-while-Schleife:
→ Funktioniert ähnlich wie while-Schleife, nur wird die Bedingung
erst nach den Anweisungen ausgewertet.
→ Anweisungen werden mindestens einmal ausgeführt.
$i = 0;
do {
echo "Die derzeitige Ziffer ist: $i“;
$i++;
}
while ($i < 5);
→ $i wird auf jeden Fall mindestens einmal ausgegeben, erst danach
die Bedingung ($i>5) überprüft.
Die for-Schleife:
→ fasst Sie die Bestandteile einer while-Schleife (Initialisierung und
Inkremetierung) im Schleifenkopf zusammen.
→ Bedingung wird auch hier vor dem ersten Schleifendurchlauf
geprüft.
for (initialisierung;bedingung;anweisung)
{
Anweisungen;
}
→ Die Anweisung (meist Inkrementierung) im Schleifenkopf ändert die
in der Bedingung geprüften Variablenwerte bei jedem Durchlauf, bis
FALSE zurückgegeben wird.
→ Jeder der drei Bestandteile des Schleifenkopfs kann auch leer
bleiben.
Beispiele:
for ($i = 1 /*(initialisierung)*/; $i <= 10 /*(bedingung)*/; $i++ /*(anweisung)*/)
{
if ( $i > 6 )
{
Schleifenrumpf
break;
}
Anweisungen
echo „Schleifendurchlauf: $i <br />“;
//
}
//
//
// mit
//
-------------------------------------------------------------------------------------------------
$i = 10;
for (;;)
// Keine Angaben im Schleifenkopf →
Endlosschleife
{
echo „$i, “;
if (--$i < 0)
break;
}
// Ausgabe: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,
Foreach-Schleife:
→ wird meist dann verwendet, wenn Arrayinhalte ausgegeben
werden sollen.
→ für ein Array werden die jeweiligen Inhalte ermittelt und
einer Variablen zugewiesen.
foreach ($array as $value) {
echo "Der aktuelle Wert ist: $value <br />";
}
→ Die foreach-Schleife benötigt keine Angabe zur Anzahl der
vorhandenen Arrayelemente, da sie deren Anzahl selbst
ermittelt.
→ Die Inhalte des Arrays $array werden also hier der Variable
$value zugewiesen, welche im Schleifenrumpf ausgegeben
wird.
Beispiel:
$frucht[0] = "Kirschen";
$frucht[2] = "Kiwis";
$frucht[6] = "Äpfel";
$frucht[3] = "Bananen";
$frucht[8] = "Mangos";
$frucht[5] = "Orangen";
$frucht[1] = "Melonen";
$frucht[7] = "Feigen";
$frucht[4] = "Birnen";
foreach ($frucht as $element)
{
echo „$element <br />";
}
Ausgabe am Bildschirm:
Kirschen
Kiwis
Äpfel
Bananen
Mangos
Orangen
Melonen
Feigen
Birnen
→ Die Indizes der Arrayelemente haben bei der foreach- Schleife
keinen Einfluss auf die Reihenfolge der Elemente.
→ PHP-intern erstellt foreach eine Kopie des angegebenen Arrays und
durchläuft diese Kopie nach dessen interner Ordnung, die nicht
notwendigerweise der "richtigen" Reihenfolge entspricht.