Practical PHP 5.3

Practical PHP 5.3
Nate Abele 2.6.2010 IPC Berlin

Me

• Former lead developer, CakePHP
• Co-founder & current lead developer,
Lithium

• Developing on 5.3 for ~2 years
• Twitter: @nateabele

PHP Renaissance

• Long-awaited features ﬁnalized and
committed

• Resurgence of energy and interest in
evolving the language

• Trunk == iteration on latest stable release

Little Things

• Performance • ext/ﬁleinfo
• Syntax • ext/sqlite3
• Phar • ext/intl
• SPL classes • mysqlnd

Big Things

• Late static binding
• Namespaces
• Lambdas / closures

Late-static binding (LSB)
class Base {
public static function foo() {
$subclass = get_called_class();
// ...do some logic with $subclass...
}
}

class Child extends Base {
public static function bar() {
return static::foo() + 1;
}
}

class Grandchild extends Child {
public static function foo() {
$result = parent::foo();
// ...do some logic with $result...
return $result;
}
}

• static:: ~= $this->

• get_called_class() - the subclass that
invoked the method

• parent:: - same idea you’re used to
• Always use static:: or parent::, self::
etc. breaks the chain


• Attributes still a little “broken”
class A {
public static $message;
}
class B extends A {}
class C extends A {}

B::$message = 'WTF?';
echo C::$message; // echoes 'WTF?'


class A {
}
class B extends A {}
class C extends A {
public static $message = 'Overridden';
}

B::$message = 'WTF?';
echo C::$message; // echoes 'Overridden'


class A {
}
class B extends A {
public static $message = 'Overridden';
}
class C extends A {
}

A::$message = 'WTF?';
echo C::$message; // echoes 'WTF?'

Why?

• Properly architect stateless portions of
apps

• Utility classes
• Immutable state

“Dynamic” statics

• $foo->$bar() vs. Foo::bar()

• $foo = 'Foo';
$bar = 'bar';
$foo::$bar();

• __callStatic()


class Dispatcher {

public function run($url) {
$parameters = Router::match($url);
// ...
}
}

class Dispatcher {

public $router = 'Router';

public function run($url) {
$router = $this->router;
$parameters = $router::match($url);
// ...
}
}

Namespaces

• Finally!
• What’s up with the ?
• Actually “packages”

Namespaces
namespace foobar;

class MyClass {
// ...
}

$class = new foobarMyClass();

// -- or --

use foobarMyClass;
$class = new MyClass();

Namespace
use foobar;
$class = new barMyClass();

namespace me;
$list = new SplDoublyLinkedList();

namespace me;
$list = new SplDoublyLinkedList();

namespace me;
$class = 'foobarMyClass';
$object = new $class();

PSR-0
http://groups.google.com/group/php-standards/web/psr-0-ﬁnal-proposal

PSR-0

• Maps top-level vendor package name to
ﬁlesystem location

• Maps ﬁle names 1:1 with class name

PSR-0
• lithiumcoreLibraries =>
/path/to/classes/lithium/core/Libraries.php

• lithiumLibraries =>
/path/to/classes/lithium/Libraries.php

• LithiumCoreLibraries =>
/path/to/classes/Lithium/Core/Libraries.php

• Lithium_Core_Libraries =>
/path/to/classes/Lithium/Core/Libraries.php

Original (PEAR) Draft

• Requires sub-packages
• Namespaces must be lower-cased and
underscored

Original (PEAR) Draft

• LithiumCore: ?
• lithiumcore: Obviously a namespace
• Sub-packages promote reuse outside
vendor libraries

SplClassLoader

• Concrete implementation of PSR-0
• PHP version:
http://gist.github.com/221634

• C version:
http://github.com/metagoto/splclassloader

Ternary Shortcut

// Old:
public function foo($parameter = null) {
$parameter = $parameter ? $parameter : $this->_calculateDefault();
// ...
}

// New:
public function foo($parameter = null) {
$parameter = $parameter ?: $this->_calculateDefault();
// ...
}

Phar

• include 'phar:///path/to/file.phar/file.php';

• Redistributable apps
• Plugins
• Application templates

Phar

$archive = new Phar("/path/new_file.phar");

$archive->buildFromDirectory(
'/path/to/my/app',
'/.(php|htaccess|jpg|png|gif|css|js|ico|json|ini)$/'
);

$archive->compress(Phar::GZ);

Lambdas & Closures

• Lambda: a function assigned to a variable
• Closure: a lambda, but bound to variables
in the current scope

• This is an extremely big deal

Lambdas & Closures
$names = array(
'Nate Abele', 'David Coallier', 'Cap'n Crunch'
);
$split = array_map(
function($name) {
list($first, $last) = explode(' ', $name);
return compact('first', 'last');
},
$names
);

// Result:
array(
array('first' => 'Nate', 'last' => 'Abele'),
array('first' => 'David', 'last' => 'Coallier'),
array('first' => 'Cap'n', 'last' => 'Crunch')
)

Lambdas & Closures
$names = array('Nate Abele', 'David Coallier', /* ... */);
$filter = array('Nate', 'David');

$mapper = function($name) use ($filter) {
list($first, $last) = explode(' ', $name);
if (!in_array($first, $filter)) {
return null;
}
return compact('first', 'last');
};
$filtered = array_map($mapper, $names);

Lambdas & Closures
$findActive = function($object) use (&$findActive) {
if ($object->isActive) {
return $object;
}
if ($object->children) {
foreach ($object->children as $child) {
return $findActive($child);
}
}
};

Lambdas & Closures
class SomeWebService {

public function call($data) {
$request = new HttpRequest();
// Configure $request...
$result = $request->send();
// Do some processing...
// Update $request for next operation...
$final = $request->send();
// Post-process $final to extract some value
return $someExtractedValue;
}
}

Lambdas & Closures
class SomeWebService {

public function call($data, $pre = null, $post = null) {
$request = new HttpRequest();
// ...
if ($pre) {
$request = $pre($request);
}
$result = $request->send();

if ($post) {
$result = $post($result);
}
// ...
$final = $request->send();
// ...
}
}

Lambdas & Closures
class Database {

public $callThisOnEveryRead;

public function read($query) {
if ($callback = $this->callThisOnEveryRead) {
$callback($query);
}
// ...
}
}

Lambdas & Closures
class Database {

public $callThisOnEveryRead;

if ($callback = $this->callThisOnEveryRead) {
$result = $callback($query)
if ($result !== null) {
return $result;
}
}
// ...
}
}

Referential Transparency
• Only needs parameters to calculate a
return value (i.e. no $_*, $this or date(),
etc.)

• Doesn’t produce any side-effects
• No modiﬁcations outside current scope
• No references
• No , , etc.
echo headers()

Method Filters

class Database {

// ... run the query ...
return $result;
}
}

Method Filters

class Database {

$method = function() {
return $result;
};
}
}

Method Filters

class Database {

$method = function($query) {
return $result;
};
return $method($query);
}
}

Method Filters

class Database extends lithiumcoreObject {

$method = function($self, $params) {
return $result;
};
return $this->_filter(
__METHOD__, compact('query'), $method
);
}
}

Method Filters
$database = new Database($connectionDetails);

$database->applyFilter('read', function($self, $params, $chain) {
$key = md5(serialize($params['query']));

if ($result = Cache::read($key)) {
return $result;
}

$result = $chain->next($self, $params, $chain);
Cache::write($key, $result);
return $result;
});

lithiumutilcollectionFilters

outer

inner

read()

AOP in a Nutshell

• Obliviousness
• Eliminates boilerplate code per class
relationship

• Centralized conﬁguration of concerns

Thanks!

• nate.abele@gmail.com
• @nateabele
• http://lithify.me/

Practical PHP 5.3

More Related Content

What's hot

Viewers also liked

Similar to Practical PHP 5.3

Recently uploaded

Practical PHP 5.3