PHP 5 - Wat is nieuw

Voorwoord
Nu heb ik nog maar 12 pagina's en dat kunnen er dus meer worden. Bedenk dat ik niet heb gezegd dat ik alle nieuwe dingen in PHP 5 benoem.

Inleiding
In php 5 zijn er veel nieuwe dingen bijgekomen, vooral in het gebeuren van Classes in er zeer veel veranderd. Maar we gaan in deze tutorial ook te maken krijgen met Exeptions, en dat is ook nieuw in PHP 5.

Handleiding Tutorial Lezen
Hoe gaat deze tutorial in z'n werk:
-Ik voeg boven iedere code start.php in.
-Start.php bestaat uit de volgende code:
<?php
header("Content-type: text/plain");
function newline($num = 1, $return = false) {
$to_return = "";
if ($num < 1) {
$num = 1;
}
while ($num != 0) {
$num--;
if ($return == true) {
$to_return .= "\n";
} elseif ($return == false) {
echo "\n";
} else {
$num++;
echo "Error:\nReturn = {$return}\nNum = {$num}";
break;
}
}
if ($return == true) {
return $to_return;
}
}
?>

-Zoals je ziet zal php iedere pagina als een textbestand versturen
-Dat is handig, want ik heb geen zin om met Html te werken

Intro
Laten we maar beginnen met het makkelijkste, he?

Veel php-ers moesten voor php 5 steeds voor iedere class een include te doen. Dat was onhandig af en toe, want sommigen hadden echt een stuk of tien regels met alleen maar include stuff.

In PHP 5 mogen we daar geen last meer van hebben. De mensen die PHP 5 ontwikkeld hebben, hebben nagedacht en ze zijn tot de conclusie gekomen dat je nu een __autoload() functie aan de top van je script mag defineren.

De lange lijst met includes is voorbij, nu krijgen we de lange lijst van $obj = new my_class; ;)

Praktijk
Aangezien de meeste meestal beter leren van voorbeelden, dan van text, ziehier:

Deze code:
<?php
function __autoload($class_name) {
require_once $class_name . '.php';
}

$obj = new MijnClass1();
$obj2 = new MijnClass2();
?>
Is praktisch gezien hetzelfde als deze code:
<?php
require_once 'MijnClass1.php';
require_once 'MijnClass2.php';

$obj = new MijnClass1();
$obj2 = new MijnClass2();
?>

Dat betekent eigenlijk dat je van alles kan aanpassen aan __autoload();
Je zou bijvoorbeeld een switch loop erin kunnen zetten, die met de inkomende $class_name aan de gang gaat.
Of nog mooier, zoiets:
<?php
function __autoload($class_name) {
$keuzes = array('FUNC' => 'functions',
'session' => 'functions',
'board' => 'sources/board',
);
if (!isset($keuzes[ $class_name ])) {
die();
}

require_once "./".$keuzes[ $class_name ].".php";
}
?>

Gebruik het, als het kan, doe er wat mee als je het nuttig vindt. Doe ermee wat je zelf wilt!

Intro
Hier gaan we het hebben over constructors en desctrutors.

Constructors, hadden we al vanaf PHP 3!
Ja, maar die manier kan in PHP 5 ook anders!

Destructor? WTF?
Dat ga ik zo uitleggen ;)

Constructors
Constructors dat was altijd al de functie in een class, die dezelfde naam had ineen class. Maar in php 5 kan het ook (weer ;)) anders!

Deze code:
<?php
class de_CLASS {
__construct() {
echo "Blub zei de vis ";
echo "vanmiddag toen ik ";
echo "naar huis liep";
}
}
$obj = new de_CLASS();
?>
geeft dezelfde output als
<?php
class de_CLASS {
de_CLASS() {
echo "Blub zei de vis ";
echo "vanmiddag toen ik ";
echo "naar huis liep";
}
}
$obj = new de_CLASS();
?>
Het zal allenbij "Blub zei de vis vanmiddag toen ik naar huis liep" geven.

De volgende code zal als output geven: "Mijn cavia zit in de modder."
<?php
class verhaal {
__construct() {
echo "Mijn cavia zit ";
}
}

class cavia extends verhaal {
__construct() {
parent::__construct();
echo "in de modder.";
}
}
$obj = new cavia();
?>

Destructors
Als je al in talen zoals C++ ben bezig geweest zal je destructors vast wel bekend in de oren klinken. De destructor wordt meteen na de constructor geactiveerd. Als je daarna nog iets probeerd zal je een E_NOTICE error krijgen.

De output van het onderstaande script: "In constructor
Destroying MyDestructableClass"
<?php
class MyDestructableClass {
function __construct() {
print "In constructor\n";
$this->name = "MyDestructableClass";
}

function __destruct() {
print "Destroying " . $this->name . "\n";
}
}

$obj = new MyDestructableClass();
?>

:: ?
Ja, ::. Dit is geen nieuw soort MSN Taal voor in PHP, maar de Scope Resolution Operator. Volgens Php.net mag je hem ook Paamayim Nekudotayim noemen. :) Paamayim Nekudotayim betekent 'double colon' in het hebreews, en de naam is gegeven door het Zend Team, dat toen bezig was Zend 0.5 voor PHP 3 te schrijven.

Deze Paamayim Nekudotayim hadden we in PHP 4 al, Sebas!
Ja, dat weet ik, maar net zoals de vorige pagina: Er is iets anders aan.

Waar gebruiken we hem voor?
Met dit token mogen wij de const en static waardes uit classes opvragen.

Voorbeelden "::"
<?php
class MijnClass {
const CONST_WAARDE = 'Een constante waarde';
}

echo MijnClass::CONST_WAARDE;
?>
Het bovenstaande gaat "Een constante waarde" outputten.

Het onderstaande geeft een notice.
<?php
class MijnClass {
const CONST_WAARDE = 'Een constante waarde';
}
$obj = new MijnClass;
echo $obj->CONST_WAARDE;
?>

Met :: moet je ook static functions aanspreken. Over Static ga ik het in de volgende pagina hebben.

Intro
Misschien is een 'compare' goed. Dus ziehier:
- Een gewone class variable wordt pas beschikbaar als je de class heb initiated
- Een static variable is zichtbaar, zelfs al is de class niet initiated. Maar met de object variable kan je een static var niet aanroepen, alleen met ons-rare-naam-tekentje " ::".

Praktijk
Wat ik boven heb neergezet, toen ik eigenlijk nu hieronderaan.
<?php
class IKKE {
public static $ikke = 'Jan';

public function staticwaarde() {
return self::$ikke;
}
}

class JIJ extends IKKE {
public function mijn_waarde() {
return parent::$ikke;
}
}

echo IKKE::$ikke;

newline();
$obj = new IKKE;
echo $obj->staticwaarde();
newline();

echo $obj->ikke;

newline(2);

echo JIJ::$ikke;
newline();

$obj2 = new JIJ;
echo $obj2->mijn_waarde();
newline();

echo $obj2->ikke;
?>
De output van het bovenstaande script:
Jan
Jan
<br />
<b>Notice</b>: Undefined property: IKKE::$ikke in <b>H:\Server\Apache2\htdocs\class\static.php</b> on line <b>46</b><br />


Jan
Jan
<br />
<b>Notice</b>: Undefined property: JIJ::$ikke in <b>H:\Server\Apache2\htdocs\class\static.php</b> on line <b>57</b><br />

Static methodes
Jawel, methodes kunnen ook static zijn.
Kijk maar:
<?php
class vis {
static function blub() {
echo "Bluuub!";
}
}
vis::blub();
?>
Dit zal "Bluuub!" outputten.

Let op: Je kan geen non-static functies aanroepen met ::. Als je dat wel doet, gebeurt er niet veel, behalve dat je een gratis E_STRICT error krijgt.

Intro
In classes kan je ook constants hebben. Deze constants zijn te vergelijken met static, alleen je kan geen constante functies hebben ;)

Praktijk
<?php
class MijnClass
{
const constant = 'constante waarde';

function showConstant() {
echo self::constant . "\n";
}
}

echo MijnClass::constant . "\n";

$class = new MijnClass();
$class->showConstant();
//dit zal twee keer ' constante waarde' outputten'
?>

Intro
Nu gaan we met Type Hinting echt in de richting van talen zoals C++, want Type Hinting is niks anders dan vertellen aan een functie welke input hij mag accepteren.

Praktijk
<?php

class TH {
public function print_name(Persoon $persoon) {
echo $persoon->naam;
}

public function test_array(array $arr) {
print_r($arr);
}
}

class Persoon {
public $naam;
public $leeftijd;
//etc...
}
?>

Het onderstaande zal allemaal werken:
<?php
$type = new TH;
$pers = new Persoon;
$X = new Persoon;
$pers->naam = "Pieter";
$X->naam = "Mr. X";
$array = array('Salpeterzuur' , 'Zwavelzuur', 'Zoutzuur' );

//werkt: een object van Persoon in input van de functie
$type->print_name($pers);

//werkt: een object van persoon in input
$type->print_name($X);

//werkt: een array is input
$type->test_array($array);
?>

Het onderstaande zal juist niet werken:
<?php
class Dier {
public $naam;
public $soort; //type klinkt anders zo 'voorwerpig' ;)
//etc...
}

$dier = new Dier;
$dier->naam = "Fifi";
$dier->soort = "Bulldog";

$type = new TH;
$pers = new pers;
$pers->naam = " Pieter";
$array = " Geen array ";

//werkt niet, string in input en daarom een Fatal Error
$type->print_name($array);

//werkt niet, geen object van de Persoon klasse in input, E_FATAL
$type->print_name($dier);

//werkt niet, geen array in input: E_FATAL
$type->test_array($array);
?>

Dit kan natuurlijk handig zijn.


Note: Ik krijg toch steeds unexpeted T_ARRAY, zelfs met het voorbeeld gekopieerd van php.net en ik heb toch Php 5
Dus kijk niet gek op als je een parse_error krijgt.

Intro
Final vind ik wel een leuke. Want met Final mag je aangeven dat een functie, of zelfs de hele class als het ware 'klaar' is. Dat betekent in php in het geval van een functie dat de functie in de 'child' classes niet meer kan worden hergedefineerd, want dan krijg je een E_FATAL error. In het geval van een final class, kan de class geen 'child' classes meer hebben.

Praktijk
Voorbeeld
<?php
class Dier {
public $naam;
public $type;

function Dier($naam = 'Dier', $soort = 'Dier') {
$this->naam = $naam;
$this->type = $soort;
}

final function beweging($beweging) {
echo "Dier beweegt:";
newline();
echo "Beweging: ".$beweging;
newline();
}

function plassen() { //sorry, maar het een voorbeeld.. mmm?
echo "{$this->type} \"{$this->naam}\" plast";
newline(2);
}
}

class Hond extends Dier {

function Hond($naam = 'Luna', $soort = 'Hond') {
$this->Dier($naam, $soort);
}

function plassen() {
$this->beweging('Poot opheffen');
echo "{$this->type} \"{$this->naam}\" plast";
newline(2);
}

//dit gaat niet en geeft een E_FATAL:
/*
function beweging ($beweging) {
echo "Hond beweegt: {$beweging}";
newline();
}
*/
}
?>

Dit gaat niet werken, want beweging is al Final:
<?php

class vreemd_dier extends Dier {
function beweging ($beweging) {
echo "Zou gaan bewegen: {$beweging}";
newline();
echo "Maar doet het toch niet.";
}
}
?>
Voorbeeld 2:
<?php
final class school {
function school() {
echo "School";
}
}
?>
Dit gaat niet werken, omdat school al de final klasse is:
<?php
class bom extends school {
public $bomba_type;
function bom($type = 'TNT') {
$this->bomba_type = $type;
}
}
?>

Object Iteration
Dit is nu mogelijk in PHP 5 om je $this varaiablen te laten zien met foreach.

Voorbeeld:
<?php
class MyClass
{
public $var1 = 'value 1';
public $var2 = 'value 2';
public $var3 = 'value 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();

?>
Dit output:
var1 => value 1
var2 => value 2
var3 => value 3

MyClass::iterateVisible:
var1 => value 1
var2 => value 2
var3 => value 3
protected => protected var
private => private var

Intro
Dit begint ook op talen zoals C++ te lijken; Exceptions.
Exception werkt met try {} en catch {}
In try mag je iets uitproberen, en in catch vang je het op al het niet lukt.

Praktijk
<?php
try {
$error = 'Always throw this error';
throw new Exception($error);

// Code following an exception is not executed.
echo 'Never executed';

} catch (Exception $e) {
echo 'Caught exception: ', $e->getMessage(), "\n";
}

// Continue execution
echo 'Hello World';
?>

Dit zal "Caught exception: Always throw this error Hello World" geven.
In try{} zou je bijvoorbeeld kunnen proberen te delen met twee ingegeven getallen. Lukt dat niet, geef je dat aan in het catch blok.

Je mag de exception class extenden. Daarom, hier de code van de expetion class:
<?php
class Exception
{
protected $message = 'Unknown exception'; // exception message
protected $code = 0; // user defined exception code
protected $file; // source filename of exception
protected $line; // source line of exception

function __construct($message = null, $code = 0);

final function getMessage(); // message of exception
final function getCode(); // code of exception
final function getFile(); // source filename
final function getLine(); // source line
final function getTrace(); // an array of the backtrace()
final function getTraceAsString(); // formated string of trace

/* Overrideable */
function __toString(); // formated string for display
}
?>

Intro
Het zal heel abstract :p zijn wat ik nu ga zeggen, maar het feit in PHP 5 is dat class abstract kunnen zijn.

Abstract?
Ja. Een class die abstract is gezet, kan geen object van worden gemaakt. De class kan echter wel worden ge-extend, en daar kunnen wel objecten van worden gemaakt.

Praktijk
Je mag dus een class abstract maken. Het heeft de volgende syntax:
abstract class klassenaam {

<?php
abstract class de_basis {
abstract function blub(); //puntkomma ja, geen { }

public function printout() {
echo $this->blub();
}
}
?>
Als je een abstracte class extend, dan moet je alle abstracte functies overnemen.
Zoiets dus:
<?php
class subklasse extends de_basis {
protected function blub() {
return "Blub, dat zei de vis!";
}
}
?>

Als we nu dit doen:
<?php
$obj = new subklasse;
$obj->printout();
?>
is de output "Blub, dat zei de vis!"

Dit is weer een van de vele dingen waarvan jij bepaald of je het nuttig vindt of niet. Oftwel, gebruik je het: Oke! Gebruik je het niet: Ook oke!

Er is veel veranderd in PHP 5. We hebben 'abstract' erg abstract bekeken ;),
we hebben exceptions gezien,
we kennen nu het autoload principe en
we weten van constructors af.

Dus ik hoop dat je het een nuttige tutorial vond, en als dat
niet zo was dat maakt dat mij eigenlijk niet zo uit :p

Verder kan ik je nog twee dingen aanraden:
-Check de manual van PHP.net
-En start anders een nieuw topic(onderwerp)