En PHP 5 está disponible el nuevo nivel de error E_STRICT [...] Habilitar E_STRICT durante el desarrollo tiene algunos beneficios. Los mensajes STRICT le ayudarán a usar el último y más sugerente método de codificación, por ejemplo le advertirá del uso de funciones obsoletas.

Con la inclusión de E_STRICT en el E_ALL en PHP 5.4 no tendremos escusas para no mirar estos mensajes.

¿POR QUÉ UTILIZAR E_STRICT?

E_STRICT nos permite desarrollar código más limpio y asegura la mejor interoperabilidad y compatibilidad con versiones posteriores de PHP.

LOS 5 ERRORES MÁS COMUNES UTILIZANDO E_STRICT

Recientemente activé el E_STRICT en una web para actualizar su código y estos son los 5 errores más frecuentes con los que me he enfrentado:

1. Funciones obsoletas

PHP nos indica si una función es deprecada. Aquí la lista de las obsoletas para la versión 5.3: http://php.net/manual/en/migration53.deprecated.php

Error:

PHP Deprecated: Function xxx() is deprecated

2. Static

Muchas veces olvidamos de poner la keyword "static" en la definición de una función que luego utilizaremos con clase::método

Error:

Non-static method XXX should not be called statically, assuming $this from incompatible context

3. Overloading

En PHP no existe el overloading, lo podemos sólo "simular" con __call pero como todos los métodos mágicos es bastante costoso. Es decir no podemos declarar dos funciones con el mismo nombre que se diferencien sólo por la firma (parámetros). Entonces en el caso de overriding (sobrescritura de un método de la clase padre que hemos heredado) tenemos que utilizar los mismo parámetros o al máximo añadir otros.

Error:

Declaration of XXX should be compatible with that of YYY

4. Pasar una variable a una función que acepta un parámetro por referencia

No es posible pasar una variable a una función que acepta un parámetro por referencia. En concreto no podemos hacer algo así:

array_pop(explode('-', 'hola-mundo'));

Tenemos que guardar el resultado del explode en una variable y luego pasarla a array_pop:

$hola = explode('-', 'hola-mundo');
array_pop($var);

Algunas funciones que cogen parámetros por referencia: array_shift, array_unshift, array_pop, array_push, current, end...

Error:

Only variables should be passed by reference

5. Crear un objeto genérico

A veces para pasar algo por json o por comodidad creamos un objeto genérico sin inicializarlo. Por ejemplo:

$obj->propriedad = true;

En este caso tenemos que inicializar el objeto de esta manera:

$obj = new stdClass();
$obj->propriedad = true;

Error:

Creating default object from empty value

CONCLUSIONES

El utilizo de E_STRICT nos permitirá desarrollar aplicaciones compatibles con el futuro y nos ayuda a aprender detalles del PHP que desconocíamos.

¿Cuáles son los más famosos y cuáles son estos problemas recurrentes? En este articulo propongo una lista de los patrones de diseño más famosos asociados con el problema que solucionan para poderlos encontrarlos de manera rápida.

PROS Y CONTRAS DEL UTILIZO DE PATRONES DE DISEÑO

Antes de todo se tiene que evidenciar que utilizar patrones de diseño tiene lados positivos y negativos.
Aquí un resumen:

PROS:

• soluciones probadas
• arquitectura más sencilla de decodificar (ingeniería inversa)

CONTRAS:

• no siempre representan la solución más optimizada
• entender cuándo es posible utilizarlos necesita gente con un mínimo de experiencia

LOS PATRONES DE DISEÑO MÁS CONOCIDOS Y QUÉ PROBLEMA SOLUCIONAN

Adapter

Adaptar un nuevo objeto a un sistema de clases que ya existen.

Builder

Delegar la construcción de un objecto a otra clase. Se utiliza sobretodo para objecto complejos la cuya construcción depende de diferentes factores.

Decorator

Añadir o modificar funcionalidades de un objecto sin modificar su estructura interna.

Delegate

Modificar un objecto extrayendo una parte de código complejo pero independiente para crear una nueva clase. Se aconseja utilizarlo en caso de if o swtich complejos.

Façade

Se utiliza para crear una nueva tapa (clase) para ocultar la complejidad de un objecto.

Factory

Crear una "interfaz" que cree una instancia de un objecto sin especificar a priori la clase.

Interpreter

Analiza los elementos claves de una entidad y devuelve una interpretación (por ejemplo para crear un sistema de plantillas)..

Iterator

Ayuda a construir objectos cuyos elementos se puedas manipular de manera similar a un array.

Mediator

Se utiliza cuando tenemos que modificar muchos objectos similares. La clase mediator se ocupa de modificarlas todas de una vez.

Observer

Se utiliza para crear objectos que observan otros para proporcionar noticias sobre el estado de éstos.

Prototype

Crea un objecto que clona otro para ahorrar recursos (por ejemplo para objectos con constructores muy pesado y en parte inútil).

Proxy

Crea un objecto que se interpone de manera transparente entre otros dos para controlar el acceso o sobrescribir funcionalidades.

Singleton

Se utiliza para crear una única instancia de un objecto (por ejemplo el acceso a una BBDD).

Strategy

Aísla un algoritmo de un objecto que sepamos pueda variar de manera dinámica y creamos diferentes clases.

Template

Simplemente para crear una clase abstracta que proporciona métodos que utilizaremos en las clases que la heredan.

Visitor

Para minimizar las modificaciones de una clase (principio open/close) se crea otra que se tiene que llamar cada vez que se instancia la primera. Es como si "extendíamos" la clase virtualmente.

CONCLUSIONES

Los patrones de diseño son muy potentes y útiles. Cada buen programador tendría que conocerlos y utilizarlos. Espero que esta mini-guía os ayude a a reconocer cuando es posible utilizarlos para cumplir el principio del "no reinventes la rueda".

Este proceso se llama Refactoring, palabra que mucha gente odia porque necesita recursos para algo que no es ni un producto completo ni una release. Entonces es natural que vuestro Product Owner no lo vea favorablemente. Aunque en continua lucha para el Time To Market los desarrolladores deberían prestar la debida atención a esta fase ya que se podría llegar a la clásica situación de entrada en pérdida en la que para modificar el código spaghetti que hemos generado tiene un coste mayor que refactorizarlo.

Entonces cuáles son las lineas guías para un buen Refactogin? Buscamosles juntos...

CUÁL ES LA DEFINICIÓN DE REFACTORING

Oficialmente podemos definir el refactoring como el proceso para alterar el funcionamiento interno de una aplicación sin modificar su comportamiento externo.

LOS OBJETIVOS

• Menor complejidad
• Mayor legibilidad
• Mejorar la fase de mantenimiento
• Mejorar la escalabilidad

Entonce aquí un decálogo para acabar de manera satisfactoria un refactoring:

1. CREAR NUEVOS MÉTODOS
2. INTRODUCCIÓN DE NUEVAS VARIABLES EXPLICATIVAS
3. RENOMBRAR MÉTODOS
4. MOVER ELEMENTOS
5. CREAR NUEVAS CLASES
6. OCULTAR DELEGADOS
7. TRANSFORMAR ARRAY EN OBJECTOS
8. CAMBIAR LAS HERENCIAS POR DELEGADOS
9. LAS ÚLTIMAS TRES REGLAS

1. CREAR NUEVOS MÉTODOS

Asumimos de tener esta función que calcula el precio total de un articulo con impuestos y gastos de envío:

public function getTotalPrice($id_product)
{
	$product_price = $this->getProductPrice($id_product);
	$product_price_taxed = $this->tax * $product_price;
	$product_price_shipping = $this->getProductShipping($id_product);

	$product_price_total =
		$product_price_taxed + $product_price_shipping;

	return $product_price_total;
}

Podemos aislar la línea para calcular los impuestos en un nuevo método:

// line 4 modified
$product_price_taxed = $this->getPriceTaxed($product_price);

// new method
public function getPriceTaxed($product_price)
{
	return $this->tax * $product_price;
}

2. INTRODUCCIÓN DE NUEVAS VARIABLES EXPLICATIVAS

Sobretodo en los casos de ciclos con condiciones muy complejas es aconsejable crear nuevas variables explicativas.

if (strpos($_SERVER['SERVER_NAME'], 'local') === FALSE)
	// do something

Aquí la vesión con una nueva variable explicativa:

$is_local = strpos($_SERVER['SERVER_NAME'], 'local');

if ($is_local === FALSE)
	// do something

3. RENOMBRAR MÉTODOS

Odio profundamente los desarrolladores que crean métodos con nombre inútiles porque genéricos:get, set, getForm, setValue...

Los nombres de los métodos son como los titulares de los periódicos: tienen que ser explicativos pero no demasiado largos.

4. MOVER ELEMENTOS

Otro paso para un buen refactoring es encontrar la posición correcta para métodos y atributos. Asumimos de haber creado una clase car con la variable piston y que luego hayamos creado la clase motor. Es evidente que la variable piston es un atributo de la clase motor y no de la clase car. Entonces en la fase de refactoring tenemos que reorganizar las asociaciones correctas entre clases, métodos y atributos.

5. CREAR NUEVAS CLASES

Si tenemos una sentencia if (o switch) de este tipo:

public class car
{
	private $motor;

	public function __constructor($motor)
	{
		$this->motor = $motor;
	}

	public function getMotor()
	{
		if($this->motor == 'DIESEL')
			return $this->getDieselPrice();
		elseif($this->motor == 'UNLEADED')
			return $this->getUnleadedPrice();
	}
}

Entonces es muy probable que tenemos que crear tres nuevas clases:

• una abstracta motor
• una dieselMotor que extende motor
• una unleadedMotor que extende motor

6. OCULTAR DELEGADOS

Si tenemos una línea de código del tipo:

$fuelType = $car->getMotor()->getFuelType();

En que el método getMotor es:

public function getMotor()
{
	return $this->motor;
}

Tenemos que modificarlo para devolver directamente el atributo que necesitamos:

public function getMotor()
{
	return $this->motor->getFuelType();
}

Ésto para seguir la Ley de Demeter que dice que no tenemos que confiar en la estructura interna de un objecto ya que si viene modificado tendremos que cambiar muchas partes del código.

7. TRANSFORMAR ARRAY EN OBJECTOS

Asumimos que tenemos una clase car así:

public class car
{
	private $details;

	public function __constructor($details)
	{
		$this->details = $details;
	}
}

Entonces para crear el objecto car tenemos que pasar como parámetro un array con las características del coche. Si queremos devolver un detalle del coche tendremos que leerlo del array $details.
La manera más correcta para inicializar un objecto y almacenar sus atributos es crear una variable por cada característica.

public class car
{
	private $motor;
	private $brand;
	private $model;

	public function __constructor($motor, $brand, $model)
	{
		$this->motor = $motor;
		$this->brand = $brand;
		$this->model = $model;
	}
}

8. CAMBIAR LAS HERENCIAS POR DELEGADOS

Asumimos de tener una clase que implementa una interfaz para efectuar el log de la aplicación:

public class car extends Logger
{
	public function run()
	{
		...
		$this->log(...);
	}
}

La manera más correcta para hacerlo es pasa el objecto logger como parámetro en el momento de crear el objecto car y acceder a la variable sin extender ninguna clase. También en este caso estamos siguiendo la Ley de Demeter.

public class car
{
	private $logger;

	public function __contruct($logger)
	{
		$this->logger = $logger;
	}
	public function run()
	{
		...
		$this->logger->log(...);
	}
}

9. LAS ÚLTIMAS TRES REGLAS

Los últimos tres consejos para un buen refactoring son:

1. eliminar código redundante
2. escribir bloques de código pequeños
3. separar conceptos diferentes

CONCLUSIONES

La fase de refactoring tiene que ser incluida en un buen proyecto y es fundamental para que la aplicación se mantenga simple, rápida y fácil de mantener.

• requisitos poco claros (o idas poco claras por parte del desarrollador) en la fase de diseño
• poco conocimiento de estos conceptos

Entonces intentamos aclararlos.

QUÈ ES UNA INTERFAZ

La definición más clara es que una interfaz es un contrato.

Características:

• todas las clases que implementan una interfaz tienen que desarrollar todos los métodos que han sido definidos
• por cada método se define sólo la firma
• los métodos pueden ser solo públicos
• una clase puede implementar más de una interfaz
• una interfaz puede ser utilizada por el Type Hinting

interface logsInterface
{
  public function log($message, $priority = null);
}

QUÉ ES UNA CLASE ABSTRACTA

Es una clase "padre" que tiene que ser heredada para poder ser utilizada. Las clases que la heredan se diferencian entre ellas solo en los métodos abstractos y pueden acceder a los métodos de la clase padre utilizando la keyword parent.

Características:

• no se puede instanciar
• los métodos pueden ser abstractos (no implementados)
• los métodos pueden ser no abstractos (implementados)
• un clase puede heredar de una sóla clase abstracta

abstract class logsAbstract
{
    private $variable;
    abstract public function logMethod();

    public function getVariable()
    {
        return $this->variable;
    }
}

RESUMEN DE INTERFACE VS ABSTRACT CLASS

En principio si una clase abstracta contiene sólo métodos abstractos la estamos utilizando como una interfaz.

CONCLUSIONES

Las clases abstractas se utilizan para compartir funciones.
Las interfaces se utilizan para compartir como se tiene que hacer algo.

LINKS

• Why are interfaces widely ignored in the PHP world and what use do they have when working with symfony?
• Difference between abstract classes and interfaces
• Ejemplo de interface y abstract class

El problema que se nos presenta es lo de las name collitions o sea de la confusión que se puede producir hablando de dos cosas distintas que tienen el mismo nombre. En el caso de PHP se podría producir sobrescribiendo nombres de clases, funciones y constantes.

La solución en PHP es tan sencilla cuanto genial y se llama namespaces. Además si se utiliza en la nueva versión de Zend Framework (2.0) será algo bueno 

Oficialmente los namespaces sirven para encapsular. Ésto significa que podemos crear paquetes de clases estando seguros que no vamos a producir name collitions. Un ejemplo vale más de mil palabras:

EJEMPLO:

/*FILE file1.php*/
namespace namespace1;
class testClass {
        function whoAmI (){
                return 'file1' . PHP_EOL;
        }
}

/*FILE file2.php*/
namespace namespace2;
class testClass {
        function whoAmI() {
                return 'file2' . PHP_EOL;
        }
}

/*FILE test.php*/
require_once('./file1.php');
require_once('./file2.php');

$class1 = new \namespace1\testClass();
echo $class1->whoAmI();

$class2 = new \namespace2\testClass();
echo $class2->whoAmI();

/*********
Output:
file1
file2
*********/

Como podemos ver hemos utilizado dos clases con el mismo nombre sin generar colisiones. Lo mismo vale utilizando constantes y funciones.

VENTAJAS:

Entonces ¿cuáles son las ventajas?

1. código más claro
2. mejor organización si estamos desarrollando una aplicación muy grande
3. empezar a utilizar un nuevo elemento que será nuestro pan diario en los próximo años

SUB-NAMESPACES:

A diferencia de los packages de Java en PHP podemos crear diferentes niveles de namespace para que nuestro código resulte más organizado.

\namespace1\subnamespace\subsubnamespace

UTILIZAR UN NAMESPACE (use):

En los ejemplos anteriores hemos utilizado una barra inversa al principio del namespace. Ésto significa que el namespace que vamos a utilizar es de tipo GLOBAL. En otras palabras las rutas que utilizaremos se refieren a la root de nuestro "árbol" de namespaces. Una manera más sencilla de utilizar nuestros namespaces es definir el "nivel" que vamos a utilizar a través de la palabra reservada use.

Asumimos que tenemos la clase class1 en el siguiente namespace:

\namespace1\subnamespace\subsubnamespace

Para poder instanciarla tendríamos que utilizar este código:

$class = new \namespace1\subnamespace\subsubnamespace\class1();

Trabajando con el use podemos simplemente escribir:

use \namespace1\subnamespace\subsubnamespace;
$class = new subsubnamespace\class1();

ALIAS:

El alias es un constructo muy útil para render nuestro código más sencillo y fácil de mantener. Suponemos que en el ejemplo anterior el nombre del namespace subsubnamespace no nos guste o sea demasiado largo, podemos utilizar la siguiente sintaxis:

use \namespace1\subnamespace\subsubnamespace as newname;
$class = new newname\class1();

VARIABLE __NAMESPACE__:

Para saber en que namespace estamos actualmente podemos utilizar la variable __NAMESPACE__

CONCLUSIONES:

Este post no quiere ser una disertación completa sobre los namespaces sino mostrar una panorámica de sus capacidades.

Os dejo 3 links muy interesantes sobre este tema:

• Manual PHP
• Post de otro blog en ingés
• Otro blog que trata el tema de manera muy exhaustiva (recomendado)

La idea es muy sencilla:
Guardar el output en una variable y devolverla de una única vez.

VENTAJAS:

Las vantajas de utilizar el Output Buffering Control son múltiples:

• Mayor velocidad
• Menor utilizo de banda
• Mayor control
• Posibilidad de redirigir el output a un fichero
• Manipular el output
• Configurar header y cookie en cualquier punto del código

FUNCIONES:

La función para empezar a utilizar un Output Buffering Control es ob_start. Podemos pasar un parametro para definir la función callback.
La más utilizada es ob_gzhandler que permite comprimir nuestro output con el algoritmo gzip.

Podemos eliminar el output buffering con dos funciones:

• ob_end_clean: limpia el output buffering
• ob_end_flush: envía el output buffering al cliente y termina

Otras funciones útiles son:

• ob_clean: limpia el buffer de salida
• ob_get_clean: devuelve el buffer para almacenarlo en una variable y lo limpia
• ob_get_flush: devuelve el buffer al cliente y lo limpia
• ob_get_length: devuelve la longitud actual del buffer
• ob_get_level: devuelve el nivel de anidamiento del mecanismo de buffer (se pueden anidar más buffers)
• ob_get_status: devuelve el estado del buffer actual (o de todos si pasamos el parámetro TRUE)
• ob_implicit_flush: por defecto si no llamamos la función ob_end_flush se ejecuta automáticamente al final del script
• output_add_rewrite_var: añade una variable (nombre=valor) en cada URL que no sea absoluta y un campo hidden en los formularios
• output_reset_rewrite_vars: restablece los valores del mecanismo de re-escritura de URLs

EJEMPLOS:

<php
ob_start();
echo "Hello World!";
ob_end_flush();
?>

Para realizar la compresión del output tenemos que pasar el parámetro ob_gzhandler a la función ob_start:

<?php
ob_start('ob_gzhandler');
echo "Hello World!";
ob_end_flush();
?>

TIPS:
Podemos llamar a una función callback que nos limpie todo el output antes de enviarlo al cliente.
Aquí algunos usos frecuentes:
- remover espacios blancos repetidos:

trim(preg_replace('/\s+/', ' ', $buffer));

- codificar entidad HTML: por ejemplo

$buffer = str_replace('&', ' &', $buffer);

- redirigir el output a un fichero

PERFORMANCE:
Utilizando este simple script he registrado una mejora del 10% en la velocidad y el tamaño de la página ha pasado de 244.2KB a 612B

<?php
ob_start('ob_gzhandler');
for ($j=1; $j <= 5; $j++)
{
list($usec, $sec) = explode(" ",microtime());
$debut[$j] = ((float)$usec + (float)$sec);

echo str_repeat("0123456789",5000) . '<br>' ;

list($usec, $sec) = explode(" ",microtime());
$fin[$j] = ((float)$usec + (float)$sec);
}
echo '<br><br>TEST PERFORMANCE</br><br>';

$total = 0;
for ($j=1; $j <= 5; $j++)
$total += round($fin[$j]-$debut[$j], 5) . '<br>';

echo 'TOTAL: '. $total;

ob_end_flush();
?>

]]> http://www.alessiomavica.com/es/2011/08/24/php-output-buffering-control/feed/ 0