CodeIgniter

CodeIgniter es un entorno de desarrollo de aplicaciones para gente que construye sitios web usando PHP. El objetivo es habilitar el desarrollo de proyectos de forma mucho más rápida de lo que podría si escribiese código desde cero, a través de proveer un rico conjunto de librerías para tareas comúnmente necesarias, tanto como una simple interface y estructura lógica para acceder a estas librerías. CodeIgniter le permite concentrarse creativamente en su proyecto, minimizando el volumen de código necesario para una tarea determinada.

Introducción

Algunos de los puntos más interesantes sobre este framework, sobre todo en comparación con otros productos similares, son los siguientes:

• Versatilidad: Quizás la característica principal de CodeIgniter, en comparación con otros frameworks PHP. CodeIgniter es capaz de trabajar la mayoría de los entornos o servidores, incluso en sistemas de alojamiento compartido, donde sólo tenemos un acceso por FTP para enviar los archivos al servidor y donde no tenemos acceso a su configuración.
• Compatibilidad: CodeIgniter, al menos en el momento, es compatible con la versión PHP 4, lo que hace que se pueda utilizar en cualquier servidor, incluso en algunos antiguos. Por supuesto, funciona correctamente también en PHP 5.
• Facilidad de instalación: No es necesario más que una cuenta de FTP para subir CodeIgniter al servidor y su configuración se realiza con apenas la edición de un archivo, donde debemos escribir cosas como el acceso a la base de datos. Durante la configuración no necesitaremos acceso a herramientas como la línea de comandos, que no suelen estar disponibles en todos los alojamientos.
• Flexibilidad: CodeIgniter es bastante menos rígido que otros frameworks. Define una manera de trabajar específica, pero en muchos casos se pueden seguir o no, y sus reglas de codificación muchas veces se pueden saltar para trabajar como más a gusto encontremos. Algunos módulos, como el uso de plantillas, son totalmente opcionales. Esto ayuda muchas veces a que la curva de aprendizaje sea más sencilla al principio.
• Ligereza: CodeIgniter es liviano. El núcleo del sistema sólo requiere unas pocas pequeñas librerías. Esto es en duro contraste a muchos entornos de trabajo que requieren significativamente más recursos. Las librerías adicionales son cargadas dinámicamente bajo demanda, basádose en sus necesidades para un proceso dado, así que el sistema base es muy delgado y bastante rápido.
• Documentación tutorializada: La documentación de CodeIgniter es fácil de seguir y de asimilar, porque está escrita en modo de tutorial. Esto no facilita mucho la referencia rápida, cuando ya se tienen conocimientos acerca del framework y se quiere consultar sobre una función o un método en concreto, pero para iniciarnos sin duda se agradece mucho.
• Extensabilidad: El sistema puede ser fácilmente extendido a través del uso de plugins y librerías asistentes, o a través de extensión de clases o ganchos del sistema.

Autocarga de recursos

CodeIgniter posee una característica de "Auto-carga" que proporciona la inicialización de librerías, asistentes(helpers), y complementos de forma automática durante el proceso de arranque del sistema. Si necesita ciertos recursos a nivel global a lo largo de su aplicación, debe considerar la posibilidad de Auto-carga para su conveniencia. Los siguientes elementos pueden ser cargados automáticamente:

• Clases Core: situadas en la carpeta "libraries"
• Asistentes (Helpers): situados en la carpeta "helpers"
• Complementos: situados en la carpeta "plugins"
• Archivos de configuración: situados en la carpeta "config"
• Archivos de lenguaje: situados en la carpeta "system/language
• Modelos: situados en la carpeta "models"

Para autocargar recursos hay que agregar el elemento que deseamos cargar al array autoload, que se encuentra dentro del fichero de configuración application/config/autoload.php.

Manejo de errores

CodeIgniter le permite crear un reporte de errores en sus aplicaciones usando las funciones descritas abajo. Además, tiene una clase de historial de errores que le permite que los mensajes de error y depuración sean guardados en archivos de texto. A diferencia de la mayoría de los sistemas en CodeIgniter, las funciones de error son interfaces que están disponibles globalmente a lo largo de la aplicación. Este aproximamiento le permite que los mensajes de error sean activados sin tener que preocuparse del ámbito de la clase/función.

Las principales funciones son:

• show_error('mensaje'): Esta función mostrará el mensaje de error suministrado usando la siguiente plantilla de error: application/errors/error_general.php
• show_404('pagina'): Esta función mostrará el mensaje de error 404 suministrado usando la siguiente plantilla de error: application/errors/error_404.php
• log_message('nivel', 'mensaje'): Esta función le permitirá escribir mensajes de error en sus archivos de historial. Debe suministrar uno de los niveles en el primer parámetro, indicando qué tipo de mensaje es (depuración, error, info), con el mensaje mismo en el segundo parámetro.

Almacenamiento en Caché de Páginas Webs

CodeIgniter le permite cachear sus páginas con el fin de lograr el máximo rendimiento. Aunque CodeIgniter es bastante rápido, la cantidad de información dinámica que se muestran en sus páginas se correlaciona directamente a los recursos del servidor, la memoria y los ciclos de procesamiento utilizados que afectan a la velocidad de carga de páginas. Por cachear las páginas, ya que se guardan en su estado plenamente renderizadas, puede alcanzar el rendimiento que se acerca a la de las páginas web estáticas.

Cómo funciona el almacenamiento en Caché

Se puede habilitar el almacenamiento en caché para cada página, y puede establecer el tiempo que debe permanecer una página en caché antes de ser refrescada. Cuando una página se carga por primera vez, el archivo de caché se escribirá en su carpeta system/cache. En posteriores cargas de la página, se recibirá y se enviará a la solicitud del navegador del usuario. Si ha caducado, será eliminado y actualizado antes de ser enviado al navegador. Para habilitar el almacenamiento en caché, puede poner la siguiente etiqueta en cualquiera de sus funciones de controlador:

$this->output->cache(n);

Donde n es el número de minutos que desea que la página permanezca en caché entre refrescos. La etiqueta puede ir en cualquier parte dentro de una función. No se ve afectada por el orden en la que aparece, de modo que la puede poner en el lugar donde le parezca más lógico . Una vez que la etiqueta esté en su lugar, las páginas comenzarán a ser cacheadas.

CodeIgniter y el MVC

CodeIgniter está basado en el patrón de desarrollo Modelo-Vista-Controlador. MVC es una aproximación al software que separa la lógica de la aplicación de la presentación. En la práctica, permite que sus páginas web contengan mínima codificación ya que la presentación está separada del código PHP.

CodeIgniter tiene un enfoque bastante flexible del MVC, ya que los Modelos no son requeridos. Si no necesita agregar separación, o descubre que mantener los modelos requieren más complejidad de la que quería, puede ignorarlos y construir su aplicación mínimamente usando Controladores y Vista. CodeIgniter también le permite incorporar códigos existentes, o incluso desarrollar librerías de núcleo para el sistema.

Controladores

Los controladores son el corazón de la aplicación. Es el encargado de determinar cómo deben ser manejadas las solicitudes HTTP. Un controlador es simplemente un archivo de clase que es llamado en una forma que puede ser asociado con una URI.

www.your-site.com/index.php/blog/blog.php

En la URL anterior podemos ver que la palabra "blog" determina la página que queremos ver dentro de nuestra aplicación. Pues bien, para poder atender esta solicitud tendremos que crear un archivo llamado blog.php (el controlador) dentro del directorio que aloja los controladores de nuestra aplicación y que puede contener simplemente un mensaje de "Hola Mundo", como este ejemplo:

<?php
class Blog extends Controller {
  function index()
  {
    echo 'Hello World!';
  }
}
?>

Este archivo lo tenemos que guardar como "blog.php" en la carpeta "system/application/controllers/". Caben señalar unos detalles importantes:

• En nombre del archivo de controlador, en este caso blog.php, va en minúsculas.
• El nombre de la clase que implementa el controlador se tiene que llamar igual que el nombre del archivo, pero fijaros que tiene obligatoriamente la primera letra en mayúscula. Por eso aparece como class Blog extends Controller.
• Todos los controladores tienen que extender la clase "Controller" (que también tiene la primera letra "C" en mayúscula), que está creada dentro de CodeIgniter y, en principio, no necesitamos modificarla.

Por tanto, cuando CodeIgniter recibe una URL como la del ejemplo, intentará acceder al archivo blog.php, para cargarlo, procesarlo y de ese modo mostrar la página con los contenidos de esta sección. Cuando el controlador no se encuentre entre los archivos de controladores de CodeIgniter, simplemente se mostrará un error 404 de página no encontrada. Si se encontró el controlador, se procederá a la carga. Los controladores en CodeIgniter se guardan en la carpeta "system/application/controllers/", que se encuentra dentro de los archivos de CodeIgniter.

EL framework ofrece la posiblidad de usar diferentes URLs dependientes del mismo controlador. Es decir, se puede asociar a un controlador muchas páginas, con URLs distintas, que se ejecutan llamando siempre a un mismo controlador.

Modelos

Los modelos son clases PHP que se han diseñado para trabajar con la información en su base de datos. Por ejemplo, suponga que usa CodeIgniter para administrar un blog. Puede que tenga una clase de modelo que contiene funciones para insertar, actualizar y recuperar datos de su blog. Aquí está un ejemplo de lo que podría ser la clase del modelo:

class Blogmodel extends Model {

    var $title   = '';
    var $content = '';
    var $date    = '';

    function Blogmodel()
    {
        // Llamando al contructor del Modelo
        parent::Model();
    }
    
    function get_last_ten_entries()
    {
        $query = $this->db->get('entries', 10);
        return $query->result();
    }

    function insert_entry()
    {
        $this->title   = $_POST['title'];
        $this->content = $_POST['content'];
        $this->date    = time();

        $this->db->insert('entries', $this);
    }

    function update_entry()
    {
        $this->title   = $_POST['title'];
        $this->content = $_POST['content'];
        $this->date    = time();

        $this->db->update('entries', $this, array('id', $_POST['id']));
    }

}

Los modelos contendrán una serie de funciones o métodos para realizar las operaciones típicas. Por ejemplo,si se piensa en una aplicación que tiene que trabajar con usuarios., entonces es necesario un modelo de usuarios que tendrá una serie de funciones, como la selección de usuarios, inserción, actualización y borrado. La aplicación generalmente tendrá varios modelos para trabajar con cada una de las entidades de la base de datos.

Los modelos se construyen extendiendo la clase Model y tenemos que nombrarlos con la primera letra en mayúsculas. Dentro del modelo que se está creando, es necesario definir, obligatoriamente, un constructor donde se tiene que hacer una llamada al constructor de la clase de la que hereda (clase parent, llamada Model).

Este sería el modelo más básico, está vacío, ya que no tiene ninguna función para operar con la base de datos. Mostramos primero el código básico de un modelo en PHP 5, donde los constructores tienen el nombre __construct().

class Nombre_model extends Model {
   function __construct(){
      parent::Model();
   }
}

Cómo usar los modelos

Para que se pueda ver mejor cómo utilizar un modelo desde un controlador, se ofrece un ejemplo. A continuación tenemos un esquema de un controlador que utiliza los modelos para extraer datos de la base de datos y enviarlos a una vista para mostrarlos en la página.

class Factura extends Controller {
   function mostrar_factura($id_factura){
      $this->load->model('Factura_model');
      $factura = $this->Factura_model->dame_factura_id($id_factura);
      $this->load->view('mostrar_factura', $factura);
   }
}

Este controlador, llamado Factura, tiene una función para mostrar una factura, que recibe el identificador de la factura que se desea ver.

En dicha función se carga el modelo adecuado para el trabajo con facturas "Factura_model". Luego, llamamos a la función dame_factura_id() del modelo cargado, a la que le pasamos el identificador de la factura que deseábamos ver. La función dame_factura_id() del modelo devuelve un array con los datos de la factura. Después, mostramos los datos de la factura con la vista "mostrar_factura" y con los datos de configuración, que es el array que obtuvimos al invocar la función del modelo.

Con esto hemos podido ver un controlador simplificado, que utiliza tanto un modelo como una vista para mostrar el contenido de una factura que se ha traído de la base datos. Por fin hemos visto todos los componentes del MVC trabajando por separado y coordinados desde el controlador.

Vistas

Una vista es simplemente una página web, o un fragmento de ella, como un encabezado, un píe de página, una barra lateral, etc. De hecho, las vistas pueden ser flexiblemente embebidas dentro de otras vistas (dentro de otras vistas, etc., etc.) si necesita este tipo de jerarquía.

Las vistas nunca son llamadas directamente, deben ser cargadas por un controlador. Recuerda que en un entorno de trabajo MVC, el Controlador actúa como el "policía de tránsito", así que es responsable de traer una vista en particular. Usando el controlador que creó en la página de controlador, le permite agregar una vista a él.

Para cargar un archivo de vista en particular, usará la siguiente función:

$this->load->view('nombre');

CodeIgniter manejará inteligentemente múltiples llamadas a $this->load->view desde dentro de un controlador. Si ocurren más de una llamada serán agregados juntos. Por ejemplo, puede querer tener una vista de encabezado, una vista de menú, una vista de contenido, y una vista de píe de página. Eso puede verse más o menos así:

<?php

class Pagina extends Controller {

   function index()
   {
      $datos['titulo_pagina'] = 'Su titulo';
      $this->load->view('encabezado');
      $this->load->view('menu');
      $this->load->view('contenido', $datos);
      $this->load->view('pie_de_pagina');
   }

}
?>

Validaciones de los formularios

A continuación se pone un ejemplo en el que se indíca cómo realizar la validación de los formularios en una biblioteca independiente:

// controller
$this->load->library('formactions');
function index()
{
   if(array_key_exists('addbutton',$_POST))
   {
      list($msg,$redirect) = $this->formactions->add();
   }
   if(array_key_exists('updatebutton',$_POST))
   {
      list($msg,$redirect) = $this->formactions->update();
   }
   if(array_key_exists('deletebutton',$_POST))
   {
      list($msg,$redirect) = $this->formactions->delete();
   }
   if($redirect != '')
   {
       redirect($redirect);
   }
   else
   {
       $data['msg'] = $msg;
   }
   $this->load->view('someview',$data);
}

// library
class Formactions
{
   var $ci;
   
   function Formactions()
   {
      $this->ci =& get_instance();
   }
   
   function add()
   {
      $msg = '';
      $redirect = '';
      // validation
      if(!$this->ci->validation->run())
      {
         $msg = $this->ci->validation->errror_string;
      }
      else
      {
         // hacer algo más (por ejemplo, una acción en la base de datos, manipular una imagen, escribir en un fichero, ...)
         // se redirecciona si es necesario
         $redirect = 'controller/success';
      }
      return array($msg,$redirect);
   }
}