PHPHypertext Preprozessorhttp://www.php.netVorgestellt durch Daniel SMIDT

GESCHICHTE (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

GESCHICHTE (II) PHP 4 – Zend Engine 1

Ausgabepufferung, Anfängliches „OOP“

PHP 5 – Zend Engine 2 (2004) Mehr OOP

PHP 6 Namespace, mehr OOP

PHP GRUNDSTRUKTUR 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

PHP - EINFÜ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

PHP - EINFÜHRUNG Module – Einfügen bestenhenden PHP Code

in die Anwendung über include(<PATH>) 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

PHP – OOP (1) CLASS class SimpleClass

{    // Deklaration einer Eigenschaft    public $var = 'ein Standardwert';

    // Deklaration einer Methode    public function displayVar() {        echo $this->var;    }}

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

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!

PHP – OOP (4) DESTRUKTOREN UND KONSTRUKTOREN

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();

PHP – OOP (5) SICHTBARKEITEN (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; // Funktioniertecho $obj->protected; // Fataler Fehlerecho $obj->private; // Fataler Fehler$obj->printHello(); // Zeigt Public, Protected und Private

PHP – OOP (6) SICHTBARKEITEN (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; // Funktioniertecho $obj2->private; // Undefiniertecho $obj2->protected; // Fataler Fehler$obj2->printHello(); // Zeigt Public, Protected2, Undefined

PHP – OOP (7) SICHTBARKEITEN (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

PHP – OOP (8) SICHTBARKEITEN (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

PHP – OOP (9) VERBUNG 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'

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();

PHP – OOP (11) STATIC 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";

PHP – OOP (12) KLASSENABSTRAKTION

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";

PHP – OOP (13) INTERFACE (A) // Deklariere das Interface 'iTemplate'

interface iTemplate{    public function setVariable($name, $var);    public function getHtml($template);}

// Implementiere das Interface// Dies funktioniertclass 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;    }}

PHP – OOP (14) INTERFACE (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()   {   }}

PHP – OOP (15) OVERLOADING Property overloading

void __set ( string $name , mixed $value ) mixed __get ( string $name ) 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. __unset() is invoked when unset() is used on inaccessible

properties. 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.

PHP – OOP (16) OBJEKTITERATION 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

PHP – OOP (17) PATTERN 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 gefunden');        }    }}

// 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);    }}

PHP – OOP (18) FINAL 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::moreTesting()

PHP – OOP (19) CLONE UND VERGLEICH 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.

PHP – OOP (20) TYPE HINTING 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';}

PHP - WEBANWENDUNGEN

WEBANWENDUNGEN

Quelle: Wikipedia http://de.wikipedia.org/wiki/Webanwendungen

WEBANWENDUNGEN – ALTERNATIVE

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

WEBANWENDUNGEN – ALTERNATIVE

Evolution von HTML bis Web 2.0 Quelle: Daniel SMIDT

WEBANWENDUNGEN – „WEB 2.0“

Quelle: adaptivepath.com

WEBANWENDUNGEN – „WEB 1.5“

Quelle: : adaptivepath.com

WEBANWENDUNGEN – „WEB 2.0“

Quelle: : adaptivepath.com

JETZT GIBT ES NOCH EIN KLEINES BEISPIEL…