Traduccion POO en PHP5 (version BETA)

[Calisco]

Seguro; esa es la idea. No por nada el topic tiene entre parentesis (version BETA). EL desarrollo es tratar que entre los que quieran aportar mejores e ideas lo hagan en este topic que sin lugar a dudas esta desprolijo. Una vez terminado, se hace el trabajo mas facil.

[Calisco]

Patrones
Los patrones son una forma para describir buenos diseños y mejores practicas. Muestran una solucion flexible problemas comunes de programacion.

Patterns are ways to describe best practices and good designs. They show a flexible solution to common programming problems.

Factory
La construccion de patrones permite la instanciacion de objetos en tiempo de ejecucion. Es llamado pa

The Factory pattern allows for the instantation of objects at runtime. It is called a Factory Pattern since it is responsible for "manufacturing" an object.

Example 19-23. Factory Method
<?php
class Example
{
// The factory method
function &factory($type)
{
if (include_once 'Drivers/' . $type . '.php') {
$classname = 'Driver_' . $type;
return new $classname;
} else {
throw new Exception ('Driver not found');
}
}
}
?>

Defining this method in a class allows drivers to be loaded on the fly. If the Example class was a database abstraction class, loading a MySQL and SQLite driver could be done as follows:
<?php
// Load a MySQL Driver
$mysql = Example::factory('MySQL');

// Load a SQLite Driver
$sqlite = Example::factory('SQLite');
?>
Singleton

The Singleton pattern applies to situations in which there needs to be a single instance of a class. The most common example of this is a database connection. Implementing this pattern allows a programmer to make this single instance easily accessible by many other objects.

Example 19-24. Singleton Function
<?php
class Example
{
// Hold an instance of the class
static private $instance;

// A private constructor
private function __construct()
{
echo 'I am constructed';
}

// The singleton method
static public function singleton()
{
if (!isset(self::$instance)) {
$c = __CLASS__;
self::$instance = new $c;
}

return self::$instance;
}

// Example method
public function bark()
{
echo 'Woof!';
}
}

?>

This allows a single instance of the Example class to be retrieved.
<?php
// This would fail because the constructor is private
$test = new Example;

// This will always retrieve a single instance of the class
$test = Example::singleton();
$test->bark();

?>

[jpinedo]

Patrones
Los patrones son maneras de describir las mejores prácticas y los buenos diseños. Muestran una solución flexible a los problemas de programación comunes.
Patterns are ways to describe best practices and good designs. They show a flexible solution to common programming problems.

Factory
El patrón "factory" permite la instanciación de objetos en tiempo de ejecución. Se llama patrón "factory" (fábrica) ya que es responsable de la "fabricación" un objeto.
The Factory pattern allows for the instantation of objects at runtime. It is called a Factory Pattern since it is responsible for "manufacturing" an object.

Ejemplo 19-23. Factory Method

Código PHP:

  <?php
class Example
{
   // El método "factory"
   function &factory($type)
   {
       if (include_once 'Drivers/' . $type . '.php') {
           $classname = 'Driver_' . $type;
           return new $classname;
       } else {
           throw new Exception ('Driver no encontrado');
       }
   }
}
?>   

Definir este método en una clase permite que los drivers sean cargados sobre la marcha. Si la clase Ejemplo era una clase de la abstracción de la base de datos, podríamos cargar un driver de MySQL o SQLite como sigue:
Defining this method in a class allows drivers to be loaded on the fly. If the Example class was a database abstraction class, loading a MySQL and SQLite driver could be done as follows:

Código PHP:

  <?php
// Carga de un driver MySQL
$mysql = Ejemplo::factory('MySQL');
 
// Carga de un driver SQLite
$sqlite = Ejemplo::factory('SQLite');
?>   

Singleton
El patrón Singleton se aplica a las situaciones en las cuales se necesita que haya una única instancia de una clase. El ejemplo más común de esto es una conexión a la base de datos. Implementar este patrón permite que un programador haga que esta única instancia sea fácilmente accesible por muchos otros objetos.
The Singleton pattern applies to situations in which there needs to be a single instance of a class. The most common example of this is a database connection. Implementing this pattern allows a programmer to make this single instance easily accessible by many other objects.
Example 19-24. Función Singleton

Código PHP:

  <?php
class Ejemplo
{
   // contiene una instancia de la clase
   static private $instancia;
  
   // Un constructor privado
   private function __construct()
   {
       echo 'Estoy construida';
   }
 
   // El método singleton
   static public function singleton()
   {
       if (!isset(self::$instancia)) {
           $c = __CLASS__;
           self::$instancia = new $c;
       }
 
       return self::$instancia;
   }
  
   // Método de ejemplo
   public function bark()
   {
       echo 'Woof!';
   }
}
 
?>   

Esto permite una sola instancia de la clase Ejemplo que será devuelta.
This allows a single instance of the Example class to be retrieved.

Código PHP:

  <?php
// Esto fallaría porque el constructor es privado
$test = new Ejemplo;
 
// Esto siempre devolverá la única instancia de Ejemplo
$test = Ejemplo::singleton();
$test->bark();
 
?>   

[Calisco]

Menos mal que hiciste esta traduccion; no tenia mucha idea del tema y mezclado con mi ingles, podria haber sido catastrofico.

[Calisco]

Metodos Magicos

Los nombres de las funciones __construct, __destruct (ver Constructores y Destructores), __call, __get, __set (ver Sobrecarga), __sleep, __wakeup, y _toString son "magicas" en clases de PHP. No se puede tener funciones con estos nombres en ninguna de nuestras clases a menos que se quiera el funcionamiento "magico" de las mismas.
The function names __construct, __destruct (see Constructors and Destructors), __call, __get, __set (see Overloading), __sleep, __wakeup, and __toString are magical in PHP classes. You cannot have functions with these names in any of your classes unless you want the magic functionality associated with them.

Precaucion
PHP reserva todos los nombes de las funciones comenzando con __ (doble guion bajo) como magica. Es recomendable no usar nombres de funciones que con __ en PHP a menos que se quiera algun funcionamiento magico documemntado.
PHP reserves all function names starting with __ as magical. It is recommended that you do not use function names with __ in PHP unless you want some documented magic functionality.

__sleep and __wakeup

La funcion serializacion serialize () chequea si tu clase tiene una funcion con el nombre magico __sleep. Si es asi, la funcion es ejecutada antes que cualquier serializacion. Se puede limpiar el objeto y se suspende el retorno de un array con los nombres de todas las variables del objeto que deberian ser serializadas.
serialize() checks if your class has a function with the magic name __sleep. If so, that function is executed prior to any serialization. It can clean up the object and is supposed to return an array with the names of all variables of that object that should be serialized.


El uso programado de __sleep es para cerrar cualquier coneccion de base de datos que el objeto pueda llegar a tener, datos destinados pedientes o tareas de limpieza similares a efectuar. Ademas, la funcion es muy usada si se tiene objetos muy extensos que no necesitan ser completamente guardados.
The intended use of __sleep is to close any database connections that the object may have, commit pending data or perform similar cleanup tasks. Also, the function is useful if you have very large objects which do not need to be saved completely.



En cambio, la funcion unserialize() se usa para chequear la presencia de una funcion con el nombre magico __wakeup. Si esta presente, esta funcion puede reconstruir cualquier recursos que el objeto pueda tener.Conversely, unserialize() checks for the presence of a function with the magic name __wakeup. If present, this function can reconstruct any resources that the object may have.
El uso programado de __wakeup es para reestablecer cualquier coneccion de base de datos que se pueda haber perdido durante la serializacion y otros tareas de reinicializacion pendientes.
The intended use of __wakeup is to reestablish any database connections that may have been lost during serialization and perform other reinitialization tasks.

__toString
El metodo __toString permite a una clase decidir como "reaccionara" cuando es usada como un string.
The __toString method allows a class to decide how it will react when it is converted to a string.

Ejemplo 19-25. Ejemplo Simple

Código PHP:

  <?php
// Declaracion de una clase simple
class ClaseTest
{
   public $foo;
 
   public function __construct($foo) {
       $this->foo = $foo;
   }
 
   public function __toString() {
       return $this->foo;
   }
}
 
$clase = new ClaseTest('Hola');
echo $clase;
?>   

La salida del ejemplo anterior mostrara:

Hola

Es un valor nulo que el metodo __toString solo sera llamado cuando este este diractemente combinado con echo() o print().
It is worth noting that the __toString method will only be called when it is directly combined with echo() or print().


Ejemplo 19-26. Casos de llamada a __toString

Código PHP:

  <?php
// Llamada a __toString
echo $clase;
 
// Llamada a __toString (todavia con un parametro normal para echo)
echo 'text', $clase;
 
// __toString not called (primero se utiliza el operador de concatenacion)
echo 'text' . $class;
 
// __toString not called (usado como un string)
echo (string) $class;
 
// __toString not called (usado como un string)
echo "text $class";
?>   

[Calisco]

Palabra Reservada FINAL
PHP 5 introduce la palabra reservada final, la cual impide clases hijas desde un metodo que tiene el prefijo final en la definicion. Si la clase en si misma es definida como final entonces no puede ser extendida.

PHP 5 introduces the final keyword, which prevents child classes from overriding a method by prefixing the definition with final. If the class itself is being defined final then it cannot be extended.

Ejemplo 19-27. Ejemplo de Metodo FINAL

Código PHP:

  <?php
class ClaseBase {
   public function test() {
       echo "ClaseBase::Llamada a test() \n";
   }
  
   final public function MasTesteo() {
       echo "ClaseBase::Llamada a masTesteto()\n";
   }
}
 
class ClHijaase extends ClaseBase {
   public function masTesteo() {
       echo "ClaseHija::Llamada a masTesteo()\n";
   }
}
// Resulta un error Fatal, no puede sobreescribir el metodo final
ClaseBase::masTesteo()
?>   

Ejemplo 19-28. Ejemplo de Clase FINAL

Código PHP:

  <?php
final class ClaseBase {
   public function test() {
       echo "ClaseBase::Llamada a test() \n";
   }
 
   // Here it doesn't matter if you specify the function as final or not
   final public function moreTesting() {
       echo "ClaseBase::Llamada a masTesteo() \n";
   }
}
 
class ClaseHija extends ClaseBase {
}
// Resulta un error Fatal: La clase Clasehija no puede heredarse desde la clase final (ClaseBase)
?>   

[dav1981]

bueno gracias a ti y a los que como vos contribuyen en este foro no se mucho de ingles por eso se me hace dificil hay veces leer sobre php gracias.

[Calisco]

Bueno, yo tampoco se mucho de ingles; se debe notar bastante para alguien que sepa un poco mas. El tema es ayudar entre todos; yo creo que no tenemos porque adaptarnos a un idioma que no es el nuestro; por lo menos no deberia ser imprescindible saber ingles. . .

[anthemfor182]

Clonación de Objetos
Object cloning

Crear una copia de un objeto que duplique todos los valores de sus propiedades no siempre funciona como esperamos. Un buen ejemplo esta en la necesidad de copiar construcciones, de esta forma si tienes un objeto que representa una ventana GtK y el objeto es una fuente a esta ventana GTK, y cuando lo creas o duplicas buscas crear una nueva instancia del objeto con las mismas propiedades y tienes un nuevo objeto que es una fuente a una nueva ventana Gtk.

Otro ejemplo es si su objeto mantiene una referencia a otro objeto que el usa y cuando lo duplicas el objeto padre, tu quieres crear una nueva instancia de este otro objeto asi que la replica tiene su copia por separado.

Una copia de un objeto es creada usando la palabra reservada clone (que llama el método del objeto __clone() si es posible). Un metodo de objeto __clone() no puede ser llamado directamente.

$copia_de_objeto = clone $objeto;

Cuando un objeto es clonado, PHP5 realizara una copia a bajo nvel de todas las propiedades del objeto. Cualquier propiedad que sea referencia a otras variables mantendrá su referencia. Si un metodo __clone() es definido, entonces cuando un nuevo objeto sea creado, este metodo será llamado para
controlar que propiedades deben ser cambiadas.

Ejemplo 19.31. Clonando un Objeto

Código PHP:

  <?php
class SubObject
{
    static $instances = 0;
    public $instance;

    public function __construct() {
        $this->instance = ++self::$instances;
    }

    public function __clone() {
        $this->instance = ++self::$instances;
    }
}

class MyCloneable
{
    public $object1;
    public $object2;

    function __clone()
    {
        // Forza a sacar una copia de of this->object, de otra forma
        // apuntará al mismo objeto
        $this->object1 = clone $this->object1;
    }
}

$obj = new MyCloneable();

$obj->object1 = new SubObject();
$obj->object2 = new SubObject();

$obj2 = clone $obj;

print("Original Object:\n");
print_r($obj);

print("Cloned Object:\n");
print_r($obj2);

?>

El ejemplo anterior muestra:
Original Object:
MyCloneable Object
(
    [object1] => SubObject Object
        (
            [instance] => 1
        )

    [object2] => SubObject Object
        (
            [instance] => 2
        )

)
Cloned Object:
MyCloneable Object
(
    [object1] => SubObject Object
        (
            [instance] => 3
        )

    [object2] => SubObject Object
        (
            [instance] => 2
        )

)  

[anthemfor182]

Comparando Objetos
Comparing objects

En PHP5, la comparación entre objetos es más complicada que en PHP4 y más de acuerdo a lo que uno esperaría de un lenguaje orientado a objetos (PHP5 es es un lenguaje de esos).

Cuando se usa el operador de comparación (==), variables objetos son comparadas de una simple manera, a saber: Dos instancias de objetos son iguales si tienen los mismos atributos y valores, y las instancias son de una misma clase.

Por otro lado, tenemos el operador idéntico (===), variables objetos son idénticos si y solo si se refieren a la misma instancia de la misma clase.

Un ejemplo puede clarificar esas reglas:

Example 19.32. Ejemplo de comparación de objetos en PHP 5

Código PHP:

  <?php
function bool2str($bool)
{
    if ($bool === false) {
        return 'FALSE';
    } else {
        return 'TRUE';
    }
}

function compareObjects(&$o1, &$o2)
{
    echo 'o1 == o2 : ' . bool2str($o1 == $o2) . "\n";
    echo 'o1 != o2 : ' . bool2str($o1 != $o2) . "\n";
    echo 'o1 === o2 : ' . bool2str($o1 === $o2) . "\n";
    echo 'o1 !== o2 : ' . bool2str($o1 !== $o2) . "\n";
}

class Flag
{
    public $flag;

    function Flag($flag = true) {
        $this->flag = $flag;
    }
}

class OtherFlag
{
    public $flag;

    function OtherFlag($flag = true) {
        $this->flag = $flag;
    }
}

$o = new Flag();
$p = new Flag();
$q = $o;
$r = new OtherFlag();

echo "Dos instancias de la misma clase\n";
compareObjects($o, $p);

echo "\nDos referencias a la misma instancia\n";
compareObjects($o, $q);

echo "\nInstancias de dos clases diferentes\n";
compareObjects($o, $r);
?>   

[anthemfor182]

Alusión de Tipos??
Type Hinting

PHP 5 introduce Type Hinting. Las funciones ahora estan en la capacidad de forzar a que los parametros sean objetos(especificando el nombre de la clase en el prototipo de la función) ó arrays (desde PHP 5.1).

Código PHP:

  <?php
// Una clase de Ejemplo
class MyClass
{
    /**
     * Una función de prueba
     *
     * El primer parametro debe ser un objeto de la clase OtherClass
     */
    public function test(OtherClass $otherclass) {
        echo $otherclass->var;
    }
 
 
    /**
     * Otra función de prueba 
     *
     * El primer parámetro debe ser un array
     */
    public function test_array(array $input_array) {
        print_r($input_array);
    }
}
 
// Otra clase de Ejemplo
class OtherClass {
    public $var = 'Hello World';
}
?>   

Cuando falla el type hint se produce un error fatal.

Código PHP:

  <?php
// Una instancia de cada clase
$myclass = new MyClass;
$otherclass = new OtherClass;
 
// Fatal Error: Argumento 1 debe ser de la clase OtherClass
$myclass->test('hello');
 
// Fatal Error: argumento 1 debe ser una instancia de la clase OtherClass
$foo = new stdClass;
$myclass->test($foo);
 
// Fatal Error: Argumento 1 no debe ser nulo
$myclass->test(null);
 
// Funciona: imprime Hello World
$myclass->test($otherclass);
 
// Fatal Error: Argumento 1 debe ser un array
$myclass->test_array('a string');
 
// Trabaja: Imprime el array
$myclass->test_array(array('a', 'b', 'c'));
?>   

Type hinting también trabaja con funciones:

Código PHP:

  <?php
// Una clase de Ejemplo
class MyClass {
    public $var = 'Hello World';
}
 
/**
 * Una funcion de prueba
 *
 * El primer argumento debe ser un objeto de la clase MyClass
 */
function MyFunction (MyClass $foo) {
    echo $foo->var;
}
 
// Trabaja!
$myclass = new MyClass;
MyFunction($myclass);
?>