Auszug aus: "PHP KOMMANDO" ©® (rev. 0.1b)
© 2004-2011 simon@plan9.at (simon.bauer@ufg.ac.at)

 

PHP ist eine Skriptsprache, die wie Javascript in HTML Quellcode eingebunden werden kann.
Im Gegensatz zu Javascript wird der eingebundene Quellcode (source code) aber serverseitig verarbeitet
und nicht am Rechner des Benutzers (client-seitig).

Kurz erwähnt “der Anfang von PHP”: PHP entstand ca. 1994 und bestand damals aus einer Reihe
von Perl Skripts, die als “Personal Home Page”-Package (“PHP”) herausgegeben wurden. Danach
entwickelte sich PHP als eigenständige Skriptsprache. Da PHP "open-source" ist, sprich quelloffen,
kann auch jede/r Veränderung am Code selbst tätigen.

Vorteile von PHP:

• Kompatibel, sprich kein Plug-in nötig wie bei Flash oder Silverlight,
  da im Endeffekt nur eine “HTML” Seite an den Client geschickt wird, die
  zuvor am Server erstellt wurde; Inkompatibilitäten werden größtenteils aus
  der Welt geschafft, da z.B. keine Plug-ins auf der Client-Seite laufen müssen.
• Großer Funktionsumfang für den Webbereich und leicht erlernbar
• Plattform unabhängig (Linux, Windows, OSX, Irix, Solaris,...)
• Der Source-Code (Quellcode), also die Programmierung der Skripts, kann Client-Seitig nicht
  eingesehen werden - im Gegensatz z.B. zu Javascript (uU. dadurch mehr Sicherheit)

Vergleichbare serverseitige "Webprogrammiersprachen" sind z.B.:

• ASP (Active Server Pages
• SSJS (Server Side Javascript, Netscapes Antwort auf ASP)
• Perl (Pratical extraction and report language)
• Cold Fusion (Macromedia - von Adobe übernommen)
• Java Servlets und JSP (von Sun entwickelt)
• Python etc.
• Ruby

"Clientseitige Sprachen/Programme/Appletes" wären:

• ActiveX-Controls (mit Visual Basic, Visual C++, C#, .NET-Framework allgemein etc.) erstellt
  (meist nur für den Internet-Explorer geeignet, da wenige Browser ActiveX-Controls unterstützen)
• Java Applets (in Java geschrieben)
  Das Java-Runtime Environment (JRE) muss am Client installiert sein
• Javascript / “Dynamic HTML”, "HTML5"
• Flash/Shockwave, Silverlight,...

Da PHP ja vom Server interpretiert wird und dann erst das Ergebnis an den Client geliefert wird,
lässt sich PHP am besten mittels einer XAMP(P)-Umgebung lernen, die gleichzeitig eine vollwertige
"Hosting-Umgebung" darstellt. Dass der Client und der Server am gleichen Rechner laufen,
sollte bei der Entwicklung ja kein Nachteil sein. Ansonsten bieten fast alle Webspace-Provider
günstig geeignete Pakete, die PHP unterstützen.

PHP Scripts werden wie Javascript-Befehle durch bestimmte Tags begrenzt: Mit spitzer-Klammer-auf, Fragezeichen und "php" wird das PHP-Script eingeleitet und mit Fragezeichen und spitzer-Klammer-zu abgeschlossen. Dazwischen befinden sich die PHP-Befehle.

Wenn der Webserver also eine Anfrage (Request) für eine Webseite erhält (z.B. für die Datei test.php), die auch PHP-Code enthält, interpretiert der "PHP-Interpret"/Parser eben alle Befehle (Statements), die sich zwischen dem öffnenden-PHP-Tag  und dem schließenden-PHP-Tag  befinden. Dieser Vorgang wird direkt am Server vor der Seitenauslieferung an den Client durchgeführt.

 

Die Ausgabe (das Ergebnis) dieser PHP-Befehle wird dann an der Stelle eingefügt, an der sich vorher die PHP-Befehle befanden. Die so entstandene (HTML-)Datei wird an den Webserver (zB Apache) zurückgeliefert. Erst dann sendet der Webserver die Seite an den Webbrowser des Clients (zB Firefox), der die weitere clientseitige Verarbeitung (Ausgabe) übernimmt ("rendering").

 

Ausgabe Beispiele per php-Befehl "echo":

ZB über Echo werden Daten ausgegeben. Hier noch einige zusätzliche Beispiele:

$myname = "Frank";
echo $myname;  // gibt Frank aus
echo "Tabulator: \t99";  // \t setzt einen Tabulator
echo "mehr-
zeiliger
text";

echo 456;  //Ausgabe: 456 numerisch

// \n schaltet in die nächste Zeile (
ist im HTML-Code zu verwenden)
echo "Neue Zeile \nhier"; 
echo "Neue Zeile
hier"; 

echo "Zusam" . "men";  // Ausgabe: Zusammen
echo "Zusam";
echo "men";             // Ausgabe auch: Zusammen

echo $myname . " Black";  // Ausgabe: Frank Black, Verknüpfung durch den "." Operator

 

 

Weil der Server die Abarbeitung der Befehle übernimmt, nennt man dies(e) eben Server-Side(-Scripting-Language). Javascript z.B. ist eine Client-Side-Scripting-Language, da erst der lokale Webbrowser die Javascriptbefehle beim abarbeitet interpretiert.

Je nachdem wie der Web-Server konfiguriert ist, interpretiert er nur Dateien, die die Deteiendung .php haben. Es gibt aber auch Server, die .html oder .htm Dateien auf PHP-Code überprüfen (parsen).

Andere Server verwenden zB. .php4 bzw. .php5, .php6 um die geeignete Version des PHP-Interpreten die Datei analysieren und auswerten zu lassen.

Sprich .php4 wird mit dem PHP Version 4 Interpret "geparst" und .php6 mit einem der Version 6.

Je nachdem stehen unterschiedliche Möglichkeiten der Programmierung zur Verfügung bzw. gibt es Unterschiede in der Kompatibilität der Skripts.  Ein für PHP6 geschrieben Skript, das Neuerungen der Sprache verwendet, kann meist nicht fehlerfrei mit einem PHP4 Interpret verarbeitet werden. 

 

 

 

 

 

 

Variablenname / Konstantenname / Variable und Konstanten / Kommentare / Datentypen / logische Operatoren / Vergleichsoperatoren...

 

Konstanten

Wie in jeder Programmiersprache können Daten in Variablen oder Konstanten abgelegt werden,
die für den Programmablauf nötig sind.

Im Programm wird auf die "Daten" somit über den Variablen- bzw. Konstantennamen zugegriffen.

Variablen können während des Programmablaufes neue Werte erhalten,
Konstante behalten ihren Wert über den gesamten Programmablauf hinweg - unveränderlich.

 

Konstante sind "Objekte", deren Wert sich im ganzen Skript, in dem sie definiert wurden, nicht mehr verändern kann.
Definiert werden Konstante über den Befehl define:

define("MYPI", 3.14159);
define("BEST_FILM", "Rosencrantz and Guildenstern Are Dead");

NB. Auf Konstante kann im gesamten Quellcode zugegriffen
werden (siehe auch: Geltungsbereich von Variablen - globale/lokale Variablen).

Von PHP vordefinierte Konstanten: http://php.net/manual/de/reserved.constants.php

Vielleicht lassen sich Konstante auch besser als “Platzhalter” vorstellen, deren Platz später durch den zugehörigen Wert einfach “ersetzt” wird. Konstante werden im Gegensatz zu Variablen direkt über den Namen ohne das Dollar-Zeichen $Zeichen angesprochen (siehe Variablen).

echo "PI ist " . MYPI;
echo BEST_FILM;

Konstanten können in jedem Teil des Skripts und auch in eingebundenen externen Dateien/Funktionen
verwendet werden. Sie sollten der Konventionen wegen immer in GROSSBUCHSTABEN geschrieben werden.
So wird sofort deutlich, dass hier eine KONSTANTE verwendet wird.

Es gibt aber auch in PHP vordefinierte Konstanten wie zB.

__FILE__;

Diese Konstante beinhaltet zB. den Pfad und Dateinamen des Skripts, das gerade abgearbeitet wird.

Variablen

Variablen sind Objekte (Container), die einen beliebigen Wert repräsentieren (innehaben)
und diesen während des Programmablaufs bei Bedarf jederzeit ändern können – wie der Name sagt,
sie sind “variabel”. Dar Variablenname ist dabei während des Programms unveränderlich.

Erstellen einer Variablen
Es sollte zuerst ein passender Name gefunden werden zB.

filmtitel

Um den Namen zu einem Variablennamen zu machen, muss man den “Identifier” für Variablen,
das ist in PHP das Doller-Zeichen ($) voranstellen:

$filmtitel

Einen Wert weist man Variablen durch das Ist-Gleich Zeichen (=) zu:

$filmtitel =

Den Wert der Variablen gibt man rechts vom Istgleich-Zeichen an (bekommt
die Variable bei der Erstellung gleich einen Wert, nennt man dies Variableninitialisierung);

$filmtitel = "BadTaste"

Wie jedes PHP-Statement wird auch die Variablendefiniton
mit einem Strichpunkt ( ; )abgeschlossen:

$filmtitel = "BadTaste"; // Variabledefinition und Initialisierung

Nachdem man der Variablen einen Wert gegeben hat, kann man sie genauso verwenden
wie den zugewiesenen Wert selbst.

echo $filmtitel; // gibt BadTaste aus
echo "BadTaste"; // gibt BadTaste aus

// Variablendefinition ohne Wertzuweisung.

$filmtitel_xy;

$i_am  = "Bart";
$iLike = "call Moe";
$satz  = $i_am . ' likes to ' . $iLike; // Satz: Bart likest to call Moe
$age   = 10;
$i_am  = "gone";
$iLike = "to be upset";
$age   = NULL;

 

Regeln zur Benennung

Variable beginnen mit einem $ Zeichen. So weiß PHP, dass ein Variablennamen folgt.
Ein Name besteht aus einer Folge von Buchstaben, Ziffern und Unterstrichen (_). Deutsche
Umlaute und das ß sind nicht erlaubt; das erstes Zeichen muss ein Buchstabe oder ein Unterstrich (_)sein.
Groß-/Kleinschreibung ist von Bedeutung, d.h. $test; ist ein anderer Variablen-Namen als $Test; und
kann somit auch einen Unterschiedlichen Wert haben (case-sesitiv).

Es ist auch möglich Variablen mit dem Befehl unset($VariablenName); wieder aus
dem Speicher zu löschen. Der für die Variable belegte oder reservierte Speicher wird dadurch freigegeben.
Nach dem Löschen kann die Variable natürlich nicht mehr eingesetzt werden.

Datentyp
Variablen haben einen bestimmten Daten-Typus (datatype), d.h. unterschiedliche Variablen können einen bestimmten Wert (innerhalb eines Wertebereichs) annehmen. Der Variablentyp sollte im Programm möglichst nie geändert werden und kann es in manchen Scriptsprachen auch nicht. PHP verwendet automatisch den Typ, der laut Zuordnung passend ist (PHP-Variablen sind an sich untypisiert und haben eben eine dynamische Typisierung, dh der Typ der Variablen kann sich im Laufe des Programmes ändern: $i = 1; $i++; $i = "99"; $i++; Das letzte $i++ führt dennoch nicht zu einer Fehlermeldung, obwohl der Typ nicht mehr "integer", sondern "string"(Zeichenkette) ist!. Der Typ von Variablen sollte möglichst nicht gewechselt werden, besser ist es zB $s = (String) $i; zu verwenden und $s verwenden, wenn eine Zeichenkette verlangt wird bzw. $i, wenn ein nummerischer Wert gefordert ist.

$i = 1;
$i++;
$i = 99;
$s = (string) $i;
var_dump($i);
var_dump($s);
?>  

Programmausagabe:

int(99)
string(2) "99"

 

$variable_a = "1";  // Datentyp: String (Zeichenkette), Zeichen zwischen “ oder '
$variable_b = 1;    // Datentyp "Integer" (Ganzzahl)
$hofer      = 1.99; // Datentyp "Float" (Gleitkommazahl)

Variablen können verschiedenste Datentypen wie Zeichen, Zahlenwerte
(Fließkomma- und Ganzahl), Arrays, Booleanwerte (boolsche Werte) und Objekte beinhalten.

 

Zusatz/Spezialfall (nur in den seltensten/seltsamsten Fällen zu empfehlen):
Den Variablennamen kann man indirekt mit folgendem Konstrukt "ändern":

$filmtitel    = "BadTaste";
$neuevariable = "filmtitel";
echo "${$neuevariable}"; // $neuevariable wird substituiert mit filmtitel,
                                     // daraus folgt wieder: echo "$filmtitel";
so folgt Programm-Ausgabe: BadTaste

Referenzierte Variablen

Es gibt auch sogenannte referenzierte Variablen, das sind Variablen, die selbst keinen Speicherplatz für Daten anlegen,
sonder nur auf den Speicherplatz “hinzeigen” (also eine Referenz darauf bilden), an dem bereits Daten einer Variablen vorhanden sind.

$variableDieSpeicherplatzbelegt = "1234567890";
// Im Speicher wird für die Daten “1234567890”
// Speicherplatz reserviert, auf den wie üblich über den
// Variablennamen zugegriffen werden kann

$gleicheDaten = &$variableDieSpeicherplatzbelegt;
// Die Variable $gleichDaten zeigt nur an die
// Speicherstelle an der die Daten der Variablen $variableDieSpeicherplatzbelegt // stehen.

Sie hat somit den gleichen Wert, aber belegt nicht extra noch mal so viel Hauptspeicher wie die Variable selbst.

 

echo $variableDieSpeicherplatzbelegt . ';
echo $gleicheDaten;

gibt beidemale 123456789 aus.

 

 

 

 

Datentypen

PHP verwendet “lose Datentypen” (loose type), d.h. der Datentyp einer Variablen stellt sich erst bei der Zuweisung heraus.

z.B.
$myVar = 7;     // Datentyp: Ganzzahl(Integer)
$myVar = ”7”;   // Datentyp: Zeichenkette(String)
$myVar = TRUE;// Datentyp: Wahrheitswert/Boolean (TRUE oder FALSE)
$myVar = 0.7;   // Datentyp: float (Gleitkommazahl)

Wenn möglich sollte man also folgendes vermeiden, da sich hier der Datentyp der
variable implizit ändert. Bei umfangreichen Projekten oder bei gemeinschaftlicher Projektarbeit
kann dies relativ schnell zu Fehlern fürhren:

$age = 10;
$age = "10"; // nicht vorteilhaft; man sollte den Typ der Variablen
// im Programm möglichst nicht verändern (zB hier der Wechsel von “Zahl” auf
// “Zeichenkette”.

Gängige Datentypen sind zB:

Integer	10	eine Ganzzahl
Double	3.14159	eine Gleitkommazahl
String	“Bart	eine Zeichenkette
Boolean	TRUE/FALSE	“Wahrheitswerte”: Falsch oder Richtig für logische Operationen
Array und Objekt

Statements (Befehlszeilen) werden in PHP wie gesagt immer mit einem Strichpunkt
abgeschlossen ';' und setzen sich hauptsächlich aus Konstanten, Variablen und Operatoren zusammen, z.B.

$kreisflaeche_weniger_eins = 2 * r * PI - 1;

Konstante	PI
Variable	$kreisflaeche_weniger_eins
Operatoren	* und – (Multiplikation und Subtraktion) dabei gilt, wie allgemein in der Mathematik zB Punkt- vor Strichrechnung, außer es wird natürlich dezitiert geklammert: zB 2*r*(PI-1)

Im Gegensatz zu Zeichenketten (Strings), stehen nummerische Werte (z.B. auch obiger Wert 10) nicht unter Anführungszeichen ".

 

 

 

Kommentare

Sie können durch einen zweichfach-Forward-Slash

// 

hinter einem Befehl oder in einer neuer Zeile angebracht werden.

Alles nach // wird von Interpret bist zur Zeilenschaltung (RETURN) ignoriert und dient rein zur Dokumentation.

Eine zweite Möglichkeit den Kommentar über mehrer Zeilen zu schreiben ist /* und */. Vergleichbar mit in Javascript.

Der Kommentar darf aber nicht verschachtelt sein, also wäre dies ein Fehler:
/* Summer's /* almost */ gone */

 

 

Logische Operatoren

Logische Operatoren prüfen ebenso wie Vergleichsoperatoren den Wahrheitswert (TRUE oder FALSE) von Konstrukten.

Folgende logische Operatoren werden meist verwendet:

&&	UND
||	ODER
!	NICHT

 

Auf diese Weise können Programmverzweigungen von logischen Bedingungen abhängig gemacht werden.

Die logischen Operatoren heißen auch boolsche Operatoren.

UND (&&)

UND-Operator "&&" liefert genau dann WAHR (TRUE) (1), wenn beide
Operaden WAHR sind, sonst liefert er 0 (=FALSCH) (FALSE).

Beispiel:

(($x < $max) && ($y > 0))
Dies trifft nur zu, wenn der Wert der Variablen $x kleiner ist als der der Variablen $max UND $ygrößer als 0 ist.

Statt dem &&-Operator kann in PHP auch “and ” verwendet werden (eher unüblich).

if ((7 == 7) and (10 / 2 == 5))
    echo "Dies stimmt, da beim logischen UND (&&) BEIDE Ausdrücke 
TRUE(1) zurueckliefern müssen.";

 

 ODER (||)
(Das | Zeichen erreicht man auf der Tastatur durch gedrückt halten von AltGr und > Taste)

 

Der ODER-Operator "||" liefert genau dann WAHR (1), wenn
mindestens 1 Operand WAHR ist. Nur wenn beide Operandenbeziehungen
FALSCH (FALSE, 0) sind, liefert der oder-Operator "FALSCH" (FALSE) zurück.

Beispiel:

(($laenge < 0.2) || ($laenge > 9.2))

Diese Bedingung ist WAHR, wenn die Länge kleiner als 0.2 ($laenge < 0.2) ist oder wenn
die Länge größer als 9.2 ($lange > 9.2) ist. Wäre die Länge 2, so wäre die Bedingung
FALSCH, da: (2 < 0.2) => FALSCH und (2 > 9.2) => FALSCH.

Die Bedingung wäre aber WAHR, sobald nur eine der beiden Bedingungen zutreffen würde.

Auch wenn mehr als zwei Bedingungen gegeben sind, muss immer nur eine den Wahrheitswert
TRUE liefern um die ODER-Bedingungen zu erfüllen.

 

Statt dem ||-Operator kann auch “or” verwendet werden.

if ((7 == 99) or (10 / 2 == 5))
    echo "Das stimmt, da beim logischen OR (||) nur einer aller Ausdrücke 'wahr  sein' muss. um insgesamt TRUE (wahr) nach der oder-Verknüpfung zu werden.";

 

NICHT (!)

Der NICHT-Operator "!" liefert genau dann WAHR (1), wenn sein Operand
FALSCH (0) ist. Enthält die Variable $flag den Wert 1, so liefert

!$flag den Wert 0.

  // => !true == false
  $falsch   =  !true;
  //  => !false == true
  $richtig  =  !false;
?>

Exkurs "Digitaltechnik", Quelle: Wikipedia

TRUE = 1, FALSE = 0

AND, OR, XOR, NOT

Das Und-Gatter (engl. AND)	Das Oder-Gatter (engl. OR)	Das XOR-Gatter	Das Nicht-Gatter (engl. NOT)
Das Und-Gatter (die Verknüpfung von Leitungen mittels Und-Gattern wird Konjunktion genannt) ist ein wichtiges Element der Schaltungslogik. Im Gegensatz zum Nicht-Gatter hat ein Und-Gatter jedoch mindestens zwei Eingänge, die es vergleicht. So stellt sich die Schaltfunktion anders dar als die des Nicht-Gatters: Wahrheitstabelle x1 x0 y 0 0 0 0 1 0 1 0 0 1 1 1 Um eine logische 1 am Ausgang y zu erreichen, müssen also beide Eingänge auf logisch 1 sein.	Auch das Oder-Gatter (die Verknüpfung von Leitungen mit Oder-Gattern wird Disjunktion genannt) hat mind. zwei Eingänge, welche es vergleicht. Im Gegensatz zum Und-Gatter folgt aber bereits durch eine logische 1 an einem Eingang automatisch eine logische 1 am Ausgang. y = x1 + x0 Wahrheitstabelle x1 x0 y 0 0 0 0 1 1 1 0 1 1 1 1 Um eine logische 1 am Ausgang y zu erreichen, müssen also ein oder beide Eingänge auf logisch 1 sein.	Das XOR-Gatter (von engl. eXclusive OR - exklusives Oder, entweder oder) ist ein Gatter mit mehreren Eingängen und einem Ausgang, bei dem der Ausgang genau dann logisch „1“ ist, wenn an einer ungeraden Anzahl von Eingängen „1“ anliegt und an den restlichen „0“. Die XOR-Verknüpfung wird auch als Anti- oder Kontravalenz bezeichnet. Wahrheitstabelle x1 x0 y 0 0 0 0 1 1 1 0 1 1 1 0	Das Nicht-Gatter (auch Komplement-Gatter oder Inverter genannt) ist die elementarste digitale Logikfunktion. Es besitzt lediglich einen Eingang. Der Ausgang dreht dabei den logischen Zustand des Eingangs um. (gesprochen: y ist x nicht) Wahrheitstabelle x y 0 1 1 0 Somit ist der Ausgang y das Komplement des Eingangs x.

Vergleichsoperatoren

Vergleichsoperatoren führen zu einem boolschen Ergebnis, d.h. entweder der Vergleich stimmt (TRUE) oder er ist falsch (FALSE).

Mit Vergleichsoperatoren lassen sich Aussagen über die Wahrheit von Ausdrücken feststellen.zB.

$ist = (7 == 5);	// da 7 nicht 5 ist wird in $ist der Wert FALSE (falsch, 0) zurückgeliefert.
$ist = (10 / 2 == 5);	// da 10 dividiert durch zwei 5 ergibt und 5 gleich 5 ist wird TRUE (wahr,1) zurückgeliefert.

 

ist gleich	==	$x == $y ist $x gleich $y? (Achtung! Zwei Istgleichzeichen == sind nötig)
ungleich	!=	$x != $y ist $x ungleich $y?
kleiner	<	$x < $y ist $x kleiner als $y?
größer	>	$x > $y ist $x größer als $y?
größer-gleich	>=	$x >= $y ist $x größer gleich $y?
kleiner-gleich	<=	$x <= $y ist $x kleiner gleich $y?

 

 

Operatoren

Um nun Manipulationen mit den Daten, die in den Variablen oder Konstanten, Arrays etc.
gespeichert sind durchzuführen benötigt es Operatoren.
Kurz gesagt sind Operatoren Symbole, die meist aus zwei oder mehreren Werten einen neuen erschaffen (errechnen).

Je nach Datentyp gibt es meist noch spezielle(re) Operatoren. Das “+” Symbol ist zB sehr universell einsetzbar:
Folgendes Beispiel funktioniert natürlich mit numerischen Werten, aber auch mit Zeichenketten.

 

 

$a = 1;	// Variable $a erhält den numerischen Wert 1
$b = 2;	// Variable $b erhält den numerischen Wert 2
$c = $a + $b;	// $a und $b nennt man Operanden, das Pluszeichen nennt man Operator // das Ergebnis dieser “Operation” landet durch das Zuewisungszeichen in $c
echo $c;	// 3 wird ausgegeben
$a = "1";	// Variable $a erhält das Zeichen “1”
$b = "2";	// Variable $b erhält das Zeichen “2”
$c = $a + $b;	// $a und $b nennt man Operanden, das Pluszeichen nennt man Operator // das Ergebnis dieser “Operation” landet durch das Zuewisungszeichen in $c // Ausdruck nennt man eine Zusammensetzung aus Operanden und Operatoren // hier wäre: $a+$b; der Ausruck (expression)
echo $c;	// “12” wird ausgegeben, da Variablen die Zeichen beinhalten mit dem Operator “+” // zusammengefügt werden.

 

gängige Operatoren sind:

+	Addition x + y
-	Subtraktion x - y
*	Multiplikation x * y
/	Division x / y
%	Modulus Operation (Restwert der Division) x % y

 

Einschub: Arrays / "Datentypen"

 

Ein Array ist eine Datenstruktur, die mehrere Daten des gleichen Typs aufnehmen soll -
wer mit anderen Programmiersprachen programmiert, für die/den sind gleiche Datentypen (integer oder zB string) je "Array" ohnehin meist Pflicht.

Es ist auch sinnvoll nicht alle "Features" die möglich wären auszunutzen, so fällt ein Umstieg auf eine Programmiersprache, die strengeren Gepflogenheiten folgt / strenger typisiert ist auch wohl einfach leichter.

$doNotDo = array(      // "wirrwarr"
    "days" => array(
        6 => 6,
        // fehlerträchtig
        0 => "So",
        "Mo" => 0
    )
);

echo $doNotDo["days"][0]; 
echo $doNotDo["days"]['Mo'];

// Ausgabe: 
// So
// 0

 

Über den "Arrayindex", ersichtlich durch die eckigen Klammern [ ], wird auf die einzelnen Elemente des Arrays zugegriffen.
Zu beachten ist, dass das erste Element eines Arrays den Indexwert 0 hat.

 

 

Die Ausgabe ist wie folgt:

 

 

"Speicherverbrauch"

Mit unset($arraynamen); wird ein Array wieder aus dem Cpmputer-Hauptspeicher entfernt.

Ein neues Element kann man mit $arrayNamen[] = neuesElement; anfügen.
Will man wissen, wie viele Elemente letztendlich im Array sind, lässt sich das über

$anzahl_der_elemente = sizeof($arrayNamen);

herausfinden; diesen Wert kann man natürlich zB in einer for-Schleife auch gleich verwenden:

$filme[] = "Brain Dead";
$filme[] = "Dogma";
sort($filme); // sortieren
echo "
 Schleife nach Sortieren: 
";
for ($i = 0; $i <= sizeof($filme); $i++) {
    echo $filme[$i];
    echo "
";
}

 

 

 

 

 

Bedingte Entscheidungen

Sie bestimmen ob Programmabschnitte ausgeführt (abgearbeitet) werden
oder übersprungen werden.

Dies wird benötigt, da sich die Skripts unter “bestimmten Bedingungen” anders verhalten sollen:
ZB könnte man eine Webseite nachts mit einem “Abend-Theme” versehen und
tagsüber mit einem kontrastreicheren „Tageslook“.

Für so etwas braucht man Entscheidungen, hier aufgrund der Zeitzone/Zeit
des Benutzers und nicht des Servers.

 

Ein logisches Konstrukt frei formuliert wäre:

“Bedingung:
WENN ( die Aktuelle-Zeit ENTSPRICHT der Nachtzeit )
       ...DANN zeige die Nacht-Design-Html-Datei an
SONST
       ...zeige die Standard-Tages-Html-Datei an.
ende der Bedingung.”

 

 

IF
wenn-dann Entscheidungen – nur wenn die Bedingung in den runden Klammern wahr ist (TRUE),
dann führe folgenden Programmteil aus.

$x = 10;
$y = 0;
if ($x > $y)
    echo "Der Wert der Variablen x ist größer als der der Variablen y";

Umfasst der von der Entscheidung abhängige Programmteil mehr als einen Befehl (hier: echo) muss
dieser als Block zwischen geschweiften Klammern stehen -  { kennzeichnet den Anfang des Blocks, } das Ende:

if ($x > $y) { // Bedingungsblock Anfang - durch { eingeleitet
    echo "Der Wert der Variablen x ist größer als der der zweiten
";
    echo "----------------------------------------------------------";
} // Bedingungsblock Ende – durch } abgeschlossen


Zu jedem mit { geöffneten Block muss immer genau ein Gegenstück } existieren,
um den Block wieder zu schließen (hier: conditional block, d.h. der Block wird in bestimmter Abhängigkeit ausgeführt - Konditionaler Block)

IF/ELSE

wenn-dann-sonst Entscheidungen – wenn (if) die Bedingung wahr ist (true),
führe folgenden Programmteil aus, sonst (else) den Teil im else-Block (else-Zweig).

if ($x > $y) {
    echo "TRUE!";
} else {
    echo "FALSE!";
}

IF-ELSE VERZWEIGUNG

if (x < y)	if (Ausdruck)	Statt Anweisung1
$min = x;	Anweisung1;	kann auch ein Anweisungs-
else	[else	block stehen; dieser muss wieder mit "{"
$ min = y;	Anweisung2;]	geöffnte und mit "}" abgeschlossen werden.

IF / ELSEIF / ELSE

“wenn-dann|sonstwenn...|sonst-Entscheidungen –
wenn (if) die Bedingung in den runden Klammern ( Bedingung ) wahr ist (true),
führe folgenden Programmblock (Zweig) aus,
sonst – wenn eine andere Bedingung (elseif) wahr ist,
führe diesen Programmteil aus;
trifft dies auch nicht zu (else) führe eben den else-Zweig aus:

if ($x > $y) {
    echo "Variable x ist größer als Variable y";
} elseif ($x < $y) {
    echo "Variable x ist kleiner als Variable y";
} else {
    echo "die Variablen haben den gleichen Wert";
}

ELSE-IF KETTEN

$a = 22;
if ($a < 20)
    echo "Variablenwert von a ist kleiner als 20";
else if ($a > 40)
    echo "Variablenwert von a ist größer 40";
else if ($a == 21)
    echo "a hat den Wert 21";
else
    echo "a ist weder kleiner 20, noch größer 40 und auch nicht 21";

 

 

Schleifen ("wie oft")

Durch Schleifen kann entschieden werden, wie oft etwas ausgeführt wird (niemals, einmal, mehrmals,...);
bisher hatten wir bei if nur die Entscheidung „wenn dann - sonst“, aber nicht "wie oft".

WHILE-Schleifen

 

while (ausdruck) {

// mach etwas

}

Hier wird am Ende des while-Blocks erneut der Ausdruck auf TRUE oder FALSE geprüft.
Solange der Ausdruck in den runden Klammern TRUE ist, also die Bedingung für die while-Schleife zutrifft,
wird erneut der darauffolgene Block ausgeführt.

$x = 0;
while ($x < 10) //    while (WAHR)
    {
    echo $x; //Anweisungsblock
    $x = $x + 1;
}

Programm-Ausgabe:

0123456789

Solang $x kleiner als 10 ist, wird der Wert von $x ausgegeben UND dann um 1 erhöht; nach 10 Durchgängen – wenn
die Bedingung FALSE ist (d.h. 10<10 - stimmt ja nicht, liefert false) und somit der Schleifenblock nicht mehr ausgeführt wird,
wird mit den Befehlen nach } fortgefahren.

Würde darauf vergessen, den Wert, der in der Bedingung geprüft wird in dem "while Block",
also zwischen { und } zu verändern ist schnell eine "Endlosschleife" entstanden.

 

FOR-Schleife

 

Wird meist eingesetzt, wenn abschätzbar ist, wie oft die Schleife durchlaufen werden wird bzw. wenn Befehle zB genau 10 Mal hintereinander ausgeführt werden müssen.

for (Initialisierung; Bedingung; "Iterationswert"-ändern) {
   // Statements;
}

 

Solange die "Bedingung" den Wahrheitswert "true"(1) liefert, wird die for-Schleife erneut durchlaufen.
Der Iterationswert, der geändert wird, ist meist Bestandteil der "Bedingung":

 

for ($x = 0; $x <= 10; $x = $x + 1)
{	A1 ... Initialisierung
echo $x;	A2 ... Bedingung
}	A3 ... Re-Initialisierung
Mit einer for-Schleife können sich Endlosschleifen weniger leicht ergeben, da sich alle Parameter bereits - meist übersichtlich - im “Schleifenkopf” befinden. Die Parameter A1, A2, A3 werden durch einen Strichpunkt ; voneinander getrennt.
// A1 ... Initialisierung // A2 ... Bedingung, die erfüllt sein muss für einen erneuten Durchlauf // A3 ... Re-Initialisierung for (A1; A2; A3)
{ // Statements, wenn Bedinung A2 == true
}

Programm-Ausgabe:

0,1,2,3,4,5,6,7,8,9,10

 

for ($x = 0; $x <= 10; $x = $x - 1)

{ echo $x;
}

Die zweite for-Schleife wäre doch eine "Endlosschleife", da $x nie größer oder gleich 10 wird,
sondern immer kleiner wird ($x=$x-1) – es wird jedes Mal 1 subtrahiert und $x ist somit immer kleiner gleich 10 -
diese Schleife würde sozusagen wieder endlos laufen.

DO-WHILE-Schleife (how do we do)

Auch genant "Durchlauf-Schleife", da erst nach dem ersten Durchlauf die Bedingung für einen weiteren Durchlauf geprüft wird.
Sprich die Befehle des Schleifenblocks werden auf alle Fälle mindestens einmal ausgeführt.

$x = 0;
do {
    echo "ho ho ho";
    ++$x;
} while ($x < 10);

 

 

 

 

 

Funktionen

Funktionen sind sozusagen Subprogramme (Subroutinen), die bestimmte (meist zu wiederholende) Aufgaben erfüllen.

Man kann sich diese als "kleinere eigenständige Programme" im Hauptprogramm vorstellen, die ebenso
dem EVA (Eingabe=Parameter, Verarbeitung=Befehlsfolgen, Ausgabe=zB der Return Wert der Funktion) Prinzip folgen können.

Es gibt grundsätzlich zwei Arten von Funktionen, die die man selber schreibt und jene die in PHP schon vorhanden sind.

Aufgerufen werden Funktionen über Ihren Funktionsnamen gefolgt von runden Klammern,
die ev. Parameter (Argumente) enthalten (Parameterübergabe), die der Funktion übergeben werden:

meineFunktion();
// Nur der Funktionsaufruf über den Funktionsnamen.
// Die Funktion hat keinen Rückgabewert und keine Übergabe-Parameter

meineFunktion($myparameter1, $myparameter2); 
// Eine Funktion die mit 2 Parameter aufgerufen wird.
// Übergabeparameter werden durch Beistirche "," getrennt

$Rueckgabe = meineFunktion($myparameter1);
// Eine Funktion, die mit 1 Parameter
// aufgerufen wird und auch einen Wert zurückgibt (return value)

 

Funktionen könnte man sich als eine "Blackbox" vorstellen:
Es werden also beim Funktionsaufruf meist Werte “hineingeschickt” (durch die Parameterübergabe),
dann in der Funktion verarbeitet und später eventuell wieder “ausgespuckt” als der "Return-Wert",
also der Rückgabewert, den die Funktion liefert:

 

$myReturnValue = my_black_box_function ( $myparameter1, $myparameter2 );

 

Funktionen werden hauptsächlich verwendet und sich wiederkehrende “Aufgaben” zu ersparen. Jedes Mal wenn die gleiche Aufgabe erledigt werden soll, kann man die dafür vorgesehene Funktion aufrufen.

Eigene Funktionen müssen definiert werden und können dann bei Bedarf aufgerufen werden.
Also erst wenn der Funktionsaufruf in einem Skript erfolgt, wird die Funktion aufgerufen und
ihr Funktionscode abgearbeitet. Wird die Funktion nie aufgerufen, ist sie meist fehl
am Platz im jeweiligen Skript.

Es gibt in PHP natürlich schon eine (wirklich große) Menge an vorgefertigten
Funktionen/Methoden, wie zB die Sinus-Funktion: sin();

http://at.php.net/manual/en/function.sin.php

im Handbuch heißt es dazu:

"float sin ( float arg)
sin() returns the sine of the arg parameter. The arg parameter is in radians"

D.h. nun, die Funktion sin liefert einen Gleitkommawert zurück (float ist ja der
Datentyp für Gleitkommazahlen) und erwartet auch einen solchen als Übergabe-Parameter (Argument) .

zB.

$sin_rad = sin(6.4);

in $sin_rad befindet sich der Rückgabewert der Funktion mit dem Name "sin();",
der der Parameter in Form der Gleitkommazahl 6.4 übergeben wurde.
Die Funktion berechnet den Wert und liefert das Ergebnis wie gesagt
über den Zuweisungsoperator = an die Variable $sin_rad zurück.

 

 

Eigene Funktionen

Wir wollen die schon eingebaute PHP Funktion abs(); nachbilden.

Die Definition von php.net: http://at.php.net/abs

"Description: number abs ( number )
Returns the absolute value of number."

Der Absolut-Betrag bedeutet dabei mathematisch, dass immer ein positiver Wert
oder 0 zurückgegeben wird: (absolute Wert von |-a| = a)

zB.

$positiver_wert = abs(-1); //$positiver_wert wäre dann 1
$positiver_wert = abs(-3.14159); //$positiver_wert wäre dann 3.14159
$wert           = abs(0); // $wert wäre dann 0

Wir wollen diese Funktion jetzt selbst nachbilden:

Funktionsdefinitionen sehen im Allgemeinen folgend aus: Vor dem Funktionsnamen steht der Begriff function,
damit PHP weiß, dass es eine Funktion ist. Danach schreibt man den Funktionsnamen
(für ihn gelten die gleichen Regeln wie für Variablennamen). Nun folgt eine geöffnete runde Klammer (,
dann eventuell Parameter, wenn Werte an die Funktion übergeben werden sollen und am Ende
eine geschlossenen Runde Klammer ). Darauf folgt der Funktionsblock, der durch { und } begrenzt ist:

function derFunktionsname ( eventuell Argumente, die an die Funktion übergeben werden )
{ // Hier stehen die Anweisungen der Funktion.

return ( Rückgabewert );
// Funktionen müssen keinen Rückgabewert haben, dann lässt man das
// "return"-Statement einfach weg.
}

 

Zurück zum Beispiel: Wir wollen also die abs() Funktion nachbilden. Wir brauchen nun einen eigenen Funktionsnamen, da Namen, die gleichlautende Funktionsbezeichnungen wie die on PHP eingebauten Funktionsnamen besitzen nicht verwendet werden können: Wir nennen die Funktion einfach mein_abs und definieren den leeren „Funktionskörper“:

function mein_abs()
{
}

Diese Funktion macht noch gar nichts – aber sie ist definiert. Damit die Funktion weiß, mit welchen Daten sie zu arbeiten hat, müssen wir ihr die Daten übergeben, d.h., wir brauchen einen Übergabeparameter. Wir wollen die Funktion ja mit mein_abs (-1) zB aufrufen. Damit der Wert -1 in der Funktion “landet”, müssen wir ihr auch als Parameter (Parameterübergabe) angeben:

function mein_abs($derWert)
{
}
main_abs(-1); // Aufruf der obigen Funktion mit dem Parameter -1

 

Wird nun mein_abs (-1); aufgerufen, steht der Wert -1 der Funktion als Variable "$derWert" im Funktionsblock zur Verfügung. Wir speichern die Datei unter mein_abs1.php und testen sie am Webserver und rufen sie über den Webbroswer auf:

http://meinwebserver/mein_abs1.php

Man sieht, es kommt keine Fehlermeldung, aber es geschieht auch nicht wirklich etwas, außer, dass die Funktion aufgerufen wird und ihr der Wert -1 übergeben wurde - was fehlt ist die Ausgabe.

 

Wir testen nun, ob die Parameterübergabe funktioniert hat.
Das machen wir, indem der Parameter einfach wieder mit echo-Befehl innerhalb der Funktion ausgeben wird.
Folgene Funktion hat immer noch keinen Rückgabewert (return value), liefert aber zwischenzeitlich
ein visuelles feedback durch die Ausgabe.

 

Dazu ändern wir die Funktion wie folgt:

function mein_abs($derWert)
{
    echo $derWert;
}
main_abs(-1); // Funktionsaufruf

So folgt. Es wird "-1" im Browserfenster beim Aufruf der PHP-Datei angezeigt.

Die Parameterübergabe scheint also zu funktionieren. Wir wollen aber immer einen positiven Wert erhalten, d.h. zB -1 sollte 1 werden, -500 soll 500 werden etc. Wir müssen alle Möglichkeiten ausloten, die es zu berücksichtigen gibt ("Fallunterscheidungen"):

Ist der übergebene Wert 0 oder größer als 0, also somit nicht negativ, brauchen wir eigentlich gar nichts zu tun. Ist er kleiner als 0 also negativ, müssen wir ihn in einen positiven Wert wandeln. Das bedeutet, wir brauchen eine Abfrage, ob der Wert kleiner 0 ist, und müssen den Wert dann, falls dies der Fall ist „positiv machen“, sprich einfach mit -1 multiplizieren.

Wir testen also mit if ($derWert < 0) ob der Wert negativ ist. Ist dies der Fall, brauchen wir den Wert nur mit -1 zu multiplizieren$derWert = $derWert * -1; und erhalten so den positiven Wert, den wir gleich der Variablen $derWert zuweisen.

Anmerkung: $derWert = $derWert * -1; kann auch als $derWert *= -1; geschrieben werden.

function mein_abs($derWert)

{
    if ($derWert < 0) {
        $derWert = $derWert * -1; // eine negative Zahl mit -1 multipliziert
        // ergibt ja eine Positive: -1 * -1 = 1
        // -3.4 * -1 = 3.4 etc.
    }
    echo $derWert; // Ausgabe
    echo "
"; // Zeilenumbruch
}

Wir Testen dies jetzt mit verschiedenen Parametern beim Funktionsaufruf:
mein_abs(-3.14159);
mein_abs(0);
mein_abs(22);
mein_abs(-10000000000000000);

Prorgrammausagebe:
3.14159
0
22
1E+16

Da wir die positiv ausgegebenen Werte im weiteren Programmablauf verwenden wollen und nicht als Text im "Browserfenster" anzeigen möchten, müssen wir den positiven Wert, den die Funktion "errechnet" hat statt Ausgeben einfach zurückgeben. Dies geschieht wie schon kurz erwähnt über den "return"-Befehl in Funktionen:

return ($derWert);

So folgt:

function mein_abs($derWert)
{
    if ($derWert < 0) {
        $derWert = $derWert * -1; // eine negative Zahl mit -1 multipliziert
        // ergibt ja eine Positive: -1 * -1 = 1
        // -3.4 * -1 = 3.4 etc.
    }
    return ($derWert); // gibt den Wert an den “Aufrufer” der Funktion
    // zurück
}

$positiver_Wert1 = mein_abs(-3.14159);
$positiver_Wert2 = mein_abs(-1);
$positiver_Wert3 = mein_abs(11);
echo $positiver_Wert1;
echo "
";
echo $positiver_Wert2;
echo "
";
echo $positiver_Wert3;

Programmausgabe:

3.14159
1
11

Wir haben also nun unsere eigene Funktion fzur Errechnung des Absolutbetrages geschrieben. Die Berechnung wird von der Funktion per return zurückgegeben und per = an beliebige Variablen weitergegeben.

Die Variablen haben wir hier noch zur Überprüfung per "echo"-Statement zur Anzeige gebracht.

 

 

 

 

Geltungsbereich von Variablen (scope)

Variablen, die zB innerhalb von Funktionen erzeugt werden, haben nur in dieser Funktion Gültigkeit und können nicht außerhalb dieser Funktion mit dem Wert angesprochen werden.

function test()
{
    $i = 1;
    echo "i in der Funktion, definiert als: ";
    echo $i . "<br>";
}
echo "i ist hier nicht definiert: ";
echo $i . "<br>";
$i = 99;
test();
echo "i außerhalb der Funktion, definiert als: " . $i;

 

 

Hieraus ist ersichtlich, dass die Variable $i innerhalb der Funktion eine andere ist als außerhalb.

 

Ebenso kann man in der Funktion nicht ohne Weiteres auf Variablen zugreifen, die außerhalb der Funktion definiert wurden. Über das Statement “global” in der Funktion ist es allerdings möglich:

$i = 99;
test();

function test()
{
    global $i;
    echo "i in der Funktion, definiert als: ";
    echo $i . "<br>";
}

echo "i außerhalb der Funktion, definiert als: " . $i;

 

Wird die Variable innerhalb der Funktion geändert, ändert sich ihr Wert gleichzeitig auch außerhalb der Funktion! Globale Variablen sind mit Vorsicht einzusetzen und meist besser zu vermeiden.