Bläul.de>Computer>PHP>Erste Schritte>Sprachelemente   

PHP-Sprachelemente

 

 

Funktionen

Mit Hilfe von Funktionen kannst du eigene, in sich abgeschlossene PHP-Prozeduren programmieren, die du dann über den Aufruf der Funktion ausführen kannst.
Code, der nicht innerhalb einer Funktion steht, wird beim Einlesen der Datei sofort ausgeführt!

Funktionen werden definiert, indem zuerst das Schlüsselwort function, dann der selbstdefinierte Name der Funktion (Es gelten die selben Regeln wie beim Benennen von Variablen), anschließend alle Parameter in runden () Klammern und last but not least in geschweiften {} Klammern die Anweisungen der Funktion: function fuenfplusdrei() {
  $i = 5; $j = 3;
  $summe = $i + $j;
  echo($summe);
} So ist die Sache allerdings noch nicht besonders sinnvoll, den bei jedem Aufruf tut die Funktion nix weiter, außer "8" auszugeben. Funktionen können auf 2 Arten an Informationen aus der Außenwelt herankommen:
  • Durch Parameter. Das sind Variablen, die nur innerhalb der Funktion gültig sind und ihren Wert beim Funktionsaufruf erhalten
  • Durch globale Variablen. In PHP kann eine Funktion nur auf die globalen, also außerhalb jeder Funktion definierten Variablen zugreifen, wenn sie hinter dem Schlüsselwort global innerhalb der Funktion erwähnt werden
<?
  $a = 4; $b = 8; $c = 12;
  function summe($i, $j) {
    global $a;

    $summe = $i + $j + $a + $b;
    echo($summe);
  }

  summe(4, $c);     // gibt 24 aus, rechnet 4+12+4+0
?> Selbstdefinierte Funktionen können auch einen Wert zurückgeben, wie auch die vordefinierte Funktion pi(), indem sie das Schlüsselwort return verwenden.
Außerdem kann eine Funktion globale Variablen verändern, wenn diese mit global freigegeben wurden.
Die Parameter können allerdings nur verändert werden, wenn sie mit einem Ampersand & übergeben werden. <?
  $a = 4; $b = 8;
  function summe($i, $j) {
    $summe = $i++ + $j++;     // erst addieren, dann incrementieren
    return($summe);
  }

  echo(summe(&$a, $b));
  echo(", $a, $b");     // Ausgabe: "12, 5, 8"
?>

Schleifen

Schleifen sind Gruppen von Befehlen, die so lange wiederhohlt werden, wie eine bestimmte Bedingung erfüllt ist. In PHP gibt es drei verschiedene Schleifen, die im Folgenden erklärt werden.
Für jeden Befehl muss eine Bedingung angegeben werden. Wie diese definiert werden, steht unter Vergleichsoperatoren

While-Schleifen

Definition:
while (bedingung) { befehle; }
while (bedingung) befehl;
Bei dieser Schleife werden die Befehle so lange ausgeführt, bis die Bedingung nicht mehr erfüllt wird. Hierbei wird vor jedem Durchlauf der Schleife die Bedingung überprüft. Soll nur ein einziger Befehl ausgeführt werden, so können die geschweiften Klammern weggelassen werden. $i = 0;
while($i<10) {
  echo($i);
  $i++;
}
/* Ausgabe: 0123456789 */

Do-While-Schleifen

Definition:
do { befehle; } while (bedingung);
do befehl; while (bedingung);
Der Unterschied von Do While zu While ist, daß hier die Bedingung erst nach dem Durchlaufen der Schleife geprüft wird, also daß die Befehle in der Schleife mindestens einmal ausgeführt werden. $i = 0;
do {
  echo($i);
  $i++;
} while($i<0);
/* Ausgabe: 0 */

For-Schleifen

Definition:
for(anfangs_befehl; bedingung; schleifen_befehl) { befehle; }
for(anfangs_befehl; bedingung; schleifen_befehl) befehl;
Die FOR-Schleife beinhaltet neben der Bedingung auch einen Befehl (Anfangsbefehl), der ausgeführt wird, bevor die Schleife zum ersten Mal durchlaufen wird und einen Befehl (schleifen_befehl) der am Ende eines jeden Durchlaufes der Schleife ausgeführt wird, bevor geprüft wird, ob die Bedingung immer noch zutrifft. Soll nur ein einziger Befehl ausgeführt werden, so können die geschweiften Klammern weggelassen werden. for($i=0; $i<10; $i++) echo($i);
// ist äquivalent zu:
for($i=0; $i<10; $i++) {
  echo($i);
}
/* Ausgabe in beiden Fällen: 0123456789 */

Break und Continue

Die Anweisung break verläßt eine Schleife sofort, sodaß der Code nach der Schleife ausgeführt wird.
Das Kommando continue beendet den aktuellen Durchlauf der Schleife und beginnt mit dem nächsten.
for($i=0; $i<10; $i++) {
  echo($i);
  if ($i==5) break; else continue;
  echo($i*$i);
}
/* Durchläuft die Schleife 6mal,
der Befehl echo $i*$i wird aber nie ausgeführt
Ausgabe: 012345 */

Bedingungen - If & Co

If

Befehle, die innerhalb einer Bedingung (IF) stehen, werden nur ausgeführt, wenn diese Bedingung erfüllt wird. Es gibt vorgeschriebene Vergleichs-Operatoren, die in einer solchen Bedingung verwendet werden dürfen.

Definition:
if (bedingung) { befehle; }
if (bedingung) befehl;
Die Bedingung wird überprüft, und wenn sie wahr, also ungleich 0 ist, werden die Befehle ausgeführt. Soll nur ein einziger Befehl ausgeführt werden, so können die geschweiften Klammern weggelassen werden. $i=45;
if ($i==45) echo("i ist gleich 45");
/* Ausgabe: i ist gleich 45 */

Else

Definition:
if (bedingung) { befehle; } else { andere_befehle; }
if (bedingung) befehle; else andere_befehle;
Wird die Bedingung nicht erfüllt, so werden die Befehle ausgeführt, die sich in der Else-Klammer befinden.
Soll nur ein einziger Befehl ausgeführt werden, so können die geschweiften Klammern weggelassen werden.

$i=45;
if ($i==45) echo("i ist gleich 45");
  else echo("i ist ungleich 45");
/* Ausgabe: i ist gleich 45 */

ElseIf

Definition:
if (bedingung1) { befehle1; }
elseif (bedingung2) { befehle2; }
Wird die Bedingung1 nicht erfüllt, so wird geprüft, ob Bedingung2 wahr ist. Bei Wahrheit, werden die Befehle in dieser Klammer ausgeführt. Es können unbegrenzt viele ElseIf-Anweisungen verwendet werden, solange sie unterschiedliche Bedingungen aufweisen. Ansonsten wird nur die Erste überprüft. Optional kann auch noch der Else-Befehl verwendet werden. Dieser wird nur ausgeführt, wenn keine der mit IF oder ElseIf angegeben Bedingungen zutreffen.
Soll nur ein einziger Befehl ausgeführt werden, so können die geschweiften Klammern weggelassen werden. $i=45;
if ($i<30) {
  echo("i ist kleiner als 30");
} elseif ($i<40) {
  echo("i ist kleiner als 40");
} elseif ($i<50) {
  echo("i ist kleiner als 50");
} elseif ($i<60) {
  echo("i ist kleiner als 60");
} else {
  echo("i ist größer oder gleich 60");
}
/* Ausgabe: i ist kleiner als 50 */

Switch

Definition:
switch($variable) {
  case "wert1": befehle; break;
  case "wert2": befehle2; break;
  default: befehle; break;
}
Switch ist eine Struktur, die ein verkettete If-ElseIf-Anweisung ersetzt, in der immer die selbe Variable abgefragt wird. So wird als Parameter beim Aufrufen von Switch die zu untersuchende Variable angegeben. Anschließend folgt das Schlüsselwort case, gefolgt von einem Wert. Wenn die angegebene Variable gleich dem Wert ist, so werden alle folgenden Befehle ausgeführt. Daher muss auch vor der nächsten Case-Anweisung das Schlüsselwort break angegeben werden, was dafür sorgt, dass der Switch-Block verlassen wird. switch($i) {
  case 45: echo("i ist gleich 45"); break;
  case 48: echo("i ist gleich 48"); break;
  case -5: echo("i ist gleich -5"); break;
  default: echo("i ist irgendetwas anderes.");
}

Operatoren

Operatoren haben den Zweck, Variablen Werte zuzuweisen. Hierbei handelt es sich um simple Vorgänge, wie z.B. Addieren.
Kompliziertere Befehle (z.B. Potenzieren) sind im Befehlsverzeichnis in der Rubrik Mathematik aufgelistet.

Hier ist mal etwas Code zur Veranschaulichung: $a + $b;   // Addieren
$a - $b;   // Subtrahieren
$a * $b;   // Multiplizieren
$a / $b;   // Dividieren
$a % $b;   // Gibt den Rest nach dem Dividieren von $a durch $b zurück;
$a += $b;  // ist äquivalent zu $a = $a + $b
$a -= $b;  // ist äquivalent zu $a = $a - $b
$a *= $b;  // ist äquivalent zu $a = $a * $b
$a /= $b;  // ist äquivalent zu $a = $a / $b
$a %= $b;  // ist äquivalent zu $a = $a % $b
$a .= $b;  // ist äquivalent zu $a = $a . $b

$a++;      // Addiert zu $a eins;
$b = $a++; // $b bekommt den Wert von $a, $a erhöht sich um eins.
$b = $a--; // $b bekommt den Wert von $a, $a wird um eins erniedrigt.
$b = ++$a; // $a wird um eins erhöht, $b erhält neuen Wert.
$b = --$a; // $a wird um eins erniedrigt, $b erhält neuen Wert. $a = 6; $b = 3;
$c = $a + $b;
echo($c);

echo(" - ");
$a = 6; $b = 3;
$a += $b;
echo($a);

echo(" - ");
$a = 8; $b = 3;
$a %= $b;
echo($a);
// Ausgabe: 9 - 9 - 2

Vergleichsoperatoren

Vergleichsoperatoren werden für Schleifen und Bedingungen verwendet. Sie dienen dazu, um Werte (meist Variablen) miteinander zu vergleichen. Es wird immer 1 (wahr) oder 0 (falsch) zurückgegeben. Folgende Vergleichsoperatoren stehen in PHP zur Verfügung: $a == $b  // wahr, wenn $a gleich $b ist
$a === $b // wahr, wenn $a gleich $b und
          // $a vom selben Typ wie $b ist (ab PHP4)

$a != $b  // wahr, wenn $a ungleich $b ist
$a <  $b  // wahr, wenn $a kleiner als $b ist
$a >  $b  // wahr, wenn $a größer als $b ist
$a <= $b  // wahr, wenn $a kleiner oder gleich $b ist
$a >= $b  // wahr, wenn $a größer oder gleich $b ist
$a %  $b  // wahr, wenn $a eine ungerade Zahl ist
 Bei den Befehlen If, ElseIf, While und For können aber nicht nur die oben genannten Vergleichsoperatoren verwendet werden, sondern auch jede beliebige Funktion. Wird von dieser Funktion "0" oder nichts zurückgegeben, ist der Ausdruck falsch, ansonsten wahr.

Verknüpfen von Vergleichen

Für den Fall, dass ein Befehl erst dann ausgeführt werden soll, wenn mehrere Bedingungen erfüllt sind, oder auch nur eine von vielen, gibt es die folgenden "logischen Operatoren". Um Uneindeutigkeiten zu vermeiden empfehle ich, bei der Kombination von UND- und ODER-Operatoren Klammern zu setzen (siehe Beispiel). $a AND $b // wahr, wenn $a und $b wahr sind
$a OR  $b // wahr, wenn $a oder $b wahr sind
$a XOR $b // wahr, wenn $a oder $b, aber nicht beide wahr sind
   !$a    // wahr, wenn $a nicht wahr ist
$a &&  $b // äquivalent zu AND
$a ||  $b // äquivalent zu OR
Beispiel: if(($datei != "none" && is_file($datei)) || $checkfile=="nein") {
  echo("Datei existiert");
} Es wird "Datei existiert" ausgegeben, wenn:
  1. $checkfile gleich "nein" ist,
          - oder -
  2. $datei nicht gleich "none" ist und die Datei $datei existiert.

 

 

Zwischen dem Kern aus Eisen und der Kruste aus festem Gestein befindet sich ein Mantel aus schwerem Silikatgestein von etwa 2800 Metern Dicke. Der Mantel ist weder fest noch flüssig, sondern von einer zähflüssigen Konsistenz, auf der die Kruste schwimmt. Diese Kruste besteht nicht aus einem zusammenhängenden Stück fester Masse, sondern aus mehreren voneinander getrennten Platten, an deren Grenzen die geologischen Prozesse weiterhin auf die Erdoberfläche einwirken.