1 | CLASES

1.1 Constructores
Siempre construye
En PHP5, una clase puede tener un slo constructor. Si se ha declarado un mtodo __construct y un mtodo del mismo nombre que la clase (un constructor en PHP4), se ignora este ltimo como constructor. Una funcin constructora siempre construye y devuelve un objeto implcitamente. El mtodo no debe devolver ningn valor, y en caso de hacerlo se ignora y se devuelve un nuevo objeto.

class foo { function __construct() { echo "construido en PHP5 como "; return 5; } function foo() { echo "construido como en PHP4 como "; } } $bar = new foo(); echo " ", get_class($bar);

Construido en PHP5 como foo Observa que el constructor empleado es el mtodo __construct, y que el valor devuelto, el nmero 5, se ignora completamente. Ten en cuenta, este comportamiento a la hora de implementar algunos patrones como singleton, factora, etc.

1.2 Destructores
Destruir un objeto
En PHP se puede destruir un objeto y cualquier variable usando la funcionunset(variable). Si queremos que al destruir un objeto se realicen ciertas operaciones especiales,como por ejemplo cerrar una conexin abierta, debemos implementar en la clase el mtodo __destruct.
El mtodo _destruct no puede recibir argumentos

PHP recoge la basura

PHP 5 consta de lo que se llama un recolector de basura para variables. Si creamos una variable, esta ser destruido una vez todas las referencias a ese variable sean removidas. Observa esta secuencia:
class unaClase { function __construct() { echo "He sido construido"; } function __destruct() { echo " y destruido"; } } function foo() { $referencia = new unaClase(); } foo(); echo "..y la vida sigue";

He sido construido y destruido..y la vida sigue Observa que dentro de la funcin foo se construye el objeto. Al terminar la funcin, PHP5 recoge la basura: destruye el objeto ya que se trata de una variable local que dejar de existir al terminar la funcin), y sigue con la ejecucin del script.

1.3 Asignaciones y clones

Asignacin y clonacin de objetos
Si asignamos a una variable un objeto ( $var = objeto) no creamos un nuevo objeto, sino que la variable apunta o hace referencia al objeto que ya existe. Para crear una copia de un objeto debemos clonarlo. Observa este cdigo:
class SimpleClass { public $nombre; function __construct( $nombre){ $this->nombre= $nombre; } } $original $asignado $clon $referencia = new SimpleClass("A"); = $original; = clone $original; =& $original;

$original->nombre ="B"; echo "original=" , $original->nombre;

echo " referencia=", $referencia->nombre; echo " asignado=" , $asignado->nombre; echo " clon=" , $clon->nombre;

original=B referencia=B asignado=B clon=A En este ejemplo, creamos a partir de un original tres objetos. Fjate que al cambiar el original, el objeto creado por asignacin y por referencia quedan modificados; el clon, no.

1.4 Operador ::
Propiedades de clase
En PHP 5, el operador :: se aplica para hacer referencia a una propiedad o mtodo de una clase.
El operador -> requiere de un objeto (prefijo $) y :: de una clase (sin prefijo). class Animal { .. } // Animal es una clase no un objeto. Animal::sonido() // contador es una propiedad esttica. Animal::$contador ;

Cuando referenciamos propiedades de clase estas tienen que ser estticas. Si invocamos un mtodo, no existe el objeto $this.
class Animal { static private $contador=0; public $sonido; function __construct ( $sonido) { self::$contador++; $this->sonido= $sonido; } function sonido(){ if (isset( $this ) ){ echo $this->sonido, " ", $this->sonido, " "; } else { echo "tenemos " . self::$contador . " animales ". "pero no se que ruido hacen."; } } } $miPerro = new Animal("guau");

$miGato

= new Animal("miau");

$miGato->sonido(); $miPerro->sonido(); Animal::sonido();

miau miau guau guau tenemos 2 animales pero no se que ruido hacen. Para que el mtodo sonido funcione hemos tenido que hacer un test ( $this) ) para comprobar que tenemos un objeto.

isset (

1.5 self vs $this

Referencia self
Dentro de la definicin de un clase podemos hacer referencia a la clase haciendo uso del self. Podemos invocar mtodos, y acceder a las propiedades estticas de la clase. Si intentamos acceder una propiedad no esttica se genera un error.
self

no lleva dolar, pero las propiedades accedidas s, como por ejemploself::$contador

class Animal { static private $animalesCreados = 0; public $nombre; function __construct ( $nombre) { self::$animalesCreados++; $this->nombre = $nombre; } function contador(){ return self::$animalesCreados; } } $miPerro = new Animal("perro"); $miGato = new Animal("gato"); echo "Total animales creados: " .Animal::contador();

Total animales creados: 2 La propiedad $animalesCreados es comn para todos los objetos creados. Para consultar dicha propiedad podemos hacer: $miGato->contador() , $miPerro>contador() o utilizar la referencia a la clase Animal::contador()que no requiere ningun objeto para invocar el mtodo.

1.6 Constantes de clase

Definir constantes
Una clase puede tener sus propias constantes, que sern accesibles como propiedades de un objeto, o la forma mas recomendable usando el operador :: aplicado a la clase. Las propiedades constantes no se preceden con $ Para definir una propiedad constante basta con anteponer la palabra declaracin de la misma.
class miTrigometria { const public PI = '3.14'; function getPI() { return self::PI; // ejemplo de uso con self } } $oTrigo = new miTrigometria(); echo miTrigometria::PI," ", $oTrigo->PI;
const

a la

3.14 3.14

1.7 Extender clases

Personas, bomberos y fontaneros
Consideremos a las personas como instancias de la clase Persona. Ahora consideremos a los bomberos: son personas, pero especializadas. En PHP5 esto se programara asi:
class Persona{ public $nombre; function __construct($nombre){ $this->nombre = $nombre; echo " Ya tenemos una persona mas"; } function andar(){ echo " un pasito, otro pasito.."; } function habilidades(){ echo " comer, beber, dormir, andar.."; }

} class Bombero extends Persona { function sirena(){ echo " piu..piu..piuo"; } function habilidades(){ echo " comer, beber, dormir, .ah, y apagar fuegos"; } } $irene= new Bombero("irene"); $irene->existe(); $irene->sirena(); $irene->habilidades();

La clave del cdigo esta en la declaracin de la clase bombero:

class Bombero extends Persona {..

Ahora tenemos un objeto bombero, que puede hacer todo lo que hacen los objetos personas (andar) pero tiene funciones propias (sirena) y adems tiene su propia versin de otras funciones (habilidades).

1.8 Clases abstractas

Clases abstractas
En PHP5 una clase abstracta ( definida simplemente como abstract class) es una clase que contiene un modelo de clase. No se pueden instanciar objetos de la clase. Se pueden extender la clase y las nuevas clases deberan implementar los mtodos definidos en la clase abstracta. Aqu tienes un ejemplo: tenemos la clase abstracta Animal, que en realidad define las propiedades y mtodos que todo Animal (gato, perro, vaca) deberan tener:
abstract class Animal { public $tipo; function sonido(){ } function queHaceTodoElDia(){

/* nota: no se considera adecuado implementar un mtodo en un clase abstracta. */ echo "algo "; } } class Perro extends Animal { function sonido(){ echo "guau guau "; } function tiraLeUnHueso(){ echo "ahi va ese huesito"; } } class Gato extends Animal { function sonido(){ echo "miau miau "; } function queHaceTodoEldia(){ echo "dormir "; } } $miPerro = new Perro(); $miGato = new Gato(); // $miAnimal = new Animal(); no permitido $miPerro->sonido(); $miPerro->queHaceTodoElDia(); $miPerro->tiraLeUnHueso(); echo "<br>"; $miGato->sonido(); $miGato->queHaceTodoElDia();

guau guau algo ahi va ese huesito miau miau dormir Observa, el comportamiento de los mtodos. En la clase Perro se ha aadido un mtodo nuevo, implementado un mtodo abstracto, y otro ha quedado tal cual. En Gato, se han implementado los dos mtodos abstractos.

1.9 Interface
Declarar una interface

Una interface es una declaracin que dice que mtodos debera tener una clase. Las interface no son clases, y las clases no se extienden sino que se implementan.
interface Animal { function sonido(); function queHaceTodoElDia(); }

Si incluimos una propiedad o el cuerpo de un mtodo se produce un error. Para implementar una interface hacemos:
class Perro implements Animal { ...

Tenemos que implementar todos los mtodos de la interface. Si olvidamos uno, se genera un error. Podemos aadir propiedades y nuevos mtodos. Observa el ejemplo completo
interface Animal { function sonido(); function queHaceTodoElDia(); } class Perro implements Animal { function sonido(){ echo "guau guau "; } function tiraLeUnHueso(){ echo "ahi va ese huesito "; } function queHaceTodoEldia(){ echo "jugar "; } } class Gato implements Animal { function sonido(){ echo "miau miau "; } function queHaceTodoEldia(){ echo "dormir "; } } $miPerro = new Perro(); $miGato = new Gato(); $miPerro->sonido(); $miPerro->queHaceTodoElDia(); $miPerro->tiraLeUnHueso(); echo "<br>"; $miGato->sonido(); $miGato->queHaceTodoElDia();

guau guau jugar ahi va ese huesito miau miau dormir

1.10 Evitar herencia: final

Control sobre las clases extendidas
Cuando una clase hija extienda otra clase padre, puede redefinir todos los mtodos que quiera. A veces, es deseable impedir este mecanismo. Para ello basta con usar la palabra reservada final delante del mtodo que queremos proteger. PHP no permite aplicar final a propiedades. Tambin podemos usar final delante de la definicion de class para impedir extender la clase.
class Persona { final function hola() { echo "hola"; } } class Bombero extends Persona { function sirena () { echo "biu biu biu" ; } NO VALIDO function hola() {} } final class CamionBombero { .. } NO VALIDO class miCamionBomberos extends CamionBombero{..}

1.11 Mtodos mgicos

Qu son los mtodos mgicos
En PHP hay ciertos nombres de funciones especiales, como por ejemplo__construct y __desctruct, que llevan como prefijo distintivo una doble barra baja. La mayora de estas funciones tienen un papel especial dentro de la definicin de clases, por lo que a menudo reciben el nombre de mtodos mgicos. La lista completa es:

__call

__get __set __isset __unset __sleep __wakeup __toString __clone __autoload

__clone (mtodo)
Cuando se clona un objeto se realiza un copiado de memoria. Eso no asegura que el objeto resultante funcione correctamente si se trata de un objeto que requiera un conexin o realizar alguna inicializacin por ejemplo o hace uso de variables de sesin.

__autoload (funcin)
Si defines una funcin __autoload esta funcin sera invocada por PHP5 cada vez que se encuentra con una clase cuya definicin no ha sido cargada. Este sencillo mecanismo evita el uso constante de include.

__set y __get
En PHP, los objetos tienen propiedades dinmicas. Si asigno un valor a una propiedad no existente, esta se crea para mi objeto. Implictamente, cada objeto tiene un mtodo para asignar una propiedad, y otra para consultar: se trata de obj->propiedad = algo, y obj->propiedad. Podemos ver estas dos construcciones del lenguaje como si fueran dos mtodos. Con el mtodo __set crearemos nuestra propia funcin para asignar propiedades a los objetos, y con __get para consultarlos.

class Coche { public $propiedadesExclusivas;

__construct ( $lista){ $propiedadesExclusivas = $lista; }

public function __get( $propiedad ) { if (isset($this->propiedadesExclusivas[$propiedad])) {

return $this->propiedadesExclusivas[$propiedad]; } else { return "pues va a ser que no"; } }

public function __set($propiedad, $valor) { $this->propiedadesExclusivas[$propiedad] = $valor; } }

$seatPanda = new Coche ( array("color"=>"rojo"); $seatPanda->color = "amarillo"; echo $seatPanda->tieneABS;

1.12 Serialize
Serializar un objeto
En PHP serialize una variable significa codificar la variable como un cadena de carcteres. El proceso de volver a crear la variable a partir de la cadena codificada se llama unserialize.

Estos procesos se aplican por ejemplo: al guardar un objeto en un fichero (serialize) o recuperar un objeto previamente guardado (unserialize) al enviar un objeto va http en una aplicacin AJAX, o al recibir un objeto previamente serializado

Dormir (__sleep ) y despertar ( __wakeup)

Cuando se serializa un objeto, PHP comprueba si la clase posee un mtodo llamado __sleep, y en tal caso lo ejecuta. Se usa ,por ejemplo, en la conexiones para cerrar la conexin, o grabar los datos pendientes. De manera similar, cuando se unserializa un objeto, se comprueba si hay un mtodo __wakeup, y se ejecuta si la hubiere. Con ello podemos reabrir una conexin, abrir un fichero, etc.

2 | PATRONES SIMPLES

2.1 Patrones Gang of Four

Design Patterns
A principios de los aos noventa se publica el libro Design Patterns escrito por Erich Gamma, Richard Helm, Ralph Johnson y John Vlisides, conocidos como la banda de los cuatro (Gang of four). En l, se recogan 23 patrones de programacin. Un patrn es una solucin que se da una problema muy general de programacin. Por ejemplo, el patrn Singleton es la solucin al problema de querer instanciar un solo objeto de una clase. El patrn no entra en detalles tales como si el objeto es un servidor grfico, o una conexin a base de datos, o una peticin AJAX. Los patrones del libro, conocidos por patrones GoF, son: Patrones creacionales Singleton Factora Builder Mtodo factora Prototype Patrones Estructurales Adapter (Adaptador) Bridge (Puente) Composite (Objeto compuesto) Decorator (Envoltorio) Facade (Fachada) Flyweight (Peso ligero) Proxy: Patrones de comportamiento Chain of Responsibility (Cadena de responsabilidad) Command (Orden) Interpreter (Intrprete) Iterator (Iterador) Mediator (Mediador) Memento (Recuerdo) Observer (Observador) State (Estado): Strategy (Estrategia): Template Method (Mtodo plantilla): Visitor (Visitante)

2.2 Patrn singleton

Un solo objeto
El patrn Singleton se utiliza cuando se tiene que crear una nica instancia de un objeto. Por ejemplo, tenemos una conexin a un servidor, y queremos asegurarnos de que solo se realiza una nica conexin. Lo primero que hay que evitar es que se puedan crear instancias del objeto. Eso se consigue declarando el constructor como privado. Ahora, estamos obligados a implementar un mtodo que deber: crear un objeto si comprueba que no existe un previo, y devolver el objeto. Tienes aqu el cdigo resumido:
class Singleton { static private $instancia = NULL; private function __construct() {} static public function getInstancia($cual) { if (self::$instancia == NULL) { self::$instancia = new Singleton(); } return self::$instancia; } } $objetoSingleton = Singleton::getInstance()

An tenemos un problema a resolver: impedir que se pueda clonar el objeto Singleton. Tendremos que implementar el mtodo clone, para lanzar un error en caso de clonar.
public function __clone() { trigger_error('Clone no esta permitido.', E_USER_ERROR); }

Aplicar a una clase

Si tenemos una clase y queremos aplicar el patrn Singleton hacemos lo siguiente:
class Ejemplo { // Guardamos una instancia de la clase private static $instance; // el constructor privado impide new private function __construct() { echo 'existo';

} // No permitimos la clonacion public function __clone() { trigger_error('Clone no esta permitido.', E_USER_ERROR); } // creamos el mtodo singleton public static function singleton() { if (!isset(self::$instance)) { // con este pequeo truco nuestro cdigo // funciona en cualquier clase. $c = __CLASS__; self::$instance = new $c; } return self::$instance; } // Example method public function foo() echo 'foo!'; } } $nuevo = ejemplo::singleton(); {

2.3 Patrn Factora

Fabricacin de objetos
El patrn de factora se utiliza cuando necesitamos crear objetos de diferentes clases. Por ejemplo, tenemos un formulario al que queremos aadir controles del tipo comentario, del tipo familia de radios etc. Este otro ejemplo, desarrolla un factora de vehculos. Tenemos que gestionar un parque de vehculos que sern de diversos tipos: coches, motos y camiones:
.. class vehiculo { private function __construct(){ } static function fabricar($tipo){ switch ( $tipo ){ case "moto" : return new Moto(); case "coche" : return new Coche(); case "camion": return new Camion(); } } }

$coche = vehiculo::fabricar("coche"); echo get_class($coche);

Coche En el ejemplo, se declara el constructor como privado ya que no queremos instancias de vehculo.

Factora abstracta
Se pueden crear factoras abstractas. La idea es la siguiente: tengo que construir un programa con ventanas y controles para distintas plataformas: Linux, Mac y Windows. El problema es que en cada una de ellas las funciones para gestioanr ventanas y controles se llaman de manera distinta. Puedo crear una factoria abstracta, llamada factoriaVentanas, que se encargar de llamar a la funciones adecuadas para cada plataforma.
// entorVentanas es una factoria abstracta. if ( $entorno=="MAC") { $ventana = new entornoVentanas("mac"); } else { $ventana = new entornoVentanas("linux"); } // ahora me da igual estar en un entorno mac o // linux. La programacion es la misma. $ventana->abrirVentana(); $ventana->anadirControl();

Aqui tienes otro ejemplo. Hemos desarrollado un juego de marcianos y le hemos hecho separando la lgica del juego (calcular donde va mi nave, por donde aparecen los marcianos) de la presentacin. As podemos jugar al mismo juego en 2D y 3D, o hacer algo mucho mas til: probar el juego con distintos motores 3D.
class marciano3D { function mostrar(){ echo "soy un marciano en 3D "; } } class marciano2D { function mostrar(){ echo "soy un marciano en 2D "; } } class nave3D { function mostrar(){ echo "soy una nave en 3D "; } } class nave2D {

function mostrar(){ echo "soy un mave en 2D "; } } class factoria{ private $marciano, $nave; function __construct( $claseMarciano, $claseNave ){ $this->marciano= $claseMarciano; $this->nave = $claseNave; } function crear( $que ){ switch ( $que){ case "marciano": return new $this->marciano; case "nave" : return new $this->nave; } } } $juego2D= new factoria("marciano2D", "nave2D"); $juego3D= new factoria("marciano3D", "nave3D"); $marcianoA = $juego2D->crear("marciano"); $marcianoA->mostrar(); $marcianoB = $juego3D->crear("marciano"); $marcianoB->mostrar();

Observa que al crear cada factora indicamos que clases debe usar.

2.4 Patrn Builder

Mano de obra especializada
El patrn "Builder" tiene cierto parecido con la factora abstracta, pero esta ms enfocado en producir objetos de una determinada clase. Queremos producir la misma clase de objetos creados por distintos especialistas. En el ejemplo, extrado de la wikipedia, se trata de fabricar pizzas. Una cocina ( el papel del director ) dispone de varios operarios capaces de crea pizzas de distinto tipo.
/* * fuente: wikipedia. * URL: http://es.wikipedia.org/wiki/ Builder_(patr%C3%B3n_de_dise%C3%B1o) * autor Ber (java) * adaptado php: roger. */ /** Objetos a contruir : pizzas */

class Pizza private private private

{ $masa = ""; $salsa = ""; $relleno = "";

function setMasa($masa) { $this->masa = $masa; } function setSalsa($salsa) { $this->salsa = $salsa; } function setRelleno($relleno){ $this->relleno = $relleno; } function servir(){ echo "<p>Pizza de masa {$this->masa}, "; echo "salsa {$this->salsa} y con "; echo "{$this->relleno} de relleno</p>"; } } /** los especialistas abastractos. */ abstract class PizzaBuilder { protected $pizza; function getPizza() { return $this->pizza; } function crearNuevaPizza() { $this->pizza = new Pizza(); } /* cada especialista debe implementar estos mtodos */ abstract function buildMasa(); abstract function buildSalsa(); abstract function buildRelleno(); } /** un especialista para pizzas hawaianas */ class HawaiPizzaBuilder extends PizzaBuilder { function buildMasa() { $this->pizza->setMasa("suave"); } function buildSalsa() { $this->pizza->setSalsa("dulce"); } function buildRelleno() { $this->pizza>setRelleno("chorizo+alcachofas"); } } /** otro especialista para pizzas picantes */ class PicantePizzaBuilder extends PizzaBuilder { function buildMasa() { $this->pizza->setMasa("cocida"); } function buildSalsa() { $this->pizza->setSalsa("picante"); } function buildRelleno() { $this->pizza>setRelleno("pimienta+salchichn"); } } /** La cocina como personaje Director */ class Cocina { private $pizzaBuilder; function setPizzaBuilder($pb) { $this->pizzaBuilder = $pb; } function getPizza() { return $this->pizzaBuilder>getPizza(); } function construirPizza() { $this->pizzaBuilder->crearNuevaPizza(); $this->pizzaBuilder->buildMasa(); $this->pizzaBuilder->buildSalsa(); $this->pizzaBuilder->buildRelleno(); }

} /** Ponemos en marcha la cocina */ $cocina = new Cocina(); $hawai_pizzabuilder = new HawaiPizzaBuilder(); $picante_pizzabuilder = new PicantePizzaBuilder(); /** Un cliente pidiendo una pizza. */ $cocina->setPizzaBuilder( $hawai_pizzabuilder ); $cocina->construirPizza(); $cocina->getPizza()->servir(); /** Otro cliente pidiendo una pizza. */ $cocina->setPizzaBuilder( $picante_pizzabuilder ); $cocina->construirPizza(); $cocina->getPizza()->servir();

Pizza de masa suave, salsa dulce y con chorizo+alcachofas de relleno Pizza de masa cocida, salsa picante y con pimienta+salchichn de relleno

2.5 Fabricacin mediante prototipos

Clonacin
Este patrn de diseo simplifica la fabricacin o creacin de objetos mediante una serie de prototipos que se van clonando. Es adecuado cuando tienen que generarse objetos de una misma clase y se desea simplificar la creacin mediante una serie de modelos o prototipos.
// Los productos deben implementar esta interface interface Producto { function __clone(); } class UnProducto implements Producto { private $atributo; function __construct($atributo) { $this-&gt;atributo = $atributo; } function __clone() { return new UnProducto( $this-&gt;atributo); } function show() { echo $this-&gt;atributo . "&lt;br&gt;"; } }

// La clase encargada de generar objetos a partir de los prototipos class FactoriaPrototipo { private $mapaObjetos; function __construct() { $this-&gt;mapaObjetos["productoTipo1"] = $this-&gt;mapaObjetos["productoTipo2"] = } new UnProducto(1); new UnProducto(2);

function create($nombre) { return ( isset($this-&gt;mapaObjetos[$nombre]) ? clone $this&gt;mapaObjetos[$nombre] : Null); } } // Test de unidad $factoria = new FactoriaPrototipo(); $producto = $factoria-&gt;create("productoTipo1"); $producto-&gt;show(); $producto2 = $factoria-&gt;create("productoTipo2"); $producto2-&gt;show();

2.6 Lazy initialization

Creacin perezosa de objetos
Este patrn se preocupa de no crear nuevos objetos si ya existen otros similares; de no inicializar una propiedad hasta que esta no se consulte, etctera. Se utiliza cuando la creacin o el calculo de una propiedad puede llevar un tiempo excesivo. Por ejemplo, si realizamos una consulta SQL, calcular el nmero de registros devueltos, supondra leerlos todos. Podemos, demorar dicha accin, hasta que realmente se nos pida ese dato. Tambien podremos crear caches de objetos: si un nuevo objeto es igual a uno pedido recientemente, devolvemos este.
class Fruta { private static $mapa; private $tipo; // constructor privado para evitar creacin private function Fruta($tipo) { $this->tipo = $tipo; } public static function get($tipo) { if ( !isset( Fruta::$mapa[$tipo] ) ){ Fruta::$mapa[$tipo] = new Fruta ($tipo); } return Fruta::$mapa[$tipo] ; } public function show(){ echo $this->tipo . "<br>"; } }

$pera = Fruta::get("pera"); $manzana= Fruta::get("manzana"); $pera->show(); $manzana->show();

2.7 Patrn del observador

El objeto indiscreto
Este patrn se utiliza cuando necesitamos que un objeto observe a otro. Esto significa, que al cambiar los datos de objeto, o al ser creado, el observador es notificado. Este patrn presenta un problema de orden lgico: que se define antes? el observador, que tendra que saber previamente que observa, o lo observado que tiene que hacer referencia a un observador existente? En PHP es fcil desarrollar este patrn de manera robusta si se definen primero dos interfaces, una para el observador y otro para lo observable.
// fuente: http://www.ibm.com/developerworks/ library/os-php-designptrns/ interface IObserver { function onChanged( $sender, $args ); } interface IObservable { function addObserver( $observer ); } class UserList implements IObservable { private $_observers = array(); public function addCustomer( $name ) { foreach( $this->_observers as $obs ) $obs->onChanged( $this, $name ); } public function addObserver( $observer ) { $this->_observers []= $observer; } } class UserListLogger implements IObserver { public function onChanged( $sender, $args ) {

echo( "'$args' added to user list\n" ); } } $ul = new UserList(); $ul->addObserver( new UserListLogger() ); $ul->addCustomer( "Jack" ); $ul->addCustomer( " y otro mas" );

'Jack' added to user list ' y otro mas' added to user list

3 | PEAR

3.1 Libreria PEAR

PEAR son las siglas de PHP Extension and Application Repository (aunque algunos prefieren sustituir Application por Add-on). Se trata de una biblioteca de funciones de cdigo abierto escrito en PHP, similar a CPAN de Perl. En la actualidad, julio de 2009, cuenta con una 534 librerias, que en PEAR se llaman paquetes que abarcan desde gestores de correo, base de datos, html, hasta formularios.

Instalacin
PEAR se puede instalar con la mayora de distribuciones Linux. Funciona como una especie de "apt-get": incluso necesitas permisos de root para algunas operaciones. Para instalar un determinado paquete, o listar los paquetes instalados tendremos que hacer:
pear install Numbers_roman pear list

Los paquetes se instalarn en un directorio local, que en Ubuntu es usr/share/php. Adems, se prepara el entorno de PHP para incluir el este directorio dentro del PATH de los include. Si podemos instalar PEAR en el servidor, podemos optar por un mtodo mas rudimentario: copiar los paquetes a nuestro servidor web, en una carpeta llamado include/pear y cargar los paquetes manualmente.

4.2 gettext con PHP

Soporte de PHP
Desde la versin 4, PHP soporta nativamente la funcin gettext y las funciones auxiliares para establecer el locale, dominios, etctera.

// Definir idioma Alemn setlocale(LC_ALL, 'de_DE');

// Especificar la ubicacin de las tablas de traduccin bindtextdomain("miAplicacionPHP", "./locale");

// Elegir dominio textdomain("miAplicacionPHP"); /* Ahora, la traduccin busca en ./locale/de_DE/LC_MESSAGES/miAplicacionPHP.mo */

// Imprimir un mensaje de prueba echo gettext("Bienvenido a Mi Aplicacin PHP");

// O use el alias _() para gettext() echo _("Tenga un buen da");

4.3 Traduccin de web

Un sistema propio
La mayora de gestores de contenido (CMS) no utilizan directamente el sistema gettext, explicado anteriormente, ya que tendran que acceder a la configuracin del servidor. En vez de eso, implementan su propia versin gettext, intentando aprovechar todo el cdigo posible. Por ejemplo, utilizan los mismos ficheros .po y .mo.

La funcin gettext queda reemplazada por una serie de funciones que suelen ser:

_e() para traducir y echar el valor. (doble barra baja) __ () solo para traducir. t() para traducir.
Wordpress utiliza dos sistemas: 1. gettext oficial de PHP (funcion _) 2. un sistema propio ( funcin _e y __ )

Algunos programas, por ejemplo Drupal, utilizan ficheros .po sin pasarlos a .mo, otros requieren las compilacin, Wordpress, etctera.
Algunos enlaces

Wordpress wordpress (anieto)