Hace mas de un año habíamos hablado de este singular problema que
nos topábamos cuando validamos nuestro código HTML

there is no attribute “TARGET”

Ya que TARGET no es un atributo válido en el XHTML estricto por lo cual necesitaba encontrar un método de solucionarlo sin perder la accesibilidad a la pagina.

Hace tiempo encontré la forma mediante Jquery de una forma muy sencilla.

$(document).ready(function(){

$("a[href*='http://']:not([href*='"+location.hostname+"'])").click( function() { 

window.open(this.href); 

return false; 

});

});

En lo se valida que cuando se haga clic en cualquier enlace de la pagina verifique si es un enlace interno mediante location.hostname lo cual provoca en caso que sea un enlace externo que se abra en una nueva ventana y asi evitar estar colocando a todos los enlaces externos target=”_blank”.

Vero es un programador que a lo largo de estos años a estado puliendo una inmejorable forma de aliviarnos las penurias, cuando de hacer un upload se trate.

Para mi esta clase Upload es casi completa, tiene de todo y es re contra configurable.

¿Que es lo que diferencia esta clase de las demás?

• Después de subir un archivo, uno puede hacer tantas copias, conversiones y cambios de tamaños que uno desee.
• Se puede manipular la imagen de muchas maneras, rotar la imagen, jugar con los colores, añadir bordes y marcas de agua.
• Añadir textos.
• Validación del tipo de archivo a subir.
• Sumamente Flexible.
• Es Gratis.

La clase es tan poderosa para mi gusto que con un simple ejemplo veremos su potencial.

$foo = new Upload($_FILES['form_field']);
if ($foo->uploaded) {
// subimos la imagen
$foo->Process('/home/user/files/');
if ($foo->processed) {
echo 'copia original de la imagen';
} else {
echo 'error : ' . $foo->error;
}
// Volvemos a subir la imagen con otro nombre
$foo->file_new_name_body = 'carlos-montalvo';
$foo->Process('/home/user/files/');
if ($foo->processed) {
echo 'Imagen renombrada con el nombre "carlos-montalvo"';
} else {
echo 'error : ' . $foo->error;
}

// Esta vez le creamos una miniatura de 100px de ancho
$foo->file_new_name_body = 'image_miniatura';
$foo->image_resize = true;//activamos la opcion de miniaturaa
$foo->image_convert = gif; //lo convertimos a gif
$foo->image_x = 100;//asignamos 100px
$foo->image_ratio_y = true;//activamos el ratio
// Subimos la imagen con los cambios realizados
$foo->Process('/home/user/files/');
if ($foo->processed) {
echo 'Imagen renombrada y en miniatura con 100px de ancho
y convertida en gif';
$foo->Clean();//limpiamos
} else {
echo 'error : ' . $foo->error;
}
}

Así de simple logramos tantos cambios con una sola imagen subida.

Descarga Clase Upload

Documentación

Hoy en día la creación slugs basados en lo títulos de nuestros artículos es muy popular. WordPress, Drupal y muchos más lo utilizan de forma excelente. Sin duda los slugs son muy favorables para el posicionamiento web (SEO) en los buscadores especialmente en Google.

No basta con tener configurado tu htaccess o algún script que permita trabajar con urls amigables, especialmente si trabajamos con una tabla de artículos necesitaremos crear un slug de los títulos para que puedan ser leídos por el método que usemos para generar urls amigables.

Aquí un método que anos ayudara en este proceso.

function caracteres_latinos($cadena){
	//acentos
	$cadena = ereg_replace("(À|Á|Â|Ã|Ä|Å|à|á|â|ã|ä|å)","a",$cadena);
	$cadena = ereg_replace("(È|É|Ê|Ë|è|é|ê|ë)","e",$cadena);
	$cadena = ereg_replace("(Ì|Í|Î|Ï|ì|í|î|ï)","i",$cadena);
	$cadena = ereg_replace("(Ò|Ó|Ô|Õ|Ö|Ø|ò|ó|ô|õ|ö|ø)","o",$cadena);
	$cadena = ereg_replace("(Ù|Ú|Û|Ü|ù|ú|û|ü)","u",$cadena);

	//la ñ
	$cadena = ereg_replace("(Ñ|ñ)","n",$cadena);

	//caracteres extraños
	$cadena = ereg_replace("(Ç|ç)","c",$cadena);
	$cadena = ereg_replace("ÿ","y",$cadena);

	return $cadena;
}

function generar_slug($cadena, $separador = '-'){
	//sin espacios al inicio o al final
	$cadena = trim($cadena);

	//limpiamos caracteres los latinos
	$cadena =  caracteres_latinos($cadena);

	//pasamos a minuscula la cadena
	$cadena = strtolower($cadena);

	//limpiamos saltos de lineas y tab
	$cadena = ereg_replace("[ \t\n\r]+", " ", $cadena);

	//limpiamos todos los caracteres invalidos
	$cadena = ereg_replace("[^ A-Za-z0-9_]", "", $cadena);

	//limpieza de espacios vacios de los valores invalidos al final de la cadena
	$cadena = trim($cadena);

	//reemplazamos los espacios vacios por el separador
	$cadena = str_replace(" ", $separador, $cadena);

	return $cadena;
}

$str = generar_slug('Así es el ejemplo para generar el Slug ¿o no?');

//retornara #-> asi-es-el-ejemplo-para-generar-el-slug-o-no
echo $str;

Muy sencillo pero practico, lo podemos usar para generar un slug del titulo de nuestros artículos y grabarlo en otro campo de nuestra tabla el cual se convertiría en un identificador de la noticia.

Esto es un script en php simple que nos permite tener banners aleatorios en cualquier sección de nuestra pagina Web.

// Creamos el array
$banners = array();

// Creamos los banners

$banners[] = array('src'  => 'anunciar.gif',
                  'url' => 'http://www.gacetaucayalina.com/nosotros/contactanos');

$banners[] = array('src'  => "dominio.gif",
                  'url' => 'http://www.gacetaucayalina.com/nosotros/contactanos');

$banners[] = array('src'  => "gaceta.gif",
                  'url' => 'http://www.jacknoticias.com/');

/*
NOTA: Puedes seguir agregando más banners de la siguiente forma

$banners[] = array('src'  => "url_imagen",
                  'url' => "pagina_web");

*/

$rand_key = array_rand($banners, 1);

$banners_a = $banners[$rand_key];

$src = $banners_a['src'];
$url = $banners_a['url'];

echo '<a href="'.$url.'"><img src="'.$src.'"/></a>';

Sencillo pero usable puede ver un ejemplo simple aqui

El concepto de clases o método final se utiliza para promocionar al desarrollador un medio de control sobre la herencia. Las clases o métodos declarados como finales se pueden extender y/o sobrecargar mediante clases hijas. Para asegurarnos de que nunca se sobrecargué una clase o método determinado, simplemente añadimos la palabra clave final a la definición de método o clase, como muestra el ejemplo siguiente.

		final class NoExtending{
		public function myFunction(){
			/* Lógica de la Función */
		}
	}

	class restrictedExtending{
		final public function anotherFunc(){
			/* Lógica de la Función */
		}
	}

	class myChild extends restrictedExtending{
		public function thirdFunction(){
			/* Lógica de la Función */
		}
	}

Hemos definido tres clases individuales. La primera de estas clases, la clase NoExtending nunca podrá ser la clase padre de una clase hija por que toda la clase se a declarado como final. Por otro lado, aunque la clase restrictedExtending puede extenderse, el método anotherFunc() dentro de ella no se puede sobrecargar mediante una clase hija. Si nos damos cuenta la palabra clave final es útil para asegurarnos de que las cosas se hacen de una forma determinada dentro de las estructuras de nuestros objetos, aunque siguen permitiendo a los usuarios implantar sus propias subclases.

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).