PHP Hypertext Preprozessor Vorgestellt durch Daniel SMIDT.

Präsentation zum Thema: "PHP Hypertext Preprozessor Vorgestellt durch Daniel SMIDT."—  Präsentation transkript:

1 PHP Hypertext Preprozessor http://www.php.net Vorgestellt durch Daniel SMIDT

2 G ESCHICHTE (I) 1995 – PHP 1.0 von Rasmus Lerdorf Perl ähnliche in C entwickeltes „Personal Home Page Tools“ PHP 3 - Andi Gutmans und Zeev Suraski Neu Entwickelung aufgrund unzureichender E- Commerce möglichkeiten in vorhergehender Version

3 G ESCHICHTE (II) PHP 4 – Zend Engine 1 Ausgabepufferung, Anfängliches „OOP“ PHP 5 – Zend Engine 2 (2004) Mehr OOP PHP 6 Namespace, mehr OOP

4 PHP G RUNDSTRUKTUR PHP läuft Serverseitig als Modul oder CGI Kein Threading, kein Byte-Code Cache Hier setzen Optimizer an (wie ZEND Optimizer) Quelle: Wikipedia http://de.wikipedia.org/wiki/Php

5 PHP - E INFÜHRUNG C und PERL ähnlicher Syntax Funktionen Geschlossener und benannter Anweisungsblock function tuWas() { echo „Hallo“; } function tuWas2($a,$b=„2“) { echo $a. „ = „. $b;} Können zur laufzeit erzeugt werden Create_function(..) Variablengültigkeit: Probleme mit GLOBAL Konstanten Definition define(„AUTOR“,“DANIEL“); Rekursion ist möglich

6 PHP - E INFÜHRUNG Module – Einfügen bestenhenden PHP Code in die Anwendung über include( ) Arrays $array[1] = „Daniel“ $array = array ( „F1“ => „Daniel“, „F2“ => „Raphael“); Echo $array[„F1“] Schwache Typisierung: $x = 1; // Weise x explizit den Wert 1 zu (implizit den Typ int). $x = 2 + "42"; // Nun Zeichenkette $x = 2 + "Ich bin keine Zahl"; //ungültige Zeichenkette wird zu 0: $x nun 2

7 PHP – OOP (1) CLASS class SimpleClass { // Deklaration einer Eigenschaft public $var = 'ein Standardwert'; // Deklaration einer Methode public function displayVar() { echo $this->var; } }

8 PHP – OOP (2) KONSTANTEN class MyClass { const constant = 'Konstanter Wert'; function showConstant() { echo self::constant. "\n"; } } echo MyClass::constant. "\n"; $classname = "MyClass"; echo $classname::constant. "\n"; // Ab PHP 5.3.0 $class = new MyClass(); $class->showConstant(); echo $class::constant; // Ab PHP 5.3.0

9 PHP – OOP (3) AUTOLOAD function __autoload($class_name) { require_once $class_name. '.php'; } $obj = new MyClass1(); $obj2 = new MyClass2(); Kann aber eine Sicherheitslücke sein!

10 PHP – OOP (4) D ESTRUKTOREN UND K ONSTRUKTOREN class BaseClass { function __construct() { print "Im BaseClass Konstruktor\n"; } } class SubClass extends BaseClass { function __construct() { parent::__construct(); print "Im SubClass Konstruktor\n"; } } $obj = new BaseClass(); $obj = new SubClass();

11 PHP – OOP (5) S ICHTBARKEITEN (A1) class MyClass { public $public = 'Public'; protected $protected = 'Protected'; private $private = 'Private'; function printHello() { echo $this->public; echo $this->protected; echo $this->private; } } $obj = new MyClass(); echo $obj->public; // Funktioniert echo $obj->protected; // Fataler Fehler echo $obj->private; // Fataler Fehler $obj->printHello(); // Zeigt Public, Protected und Private

12 PHP – OOP (6) S ICHTBARKEITEN (A2) /** * Definiere MyClass2 */ class MyClass2 extends MyClass { // Wir können die public und protected Methoden neu deklarieren, // aber nicht private protected $protected = 'Protected2'; function printHello() { echo $this->public; echo $this->protected; echo $this->private; } } $obj2 = new MyClass2(); echo $obj2->public; // Funktioniert echo $obj2->private; // Undefiniert echo $obj2->protected; // Fataler Fehler $obj2->printHello(); // Zeigt Public, Protected2, Undefined

13 PHP – OOP (7) S ICHTBARKEITEN (B1) /** * Definiere MyClass */ class MyClass { // Deklariert einen public Konstruktor public function __construct() { } // Deklariere eine public Funktion public function MyPublic() { } // Deklariere eine protected Funktion protected function MyProtected() { } // Deklariere eine private Funktion private function MyPrivate() { } // Dies ist public function Foo() { $this->MyPublic(); $this->MyProtected(); $this->MyPrivate(); } } $myclass = new MyClass; $myclass->MyPublic(); // Funktioniert $myclass->MyProtected(); // Fataler Fehler $myclass->MyPrivate(); // Fataler Fehler $myclass->Foo(); // Public, Protected und Private funktionieren

14 PHP – OOP (8) S ICHTBARKEITEN (B2) /** * Definiere MyClass */ class MyClass { // Deklariert einen public Konstruktor public function __construct() { } // Deklariere eine public Funktion public function MyPublic() { } // Deklariere eine protected Funktion protected function MyProtected() { } // Deklariere eine private Funktion private function MyPrivate() { } // Dies ist public function Foo() { $this->MyPublic(); $this->MyProtected(); $this->MyPrivate(); } } $myclass = new MyClass; $myclass->MyPublic(); // Funktioniert $myclass->MyProtected(); // Fataler Fehler $myclass->MyPrivate(); // Fataler Fehler $myclass->Foo(); // Public, Protected und Private funktionieren

15 PHP – OOP (9) V ERBUNG class foo { public function printItem($string) { echo 'Foo: '. $string. PHP_EOL; } public function printPHP() { echo 'PHP is great.'. PHP_EOL; } } class bar extends foo { public function printItem($string) { echo 'Bar: '. $string. PHP_EOL; } } $foo = new foo(); $bar = new bar(); $foo->printItem('baz'); // Output: 'Foo: baz' $foo->printPHP(); // Output: 'PHP is great' $bar->printItem('baz'); // Output: 'Bar: baz' $bar->printPHP(); // Output: 'PHP is great'

16 PHP – OOP (10) G ÜLTIGKEITSOPERATOR class MyClass { const CONST_VALUE = 'Ein konstanter Wert'; } $classname = 'MyClass'; echo $classname::CONST_VALUE; // Ab PHP 5.3.0 echo MyClass::CONST_VALUE; class OtherClass extends MyClass { public static $my_static = 'statische var'; public static function doubleColon() { echo parent::CONST_VALUE. "\n"; echo self::$my_static. "\n"; } } $classname = 'OtherClass'; echo $classname::doubleColon(); // Ab PHP 5.3.0 OtherClass::doubleColon();

17 PHP – OOP (11) S TATIC class Foo { public static function aStaticMethod() { //... } } Foo::aStaticMethod(); $classname = 'Foo'; $classname::aStaticMethod(); class Foo { public static $my_static = 'foo'; public function staticValue () { return self::$my_static; } } class Bar extends Foo { public function fooStatic() { return parent::$my_static; } } print Foo::$my_static. "\n"; $foo = new Foo(); print $foo->staticValue(). "\n"; print $foo->my_static. "\n"; // Undefinierte "Eigenschaft" my_static print $foo::$my_static. "\n"; $classname = 'Foo'; print $classname::$my_static. "\n"; print Bar::$my_static. "\n"; $bar = new Bar(); print $bar->fooStatic(). "\n";

18 PHP – OOP (12) K LASSENABSTRAKTION abstract class AbstractClass { // Die abgeleitete Klasse zwingen, diese Methoden zu definieren abstract protected function getValue(); abstract protected function prefixValue($prefix); // Gemeinsame Methode public function printOut() { print $this->getValue(). "\n"; } } class ConcreteClass1 extends AbstractClass { protected function getValue() { return "ConcreteClass1"; } public function prefixValue($prefix) { return "{$prefix}ConcreteClass1"; } } $class1 = new ConcreteClass1; $class1->printOut(); echo $class1->prefixValue('FOO_')."\n";

19 PHP – OOP (13) I NTERFACE (A) // Deklariere das Interface 'iTemplate' interface iTemplate { public function setVariable($name, $var); public function getHtml($template); } // Implementiere das Interface // Dies funktioniert class Template implements iTemplate { private $vars = array(); public function setVariable($name, $var) { $this->vars[$name] = $var; } public function getHtml($template) { foreach($this->vars as $name => $value) { $template = str_replace('{'. $name. '}', $value, $template); } return $template; } }

20 PHP – OOP (14) I NTERFACE (B) Mehrfachvererbung: interface a { public function foo(); } interface b { public function bar(); } interface c extends a, b { public function baz(); } class d implements c { public function foo() { } public function bar() { } public function baz() { } }

21 PHP – OOP (15) O VERLOADING Property overloading void __set ( string $name, mixed $value )mixed mixed __get ( string $name ) mixed bool __isset ( string $name ) void __unset ( string $name ) __set() is run when writing data to inaccessible properties. __get() is utilized for reading data from inaccessible properties. __isset() is triggered by calling isset() or empty() on inaccessible properties.isset()empty() __unset() is invoked when unset() is used on inaccessible properties.unset() The $name argument is the name of the property being interacted with. The __set() method's $value argument specifies the value the $name 'ed property should be set to. Property overloading only works in object context. These magic methods will not be triggered in static context. Therefore these methods can not be declared static.static

22 PHP – OOP (16) O BJEKTITERATION class MyClass { public $var1 = 'Wert 1'; public $var2 = 'Wert 2'; public $var3 = 'Wert 3'; protected $protected = 'protected var'; private $private = 'private var'; function iterateVisible() { echo "MyClass::iterateVisible:\n"; foreach($this as $key => $value) { print "$key => $value\n"; } } } $class = new MyClass(); foreach($class as $key => $value) { print "$key => $value\n"; } echo "\n"; $class->iterateVisible(); var1 => Wert 1 var2 => Wert 2 var3 => Wert 3 MyClass::iterateVisible: var1 => Wert 1 var2 => Wert 2 var3 => Wert 3 protected => protected var private => private var

23 PHP – OOP (17) P ATTERN Factory: class Example { // Die parametrisierte Factorymethode public static function factory($type) { if (include_once 'Treiber/'. $type. '.php') { $classname = 'Treiber_'. $type; return new $classname; } else { throw new Exception ('Treiber nicht g efunden'); } } } // Lade den MySQL Treiber $mysql = Beispiel::factory('MySQL'); // Lade den SQLite Treiber $sqlite = Beispiel::factory('SQLite'); Singleton class Beispiel { // Speichert die Instanz der Klasse private static $instance; // Ein private Konstruktor; verhindert die direkte Erzeugung des Objektes private function __construct() { echo 'Ich bin hergestellt'; } // Die Singleton Funktion public static function singleton() { if (!isset(self::$instance)) { $c = __CLASS__; self::$instance = new $c; } return self::$instance; } // Beispielmethode public function bellen() { echo 'Wuff!'; } // Halte Benutzer vom Klonen der Instanz ab public function __clone() { trigger_error('Klonen ist nicht erlaubt.', E_USER_ERROR); } }

24 PHP – OOP (18) F INAL class BaseClass { public function test() { echo "BaseClass::test() aufgerufen\n"; } final public function moreTesting() { echo "BaseClass::moreTesting() aufgerufen\n"; } } class ChildClass extends BaseClass { public function moreTesting() { echo "ChildClass::moreTesting() aufgerufen\n"; } } // Erzeugt einen fatalen Fehler: Cannot override final method BaseClass::moreTestin g()

25 PHP – OOP (19) C LONE UND V ERGLEICH Clone $obj = new MyCloneable(); $obj2 = clone $obj; Vergleich Vergleichsoperator == Objektvariablen werden verglichen, d.h. gleich wenn Attribute und Instanzen gleich sind Identitätsoperator === 2 Objekte sind identisch wenn sie die selbe Instanz der selben Klasse referenzieren.

26 PHP – OOP (20) T YPE H INTING Nur mit Typen ARRAY und Object class MyClass { public function test(OtherClass $otherclass) { echo $otherclass->var; } public function test_array(array $input_array) { print_r($input_array); } } class OtherClass { public $var = 'Hallo Welt'; }

27 PHP - W EBANWENDUNGEN

28 W EBANWENDUNGEN Quelle: Wikipedia http://de.wikipedia.org/wiki/Webanwendungen

29 W EBANWENDUNGEN – A LTERNATIVE Rich Internet Application Verlagert Programmlogik an den Client JavaScript, ActiveX, Flash, JavaApplets, Silverlight Müssen nicht installiert werden (Out-Of-Box) Aktive Interaktion zwischen Client und BenutzerIn Kommunikation mit Server über HTTP Webservice XML-Schnittstelle Austausch der Daten mit XML

30 W EBANWENDUNGEN – A LTERNATIVE Evolution von HTML bis Web 2.0  Quelle: Daniel SMIDT

31 W EBANWENDUNGEN – „W EB 2.0“ Quelle: adaptivepath.com

32 W EBANWENDUNGEN – „W EB 1.5“ Quelle: : adaptivepath.com

33 W EBANWENDUNGEN – „W EB 2.0“ Quelle: : adaptivepath.com

34 J ETZT GIBT ES NOCH EIN KLEINES BEISPIEL …