• Pido cita (día y hora para hacer el examen a través de la página de Pearson VUE que es la empresa encarga de autorizar centros para la realización del exámen)
• Cuadro la cita con mis vacaciones
• Dos días antes del examen, repaso y hago exámenes de pruebas (se pueden comprar en la página de Zend)
• Me presento en el centro. Me tienen 30 minutos de reloj esperando para al final decirme que no puedo hacer el exámen ya que, según ellos, los de Pearson Vue han cambiado el programa y desde entonces, a ellos no les funcionan por no se cuantas escusas más.
• Me traslado a mi pueblo e intento cambiar el examen, pero ya no me dejan por que ya ha pasado.
• Tengo que llamar varias veces hasta contactar con Pearson (más vale que habléis inglés si os pasa esto) para realizar la reclamación. Tengo que mandar un e-mail a una dirección determinada.
• Mando el e-mail y contactan conmigo dos días después. Hablan con el centro y en teoría en una o dos semanas estará todo arreglado.
• Pasan las semanas, mando e-mail sin respuestas hasta que estallo y mando un e-mail acordándome de ciertos parientes. A este e-mail si que recibo respuesta. Intercambio de e-mail con tono tenso.
• Busco centro en Madrid (agosto), llamo al centro pero hasta septiembre está cerrado y no me pueden dar información.
• Llamo el 2 de septiembre y me comunican que el sistema funciona correctamente y puedo realizar el examen.
• Programo viaje para finales de septiembre (y de paso de turismo).
• Por fin hago el examen el 25 de septiembre en el centro Azpe de Madrid.
• Apruebo!!!!

Cómo podéis comprobar, el camino ha sido largo, pero bueno, ya se ha acabado y ahora toca prepararse para el SCJP de Java.

En cuanto al examen, lo que os puedo contar es que es algo más difícil que los de test, principalmente por que aparecen cuestiones referentes a funciones que no están incluidas en el libro de preparación de Apress. No os puedo contar más ya que te hacen firmar que no comentes nada sobre el examen. De todas formas, si os preparáis bien y lleváis bien controlado todo lo que aparece en el libro de Apress, (y mucha práctica, por supuesto), no tendréis problemas para sacaros la certificación.

En cuanto al lugar y forma de realizar el examen, pues lo más resañable sería que cuando lleguéis os verificarán vuestra identidad mediante la solicitación de dos documentos identificativos, luego os pedirán firmar algún documento, iréis a un habitáculo cerrado con cámara, no se puede entrar con ningún objeto personal, ni incluso el reloj. La pantalla del programa de preguntas es toda blanca y podréis revisar todas las preguntas en cualquier momento hasta al hacer clic sobre el botón de evaluar, y por supuesto, todo en inglés.

Espero que más o menos, os haya aclarado un poco la idea del examen.

Un saludo y ánimo a todos

P.D.: aquí os dejo el logotipo con el enlace al perfil mi certificación

Haz clic en el logo para ver mi perfil

Pero, a lo que iba en este post: la certificación Zend de PHP. He comenzado a prepararme seriamente dicha certificación que tenía en mente hace ya mucho tiempo. He comprado el Voucher (ticket para poder hacer el examen) y 5 exámenes de prueba. Tengo previsto realizar la prueba dentro un mes, durante junio probablemente. El examen se puede realizar en cualquier centro Vue autorizado y consiste en 70 preguntas tipo test, multiselección o de escritura, durante un tiempo máximo de 90 minutos. El temario intenta contemplar todos los ámbitos de PHP, he incluso diferencias entre la versión 4 y la 5. Una vez superada la prueba, tu perfil aparece en un listado en la página de Zend, con la gente que ha aprobado el examen, y cuya finalidad es de que si alguna empresa necesita de un programador PHP certificado, pueda ser fácil encontrarlo. Además, te ofrecen colocar un logo de la certificación enlazado con tu perfil de usuario dentro de Zend. El porcentaje de preguntas aprobadas necesarias para poder aprobar el examen, no lo he encontrado en ningún sitio, así que no puedo dar detalles sobre ese tema.

Dentro de unos días, tengo intención de continuar escribiendo tutoriales que nos ayuden con el día a día, dentro de nuestro mundo de la programación web.

Un saludo

Un problema que podemos tener al trabajar con nuestra base de datos, es que ésta no esté disponible en un momento determinado por que esté sobrecargada o por que no hay posibilidad de conexión. Por ello, debemos controlar que si no tenemos conexión a la base de datos, la ejecución de nuestra aplicación sea detenida inmediatamente (en el caso de que el uso de la base de datos sea crítico y nuestra aplicación sea 100% dependiente de la conexión a la base de datos.

Existen multitud de formas de controlar y gestionar los errores. PHP nos da ciertas herramientas para intentar capturar estas situaciones. En el ejemplo vamos a utilizar la función exit, que permite detener inmediatamente la ejecución de nuestro script, y también la función error_log que permite registrar en el log de errores de nuestro servidor web un evento, en nuestro caso, una frase identificadora para que podamos saber cúando ha pasado el problema. Si tenemos un hosting contratado (no un servidor dedicado), es prácticamente seguro que no tendremos acceso al fichero de logs del servidor web, pero lo bueno de esta función es que también es capaz de guardar el registro que nosotros queramos en un derminado fichero o incluso mandar un e-mail a una determinada cuenta. Recomiendo mirar la documentación por que además de las capacidades citadas, permite más opciones, las cuales puedes ser muy útiles para nuestra aplicación.

Lo que vamos a hacer es modificar la función pública conectar() de la clase Db. En dicha función vamos a detectar si nuestra conexión ha fallado, y si se da el caso, registrar dicho error para luego diagnosticar el problema, además de mostrar un error por pantalla avisando al visitante de existe un problema con nuestra aplicación.

/*Realiza la conexión a la base de datos.*/
private function conectar(){
   switch ($this->tipo){
      case 'mysql':       $link=mysql_connect($this->servidor, $this->usuario, $this->password);
                          if ($link){
                             mysql_select_db($this->base_datos,$this->link);
                             @mysql_query("SET NAMES 'utf8'");
                          }
                          break;

      case 'postgress':   $this->link=pg_connect("host=".$this->servidor." dbname=".$this->base_datos." user=".$this->usuario." password=".$this->password)
                          break;
      break;
   }
   if (!$link){
      error_log(0,'Problema de conexión a la base de datos.');
      exit('Perdonen las molestias. Tenemos un problema técnico. Esperamos resolverlo en los próximos minutos');
   }else{
      $this->link=$link;
   }
}

Descargar fichero Db.class.php actualizado (en formato UTF8)

Con esto ponemos fin a una pequeña colección de tips. Espero que esto les haya servidor para ir aprendiendo como poder crear y desarrollar una clase, utilizar un patrón de diseño y crear niveles de abastracción.

Temas relacionados:

Crear una clase para conectar a la base de datos

Crear una clase para conectar a la base de datos (II)

Crear una clase para conectar a la base de datos (III)

En esta siguiente parte del tutorial vamos a realizar una sencilla mejora para hacer que nuestra clase sea capaz de conectarse a diferentes tipos de base de datos. En concreto vamos a ver cómo adaptarla para que se conecte a PostgreSQL.

Lo primero que debemos realizar es agregar una nueva variable a nuestro fichero de configuración:

config.php

//Datos de configuración de la conexión a la base de datos

//Servidor
$host='localhost';

//Usuario
$user='user';

//Password
$password='test';

//Base de datos a utilizar
$db='testDB';

//Qué sistema gestor de base de datos utilizamos, mysql, oracle, ...
$dbType='mysql'

Podemos observar una nueva última variable llamada dbType la cual utilizaremos para saber que tipo de base de datos vamos a utilizar.

Ahora vamos a adaptar nuestra clase Conf para que lea dicho valor y lo guarde ($_dbType). Además agregaremos una función getDBType() para poder obtener dicho valor.

Conf.class.php

Class Conf{
   private $_domain;
   private $_userdb;
   private $_passdb;
   private $_hostdb;
   private $_db;
   private $_dbType;

   private static $_instance;

   private function __construct(){
      require 'config.php';
      $this->_domain=$domain;
      $this->_userdb=$user;
      $this->_passdb=$password;
      $this->_hostdb=$host;
      $this->_db=$db;
      $this->_dbType=$dbType;
   }

   private function __clone(){ }

   private function __wakeup(){ }

   public static function getInstance(){
      if (!(self::$_instance instanceof self)){
         self::$_instance=new self();
      }
      return self::$_instance;
   }

   public function getUserDB(){
      $var=$this->_userdb;
      return $var;
   }

   public function getHostDB(){
      $var=$this->_hostdb;
      return $var;
   }

   public function getPassDB(){
      $var=$this->_passdb;
      return $var;
   }

   public function getDB(){
      $var=$this->_db;
      return $var;
   }

   public function getDBType(){
	  $var=$this->_dbType;
	  return $var;
   }

}

Por último los cambios más significativos vienen dentro de nuestra clase Db. Dentro de las funciones de conectar, ejecutar una query y obtener una fila de resultados es dónde podemos ver cómo en función del  valor tipo de base de datos, la clase utiliza unas funciones u otras.

Db.class.php

/* Clase encargada de gestionar las conexiones a la base de datos */
Class Db{

   private $servidor;
   private $usuario;
   private $password;
   private $base_datos;
   private $tipo;
   private $link;
   private $stmt;
   private $array;

   private static $_instance;

   /*La función construct es privada para evitar que el objeto pueda ser creado mediante new*/
   private function __construct(){
      $this->setConexion();
      $this->conectar();
   }

   /*Método para establecer los parámetros de la conexión*/
   private function setConexion(){
      $conf = Conf::getInstance();
      $this->servidor=$conf->getHostDB();
      $this->base_datos=$conf->getDB();
      $this->usuario=$conf->getUserDB();
      $this->password=$conf->getPassDB();
      $this->tipo=$conf->getDBType();
   }

   /*Evitamos el clonaje del objeto. Patrón Singleton*/
   private function __clone(){ }

   private function __wakeup(){ }

   /*Función encargada de crear, si es necesario, el objeto. Esta es la función que debemos llamar desde fuera de la clase para instanciar el objeto, y así, poder utilizar sus métodos*/
   public static function getInstance(){
      if (!(self::$_instance instanceof self)){
         self::$_instance=new self();
      }
      return self::$_instance;
   }

   /*Realiza la conexión a la base de datos.*/
   private function conectar(){
      switch ($this->tipo){
         case 'mysql':     $this->link=mysql_connect($this->servidor, $this->usuario, $this->password);
	                   mysql_select_db($this->base_datos,$this->link);
	                   @mysql_query("SET NAMES 'utf8'");
			   break;

       case 'postgress':   $this->link=pg_connect("host=".$this->servidor." dbname=".$this->base_datos." user=".$this->usuario." password=".$this->password)
		           break;
       break;
      }
   }

   /*Método para ejecutar una sentencia sql*/
   public function ejecutar($sql){
      switch ($this->tipo){
         case 'mysql':     $this->stmt=mysql_query($sql,$this->link);
			   break;
         case 'postgress': $this->stmt=pg_Euery($this->link,$sql);
			   break;
         break;
      }
      return $this->stmt;
   }

   /*Método para obtener una fila de resultados de la sentencia sql*/
   public function obtener_fila($stmt,$fila){
      switch ($this->tipo){
         case 'mysql':     if ($fila==0){
	                      $this->array=mysql_fetch_array($stmt);
	                   }else{
	                      mysql_data_seek($stmt,$fila);
	                      $this->array=mysql_fetch_array($stmt);
	                   }
	                   break;
         case 'postgress': if ($fila==0){
			      $this->array=pg_fetch_row($stmt);
			   }else{
			      $this->array=pg_fetch_row($stmt,$fila);
			   }
			   break;
          break;
      }
      return $this->array;
   }

}

En el siguiente y última parte, veremos cómo controlar los errores.

Un saludo

Ficheros del ejemplo (en formato UTF-8)

Temas relacionados:

Crear una clase para conectar a la base de datos

Crear una clase para conectar a la base de datos (II)

Crear una clase para conectar a la base de datos (IV)

En en esta segunda parte vamos a ver como crear una clase, siguiendo también el patrón Singleton, que sea capaz de leer un fichero de configuración. En este fichero de configuración aparecerán los parámetros de conexión a nuestra base de datos, además de otros valores que puedan ser interesantes para nuestra aplicación. Con ello, haremos que nuestras clases sean reutilizables sin la necesidad de editarlas para adaptarlas al proyecto de turno.

Lo primero de todo veamos la estructura del fichero de configuración:

config.php

//Datos de configuración de la conexión a la base de datos

//Servidor
$host='localhost';

//Usuario
$user='user';

//Password
$password='test';

//Base de datos a utilizar
$db='testDB';

La estructura de este fichero es muy sencilla y se limita a un conjunto de variables que contiene la información necesaria para conectarse a la base de datos.

Ahora veamos la estructura de la clase Conf

Conf.class.php

Class Conf{
   private $_domain;
   private $_userdb;
   private $_passdb;
   private $_hostdb;
   private $_db;

   static $_instance;

   private function __construct(){
      require 'config.php';
      $this->_domain=$domain;
      $this->_userdb=$user;
      $this->_passdb=$password;
      $this->_hostdb=$host;
      $this->_db=$db;
   }

   private function __clone(){ }

   public static function getInstance(){
      if (!(self::$_instance instanceof self)){
         self::$_instance=new self();
      }
      return self::$_instance;
   }

   public function getUserDB(){
      $var=$this->_userdb;
      return $var;
   }

   public function getHostDB(){
      $var=$this->_hostdb;
      return $var;
   }

   public function getPassDB(){
      $var=$this->_passdb;
      return $var;
   }

   public function getDB(){
      $var=$this->_db;
      return $var;
   }

}

Como podemos observar en el código, lo único que hace esta clase es la inclusión del fichero de configuración y la importación de los valores de las variables a variables privadas de la clase. Mediante métodos podremos obtener los valores que necesitemos de la configuración sin peligro de sobreescribir ninguno de los valores, algo que si requiriésemos el fichero config.php en cualquier lugar, sería muy probable que nos pasase. Ahora debemos realizar algunas modificaciones sencillas dentro del fichero de nuestra clase de base de datos, Db.class.php:

/* Clase encargada de gestionar las conexiones a la base de datos */
Class Db{

   private $servidor;
   private $usuario;
   private $password;
   private $base_datos;
   private $link;
   private $stmt;
   private $array;

   static $_instance;

   /*La función construct es privada para evitar que el objeto pueda ser creado mediante new*/
   private function __construct(){
      $this->setConexion();
      $this->conectar();
   }

   /*Método para establecer los parámetros de la conexión*/
   private function setConexion(){
      $conf = Conf::getInstance();
      $this->servidor=$conf->getHostDB();
      $this->base_datos=$conf->getDB();
      $this->usuario=$conf->getUserDB();
      $this->password=$conf->getPassDB();
   }

   /*Evitamos el clonaje del objeto. Patrón Singleton*/
   private function __clone(){ }

   /*Función encargada de crear, si es necesario, el objeto. Esta es la función que debemos llamar desde fuera de la clase para instanciar el objeto, y así, poder utilizar sus métodos*/
   public static function getInstance(){
      if (!(self::$_instance instanceof self)){
         self::$_instance=new self();
      }
         return self::$_instance;
   }

   /*Realiza la conexión a la base de datos.*/
   private function conectar(){
      $this->link=mysql_connect($this->servidor, $this->usuario, $this->password);
      mysql_select_db($this->base_datos,$this->link);
      @mysql_query("SET NAMES 'utf8'");
   }

   /*Método para ejecutar una sentencia sql*/
   public function ejecutar($sql){
      $this->stmt=mysql_query($sql,$this->link);
      return $this->stmt;
   }

   /*Método para obtener una fila de resultados de la sentencia sql*/
   public function obtener_fila($stmt,$fila){
      if ($fila==0){
         $this->array=mysql_fetch_array($stmt);
      }else{
         mysql_data_seek($stmt,$fila);
         $this->array=mysql_fetch_array($stmt);
      }
      return $this->array;
   }

   //Devuelve el último id del insert introducido
   public function lastID(){
      return mysql_insert_id($this->link);
   }

}

Podemos ver que en la clase hay un nuevo método privado llamado setConexion() el cual se encarga de instanciar el objeto de la clase Conf y establecer el valor de las variables privadas que tenemos en la clase Db. Luego el proceso es el mismo que en la primera parte del tutorial.

Veamos que cómo debería quedar el código de ejemplo para que nos funcionase con la nueva clase:

/*Incluimos el fichero de la clase Db*/
require 'Db.class.php';
/*Incluimos el fichero de la clase Conf*/
require 'Conf.class.php';

/*Creamos la instancia del objeto. Ya estamos conectados*/
$bd=Db::getInstance();

/*Creamos una query sencilla*/
$sql='SELECT NOMBRE FROM CLIENTES';

/*Ejecutamos la query*/
$stmt=$bd->ejecutar($sql);

/*Realizamos un bucle para ir obteniendo los resultados*/
while ($x=$bd->obtener_fila($stmt,0)){
echo $x['NOMBRE'].'<br />';
}

Cómo podemos observar, únicamente hemos añadido un require para la nueva clase creada. Nada más. En la siguiente parte del tutorial veremos cómo podemos hacer que esta clase se conecte a diferentes tipos de base de datos.

Un saludo

Ficheros del ejemplo (en formato UTF-8)

Temas relacionados:

Crear una clase para conectar a la base de datos

Crear una clase para conectar a la base de datos (III)

Crear una clase para conectar a la base de datos (IV)

El problema que ya comenté en un post anterior (Cargar Google Analytics una vez se haya cargado la página), es que esto, en según que momentos, puede enlentecer de una forma muy grave nuestra página, o por ejemplo, el mapa lo tenemos en una pestaña que por defecto no es visible. Por ello, podemos obtar por una solución que incrementará sustancialmente la velocidad de carga de nuestra página y que se encargará de que, una vez se haya cargado la página, proceder a la descarga y la inicialización del nuestro Google Map.

Esta no es la única utilidad, también podríamos cargar nuestro Google Map a voluntad mediante la pulsación de cualquier elemento. Esto nos permitiría que en una página no cargásemos el Google Map hasta que el usuario decidiese utilizaro, aliviando la carga de nuestra página.

Veamos un ejemplo práctico llamando a Google Maps una vez se ha terminado la carga de nuestra página:
http://www.marcosdev.com/ejemplos/googlemaps_async/

Lo primero de todo, veamos la estructura de nuestros ficheros:

Por un lado tenemos un fichero html en el cual hay una capa que utilizaremos para insertar nuestro Google Maps y las llamadas a los ficheros googleMaps.js y jquery.js.

< !DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
   <title>Ejemplo de carga de forma asíncrona de Google Maps</title>
</head>
<body>
   <div id="mapa" style="width:300px;height: 300px">
      <p style="text-align:center"><strong>Cargando</strong></p>
   </div>
   <script type="text/javascript" src="jquery.js"></script>
   <script type="text/javascript" src="googleMaps.js"></script>
</body>
</html>

Cómo podemos ver, el div con id “mapa” tiene un texto interior que pone “Cargando”. Esto es para que mientras se carga nuestro Google Maps el visitante pueda saber que el navegador está trabajando. Después del div, insertamos las dos llamadas a nuestros ficheros javascript. El primero es la librería jQuery que nos ayudará realizar la petición de carga del conjunto de ficheros necesarios para cargar Google Maps.

En el fichero googleMaps.js tenemos el código necesario para realizar la carga del mapa:

function cargarMapa(){
   if (GBrowserIsCompatible()) {
      var map = new GMap2(document.getElementById("mapa"));
      map.setCenter(new GLatLng(39.578678,2.646021), 16);
   }
};

$(document).ready(function(){
   var api='ABQIAAAAOxTvdJxbyGuGB8_UUEe52xRHT0E5MDpBZnfhvo0jhLIefK70hRTYIol4_Lr75EWTtT9VjcaZzY2QWg';
   $.getScript('http://maps.google.com/maps?file=api&v=2.x&key='+api+'&async=2&callback=cargarMapa');
});

Lo primero que vemos es una función llamada “cargarMapa” la cual será llamada una vez tengamos cargada la librería de Google Maps. Esta función únicamente se encarga de mostrar nuestro Google Maps en un determinado div (en nuestro caso el div llamado “mapa“) y situarlo en una coordenada (new GLatLng(39.578678,2.646021)) con un determinado zoom (16).

La parte interesante viene justo después. Vemos el comienzo típico de cualquier fichero js que jQuery ( $(document).ready(function(){ ) y justo después dos líneas de código; la primera es una variable en la cual, por cuestiones de tener un código más legible, guardo el clave del api de Google Maps. Y en el segundo realizo la petición, que a simple vista, es la misma url que normalmente nos da google para poner en las etiquetas <script>. Pero si nos fijamos, existe dos diferencias. Justo al final de la línea vemos que hay dos parámetros de url nuevos: &asyn=2&callback=cargarMapa. El primero (async=2) permite llamara de forma asíncrona (cuando nosotros queramos y no siempre cuando se carga el documento al completo), y el segundo (callback=cargarMapa) es el parámetro que le dice a Google Maps que función debe ejecutar una vez tenga todo lo necesario cargado para ser ejecutado.

Ponerlo en práctica es tremendamente sencillo y podemos sacarle mucha utilidad al tema, como por ejemplo, la siguiente demostración dónde cargamos el mapa cuando alguien hace clic sobre un botón:

http://www.marcosdev.com/ejemplos/googlemaps_async/index2.html

La diferencia entre el primer ejemplo y este segundo, reside en que la capa “mapa” la tengo escondida y que en vez de cargar el mapa directamente, le agrego una funcionalidad al botón para que este lo carge cuando hagan clic sobre él, y además, haga visible la capa:

< !DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
   <title>Ejemplo de carga de forma asíncrona de Google Maps</title>
</head>
<body>
   <div id="mapa" style="width:300px;height:300px;display:none;">
      <p style="text-align:center"><strong>Cargando</strong></p>
   </div>
   <input type="button" name="bCargar" id="bCargar" value="Cargar Mapa" />
   <script type="text/javascript" src="jquery.js"></script>
   <script type="text/javascript" src="googleMaps.js"></script>
</body>
</html>

function cargarMapa(){
   if (GBrowserIsCompatible()) {
      var map = new GMap2(document.getElementById("mapa"));
      map.setCenter(new GLatLng(39.578678,2.646021), 16);
  }
};

$(document).ready(function(){

   //Agregamos evento click al botón
   $('#bCargar').click(function(){
      //Mostramos la capa mapa
      $('#mapa').show();
      var api='ABQIAAAAOxTvdJxbyGuGB8_UUEe52xRHT0E5MDpBZnfhvo0jhLIefK70hRTYIol4_Lr75EWTtT9VjcaZzY2QWg';
      $.getScript('http://maps.google.com/maps?file=api&v=2.x&key='+api+'&async=2&callback=cargarMapa');
   });
});

Espero que les sea útil

P.D.: Los estilos de la capa “mapa” están escritos utilizando el atributo style. Esto no es una buena práctica; hay que utilizar ficheros CSS de estilos. Lo he hecho así para hacerlo más visible para todos.

P.D2.: En el segundo ejemplo se podría insertar la capa “mapa” en tiempo real sin necesidad de que esté en el código, pero sería menos didácticos para aquellas personas que tengan un nivel bajo de Javascript.

Durante estos meses se me ha encargado el objetivo de dar vida a este proyecto. Estoy orgulloso de este proyecto por el cariño que le he puesto, y bajo mi punto de vista, el gran resultado que se ha conseguido. No hemos conseguido tener listo para esta primera versión todas las características que queríamos, pero creo que el resultado ha sido muy bueno.

El portal está desarrollado utilizando las siguientes tecnologías: XHTML Strict 1.0, CSS 2.1, jQuery, PHP 5 y MySQL5.

No me queda más que invitarles a visitar el portal.

1. Crea tu página utilizando los estándares. Si cumples con las normas propuestas por el W3C sobre el tipo de documento que quieras utilizar (HTML 4, 5, XHTML 1, 1.1, Transicional o Strict,…), conseguirás que los buscadores entiendan mejor el contenido y estructura de la página. Además, hacer las páginas cumpliendo los estándares te aseguras que a medida que los navegadores mejoren con este tema, tu página se vea igual en todos los navegadores. Para comprobar que tu código es correcto puedes utilizar el validador de código que pone en nuestras manos la W3C: http://validator.w3.org/check
   
2. Haz a tu página accesible. La accesibilidad es la capacidad que tiene tu página para ser utilizada por personas con minusvalías. Es cierto que ha un buscador le va a dar igual si el contraste es alto o no entre la fuente y el fondo, pero no lo que si no le va dar igual es si pones textos alternativos a las imágenes, títulos a los enlaces, documentas la relación de los enlaces con la página que estés creando,… Una manera fácil de comprobar la accesibilidad de nuestra página, es utilizar este comprobador on-line que podéis encontrar en la siguiente dirección: http://www.accesible.com.ar/examinator/. Este validador no asegura que tu página sea accesible al 100% ni mucho menos, pero si que te ayuda a mejorar muchísimas cosas. Además, en el mundo de la accesibilidad hay muchos niveles (WAI) y para muchas reglas no se pueden utilizar herramientas automáticas.
3. Reduce el uso de Flash al mínimo. Los buscadores no son capaces de entender un objeto Flash ni su contenido. Es cierto que Google comienza a leer el contenido de los ficheros Flash y que Adobe cada vez está facilitando la tarea para que esto lo puedan hacer todos los navegadores, pero a día de hoy, la cosa está muy limitada. Además las páginas hechas completamente en Flash no permite copiar la URL de un determinado Producto – Artículo – Documento,… y que una página nos enlace directamente a esa sección y aumentando el PageRank.
4. Utiliza encabezados H1, H2, H3..H6. Las etiquetas de encabezado permiten identificar dentro del código que títulos son importantes y además dan información de cual es el orden de importancia. A los buscadores les encanta los encabezados.
5. Utiliza metatags para informar sobre el contenido de tus páginas, pero eso si, cuidado que hay metatags que no son estándar y por lo tanto no te van a ayudar.
6. Los metatags deben ser diferentes en cada página. No pongas las mismas palabras claves, ni descripción, ni título en todas páginas que componen tu web.
7. El título es una de las partes más importantes de una web, normalmente es lo que suele aparecer en los resultados de la búsqueda. No repitas títulos y piénsalos bien utilizando las palabras claves por las cuales quieres que te encuentren.
8. Haz tus páginas livianas. Los motores de búsquedas descartan visitar páginas excesivamente pesadas.
9. Separa la apariencia totalmente de la estructura de la página. Para crear la estructura de la página se utiliza HTML, para la apariencia se utiliza CSS, para la interactividad Javascript (u otra tecnología). No metas todo en el mismo fichero. Todo bien separadito.
10. Reduce al máximo el uso de Javascript y Ajax. Los buscadores no podrán llegar a los contenidos que sólo sean accesibles mediante la utilización de Javascript.
11. Si tu proyecto precisa de la utilización de Ajax para, por ejemplo, refrescar una lista de resultados de una búsqueda, haz que esos resultados también sean accesibles de otra forma, como por ejemplo, una página con un listado, utilización de sitemaps, tanto visuales como en xml.
12. No utilices enjambres de enlaces (páginas con miles de enlaces) para conseguir enlaces hacia tu web. Google te penalizará.
13. Si tu página es dinámica, haz amigable las URL. Google si que sabe utilizar más de un parámetro, pero no los tiene bien considerados. El resto de buscadores sufren bastante. Utiliza mod_rewrite para formatear la apariencia de las URL. Esto te beneficia de cara al buscador y al navegante, ya que le parece mucho más clara y fácil de recordar que una URL plagada de variables concatenadas. Ej: http://www.ejemplo.com/producto.php?id=25&cat=5 -> pasaría a ser http://www.ejemplo.com/productos/informatica/25/intel-core-2-duo.
14. Evita el contenido duplicado. Hacer la URL amigables es una tarea indispensable, pero tiene un problema congénito: la posibilidad de que infinitas URL lleven al mismo contenido. Si observas el punto anterior, si cambias el texto final inte-core-2-duo por lo que sea, se mostraría el mismo contenido. Esto es un problema. Google puede pensar que estás haciendo algún tipo de spam o que tienes contenido duplicado. Además, dispersas la posibilidad de incrementar el PageRank de esa página en cuestión. Debes poner mecanismos para que si alguien modifica la URL, se autocorriga y vaya a la dirección correcta. (Redirección 301).
15. Canoniza la URL: para google es distinto www.ejemplo.com que ejemplo.com, sin las www. Esto es otro problema de contenido duplicado. Se puede acceder a la misma información con las www que sin ellas. Ya sea por programación o utilizando el fichero .htaccess, debes elegir una forma y obligar que si alguien va a la que tu no has elegido, se cambie automáticamente. Por ejemplo, tu decides que la forma correcta es www.ejemplo.com, pues si alguien escribe en el navegador ejemplo.com, esta dirección debe ser automáticamente remplazada por www.ejemplo.com. (Redirección 301).
16. Utiliza las redirecciones. Si tu proyecto está en marcha y quieres aplicar algunas de las técnicas aquí mencionadas, lo que no debes hacer es eliminar las direcciones antiguas. Lo que debes hacer es que si alguien teclea la dirección de una determinada página la cual tu ahora quieres que se acceda en otra dirección, debes detectar ese comportamiento y mandar una redirección 301. Esto es para intentar que el PageRank que tu viera la página vieja fluctúe hacia la página nueva.
17. Ten el máximo de contenido original posible, es decir, que no esté en otras webs. Una página que escribe su propio contenido, con sus propios textos y además, éste es bastante exclusivo, tendrá mejor PageRank. ¿por qué?, por que Google se ha puesto al día con el tema de los blogs y sabe que muchos copian la misma noticia tal cual. Si tu página está creciendo y tiene poco o nada de PageRank, esto te puede perjudicar mucho. Además, si un visitante observa que en tu página copias / pegas noticias de otros sitios, normalmente se queda con los sitios que ya conocía (Refrán: más vale lo malo conocido que lo bueno por conocer).
18. Las páginas diseñadas para la impresión pueden producir contenido duplicado. Muchas veces nos vemos obligados a tener que preparar un página distinta a la página que está viendo el visitante para que se la pueda imprimir. Este caso es muy típico de páginas de venta de productos y de noticias. Si Google entra en estas páginas y considera que puede ser contenido duplicado, os penalizará. Si se accede a través de un enlace html, solventar este problema es tan simple como poner el atributo rel el texto nofollow. Esto le dice a los buscadores que no deben seguir ese enlace y lo deben ignorar.
19. No realices malas prácticas como mostrar una información distinta si el que te visita es un buscador o un visitante normal. Si Google lo detecta, te pegará una buena penalización. Pero hecha la regla hecha la trampa. Hay sitios que tienen carta blanca para hacerlo ya que hay una “justificación”. Algunos diarios muy grandes no son penalizados por utilizar esta técnica. ¿Por que la utilizan?, son el tipo de medios que debes pagar para ver un contenido, pero si haces la búsqueda aparecen en Google.
20. Intenta que esté visible todo el texto posible. Google ya entiende los ficheros CSS y sabe interpretar que un div esté o no visible, que el texto y el color del div sean el mismo, que tengan ciertas técnicas para camuflar el div, … Todo esto hará que Google te penalice (en el caso de malas artes) o que no de prioridad a los textos que están ocultos (ya sea por que con javascript iremos mostrándolos, por ejemplo, como pestañas).
21. Escribe el texto pensando que lo más importante esté en las primeras líneas. Los buscadores dan prioridades a los textos que van indexando, siendo las primeras líneas las mejor indexadas.
22. Navega como un buscador. Intenta ver si eres capaz de navegar por tu página y ver el contenido que tu quieres de la forma que lo vería un Buscador: http://seobrowser.com. Esta página te permite ver más o menos como verían tu página los buscadores y te permite ver si se puede navegar o no.
23. Date de alta en el directorio dmoz.org. Es un directorio de webs revisado por humanos, y al principio de los tiempos de los buscadores, éstos lo utilizan bastante. Ahora, su importancia ha bajado mucho, pero todavía tiene su pequeña aportación.
24. Utiliza las herramientas para webmasters de Google, como Sitemap o Google Analytis. He comprobado que utilizando la herramienta de estadísticas se acelera el proceso de indexación y además mejora la profundidad.
25. Calidad de los enlaces. Ya no es tanto la cuestión de número de enlaces que hay apuntándote hacia tu página, si no de la calidad. Es mucho mejor tener pocos enlaces pero en páginas con pagerank alto. Ese pagerank afectará al pagerank de tu página. Pero también hay que tener en cuenta la temática de los enlaces que apuntan hacia tu página. Si tienes una página tecnológica ¿que hace una página de cocina con enlaces a tu página?.
26. Edad del dominio.
27. Textos escritos con las keywords (palabras claves) por las que quieres que te encuentren.
28. Utiliza la etiqueta <b></b> para resaltar en negrita contenido importante.
29. No pongas más de 100 enlaces diferentes dentro de la misma página.
30. Evita URL largas. Por ejemplo:
    - Ejemplo malo: http://www.ejemplo.com/tienda/categoria/subcategoria/producto/25/nombre-producto
    - Ejemplo bueno: http://www.ejemplo.com/producto/25/nombre-producto
31. Sintaxis recomendada para el título:
    Nombreweb | Categoría > Subcategoria > Ítem
32. Evita el uso de cierto elementos para crear la navegación:
    - Inputs
    - Sesiones en la URL
    - Páginas restringidas por Cookies
    - Frames
    - Logins innecesarios.