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

Esta forma de trabajar implica un problema muy serio si nuestro proyecto va orientado a una intranet, en la cual, de la noche a la mañana pueden tener la necesidad de cambiar la base de datos por otra diferente (por ejemplo, que una intranet crezca mucho y necesiten cambiar a una base de datos Oracle por funcionalidades específicas).

Si se da este caso podríamos tener un problema muy grave; deberíamos revisar todo el código que hemos escrito en busca de esas funciones específicas y adaptarlas a la nueva base de datos.

Para solventar este problema (crear una capa que nos abstraiga de que base de datos estemos utilizando) y además crear posibles funcionalidades nuevas, vamos a crear una clase muy sencilla la cual nos permita conectarnos a la base de datos. Esta clase la vamos a crear siguiendo el patrón de diseño Singleton. Los patrones de diseño son soluciones a problemas típicos de programación que se repiten contínuamente. El patrón Singleton nos ayuda a crear una clase la cual, si intentamos crearla dos veces, esta realmente sólo es una. En vez intentar crear el objeto, lo que haremos es instanciarlo. Esto nos permite conectarnos a la base de datos en cualquier punto del código (dentro de funciones, dentro de objectos,…) sin necesidad de crear más conexiones o tener que pasarla por parámetro (en el caso de querer que una función determinada que tengamos creada utilice una conexión existente y no cree otra nueva).

La estructura de la clase sería la siguiente:

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

private $servidor='localhost';
private $usuario='user';
private $password='test';
private $base_datos='testDB';
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->conectar();
}

/*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);
}

}

En esta clase, cómo podemos obsevar, existen varios métodos para conectar, obtener resultados de una query así como el último id que se ha creado mediante un Insert en un campo  clave autoincremental.

Ahora veamos como utilizar esta clase:

/*Incluimos el fichero de la clase*/
require 'Db.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 />';
}

Muy sencillo y práctico.

Esta clase es muy (MUY) mejorable. Por ejemplo, en el siguiente tip veremos como utilizar un fichero de configuración que será utilizado por una clase llamada Conf, la cual será utilizada a su vez por esta clase que acabamos de crear. Además, introducir control de errores de conexión, niveles de seguridad para utilizar diferentes perfiles según el ámbito de la conexión,…

Esta clase va dirigida a aquellas personas que todavía no utilizan un Framework y siguen trabajando directamente sobre PHP.

Ficheros del ejemplo (en formato UTF-8)

Temas relacionados:

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

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

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

Duración: 13:03

Descarga en formato QuickTime

Como toda buena práctica de programación, nuestro código incluye sangrías y comentarios. Si no ponemos sangrías nuestro código se hace incomprensible, y si le quitamos los comentarios, dentro de unos meses nos acordaremos de aquel día que decidimos no escribir una frase aclaratoria de que hacía aquella función.

Por ello, existen multitud de herramientas que permite que a partir de un fichero javascript nuestro, se genere un fichero javascript reducido, es decir, sin espacios, sin comentarios, e incluso ofuscado (cambia nombre a las variables por letras o números y trata de reducir la comprensión del código por alguien que quiera copiarnos o analizarnos para un ataque).

Estas herramientas el problema que tienen es que debes tener un fichero para el desarrollo y luego de haber hecho los cambios oportunos, debes generar el fichero reducido.

En este tutorial veremos como podemos reducir en tiempo real los ficheros Javascript que precise nuestro documento mediante PHP (es necesario tener la versión 5). Además, si nuestra página utiliza más de un fichero js (javascript), lograremos reducir las peticiones al mínimo. Por ejemplo, nuestra página utiliza tres ficheros js nuestros, son tres peticiones. Lograremos reducirlo a únicamente una petición. Caso aparte es cuando debes realizar la inclusión de un fichero js como el de Google Maps, con el cual no puedes utilizar esta técnica.

Vamos manos a la obra.

Lo primero que necesitamos es descargar una librería llamada Jsmin-php. Podéis encontrarlo en su página web, y justo en la derecha hay un botón para accionar la descarga.

Descargamos el dichero jsmin-1.1.1.php (esta era la versión al momento de hacer este tutorial).

Supongamos que tenemos la siguiente estructura de ficheros:

En la imagen podemos observar que tenemos un fichero index.php en el cual hay el siguiente código:

< !DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</meta></head>
<body>
<p id='parrafo'>Hola</p>

<script type='text/javascript' src='test.js'></script>
<script type='text/javascript' src='test2.js'></script>

</body>
</html>

Cómo se puede observar es un documento en blanco con un párrafo en el cual está escrito la palabra Hola. Este párrafo tiene como identificador único el id ‘parrafo’.

Más adelante podemos ver la llamada a dos ficheros js externos al documento. Cómo se puede apreciar, he puesto las inclusiones al final del documento, justo antes del final del body. Esto es una de las pautas a la hora de optimizar el rendimiento de una página web. En otro tutorial trataremos de una manera más profunda este tema.

El contenido de los ficheros js es el siguiente

Fichero test.js

/*
Esto es un fichero de prueba js
Conjunto de comentarios que explican el funcionamiento de este js
El código siguiente sustuirá el texto interior del párrafo identificado con el id parrafo
*/

document.getElementById('parrafo').innerHTML='esto funciona';

Fichero test2.js

//Comentario: esto va a mostrar un mensaje de alerta
alert('hola mundo');

El código del fichero test.js lo que hace es buscar dentro del documento un elemento que tenga como identificador ‘parrafo’ y le sustituye su contenido por un texto ‘esto funciona’.

El código del fichero test2.js lo que hace es mostrar un mensaje.

En ambos documentos se pueden ver muchos comentarios. Estos comentarios están bien para nosotros pero lo que hacen es hacer más lenta la carga de la página ya que el fichero tiene un mayor fichero.

Vamos a comenzar a solucionar este problema.

Para ello, lo primero que debemos hacer es crear un fichero php al cual le podemos llamar scripts.php. Este fichero tiene la función de solicitar los ficheros js que necesitemos, reducirlos y generar un documento único.

Para que el contenido final del documento sea entendido por el navegador como código javascript y no otro tipo de lenguaje debemos incluir como primera línea de nuestro fichero scripts.php el siguiente código:

header("content-type: application/x-javascript');

Ahora debemos incluir la librería jsmin que hemos descargado y la cual se encargará de optimizar el código:

require_once 'jsmin-1.1.1php';

La parte que viene ahora es muy sencilla. Debemos ejecutar la siguiente línea por cada fichero js que queramos llamar. En nuestro caso será dos veces:

echo JSMin::minify(file_get_contents('test.js'));

echo JSMin::minify(file_get_contents('test2.js'));

JSMin:minify es la orden que se encarga de reducir un determinado código. file_get_contents lo que hace es obtener el contenido de un determinado fichero. Por lo tanto esta orden lo que hace es obtiene el código de nuestros ficheros js, lo reduce y mediante la orden echo lo vuelca en pantalla, en nuestro caso, produciendo un nuevo fichero js.

El resultado es el siguiente:

document.getElementById('parrafo').innerHTML='esto funciona';
alert('hola mundo');

Cómo se puede observar ya no hay comentarios. Si el código tuviese sangrías o fuera más complejo, se podría observar muchas más diferencias.

Ahora ya sólo nos queda retocar el fichero index.php. Vamos a decirle que en vez de utilizar los dos ficheros js, utilice únicamente el fichero php que hemos generado. Con ello matamos dos pájaros de un tiro: reducimos las peticiones de 2 ficheros a 1, y generamos código reducido. Para ello sustituimos las siguientes líneas:

<script type='text/javascript' src='test.js'></script>

<script type='text/javascript' src='test2.js'></script>

Por esta

<script type='text/javascript' src='scripts.php'></script>

Listo. Ya tenemos nuestra página web con el js reducido y además hemos reducido el número de peticiones.

Espero que esto os pueda ser útil.

Ficheros del tutorial Reducir Js con PHP