Variablen

PHP Bereich: <?php ?>
<? ?>
Kommentare: // Kommentar
# Kommentar
/* Kommentar */
Variablen prüfen: if (isset($a)) // prüft ob eine Variable definiert wurde
if (empty($a)) // true , falls $a=0 oder $a=false, $a="" oder $a nicht definiert ist
Variablen untersuchen: if (is_integer($a)) // Variablentyp prüfen: is_string, is_array, is_bool, is_double
if (is_numeric ($a)) // prüft ob das Zahlen sind
Abfrage Variablentyp: gettype ($a); // Typ einer Variable
Variablentyp setzen: settype ($a, string); // integer, double, string, boolean
$neu = (integer) $a; // Cast
Variable löschen: unset ($a);
Konstante define: define ("A", "Wert"); // echo A;
Zeiger: $a = &$b; // $b ändert sich mit, wenn sich der Wert von $a verändert
Dynamische Variable: $a = "b"; $$a = 3; // $b ist 3
Globale Variable und Umgebungsvariablen: $GLOBALS["a"] // Zugriff auf globale Variablen, also z.B. innerhalb einer Funktion
$_SERVER['SERVER_NAME'] // aogo.de
$_SERVER['HTTP_USER_AGENT'] // Name und Versionsnummer des Browsers
$_SERVER['GEOIP_REGION_NAME'] // Berlin, sehr viele weitere
$argv // Array enthält an das Script übergebende Argumenten
php.net
Magische Konstanten: echo __FILE__ // /www/htdocs/aogo/test.php
echo __DIR__ // /www/htdocs/aogo/
echo __LINE__ // 22
echo __METHOD__ // Auto::fahr Klasse und Methode
Variablen ausgeben: echo "Hallo {$a[44]} und nun";
Variableninformation: var_dump ($a); // Ausgabe z.B. string(3) "abc"
print_r ($a); // Arrays und Objekten

Mathematik

Absoluter Wert: abs (-4); // 4
Zuweisungsoperator: $a += 5; // entspricht $a = $a + 5;
Modulo Operator: if (22 % 2 == 0); //Prüft ob gerade
Zahlen formatieren: number_format (1550, 2, ",", "."); // 1.550,00; Zahl, Nachkommastellen, Dezimalzeichen, Tausenderzeichen
number_format (1550, 2); // 1,550.00;
Runden: round (14.34); // 14
ceil (9.3); // 10 aufrunden
floor (9.8); // 9 abrunden
Potenzieren: pow(3,4); // 3 hoch 4
sqrt(4) // Wurzel aus 4 ist 2
Maximalwert Minimalwert: max (2,4,3,6); // 6 auch arrays sind so prüfbar
min (2,4,3,6); // 2
Zufallsgenerator: $zufall=mt_rand(1,100); // Ganzzahlige Zufallszahlen

Weitere

Ausgabe: echo (nl2br(htmlspecialchars($zeile));
Laufzeit verändern: set_time_limit(600); // Zeit zum ausführen manipulieren
phpinfo: phpinfo(); // Eigenschaften der aktuellen Datei und der Server-Konfiguration
flush: flush() // sendet Daten sofort an Browser
Umleitung: header("Location: test.html"); // Es darf noch keine Ausgabe an den Browser gesendet worden sein
Mail versenden: mail("an@gmx.de","Betreff","Emailtext", "From: Name <von@gmx.de> \n Bcc: kopie@email.de \n Content-Type: text/html");
Zeitunterbrechung: sleep(10); // 10 Sekunden Unterbrechung
Verschlüsselung: md5("natoll und sowas"); // eb449714251ae9486c8e153fa421ee87
Script unterbrechen: die ("Fehlerausgabe"); // Beenden mit Ausgabe
exit(); // Beenden ohne Ausgabe
Fehler anzeigen: error_reporting (E_ALL);
Code ausführen: eval ("echo \"Hallo $a\";"); // Hallo du
Bildgröße: $imgsize = getimagesize("img/bild.jpg"); // $imgsize[0] Breite [1] Höhe [2] Typ (1=GIF, 2=JPEG, 3=PNG) [3] IMG-Tag
Beispiel GD Bibliothek: $bild = imagecreatetruecolor(300, 400); // erzeugt Bild - für Diagramme eignet sich gut GD Graph
imagefilledrectangle($bild, 10, 10, 190, 40, $rot); // Rechteck zeichen

Array

Array erstellen: $a = array ("Uwe", "Tim", "Bob");
$a = array ("name" => "Bob", "alter" => 33); // Assoziatives Array
$a = array ("namen" => array (6 => 5, 11 => 4, "b" => 2)); // Mehrdimensionales Array
Arrayelemente hinzufügen: $a[] = 3; // Neues Element
$a["beruf"] = "Held";
Arrayelemente voranstellen: array_unshift ($a, "Apfel", "Birne"); // am Anfang eines Arrays hinzugefügt
Arrayelement suchen: if (in_array ("Suchbegriff", $a))
Arrayschlüssel suchen: if (array_key_exists ('Suchbegriff', $a))
Arrayanzahl: count ($a); // Zählt Anzahl der Array Elemente
Arrayelemente löschen: array_shift ($a); // löscht erstes Element
array_pop ($a); // löscht letztes Element
unset ($a["name"]); // bestimmtes Element löschen
unset ($a[1]); // bestimmtes Element löschen
Arrays zusammenfügen: $a = array_merge ($a1, $a2, $a3);
Teil eines Arrays: $b = array_slice ($a, Anfangsposition, Anzahl Elemente);
Array umdrehen: array_reverse ($a);
Doppelte löschen: array_unique ($a); // doppelte Einträge löschen
Arrays sortieren: $a = array ("Ampel", "Zebra", "Bär"); // brauch nicht in neuem Array gespeichert werden, wird auf $a dirket angewandt

sort ($a); // aufsteigend sortiert (Ampel, Bär, Zebra)
rsort ($a); // absteigend sortiert (Zebra, Bär, Ampel)
shuffle ($a); // erzeugt eine zufällige Reihenfolge
usort ($a,"funktion") // mit Hilfe einer Funktion, kann eine benutzerdefinierte Sortierung geschaffen werden
Assoziative Arrays sortieren: $a = array ("b" => "Ampel", "a" => "Zebra", "c" => "Bär");

asort ($a); // aufsteigend nach Value (b=Ampel, c=Bär, a=Zebra)
arsort ($a); // absteigend nach Value (a=Zebra, c=Bär, b=Ampel)
ksort ($a); // aufsteigend nach Key (a=Zebra, b=Ampel, c=Bär)
krsort ($a); // absteigend nach Key (c=Bär, b=Ampel, a=Zebra)
Arrayelement filtern: $n = array_filter ($a, "funktion"); // eine funktion wird aufgerufen, gibt diese wahr zurück, bleibt das Element bestehen
Arrayelement suchen: $key = array_search('Suchbegriff', $a); // Dursucht ein Array und liefert dazugehörigen Schlüssel
Funktion auf jedes Arrayelement anwenden: function fktname ( &$wert, $key, $m) // durch &$ werden die Werte im Array geändert
{ $wert = $wert*$m; } // jeder Wert im Array wird mal 5

array_walk ( $a, "fktname", 5 ); // letzter Parameter ist optional genommen
Array durchlaufen: foreach ($a as $temp) { }
Assoziatives Array durchlaufen: foreach ($a as $key => $value) { }
Array durchlaufen übersichtlich: echo "<table>"; foreach ($_SERVER as $key => $value) { echo "<tr><td>$key</td> <td>$value</td></tr>"; } echo "</table>";
Serialisieren: $serial_str = serialize ($a); // Das Array wird in einen formatieren Sring umgewandelt, den kann man z.B. in Cookie speichern
$a= unserialize ($serial_str); // Serialized String wird zurück in ein Array umgewandelt
Array in Zeichen-kette umwandeln: $zeichkette = implode (" - ", $a); // Array wird zu einem String (1 - 2 - 3)
Zeichenkette in Array umwandeln: $a = explode ("-", "1 - 2 – 3");
Weitere Array Funktionen: php.net

Kontrollstrukturen

Fallunterscheidungen: if ($a == 1 and $b != 1 ) { }
elseif ($a >= 1 or $b <= 1) { }
elseif ($a == 1 xor $b == 1) { } // nicht beide wahr
else { }
Alternative Schreibweise: if ($a == 3) : echo 1; echo 2;
else : echo 3;
endif;
Verkürte Schreibweise: ($a == 1) ? echo "wahr" : echo "unwahr";
$variable = ( 1==1 ) ? echo "wahr" : echo "unwahr"; // $varialbe=true;
Werte vergleichen: $a="froh";
switch ($a)
{
case "froh":
echo "gut";
break; // muss geschrieben werden, sonst werden alle ausgeführt
case "traurig":
echo "schlecht";
break;
default: // für alles andere
echo "weiß nicht";
}
While-Schleife: while ($a <= 10)
{
$a++;
}
Do-while-Schleife: do
{
$a++;
}
while ($a <=10); // Block wird mindestens einmal durchlaufen
For-Schleife: for ($a=1; $a<=3; $a++) // 3 Durchläufe
{
echo "$a<br>";
}
Schleifenabbruch: break; // Beendet eine Schleife
Schleifen- unterbrechung: continue; // Beendet aktuellen Durchlauf, aber nicht komplette Schleife

Funktionen

Funktion: function arbeit ($a) { $x=$a+5; return $x; } // Variablen gelten nur lokal; return beendet Funktion
$y = arbeit (4);
if (arbeit (10) < 15) { } // Funktion innerhalb einer Abfrage
Funktion mit Defaultwert: function arbeit ($a, $b = 4) { }
Aufruf einer Funktion: call_user_func ("arbeit", $a, $b); // Weitere Möglichkeit eine Funktion aufzurufen
Globaler Variablen: global $a, $b; // sonst gilt eine Variable nur innerhalb oder ausserhalb einer Funktion; Aufruf innerhalb einer Funktion
$GLOBALS["a"] // Zugriff auf eine Variable ausserhalb einer Funktion
Variablen erinnern: static $c = 0; // mit Hilfe des Schlüsselworts static merkt sich die Variable den letzten Wert; $c ist 0 beim ersten Aufruf
Referenzparameter: function arbeit (&$w) { $w += 1; } // Der übergebende Parameter wird auch ausserhalb der Funktion verändert.
$a = 2; arbeit ($a); // $a=3
Variablenfunktionen: $f = "arbeit"; $f(2); // Funktion arbeit wird aufgerufen
Argumentzugriff: $numargs = func_num_args(); // Liefert Anzahl von Funktionsargumenten; Aufruf innerhalb einer Funktion
echo "func_get_arg(1)"; // Zugriff auf Argumente
$a = func_get_args(); // Array aller übergebenden Parameter

Formulare

Formular erstellen: <form action="<?php echo htmlspecialchars ($_SERVER["PHP_SELF"]); ?>" methode="POST"> // Post bei großen Datenmengen ; GET bei Suchanfragen
Übergebene Variablen: $_GET["name"];
$_POST["name"];
Input: <input type="text" name="wert" value="$a"> // Texteingabe

<input type="checkbox" name="a[]" value="Bob"> // Checkboxes Array
<input type="checkbox" name="a[]" value="Tim">

<input type="ratio" name="a" value="Bob"> // Radiobutton Name muss immer der selbe sein
<input type="ratio" name="a" value="Tim">
Textfeld mit Zeilenumbruch: nl2br($_GET["t"]; // \n wird in <br> umgewandelt
Dateien hochgeladen: $_FILES["feldname"]; // bei einem Bild prüfen, ob es auch eins ist (mime type mit getimagesize), außerdem sollte man Dateiendung prüfen
if (isset($_FILES["feldname"]) and ! $_FILES["error"]) {
if (@move_uploaded_file($_FILES["feldname"]["tmp_name"], "upload/" . basename ($_FILES["feldname"]["name"]))) echo "Datei upload";
} // Daten werden kopiert in Ordner uploadbasename verkürzt Pfad auf Dateinamen, das @ untterdrückt Fehlermeldungen
Filtererweiterung: if (filter_var($_GET["email"], FILTER_VALIDATE_EMAIL) === false) // damit lassen sich Variablen überprüfen, hier ob s eine gültige Emailadresse ist.
if (filter_var($zahl, FILTER_VALIDATE_INT)) // prüft ob Eingabe Zahl ist
if (filter_var($seite, FILTER_VALIDATE_URL)) // URL
$optionen = array('options' => array('min_range' => 500, 'max_range' => 600));
if (filter_var($zahl, FILTER_VALIDATE_INT, $optionen)) // Range
Cross Site Scripting: echo htmlspecialchars ($_GET("wert")); // wandelt Sonderzeichen um, sonst könnte z.B. Javascript ins Formularfeld eingetragen werden
// außerdem könnte man mit in_array, srtlen oder anderen Funktionen, Eingaben einschränken oder strip_tags
SQL Injection: in ein Passwortfeld könnte man ' or 1=1 schreiben, dadurch kommt man an Daten;
z.b. duch $passwort = mysqli_real_escape_string ($verbindung, $_POST['passwort']); vorher codieren
Allgemeine Sicherheitsinformationen: keinen Inputs vertrauen
möglichst POST statt GET verwenden
Längen, Datentypen und Wertebereiche validieren
Session-Cookies schützen mit ini_set('session.cookie_httponly', true)
Keine kritischen Informationen in Sessions speichern
Magic Quotes und register_globals abschalten

Sessions und Cookies

Cookie setzen: setcookie ("name", "Werner", time()+(3600*24*7), "/"); // 7 Tage gültig, letzte Angabe ist Pfad, sonst evtl. nur in Unterordner gültig; weitere Parameter optional
Cookie auslesen: if (isset ($_COOKIE["name"])) echo htmlspecialchars($_COOKIE["name"]);
Cookie löschen: setcookie ("name");
Session starten: session_start (); // startet oder führt Session weiter aus; muss vor der ersten Textausgabe stehen; um Sessions zu nutzen, muss Cookies aktiviert sein
ID aktueller Session: session_id (); // 13a99f8c9c64a0c
Session Variablen: $_SESSION["name"] = "Marie"; // in Session speichern
if (isset ($_SESSION["name"])) echo $_SESSION["name"]; // Session Variable auslesen
Sessionvariablen löschen: session_unset ("name"); // löscht ein Sessionvariable
session_unset (); // löscht alle Sessionvariablen
Session löschen: $_SESSION = array(); // leeres Array; Session löschen z.B. beim Logout
setcookie (session_name(), "", time()-3600); // außerdem wird das Session Cookie gelöschht
session_destroy(); // außerdem Sitzung zerstörrt, um auf ganz sicher zu gehen
Kodieren einer Session: session_encode (); // Kodiert Session als Zeichenkette; a|s:9:"Wert";b|s:11:"Wert";
session_decode (); // Dekodiert Session
Session Id ernuet erzeugen: session_regenerate_id(); // behält Werte von Session und erzeute Session Schlüssel neu, dient zur Sicherheit

Datum und Zeit

Uhrzeit in Sekunden: time (); // Anzahl Sekunden, seit dem 1.1.1970
Zeitmarke mit getdate umwandeln: $datum_array = getdate ();
$datum_array[seconds]; // minutes, hours, mday (Tag des Monats), wday, mon, year, yday
Zeitmarke mit date umwandeln: date ("d.m.y H:i:s", time()); // 02.03.01 04:22:59
date ("j.n.Y G:i:s", time()); // 2.3.2001 4:22:59
Zeitmarke erzeugen: $mk = mktime (Stunden, Minuten, Sekunde, Monat, Tag, Jahr);
Zeitzone festlegen: date_default_timezone_set("Europe/Berlin");
Datum prüfen: checkdate ($monat, $tag, $jahr); // prüft, ob es das Datum geben kann; 30 Februar gibt es nicht
Microsekunden: $t_a["start"]=microtime(); // Laufzeit eines Sripts testen
$t_a["end"]=microtime(); $t_a["time"] = $t_a["end"] - $t_a["start"]; echo "Zeit:".$t_a["time"]."<br>";

Dateien

Dateien prüfen: if (file_exists ("test.txt")) // Existenz
if (is_file ("text.txt")) // Datei
if (is_dir ("/ordner")) // Ordner
if (is_readable ("test.txt")) // Lesbarkeit
if (is_writeable ("test.txt")) // Schreibbarkeit
Information über eine Datei: filesize ("test.dat"); // Länge in Bytes (Zeichen gleich Byte)
filectime ("test.dat") // Datei erstellt, z.B. 12.09.1999
fileatime ("test.dat") // letzter Zugriff auf die Datei
filemtime ("test.dat") // Datei zuletzt geändert
Informationen über Datei: $info = stat(a.txt); // viele weitere Informationen
$info[7]; // Größe in Bytes
$info[8]; // timestamp letzter Zugriff
$info[10]; // Zeitpunkt der letzten Änderung
Array aus Datei erzeugen: $zeilen = file (datei.txt); // Zeilen werdn in Arrayelementen gespeichert
foreach ($zeilen as $zeile) { echo $zeile; }
String aus einer Datei: $d = file_get_contents ('datei.txt'); // gesammte Datei, wird in einer Variable gespeichert
In Datei schreiben: file_put_contents ('datei2.txt', 'Ho ho ho'); // Öffnet und schreib gekapselt in einer Funktion
Datei öffnen: $fp = fopen ("http://www.hsv.de", "r"); // r (lesen), w (schreiben), a (anhängen), r+ (lesen und schreiben)
if (! $fp) exit ("Datei konnte nicht geöffnet werden");
Datei schließen: fclose ($fp); // zu jedem fopen ein fclose, sonst könnte die Datei evtl. nicht noch einmal geöffnet werden
Zeilenweise lesen aus einer Datei: while (!feof ($fp)) // Liest zum Zeilenvorschub und springt weiter, solange das Ende der Datei nicht erreicht ist.
{ $zeile = fgets ($fp); }
Zeilenweise lesen ohne Html: $zeile = fgetss ($fp); // entfernt HTML, PHP
Zeichenweise lesen: $zeichen = fread ($fp, 16); // Liest beliebig viele Zeichen
Positinorierung: fseek ($fp, 64);
Positinorierung lesen: ftell ($fp); // aktuelle Postition innerhalb der Datei
In Datei schreiben: fwrite ($fp, "Text"); // Text wird je nach Modus drangehängt oder ersetzt
fputs ($fp, "Text"); // Schreibt Daten an die Position des Dateizeigers
Dateien sperren und entsperren: flock ($fp,1); // 1 Leseschutz, 2 Schreibschutz, 3 Sperre aufheben, 4 keine Sperre, Wichtig damit nicht 2 User gleichzeitig in eine Datei schreiben.
Datei erstellen: touch ("test.dat"); // erstellen
unlink ("test.dat"); // löschen
copy("../test.dat","kopie_test.dat"); // kopieren
Ordner erstellen: mkdir ("testdir", 0777); // Ordner erstellen
rmdir ("testdir"); // Ordner löschen
Zugriffsrechte ändern: chmod ("/ordner/index.htm",0777);
Verzeichnishandle: if ($dh = opendir("/test")) {
while (($file = readdir($dh)) !== false) { echo "Name: $file<br>"; }
} closedir($dh); // kann mit z.B. stat untersucht werden
Datei einbinden: include ("test.php"); // Datei wird ausgegeben oder verarbeitet
require ("test.php"); // bei nicht vorhanden sein, wird das script angehalten

Zeichenketten

Verkettung: $a = "Hallo" . " Welt"; // Hallo Welt
Zuweisungsoperator: $a .= "gut"; // entspricht $a = $a ."gut";
Stringindizierung: $a = "Text"; // $a[1] ist e
HTML Sonderzeichen umwandeln: htmlspecialchars("3 > 4 & \" "); // Soderzeichen werden im HTML Sonderzeichen umgewandelt, " wird in " umgewandelt
htmlspecialchars_decode (" "); // Sonderzeichen werden in normale Zeichen umgewandelt
Entfernt HTML Tags: strip_tags("<i>Text</i>"); // HTML werden entfernt
strip_tags("<i>Text</i>", "<p><i>"); // behalten werden <p> und <i>
Zeilenumbrüche: nl2br ("Text \n"); // Zu Zeilenumbrüchen wird <br> hinzugefügt
Prüft ob Teilstring in Zeichenkette: strstr ("Text", "ex"); // true
stristr ("Text", "EX"); // true Großkleinschreibung unbeachtet
Länge Zeichenkette: strlen ("Text"); // 4
Teilzeichenkette extrahieren: substr ("Rucksack", 4, 3); // sac
substr ("Rucksack", -3); // ack
Zeichenkette ersetezen: str_replace ("suchen", "ersetzen", "hier suchen"); // wird für alle gefunden durchgeführt
str_replace (array ("ä","Ä"), array ("ae","Ae"), "Ä ä"); // Ae ae
Teilzeichenkette ersetzen: substr_replace ("Rucksack", "Schlaf", 0, 4); // Schlafsack
Position im String: strpos ("Text", "x"); // 3 sucht erstes
strrpos ("Texte", "e"); // 5 sucht letztes
Suchen und zählen: substr_count ("Hello world. The world is world", "world"); // 3 Vorkomnisse
Zeichenkette säubern: trim (" Text 1 "); // beseitigt Leerzeichen und Tabulatoren
trim ("' Text 1 ", "'."); // Mit 2 Argument; einfache Anführungzeichen und Punkte werden am Anfang und am Ende entfernt
chop ("Text 1 "); // nur am Ende
ltrim (" Text 1"); // nur am Anfang
URL in Array zerlegen: $a = parse_url ("http://www.test.de/22/datei.htm?a=3");
// $a[scheme] Protokoll -- $a[host] www.test.de -- $a[path] 22/datei.htm -- $a[query] a=3 -- $a[user] Benutzer -- $a[pass] Passwort
Text formatieren: sprintf ("Text %04d", 36); // Text 0036 - Integer -- prinf () gibt den Inhalt direkt aus
sprintf ("%.2f", 5.3333) // 5.33 runden - Flieskommazahl
sprintf ("Text %s", A); // Text A - String
Groß Kleinschreibung umwandeln: strtoupper ("alles gross"); // ALLES GROSS
strtolower ("ALLES KlEIN"); // alles klein
ucwords ("capitalized words"); // Capitalized Words
Passwörter in md5 hash speichern: $passwort = md5 (Haus); // ebacf61946ee81f386960ad2a09a147e
Kodieren: base64_encode ($a); // kodieren: VGhpcyBpcyBhbiBlbmNvZGVkIHN0cmluZw==
base64_decode ($a); // dekodieren
Sonderzeichen kodieren: awurldecode (Hans%20ist%20gr%F6%DFer); // Hansi ist größer
rawurlencode (Hansi ist größer); // Hans%20ist%20gr%F6%DFer
Parse String: parse_str ("name=Otto&age=33"); // $name=Otto; $age=33
parse_str ("name=Otto&age=33",$a); //$a[name]=Otto
Übereinstimmung: $a = similar_text ("abcd", "cbax", $p); // hier $a=1 und $p=25; gibt Anzahl an Übereinstimmung und Prozentangabe wieder

Reguläre Ausdrücke

Reguläre Ausdrücke: preg_match ("/a.c/", "abcde", $erg); // findet nur ersten Treffer, gespeichert in $erg[0]; Funktion gibt true zurück; / heisst Begrenzer

"/^abc/" am Anfang des Strings
"/cde$/" am Ende des Strings
"/a.c/" beliebiges Zeichen
"/[^xy]/" beliebiges Zeichen, ausser x und y
"/[ax]bc/" a oder x
"/(abc|dfg)/" abc oder dfg
"/[a-z]bc/" Zeichenbereiche, weiter z.B. [0-9] oder [A-Za-z] für Groß- und Kleinbuchstaben

"/[a-z]*cd/" beliebig oft; Quantifizierer
"/[a-z]+cd/" mindest einmal
"/[a-z]?cd/" einmal oder keinmal
"/[a-z]{1,4}cd/" mindestens einmal, höchstens 4 mal

"/\"xyz/" findet "xyz \ Maskierung
"/\wabc/" Wortgrenze; weitere z.B. \s Whitespace, \d Ziffer, \w Wortzeichen

"/Abc/i" Groß und Kleinschreibung ignorieren; Modifizierer
"/[a-z]*cd/U" es wird nur minimale Zeichen eingesammelt, hier bcd ohne U, wäre es abcd
Mehrere finden: preg_match_all ("/a.c/", "abcde axc", $erg); // findet alle Treffer, gespeichert in $erg[0][0] = abc; erg[0][1]= axc
Suchen und ersetzen: $x = preg_replace ("/abc/", "xyz", "abcd"); // xyzd; jedes Vorkommins wird ersetzt; funktioniert auch mit arrays
Array erzeugen mit regulären Ausdruck: $a = preg_split("/ /", "abc def");Array mit [0] abc und [1] def

Objekte

Klasse und Instanz: class Auto { // Auto ist der Bauplan; beginnt üblicherweise mit großem Anfangsbuchstaben
public $farbe = "weiss"; // Eigenschaften eines Objekts
public $ps; }

$vw = new Auto; // Objekt wird erzeugt; Objekte sind konkreten Realisierungen einer Klassen;
$vw->farbe = "blau"; // Objekt Eigenschaft wird verändert
Mehtoden: class Auto {
public $kmh=0;
public function fahr ($x) {
$this->kmh += $x; } } // $this ermöglicht Zugriff auf aktuelless Objekt

$vw = new Auto;
$vw->fahr(20); // Der Wert kmh wird, um 20 erhöht
Zugriffsmodifizierer: public $farbe; // lässt sich durch $vw->farbe="blau" setzen oder drauf zugreifen
private $farbe; // lässt sich nicht ausserhalb des Objektes ändern oder zugreifen
protected $farbe; // lässt sich nicht ausserhalb des Objektes ändern oder zugreifen, aber in Vererbungsobjekten
Konstruktor und Destruktor: class Auto {
public function __construct($n) { // Diese Methode wird aufgerufen wenn ein Objekt erzeugt wird
echo $n;
$this->name = $n; } // name wird Eigenschaft des Objekts

public function __destruct() { // wird aufgerufen wenn ein Objekt zerstörrt wird
echo "weg"; } }

$vw = new Auto("Polo");
unset ($vw);
Objekt Ausgabe: class Auto {
function __toString() { // wird zurück gegeben, wenn objekt per echo aufgerufen wird
return echo "dies und das"; } }

$vw = new Auto();
echo $vw; // gibt "dies und das" aus
Objekt Kopie: $audi = clone $vw; // Eine Kopie des Objekts Audi wird erstellt, durch Einsatz der Methode __clone() kann das neue Objekt verändert sein
Objekte als Parameter und Rückgabewerte: class Auto {
private $farbe="rot";
function aus() { return $this->farbe; }

function col ($a) {
$erg = new Auto;
$erg->farbe = $a->farbe; Die Farbe des neuen Objekts ist die Farbe des übergebenden Objekts
return $erg; } }

$vw = new Auto;
$audi = new Auto;
echo $vw->col($audi)->aus(); // Objetkt wir an Methode von $vw übergeben, anderes Objekt entgegenommen und ausgegeben
Vererbung: class Auto { // Elternklasse
public $kmh=0;
public function fahr ($x) {
$this->kmh += $x; } }

class Rennauto extends< Auto { // Rennauto Klasse erbt Eigenschaften und Methoden von Auto
function bonus($y) {
$y+=10;
parent::fahr($y); // Elternmethode direkt zugreifen
$this->kmh+=10; } } // Elterneingenschaft zugreifen

$porsche = new Rennauto;
$porsche-> fahr(5);
$porsche-> bonus(5); // Der Porsche wird auf 30 Beschleunigt
Vererbung: final: final public function fahr() { } // durch final kann es in der Vererbung nicht überschrieben weren
final class Auto // final vor einer Klasse, macht diese nicht mehr ableitbar
Vererbung: abstract: abstract class Auto { // Abstrakt muss vor Klasse stehen und vor den betreffenden Methoden.
abstract public function fahr() } // Diese Methoden müssen in Unterklassen ersetzt werden und können nicht direkt aufgerufen werden
Vorhandensein von Methoden erzwingen: interface Zwang { public function fahr (); } // die hier aufgeführten Methoden müssen in der folgenden Klasse vorhanden sein

class Auto implements Zwang {
public function auto () {} } // wär die Methode nicht vorhanden, erschien eine Fehlermeldung
Direktzugriff auf Methoden: class Auto {
public static $farbe = 2; // durch static, braucht ein Objekt nicht erstellt werden, man hat Direktzugriff
const k = 3; // Konstante ohne $
public static function fkt_a() { echo "1"; }

public static function fkt_b() {
echo self::$farbe; // Zugriff innerhalb einer Klasse
echo self::fkt_a(); // Bei statischen Methoden muss self anstatt this verwendet werden.
echo self::k; } }

echo Auto::fkt_b(); // 123
echo Auto::$farbe; // 2
Eigenschaften merken: class Auto { // mi Hilfe von static und self werden Instanzen gezählt
private static $zaehler = 0;
public function __construct() {
self::$zaehler++; // Mit Hilfe von self werden die erstellten Objekte gezählt
echo "Nummer " . self::$zaehler; } } jedes erstelltes Objekt hat neue Nummer
Instanz prüfen: if ($vw instanceof Auto) echo "Das Objekt vw ist Instance der Klasse Auto";
Hilfsfunktionen: echo (class_exists(Auto)); // 1
echo (get_class($vw)); // Auto
echo (get_parent_class(Auto)); // übergeordnete Klasse, hier keine
echo method_exists($vw, fahr); // 1
print_r (get_class_methods(Auto)); // funktioniert mit Auto und mit $vw -- Array mit [0]=>fahr
print_r (get_class_vars(Auto)); // Array ( [farbe] => weiss [ps] => [kmh] => )
print_r (get_object_vars($vw)); // Array ( [farbe] => blau [ps] => [kmh] => 20 )
print_r (get_declared_classes()); // Array mit vielen exestierenden Klassen und eigenen
Serialisierung: $s = serialize($vw); // O:4:"Auto":2:{s:5:"farbe";s:4:"blau";s:2:"ps";N;} Objekt kann so abgespeichert werden
$vw = unserialize ($s) // Die zugehörige Klasse muss aufgeführt sein
Fehlermeldungen: try { if (2>1) throw new Exception ('Ausnahme'); } // Bei Fehlern oder, wenn bewußt Ausnahme geworfen wird, wird catch aufgerufen
catch (Exception $e) { echo $e->getMessage(); exit; } // Bei Fehler im Bereich try, wird catch aufgerufen und das Objekt ausgegeben