CalinSoft

Al contrario que las clases abstract, que proporcionan un medio para expresar conceptos abstractos en programación, las interfaces se han diseñado para asegurar la funcionalidad dentro de una clase. Específicamente, las interfaces son medios para definir el conjunto de métodos que debe tener una clase para implantar dicha interfaz. Para utilizar las interfaces, deben declararse con la palabra clave interface.

interface printable
{
public function printme();
}

Las interfaces, para ser útiles, deben implantarse mediante una o más clases. En el ejemplo hemos definido la interfaz printable, que estipula que cualquier clase que implante una interfaz el método printme(). Para crear una clase que implante una interfaz como ésta, utilizamos la palabra clave implements en la definición de clase, seguida por una lista de interfaces implantadas.

class Integer implements printable
{
private $value;
public function getValue(){
return (int) $this->value;
}

public function printme(){
echo (int) $this->value;
}
}

Hemos modificado la clase Integer original del entrada anterior para implantar la interfaz printable definida en el primer ejemplo. Como clase que implanta esta interfaz, se asegura efectivamente que la clase Integer va a proporcionar los métodos definidos por la interfaz.

Ahora que hemos definido una clase que implanta una interfaz, podemos utilizar este hecho dentro de nuestro código para asegurarnos de que cualquier función o método que requiera determinada funcionalidad de una clase la tendrá disponible desde la clase sin comprobar el nombre de clase específica utilizando la indicación de tipo o el operador instanceof. En su lugar, podemos utilizar estas técnicas para especificar la interfaz printable como muestra el siguiente ejemplo.

interface printable
{
public function printme();
}

abstract class Number
{
private $value;
abstract public function value();

public function reset(){
$this->value = NULL;
}
}

class Integer extends Number implements printable
{
private $value;
function __construct($value){
$this->value = $value;
}

public function getValue(){
return (int) $this->value;
}

public function printme(){
echo (int) $this->value;
}
}

/* Creamos una funcion que requiera de la interfaz printable*/
function printNumber(printable $myObject){
/* Si se llama a esta funcion, podemos estar seguros de que tiene un método printme()*/
$myObject->printme();
}

$inst = new Integer(10);

printNumber($inst);

Hemos utilizado las interfaces para asegurarnos de que la función printNumber() siempre va a recibir un objeto que tiene un método printme().

Como su mismo nombre lo dice, las clases abstractas se utilizan en la OOP para especificar objetos abstractos. Solo sirven para ser heredadas por otras clases o para usarlas sin instanciar es decir son aquellas que forzosamente se ha de derivar si se desea que se puedan crear objetos de la misma o acceder a sus miembros estáticos.

Cuando una clase contiene un método abstracto tiene que declararse abstracta. No obstante, no todos los métodos de una clase abstracta tienen que ser abstractos.

		abstract class Number
	{
		private $value;
		abstract public function value();
		public function reset()
		{
			$this->value = NULL;
		}

	}

	class Integer extends Number
	{
		private $value;
		public function value()
		{
			return (int) $this->value;
		}
	}

	$num = new Integer; /* Bien */
	$num2 = new Number; /* Mal */

Hemos creado una clase abstracta, Number que se extendiendo por la clase Integer. Como hemos declarado la clase Number como abstracta, no podemos crear una instancia de ella. Si miramos a la clase Number, podremos comprobar que se define 2 funciones: value() y resert(). En una clase abstracta, no es necesario proporcionar ningún código para métodos, aunque podemos incluir si lo deseamos. En el caso de la clase Number, como value() es algo específico a un tipo determinado de número, se deja para que lo implante la clase hija.

Para forzar este comportamiento en un código de escritura de desarrollador, la palabra clave abstract utilizada para identificarlo tiene simplemente un marcador de posición en la clase Number, algo que no obstante, no es cierto para el método reset(), que es consistente para cualquier tipo de número específico.

Las clases abstractas pueden extenderse sin implantar todos los métodos abstractos definidos dentro. Es decir, una clase hija puede también declararse como abstracta si no implanta todos los métodos abstractos de su padre(o padres).

En el foro de WebLiveHelp trataban un problema de conversión de array a objeto y viceversa no se si es el mejor método de conversión pero creo una alternativa seria esta..

// Funcion de Objeto a Array
function object_to_array($object)
{
  if(is_array($object) || is_object($object))
  {
    $array = array();
    foreach($object as $key => $value)
    {
      $array[$key] = object_to_array($value);
    }
    return $array;
  }
  return $object;
}

// Funcion de Array a Objeto
function array_to_object($array = array())
{
	return (object) $array;
}

Metodo de funcionamiento
- Trabajando con array_to_object

//creamos un array de dominios
$array_urls = array("a"=>"calinsoft.com","b"=>"gacetaucayalina.com","c"=>"jacknoticias.com");

//Se vuelca la informacion para darnos cuenta de la estructura.
echo "<pre>";
	var_dump($array_urls);
echo "</pre>";

/* nos dara
array(3) {
  ["a"]=>
  string(13) "calinsoft.com"
  ["b"]=>
  string(19) "gacetaucayalina.com"
  ["c"]=>
  string(16) "jacknoticias.com"
}
*/

//Ahora ese array lo convertimos en objeto mediante la funcion "array_to_object"
$object_urls =	array_to_object($array_urls);

//Volcamos la informacion de la conversion
echo "<pre>";
	var_dump($object_urls);
echo "</pre>";

/* nos dara
object(stdClass)#1 (3) {
  ["a"]=>
  string(13) "calinsoft.com"
  ["b"]=>
  string(19) "gacetaucayalina.com"
  ["c"]=>
  string(16) "jacknoticias.com"
}
*/

//Y con el objeto ya creado para mostrar el valor "a"
echo $object_urls->a;
/*nos dara
    "calinsoft.com"
*/

- Trabajando con object_to_array

//Ahora creamos una clase sencilla

class object_urls{

	var $a ;
	var $b ;
	var $c ;

	//php5
	function __construct(){
		$this->a ="calinsoft.con";
		$this->b ="gacetaucayalina.com";
		$this->c ="jacknoticias.com";

	}

	//php4
	function object_urls(){
		$this->__construct();
	}

}

//creamos un instancia de la clase
$object_urls2 = new object_urls();

//Se vuelca la informacion del objeto para darnos cuenta de su estructura.
echo "<pre>";
	var_dump($object_urls2);
echo "</pre>";
/* nos dara
object(object_urls)#2 (3) {
  ["a"]=>
  string(13) "calinsoft.con"
  ["b"]=>
  string(19) "gacetaucayalina.com"
  ["c"]=>
  string(16) "jacknoticias.com"
}

*/

//Ahora convertimos la clase en array mediante la funcion "object_to_array"
$array_urls2 = object_to_array($object_urls2) ;

//Volcamos la informacion de la conversion
echo "<pre>";
	var_dump($array_urls2);
echo "</pre>";
/*nos dara
array(3) {
  ["a"]=>
  string(13) "calinsoft.con"
  ["b"]=>
  string(19) "gacetaucayalina.com"
  ["c"]=>
  string(16) "jacknoticias.com"
}
*/

//Para trabajas con el array solo
echo $array_urls2["a"];

/*nos dara
    "calinsoft.com"
*/

Espero que les aya servido .

Esta es una detección simple mediante las variables globales definidas por el servidor Web para este caso usaremos $_SERVER.

//para Apache
$es_apache = ((strpos($_SERVER['SERVER_SOFTWARE'], 'Apache') !== false) || (strpos($_SERVER['SERVER_SOFTWARE'], 'LiteSpeed') !== false)) ? true : false;

//para IIS (Internet Information Server)
$es_IIS = (strpos($_SERVER['SERVER_SOFTWARE'], 'Microsoft-IIS') !== false) ? true : false;

//Metodo de uso
if ($es_apache) echo " Estamos Bajo Apache ";

if ($es_IIS) echo " Estamos IIS ";

Esta función nos ayuda a comprobar si una cadena o campo específico en un formulario es un email o no.

function es_email($email) {
	$regex = "/^([a-z0-9+_]|\\-|\\.)+@(([a-z0-9_]|\\-)+\\.)+[a-z]{2,6}\$/i";
	//comprovamos si la cadena tiene el simbolo de @ y el punto
	if (strpos($email, '@') !== false && strpos($email, '.') !== false) {
	//comparamos con la expresion regular la cadena
		if (preg_match($regex, $email)) {
			return true;
		} else {
			return false;
		}
	} else {
		return false;
	}
}

//metodo de uso

if (es_email("miemail@dominio.com")):
	echo "es valido";
else:
	echo "invalido";
endif;

El tema de las Urls Amigables (friendly urls) esta relacionado con el SEO y el posicionamiento Web en los diversos buscadores algo que se a hablado hasta el cansancio, los métodos de poder construirlas son como los colores ( para todos los gustos ).

En la actualidad las Urls Amigables (friendly urls) no es una simple moda Web 2, si no que en sistemas de gestión de contenidos y servicios prestigiosos como Blogger, Drupal, Wordpress y muchos más lo tienen implementado. ¿Pero cual es el mejor? ya de por si se sabe que implementando Urls Amigables en tus paginas o proyectos Web estas a 2 o 3 pasos arriba que otras paginas que usan las Urls tradicionales muy aparte de la publicidad o herramientas de posicionamiento que usen.

Al principio no todos podían usar Urls Amigables en sus sitios, mucho dependía de tener activado el mod_rewrite , aun que wordpress fue un paso mas allá y nos dio una solución como nos comentaba Andres Nieto a principios de año desconozco si wordpress fue el pionero en esto.

En el posicionamiento Web 2 de los mejores son Blogger y Wordpress por el método que usan aunque este ultimo con la opción de personalizar la estructura de la url a nuestro gusto por ser una herramienta de construcción de blogs de codigo abierto que a permitido que crezca gracias a la comunidad que lo rodea.

Las hasta 3 formas mas conocidas de construir las Urls Amigables es mediante PATH_INFO, mediante directivas en el archivo .htaccess como nos explica manu en TuFunción o mediante peticiones $_GET como nos enseña William Wong Garay en MaestrosDelWeb.

Todos estos métodos construyen Urls Amigables pero tienen sus limitaciones.

• PATH_INFO no se puede expandir la estructura de Urls Amigables
• mod_rewrite y .htaccess mientras mas directivas se ralentiza el servidor
• Metodo $_GET limite del numero de variables a enviar como explica Willy

¿Cual método usa Wordpress? si observamos su archivo .htaccess solo utiliza unas directivas simples.

# BEGIN WordPress

RewriteEngine On
RewriteBase /
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /index.php [L]

# END WordPress

El archivo clave es wp-includes/rewrite.php (WP_Rewrite API) el encargado de identificar las peticiones que se hacen en el sistema.

¿Pero como trabaja? muy simple con reglas muy similares a las que se usan en el .htaccess con diferencia que estas se procesan en un archivo php y acelerando el proceso.

¿Pero como implementarlo en una pagina que no sea wordpress? … destripando el codigo he logrado desarrollar una clase muy básica basada en WP_Rewrite API que nos permitirá personalizar la estructura de las Urls amigables al estilo Wordpress.

Pueden verlo en funcionamiento en http://web2developement.calinsoft.com/urls-amigables .

El funcionamiento es básico la regla esta compuesta de una Expresion Regular y la marca que vendría hacer los parámetros a usar.

// para poder obtener una estructura /2008/08/28/urls-amigables-facilmente
$this->rules["([0-9]{4})/([0-9]{1,2})/([0-9]{1,2})/(.+?)/?$"]="y=\$matches[1]&m=\$matches[2]&d=\$matches[3]&nslug=\$matches[4]";

//la cual mediante una identificación y parseo previo obtendríamos los valores listo para usarlos segun lo deseemos

Array
(
    [y] => 2008
    [m] => 08
    [d] => 28
    [nslug] => urls-amigables-facilmente
)

Los interesados pueden comentar si creen que es un buen método, tratare de afinar el script y lo publicare en estos días para mis lectores de Feed tendrán una sorpresa.