Sprachgrundlage von PHP

Hier gibt es einige Grundlagen zu PHP. Eine etwas ausführlichere Beschreibung gibt es als PDF.

>> Einführung in PHP [pdf]
Name von benutzerdefinierten Klassen und Funktionen, sowie Standardkonstruktoren und Schlüsselwörtern, wie z. B. echo, while,… sind case-insensitiv
echo („Hallo“)  = ECHO („Hallo“) = Echo („Hallo“)   
Namen von Variablen sind case-sensitive
$name != $Name != $NAME   
PHP benutzt Semikolons, um einfache Befehle voneinander zu trennen
Zusammengesetzte Befehle werden durch { } umschlossen, kein ; nach der schließenden Klammer nötig
Semikolon vor der schließenden Klammer muss dort stehen
if ($needed) {
                   echo („we must have it“);  }  //Semikolon muss stehen 
Semikolon vor einem schließenden PHP-Tag ist optional (wird aber empfohlen)
<?php echo („Blabla“); ?> //Semikolon nicht notwendig  
Leerzeichen und Zeilenumbrüche werden ignoriert
Kommentare
# Kommentar = Shell-Style (alles von # bis zum Zeilenende ist Kommentar, PHP-Tag beendet Kommentar
// Kommentar = C++ Style

*/ …. */ = C-Style von */ bis */ ist Kommentar, PHP-Tag beendet Kommentar nicht.
<?php $d=4 //set $d to 4 ?>
Then another <?php echo $d ?>
Ausgabe: Then another 4  
Literal: Datenwert, der direkt im Programm auftaucht z. B. 2001, 0xEE, „Hallo“, ‚hi’, true, false, null

Identifier: Namen für Variablen, Funktionen, Konstanten und Klassen (erstes Zeichen ASCII-Buchstabe, Unterstrich(_) oder alles zwischen ASCII 0x7F und ASCII 0xFF; danach sind diese Zeichen und 0 – 9 gültig
z. B. $bill, $ not valid, $head-count , $I, $3wa, $_underscore

Konstanten gibt es nur für die Datentypen, boolean, double und String (haben den Wert, der mit der define()-Funktion gesetzt wurde)
define(‚PUBLISHER’, „O`Reilly & Associates“); echo PUBLISHER;
Man darf Variablen, Funktionen, Klassen und Konstanen nicht Namen von Schlüsselworten geben - > selbiges gilt für die eingebauten PHP-Funktionen

DATENTYPEN

Es gibt 8 unterschiedliche Datentypen
  1. Integer
  2. Float
  3. Strings
  4. Boolean
  5. Arrays
  6. Objects
  7. Resources
  8. Null
INTEGER
Schreibweise dezimal (-17) , oktal (0755) oder hexadezimal (0x12B) Ist der Wert zu groß für den Integerzahlenbereich, wird automatisch in eine Gleitkommazahl umgewandelt Mit is_int() oder is_integer() prüft man ob Variable einen Integer-Wert enthält
GLEITKOMMAZAHLEN
normale Darstellung (-3.14) oder wissenschaftliche Notation (17.03E-5) Achtung: Rundungsfehler !-> s. h. Java is_float() oder is_real()
STRINGS
wichtig bei Webapplicationen
umfangreiche Funktionen zum Zeichenketten zu manipulieren
2 Schreibweisen ‚big dog’; oder „big dog“
Variablen in Zeichenketten werden immer in „“ ersetzt
$name = „Guido“;
echo „Hi $name \n“;
echo ‘Hi $name’;
Ausgabe: Hi Guido
            Hi $name
Testen auf Gleicheit:
if ($a == $b) {}
is_string()
BOOLEAN
folgende Werte sind false (das Schlüsselwort false, integer 0, double 0.0, leere Zeichenkette „“ oder String „0“, ein Array mit 0 Elementen, ein Objekt ohne Datenfelder und Methoden, der Wert null) alle anderen Werte sind true
is_bool() 
ARRAY
mehrere Zugriffsverfahren sind implementiert Zahlen -> 0…n
$person [0] =„Bob“
$person[1]=“Jane“
$person[2]=“paul“
Namen
$creator[‘lightbulb’] = “Edison”
$creator[‘rotary engine’]=” Wankel”»
$creator[‘toilet’]=”Crapper”
$person = array (‘Bob’, ‘Jane’, ‘Paul’)
$creator = array(‘Light bulb’ => ‘Edison’; ‘Rotary engine’ => ‘Wankel’; ‘Toilet’ => ‘Crapper’;)

Test mit is_array()
OBJEKTE
PHP unterstützt die objektorientierte Programmierung Klasse ist definiert durch Datenfelder und Methoden (functions)
class Person {
  var $name = ‚’;
 function name ($newname = NULL) {
    if (!is null ($newname)) { $this -> name = $newname;
    }
  return this -> name;
 }
}
Erzeugen neuer Objekte über new $tc = new Person;
Zugriff auf Datenfelder und Methoden des Objektes über -> $tc -> name (‚Crapper’); Test mit is_object()
if (is_object($x) {
  //$x is object
}
RESOURCES
Viele Module liefern viele Funktionen, um mit der Umgebung zu kommunizieren z. B. DB – eine Funktion für den connect, Query, close… häufig hat man mehrere Verbindungen gleichzeitig geöffnet -> die Connect-Funktion liefert somit etwas um die Verbindungen zu unterscheiden -> eine Resource Resourcen weden per Garbage Collection wieder automatisch freigeben, wenn sie nicht mehr verwendet werden.
$res = database.connect (); /fictiveFunktion
                   database_query($res);

$res = „boo“; //DB-Verbindung wird automatisch geschlossen

Test mit is_resource()-Funktion
NULL
Variablen, die keinen Wert haben sind Null
Test mit is_null()

VARIABLEN

Variablen sind Identifier mit einem $-Zeichen davor Variablen können prinzipiell werte von jedem Typ enthalten es gibt keine Compiler – oder Laufzeit-Typüberprüfung
$Wort = „Fred“;
$Wort=35;
$Wort=array(„Fred“, 35, ‚Wilma’);   
man kann in PHP keine Variablen deklarieren - bei der ersten Verwendung wird eine Variable erzeugt - d. h. das Setzen der Variablen ist eine Deklaration mann kann auf eine Variable zugreifen, deren Name in einer anderen Variable gespeichert ist.
$foo = ‚bar’;
$$foo = ‚baz’;
die Variable $bar hat nun den Wert ‘baz’
VARIABLEN – REFERENZEN
Um ein Alias für $black für die Variablen $white zu erstellen $black = $white löscht man eine der beiden Variablen z. B. mit der Funktion
unset $white so beeinflusst dies die andere Variable nicht Funktionen können Werte per Referenz zurückgeben, um z. B das Kopieren großer Felder zu vermeiden
function $ref_ref() {
  $var = “PHP”
  return  $var;
  }
$v = &ref_ref(); // beachte das &

GÜLTIGKEITSBEREICH FÜR VARIABLEN

es gibt 4 unterschiedliche Gültigkeitsbereiche
  1. local
  2. global
  3. static
  4. Funktionsparameter
local
wird eine Variable in einer Funktion deklariert, so ist sie lokal definiert
sie ist nur innerhalb dieser Funktion sichtbar / und in weiter verschachtelten Funktionen innerhalb dieser Funktion sichtbar
function update_counter() {
  $counter++;
  }
  $counter=10;
  update_counter();
  echo $counter;
  Ausgabe: 10
die lokale Variable innerhalb der Funktion wird nach Beendigung der Funktion gelöscht
es gibt in PHP nur lokale Variablen in Funktionen (Konzept funktioniert nicht für andere Blöcke, z. B. Schleifen)
global
Variablen, die außerhalb einer Funktion deklariert werden sind global man kann auf sie von überall im Programm zugreifen
standardmäßig aber nicht in Funktionen
will man auf globale Variablen innerhalb von Funktionen zugreifen, so muss man das Schlüsselwort glabal vor die Variablendeklaration innerhalb der Funktion stellen
function update_counter() {
  global $counter;
  $counter++;
  }
$counter=10;
update_counter();
echo $counter;
Ausgabe: 11
alternativ kann man auch auf das $GLOBALS-Array von PHP zugreifen
function update_counter() {
   $GLOBALS[counter]++;
   }
$counter=10;
update_counter();
echo $couner;
Ausgabe 11;
static
eine static-Variable behält ihren Wert zwischen zwei Funktionsaufrufen ist aber nur sichtbar innerhalb der Funktionen
function update_counter () {
   static $counter=0;
   $counter++;
   echo “static counter ist no $counter \n”);
   }
$counter =10;
update_counter();
update_counter();
echo “Globaler counter ist $counter \n”;

Ausgabe: static counter is now 1
                static counter ist now 2
                Globaler counter ist 10
Funktionsparameter
eine Funktion kann Parameter besitzen
Funktionsparameter sind local -> nur innerhalb der Funktion zugreifbar
function greet ( $name) {
    echo „Hello $name \n „;
    }
greet (“Janet”);
Ausgabe: Hello Janet