En heeft een hele hoop nieuwe functies, improvements, bug fixes etc etc...
Maar een van de key features is wel: namespaces
Wat is een namespace?
Simpel gezegd is een namespace een container, een dimensie in je 'landschap', een scope.
We kennen allemaal de globale scope, gegeven het volgende script:
PHP-code:
<?php
$var = 'global scope';
?>
Is de variabele $var gedefinieerd in de global scope.
Hier nog wat extra voorbeelden van definities en welke scope erbij hoort:
PHP-code:
<?php
namespace my/space;
$var = 'namespace scope';
function my_func()
{
$var = 'function scope';
}
class MyClass
{
public static $foo = 'class scope';
public $bar = 'object scope';
public function __construct()
{
$var = 'function scope';
}
}
?>
Stel, we saven voorgaande code in het bestand 'namespace.php' en includen het vanuit een ander php-bestand zullen we de class MyClass op de volgende manier moeten instantiëren:
PHP-code:
<?php
$my_class = new /my/space/MyClass();
?>
Het zal met name voor grotere projecten interessant zijn waarbij frameworks en andere 3rd party software gebruikt wordt. Je hebt nu namelijk eindelijk de mogelijkheid om bijvoorbeeld twee keer de klasse MyClass te definiëren, in verschillende namespaces.
Veel developers gebruiken eigenlijk al namespaces zonder het te weten. Voor wie mijn tute 'Package support voor PHP' heeft gelezen, eigenlijk is dat ook een verkapte vorm van namespaces, alleen wordt het niet geforceerd door de php engine. Namespaces zul je vaak ook op dezelfde manier gebruiken als dat de import() functie doet, en ook de bijbehorende directory structuur behouden.
Genoeg theorie, code willen we zien!
Hoe definiëer je een namespace en hoe gebruik je ze?
Zoals in het code-voorbeeld hierboven te zien is definiëer je een namespace dmv het namespace-keyword. De namespace declaratie moet altijd als eerste in je bestand staan (er is echter één uitzondering:
declare(), maar daar zal ik nu verder niet op in gaan). Wat na de namespace declaratie volgt wordt allemaal gevat in de namespace.
Voorbeeld namespace declaratie:
PHP-code:
<?php
namespace my/space;
class MyClass
{
}
?>
We definiëren hier de namespace my\space met daarin een class MyClass. Het gebruik van de class kan op de volgende manieren:
PHP-code:
<?php
$my_class = new /my/space/MyClass();
// of op de volgende manier:
use /my/space/MyClass;
$my_class = new MyClass();
// of:
use /my/space/MyClass as Foo;
$my_class = new Foo();
?>
We zien hier drie verschillende manieren om de class te instantiëren. Ik zal over alle drie wat uitleg geven.
Zie namespaces als een bestandssysteem, waarbij je het 'pad' aangeeft naar een bepaalde 'file', of in namespace taal: de package structuur naar een bepaalde class.
Volledig uitgeschreven class name
Door een class name te prefixen met zijn namespace heb je een directe ingang naar de class.
Bestandssysteem voorbeeld: Stel, je staat in de hoofdmap C:\ en wilt toegang tot het bestand C:\documenten\violentj\bestand.txt, dan roep je die aan als documenten\violentj\bestand.txt
Het 'use' keyword
Met het use keyword geef je aan welke specificatie je uit een bepaalde namespace wilt gebruiken.
Bestandssysteem voorbeeld: het use statement komt een beetje neer op het toevoegen van C:\document\violentj aan je PATH.
Het 'use ... as' keyword
Dit doet hetzelfde als gewoon 'use' gebruiken, maar maakt een alias aan voor de specifieke class.
Stel, je zit in de namespace \my\space waar een klasse MyClass is gedefiniëerd, maar je wilt ook een MyClass gebruiken uit de namespace \my\other\space kun je dat op de volgende manier doen:
PHP-code:
<?php
namespace my/space;
class MyClass
{
}
use /my/other/space/MyClass as MyOtherClass;
$my_class = new MyClass(); // $my_class IS_A /my/space/MyClass
$my_class = new MyOtherClass(); // $my_class IS_A /my/other/space/MyClass
?>
Er is ook een nieuwe 'magic' constant toegevoegd: __NAMESPACE__.
Deze werkt op dezelfde manier als bijv. __FUNCTION__, __METHOD__ of __FILE__. Binnen een namespace zal hij altijd de naam van de namespace bevatten:
PHP-code:
<?php
namespace my/space;
echo __NAMESPACE__; // outputs: my/space
?>
Gegeven de volgende code:
PHP-code:
<?php
namespace my/space;
$foo = array('index 0', 'index 1');
$bar = implode('.', $foo);
?>
Deze code zal een fout opleveren, iets als: could not find function \my\space\implode()
Dit is volstrekt logisch gezien we aangegeven hebben ons in de namespace \my\space te bevinden en daar geen functie implode() hebben gedefiniëerd. We zullen de implode() functie dus op de volgende manier aan moeten roepen:
PHP-code:
<?php
namespace my/space;
$foo = array('index 0', 'index 1');
$bar = /implode('.', $foo);
?>
Met de \ geven we aan de global scope te willen gebruiken.
Zo, ik geloof dat dit wel een aardig stukje basis informatie is omtrent de nieuwe namespace functionaliteit in PHP5.3.
Er zijn nog een aantal andere, hele interessante, nieuwe features zoals Late Static Binding en Closures, hier zal ik eventueel later nog wat over schrijven. Voor nu lijkt dit me genoeg
Zoals gezegd, dit is voornamelijk basis informatie, voor alle details zie:
http://php.net/namespaces
Ik hoop dat het duidelijk is en leerzaam!
Vragen/feedback/suggesties zijn natuurlijk altijd welkom!
- Dennis
Zoeken
Ledenlijst
Kalender
Help
