Manual Codeigniter
Manual Codeigniter
www.desarrolloweb.com
Manual de CodeIgniter
CodeIgniter
Probablemente ya sepamos que un framework es un programa para desarrollar otros
programas, CodeIgniter, por tanto, es un programa o aplicación web desarrollada en PHP para
la creación de cualquier tipo de aplicación web bajo PHP. Es un producto de código libre, libre
de uso para cualquier aplicación.
Como cualquier otro framework, Codeigniter contiene una serie de librerías que sirven para el
desarrollo de aplicaciones web y además propone una manera de desarrollarlas que debemos
seguir para obtener provecho de la aplicación. Esto es, marca una manera específica de
codificar las páginas web y clasificar sus diferentes scripts, que sirve para que el código esté
organizado y sea más fácil de crear y mantener. CodeIgniter implementa el proceso de
desarrollo llamado Model View Controller (MVC), que es un estándar de programación de
aplicaciones, utilizado tanto para hacer sitios web como programas tradicionales. Este sistema
tiene sus características, que veremos en artículos siguientes.
CodeIgniter no es magia, pero contiene muchas ayudas para la creación de aplicaciones PHP
avanzadas, que hacen que el proceso de desarrollo más rápido. A la vez, define una
arquitectura de desarrollo que hará que programemos de una manera más ordenada y
contiene diversas herramientas que ayudan a hacer aplicaciones más versátiles y seguras.
CodeIgniter y otros frameworks PHP pueden ayudarte a dar el salto definitivo como
desarrollador PHP, creando aplicaciones web más profesionales y con código más reutilizable,
con la diferencia que Code Igniter está creado para que sea fácil de instalar en cualquier
servidor y de empezar a usar que cualquier otro framework. Además muchas de sus utilidades
y modos de funcionamiento son opcionales, lo que hace que goces de mayor libertad a la hora
de desarrollar sitios web.
encontremos. Algunos módulos como el uso de plantillas son totalmente opcionales. Esto
ayuda muchas veces también a que la curva de aprendizaje sea más sencilla al principio.
Ligereza: El núcleo de CodeIgniter es bastante ligero, lo que permite que el servidor no se
sobrecargue interpretando o ejecutando grandes porciones de código. La mayoría de los
módulos o clases que ofrece se pueden cargar de manera opcional, sólo cuando se van a
utilizar realmente.
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 sabemos acerca del framework y queremos consultar sobre una función o un
método en concreto, pero para iniciarnos sin duda se agradece mucho.
Sin duda, lo más destacable de CodeIgniter es su accesibilidad, ya que podemos utilizarlo en la
mayor gama de entornos. Esta es la razón por la que en DesarrolloWeb.com hemos elegido
este framework PHP para comenzar un manual que explicará cómo utilizarlo para desarrollar
nuestras propias aplicaciones web. En siguientes artículos iremos contando diferentes aspectos
de este framework y lo utilizaremos para crear una primera aplicación web. Para continuar
puedes leer el artículo Instalación y configuración de CodeIgniter. También puedes ir al Manual
de Codeigniter que estamos publicando.
Requisitos de servidor
Necesitamos disponer de un servidor PHP 4 ó PHP 5. Ambos funcionan perfectamente y en el
caso de PHP 4, la versión mínima que debemos tener es la PHP 4.3.2.
Por lo que respecta a las bases de datos, CodeIgniter es compatible con unas cuantas, las más
habituales en e desarrollo de webs: MySQL (4.1 o posterior), MySQLi, MS SQL, Postgres,
Oracle, SQLite, y acceso a cualquier base de datos en entornos Windows por ODBC.
Descarga de CodeIgniter
Podemos descargar la versión más actualizada de CodeIgniter directamente desde su página
web, en la sección de descargas: http://codeigniter.com/downloads/
En el momento de escribir este artículo la versión más actual es la 1.7.2, pero probablemente
cuando leas este texto ya la hayan actualizado, así que entra al sitio de descargas para estar
seguro sobre la versión más nueva que exista.
En resumen, para que se pueda entender el flujo de aplicación que implementa CodeIgniter,
puedes seguir los siguientes puntos:
1. Toda solicitud de una página a partir de CodeIgniter comienza en un index.php que hay
en la raíz del framework.
2. Luego se realiza un filtrado de la URL para saber cuál es elemento que tiene que
ayudarán a que nuestros programas sean mejores y disfruten de varias ventajas como ser más
organizados, extendibles y entendibles por otros desarrolladores, reutilizables, con más fácil
mantenimiento, etc.
Para los que no lo conocen, el Modelo - Vista - Controlador (en inglés Model - View -
Controller) es un patrón de desarrollo o un estilo de arquitectura de software que separa el
código fuente de las aplicaciones en tres grupos:
Modelo:
Todo el código que tiene que ver con el acceso a base de datos. En el modelo mantendremos
encapsulada la complejidad de nuestra base de datos y simplemente crearemos funciones para
recibir, insertar, actualizar o borrar información de nuestras tablas. Al mantenerse todas las
llamadas a la base de datos en un mismo código, desde otras partes del programa podremos
invocar las funciones que necesitemos del modelo y éste se encargará de procesarlas. En el
modelo nos podrán preocupar cosas como el tipo de base de datos con la que trabajamos, o
las tablas y sus relaciones, pero desde las otras partes del programa simplemente llamaremos
a las funciones del modelo sin importarnos qué tiene que hace éste para conseguir realizar las
acciones invocadas.
Vista:
La vista codifica y mantiene la presentación final de nuestra aplicación de cara al usuario. Es
decir, en la vista colocaremos todo el código HTML, CSS, Javascript, etc. que se tiene que
generar para producir la página tal cual queremos que la vea el usuario. En la práctica la vista
no sólo sirve para producir páginas web, sino también cualquier otra salida que queramos
enviar al usuario, en formatos o lenguajes distintos, como pueden ser feeds RSS, archivos
JSON, XML, etc.
Controlador:
El controlador podríamos decir que es la parte más importante, porque hace de enlace entre el
modelo, la vista y cualquier otro recurso que se tenga que procesar en el servidor para generar
la página web. En resumen, en el controlador guardamos la lógica de nuestras páginas y
realizamos todas las acciones que sean necesarias para generarlas, ayudados del modelo o la
vista.
Nota: Esto quiere decir, en la práctica para el caso de CodeIgniter, que según sea el ámbito donde estemos
codificando, tendremos que escribir las líneas de código de cualquier página web en tres grupos de archivos
distintos. En una aplicación estándar podremos tener varios modelos (por ejemplo, para cada una de las
entidades distintas de la base de datos), varias vistas (una o varias para cada página o sección) y varios
controladores (para cada página o sección de la web). Luego veremos dónde tenemos que guardar los
archivos de cada uno de estos tres grupos.
Durante el desarrollo con CodeIgniter será muy recomendable seguir las normas del diseño
Modelo - Vista - Controlador (MVC), pero realmente el framework es bastante flexible y
permite que, si lo deseamos, no sigamos el desarrollo atendiendo a dicha arquitectura. En este
caso, podríamos tener simplemente controladores y dentro de ellos realizar todas las acciones
de acceso a la base de datos directamente, sin hacer llamadas al modelo, o escribir texto en la
salida sin utilizar las vistas. Obviamente, esta opción no aprovechará las ventajas de
separación de código entre presentación, lógica y modelo de base de datos, pero si vemos que
nos resulta muy complejo el MVC, podemos dejarlo de lado.
En el caso que no utilizemos los modelos, no ocurrirá ningún efecto negativo en el desempeño
del framework, pero en el caso de las vistas, si no las utilizamos y escribimos salida
directamente desde el controlador, como por ejemplo con sentencias echo de PHP en en código
de los controladores, perderemos algunas de las ventajas que CodeIgniter realiza por nosotros
para procesar la salida antes de enviarla al usuario. Esto lo detallaremos más adelante.
Nota: Como sabemos, o podremos imaginar, separar la vista o presentación de la lógica de los programas
es una ventaja importante, ya que ayuda a mantener un código más sencillo, reducido y con mayor facilidad
de mantenimiento. En principio puede parecer un tanto complejo el hecho de manejar varios archivos con
códigos distintos, pero a medio plazo nos vendrá muy bien separar el código de cada parte de nuestra
aplicación. Nos evitará muchos de los problemas que a veces tenemos en desarrollos PHP, donde en un
mismo archivo tenemos mezclado código en varios lenguajes como HTML, CSS, SQL, con el propio código
PHP para generar la lógica de nuestro negocio.
URLs en CodeIgniter
Uno de los puntos que debemos conocer antes de empezar a trabajar con CodeIgniter es sobre
cómo son las direcciones URL que utiliza este popular framework PHP para cada una de las
páginas de las aplicaciones PHP que creemos utilizándolo. La verdad es que es un punto que
realmente resulta transparente para nosotros, puesto que las URL se generan
automáticamente a medida que vamos programando el sitio web, pero está bien comentar
algunas cosas importantes.
Éste es un artículo del Manual de CodeIgniter que estamos publicando en DesarrolloWeb.com,
por lo que para entenderlo habrá que leer alguno de los artículos previos a éste.
Nota: Hay un pequeño matiz que comentaremos más tarde en este artículo y es que en principio todas las
URL en CodeIgniter tienen el nombre de una página llamada index.php, pero esto es algo que podemos
hacer desaparecer si sabemos configurar el framework.
Nota: Esto quizás resulte ahora un poco complicado, porque todavía no tenemos una idea definida sobre
cómo son los controladores, pero dentro de poco lo veréis todo más claro.
CodeIgniter pone a nuestra disposición una clase para trabajar con URLs llamada URI Class y
una librería llamada URL Helper que contienen funciones para trabajar fácilmente con URLs y
datos enviados en las mismas. En estas librerías hay funciones tan interesantes como
site_url() que sirve para que el propio CodeIgniter cree una URL dentro del sitio a partir de un
parámetro que le pasemos. Otro ejemplo es base_url(), que simplemente devuelve la URL raíz
donde está nuestra aplicación CodeIgniter.
Nota: En DesarrolloWeb.com hemos hablado en repetidas ocasiones acerca de los archivos .htaccess,
explicando lo que son y cómo podemos utilizarlos para crear automáticamente URLs amigables a
buscadores, sin que tengan que existir físicamente los archivos en el servidor. Recomendamos la lectura del
manual Editar htaccess para crear direcciones URL amigables
Así pues, podríamos conseguir que nuestras direcciones no tuvieran siempre el mencionado
index.php y quedasen con una forma similar a esta:
http://pruebas.com/empresas/editar/1
Para ello existirían diversos métodos y según nuestro dominio de los archivos .htaccess y de
las expresiones regulares, así como de la configuración de Apache, podremos implementar una
u otra. Nosotros en este artículo vamos a explicar un modo que está disponible en la propia
guía de uso de CodeIgniter, que hemos probado y resulta sencillo y efectivo.
Se trata de utilizar un método de trabajo con .htaccess que llaman "negativo", donde todas las
URLs son redirigidas a través del archivo index.php, a no ser que tengan una forma
determinada que no queramos que se redireccione.
Por ejemplo, una URL como esta:
www.loquesea.com/empresas
Se redirigiría a una URL como esta otra:
www.loquesea.com/index.php/empresas
Pero esa redirección se haría de manera transparente al usuario y al navegador que nos visita.
Es decir, el procesamiento de la página se hace a través del index.php, pero nosotros no
llegamos a percibir que en el servidor se ha llevado a cabo esa redirección, quedando la URL
en la barra de direcciones siempre sin el index.php.
Ahora bien, hay determinadas direcciones que no vamos a desear que se redirijan, como
puede ser una hoja de estilos CSS. Es decir, podemos tener en nuestro servidor un archivo
como este:
www.loquesea.com/css/estilos.css
Y en ningún caso queremos que se procese a través del index.php, sino que directamente se
devuelva el archivo CSS que hay en esa ruta. Este es el caso en el que se utiliza el método
"negativo" del htaccess, a través del comando "RewriteCond" (condición de redirección). Este
caso obvio también lo tendríamos, por ejemplo, en archivos como el robots.txt o aquellos
donde podamos tener librerías de código Javascript.
Esto diría que se redirijan todos los archivos que se soliciten a este dominio, menos los que
contengan el propio index.php, css, js, images o robots.txt.
La redirección se hará a través de la misma URL, pero agregando "index.php/" después del
nombre del dominio y antes de lo que haya justo después de ese nombre de dominio.
Ahora, sólo nos faltaría decirle a CodeIgniter que, al componer URLs para los enlaces
entre las distintas páginas de nuestra aplicación web PHP, no coloque el index.php, pues
no lo necesitamos. Esto lo podemos hacer desde el archivo de configuración principal,
que están en: system/application/config/config.php
Simplemente tendríamos que editar la variable de configuración "index_page", poniéndola a la
cadena vacía.
$config['index_page'] = "";
Este no sería necesariamente el único método. Por ejemplo, en la Wiki oficial de Codeigniter
explican un modo distinto de conseguirlo, aunque bastante más complejo:
http://codeigniter.com/wiki/mod_rewrite/
Controllers en CodeIgniter
Los controladores son uno de los componentes que forman parte del modelo de programación
MVC (Modelo - Vista - Controlador o Model - View - Controller en inglés) que sirven como
engranaje principal a la hora de crear aplicaciones web. Dado que CodeIgniter utiliza la
arquitectura MVC, tendremos que aprender a manejar y dominar los controladores como un
primer paso para comenzar a trabajar con este framework PHP.
Para los que no sepan qué es el MVC cabe decir que ya fue explicado en este manual de
CodeIgniter, concretamente en el capítulo Modelo - Vista - Controlador en CodeIgniter. Así que
podemos pasar directamente a explicar las particularidades de los controladores en este
entorno de programación.
Para explicar los controladores voy a basarme en la propia documentación del framework PHP,
que está tutorializada, como ya dijimos en la introducción a CodeIgniter. Por lo que resulta una
manera excelente para aprender a dar los primeros pasos en el desarrollo de aplicaciones.
Qué es un controlador
Un controlador en CodeIgniter es un archivo que contiene el código de una clase, de
programación orientada a objetos, que colocamos en un directorio específico del esquema de
carpetas de nuestro sitio. Tiene un nombre cualquiera, que se asociará con una URL de nuestra
aplicación web.
Por ejemplo, esta podría ser una URL de nuestra aplicación:
midominio.com/index.php/articulos
En la URL anterior podemos ver que la palabra "artículos" determina la página que queremos
ver dentro de nuestra aplicación. Pues bien, para poder atender esta solicitud nosotros vamos
a tener que crear un archivo llamado articulos.php (el controlador) dentro del directorio que
aloja los controladores de nuestra aplicación.
Por tanto, cuando CodeIgniter detecta una URL como esta, intentará acceder al archivo
articulos.php, para cargarlo, procesarlo y de ese modo mostrar la página con los contenidos de
esta sección.
Cuando ese 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,
como se decía, se carga y se procesa para mostrar la página.
Los controladores en CodeIgniter se guardan en la carpeta "system/application/controllers/",
que se encuentra dentro de los archivos de CodeIgniter.
Nota: Todos los archivos que vamos a tener que crear o editar para desarrollar nuestra aplicación PHP con
CodeIgniter están dentro de la carpeta "system/application" y existe una carpeta dentro para cada tipo de
cosa que deseemos crear o modificar, como archivos de configuración, modelos, vistas, etc.
function index()
{
echo 'Bienvenido a mi primer controlador en CodeIgniter';
}
}
?>
Nota: Esta URL supone que has instalado CodeIgniter en la raíz de tu servidor web, pero podrías haber
instalado CodeIgniter en otro directorio, en tal caso la URL tendría una forma como
http://localhost/directorio_de_codeigniter/index.php/articulos
En caso que esté funcionando todo correctamente, tendrás que visualizar una página con el
mensaje que habías colocado en el echo que hay dentro de la función index() del controlador.
Si no funciona, comprueba tu URL, que tiene acceder al directorio correcto donde hayas
instalado CodeIgniter y que tiene que acabar con el nombre del controlador en minúsculas.
Comprueba también que la clase que has creado en el código del controlador tiene la primera
letra en mayúscula. No debe haber mucho problema ni dificultad.
En el siguiente artículo veremos cómo podemos crear funciones en los controladores, para dar
lugar páginas distintas que dependan del mismo controlador.
Si observamos el valor de esta variable de configuración, tal como está en el momento inicial,
después de la instalación de CodeIgniter, veremos que el controlador por defecto está en la
clase "Welcome", archivo application/controllers/welcome.php
Por ejemplo, pensemos que tenemos una tienda online de venta de productos informáticos.
Entonces podríamos tener una URL donde se muestran los productos, pero a su vez tendremos
muchas clasificaciones de productos y cada cliente podría ver una ficha completa con cada uno
de ellos. Todas las fichas de productos se podrían meter dentro de un mismo controlador,
dando lugar a distintas URL, como pueden ser las siguientes:
dominio.com/index.php/productos
dominio.com/index.php/productos/ordenadores
dominio.com/index.php/productos/monitores
dominio.com/index.php/productos/perifericos/raton_genius
dominio.com/index.php/productos/ordenadores/mac_mini/2gigas
dominio.com/index.php/productos/ordenadores/mac_mini/4gigas
...
Todas estas URL dependen del mismo controlador, que sería el controlador de productos (tal
como se dijo en el anterior artículo sería la clase "Productos" que extiende la clase "Controller"
y debemos colocar en el archivo "productos.php" dentro del directorio donde se colocan los
controladores (application/controllers).
Como se puede ver, el primer nombre del directorio después del dominio y el index.php es el
nombre del controlador, en este caso siempre "productos". Por eso todas las URL que teníamos
antes dependen del mismo controlador. Sin embargo, las URL que he colocado aquí son un
puro ejemplo, para que se pueda ver cómo se pueden generar URLs que dependen de un
mismo controlador. Pero dependiendo de cómo deseemos organizar nuestro sitio web
podríamos decidir hacer uso de otras URL para mostrar más o menos lo mismo. Lo bueno,
como también se puede comprobar viendo esas URL, es que en CodeIgniter siempre se
generan URLs sin paso de parámetros, es decir, siempre totalmente amistosas a motores de
búsqueda.
function index(){
echo 'Esto es la portada de productos';
}
function ordenadores(){
echo 'Aquí se muestran los productos de ordenadores';
}
function monitores(){
echo 'Aquí se muestran los productos de monitores';
}
}
?>
Como se puede ver, hemos creado dos nuevas funciones dentro de un controlador para
productos, para poder mostrar dos tipos de productos distintos.
Aclaración: Estamos refiriéndonos siempre como funciones de los controladores, pero realmente
deberíamos llamarles métodos, porque los controladores son clases y las clases tienen métodos y no
funciones.
Así tenemos el método "perifericos" que recibe el parámetro modelo. Este parámetro tomará el
valor del tercer directorio. Entonces en la URL:
dominio.com/index.php/productos/perifericos/raton_genius
Estaremos invocando el método perifericos() y pasando como valor en el parámetro $modelo
la cadena "raton_genius".
Esto se puede complicar un poco más en URL como estas:
dominio.com/index.php/productos/ordenadores/mac_mini/2gigas
Como se puede comprobar, aquí estamos pasando dos parámetros al método ordenadores()
del controlador "Productos", que podríamos procesar de una manera similar a esta:
function ordenadores($marca=null, $modelo=null){
if (is_null($marca) && is_null($modelo)){
echo 'Aquí se muestran los productos de ordenadores';
}elseif(is_null($modelo)){
echo 'Mostrando ordenadores de marca ' . $marca;
}else{
echo 'Mostrando ordenadores de marca ' . $marca . ' y modelo ' . $modelo;
}
}
En la anterior función se comprueba qué parámetros se recibe en el método antes de dar por
sentado que estamos recibiendo alguno de ellos. Procesará correctamente URLs como estas:
http://localhost/index.php/productos/ordenadores
http://localhost/index.php/productos/ordenadores/toshiba
http://localhost/index.php/productos/ordenadores/hp/pavillon590
Con todo lo que hemos visto hasta ahora de controladores, tenemos este código en el archivo
"productos.php" del directorio "controllers".
<?php
class Productos extends Controller {
function index(){
echo 'Esto es la portada de productos';
}
function monitores(){
echo 'Aquí se muestran los productos de monitores';
}
function perifericos($modelo){
echo 'Estás viendo el periférico ' . $modelo;
}
}
?>
Esperamos que con lo que se sabe hasta el momento se puedan hacer las primeras pruebas
con controladores en CodeIgniter. Sin embargo, hay que decir que aun no lo hemos visto todo
con relación a los controladores, aunque lo dejaremos para el próximo artículo.
Vistas en CodeIgniter
Vamos a pasar a un nuevo tema en el Manual de CodeIgniter en el que comenzaremos las
explicaciones de las vistas, parte fundamental en este framework PHP y en el patrón de
desarrollo de aplicaciones que utiliza, llamado modelo - vista - controlador.
En artículos anteriores de DesarrolloWeb.com ofrecimos una buena introducción a los
controladores, y aunque realmente no hemos visto todo lo que los controladores nos ofrecen,
estamos en condiciones de aprender otras cosas jugosas en CodeIgniter, que seguro nos
motivarán durante nuestro aprendizaje, al ver que todo es bastante sencillo de asimilar.
Ahora podemos guardar esa vista con el nombre que deseemos y extensión ,php, por ejemplo
mivista.php, en el directorio de las vistas que es "system/application/views".
En 'nombreDeLaVista' tendremos que indicar el nombre del archivo donde hemos guardado la
vista, pero sin el ".php".
Veamos entonces cómo quedaría un controlador que llama a la vista que hemos hecho antes
en este artículo.
<?php
function index(){
$this->load->view('mivista');
}
}
?>
En este ejemplo hemos cargado varias vistas y en una de ellas le hemos enviado datos para
configurar cómo se mostrará al visitante, en concreto la vista cuerpo.php. Esta utilidad es
fundamental para que las vistas muestren cualquier información que se envíe desde los
controladores y no solamente un texto siempre igual. En el próximo artículo sobre vistas
aprenderemos a realizar esta acción.
function index(){
$datos = array(
'titulo' => 'Página de prueba',
'descripcion' => 'Esta es la descripción de esta página, un poco más larga.',
'cuerpo' => 'El cuerpo de la página probablemente será un texto muy largo...<p>Con varios párrafos</p>'
);
$this->load->view('mivista', $datos);
}
}
?>
Ahora, en la vista, podemos acceder a todos los datos de ese array asociativo, como si fueran
variables normales, a través de los nombre de los índices del array. Veamos el código de
mivista.php que consume los datos que se le envían para configurar su contenido.
<html>
<head>
<title><?php echo $titulo?></title>
</head>
<body>
<h1><?php echo $titulo?></h1>
<blockquote>
<p><b><?php echo $descripcion?></b></p>
</blockquote>
<p><?php echo $cuerpo?></p>
</body>
</html>
Como estamos viendo, podemos mostrar los contenidos de las variables de configuración
enviadas a la vista a través de simples instrucciones echo de PHP. Los datos que se reciben en
la vista están disponibles por medio de variables normales, con nombres iguales a los índices
del array asociativo que se envió al cargar la vista.
Del mismo código CodeIgniter dispone de estructuras de control if, for, foreach y while que
se pueden escribir de una manera resumida, en comparación con las estructuras de control
habituales en PHP. Ahora no vamos a explicar la sintaxis de estos elementos, por lo que
recomendamos leer la documentación del framework para encontrar más referencias.
Nota: Estas maneras nuevas de hacer bucles y condicionales, en mi opinión, pueden ser útiles para usuarios
que no conocen PHP, pero no merece mucho la pena aprenderlas si ya dominamos PHP, como
probablemente ocurra si estamos leyendo este manual. Sin embargo, si la responsabilidad de crear las
vistas cae sobre un diseñador que no conoce PHP, puede que le sea más sencillo utilizar, por ejemplo, el IF
de CodeIgniter en vez del IF típico de PHP.
Todo depende de con qué se sienta más cómodo. La ventaja puede ser la sencillez y que en las estructuras
de CodeIgniter no hace falta utilizar las llaves en los bucles o estructuras IF. Sin embargo, existe una
desventaja y es que CodeIgniter necesitará preprocesar la vista para convertir las estructuras de código de
CodeIgniter en las estándares de PHP y esto llevará un tiempo. Además, cuando tengamos un error de
sintaxis en el código de una vista, si estamos utilizando las estructuras de control de CodeIgniter, es muy
probable que la línea de código donde PHP informe del error no corresponda con la línea de código en la
vista donde hemos hecho algo mal, lo que puede dar algún que otro dolor de cabeza en la etapa de
depuración.
Modelos en CodeIgniter
En este artículo, que forma parte del Manual de CodeIgniter, vamos a comenzar con los
modelos en CodeIgniter, el tercero y último de los integrantes del patrón de desarrollo utilizado
en este framework PHP.
En artículos anteriores ya vimos de manera general qué eran los modelos, cuando explicamos
el Modelo - Vista - Controlador (MVC), así que en este caso vamos a ver cómo CodeIgniter los
gestiona. No obstante cabe decir que los modelos en el MVC son los módulos que tienen como
responsabilidad el acceso y control de los datos que hay en bases de datos y mantienen
encapsuladas todas las particularidades y complejidades de los accesos a las tablas para
realizar cualquier tipo de operación.
Al centralizarse todas las acciones sobre la base de datos por medio de los modelos, en los
controladores podemos olvidarnos de lo compleja o simple que sea nuestra base de datos,
incluso de qué tipo de base de datos tiene el servidor con el que estamos trabajando.
En el patrón MVC, los modelos son una de las partes fundamentales, pero en el caso de
CodeIgniter, su uso es sólo opcional. El desarrollador es el responsable de decidir si le viene
bien el uso de los modelos o si prefiere realizar sus aplicaciones haciendo cualquier tipo de
operación sobre la base de datos en los propios controladores.
Nota: La posibilidad de usar o no modelos depende de nosotros. Esta libertad en cuanto a la elección de
nuestras propias costumbres de codificación es muy propia de CodeIgniter, que se vende a si mismo como
un framework flexible, que se puede adaptar a la mayoría de los entornos. Nosotros, no obstante,
queremosrecomendar su utilización, por lo menos para probar las ventajas de uso y ver si en el futuro nos
interesa o no basarnos en ellos para realizar los accesos a la base de datos. Sin duda, si queremos
programar "a lo grande", debemos utilizarlos. De hecho ofrecen muchas ventajas para proyectos grandes,
como la abstracción de base de datos.
function __construct(){
parent::Model();
}
function existe_email($email){
$this->db->select('email_usuario');
$this->db->where('email_usuario', $email);
$query = $this->db->get('usuario');
if ($query->num_rows() > 0){
return 1;
}
return 0;
}
function usuario_login($email){
$this->db->where('email_usuario', $email);
//$this->db->where('clave', md5($clave));
$query = $this->db->get('usuario');
if ($query->num_rows() > 0){
return $query->row();
}
return 0;
}
if(!$this->_required(array("email_usuario","clave"), $datos)){
return FALSE;
}
//clave, encripto
$datos['clave']=md5($datos['clave']);
$this->db->insert('usuario', $datos);
return $this->db->insert_id();
}
}
Ahora veamos cómo sería el modelo básico en PHP 4, donde los modelos tendrían una pequeña
diferencia, dado que los constructores en la versión 4 de PHP tienen siempre el mismo nombre
que la propia clase.
class Nombre_model extends Model {
function Nombre_model(){
parent::Model();
}
}
Cargar un modelo
La carga de un modelo se realiza desde el controlador que lo va a utilizar, por medio del
método de carga de modelos, con un código como este:
$this->load->model('Nombre_model');
Si queremos cargar varios modelos de una sola vez, podemos hacerlo pasando un array con
todos los modelos que deseamos cargar:
$this->load->model(array('Cliente_model','Factura_model'));
Una vez cargado un modelo, sus métodos para el acceso a los datos estarán disponibles en
nuestro controlador, a través del propio objeto controlador, el nombre del modelo que
queremos accionar y la función que queremos invocar dentro del modelo.
$this->Nombre_model->funcion_del_modelo();
Esto cargaría el modelo de usuarios y el modelo de empresas en todas las páginas de nuestra
aplicación web con CodeIgniter.
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. Luego 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. Espero que hasta este punto haya quedado claro al menos el modo en el que
trabajaremos con CodeIgniter, aunque todavía hay muchas cosas en el aire que trataremos de
explicar en el futuro.
Simplemente hemos colocado una función index(), que es la que se llamará cuando se acceda
a este controlador tal cual. Dentro de index estamos invocando una vista.
Este controlador lo tenemos que guardar en un archivo llamado articulos.php que meteremos
en el directorio de los controladores: system/application/controllers.
Ahora podremos acceder a la URL raíz de CodeIgniter y ver el mismo mensaje de bienvenida,
en una url como esta:
http://localhost/
En el siguiente artículo continuaremos con la creación de esta aplicación web de prueba en
CodeIgniter. Veremos cómo crear nuestra base de datos y hacer la primera página que
muestre los datos de la tabla de artículos.
Antes de salir de PhpMyAdmin, o cualquier otro gestor de base de datos, vamos a insertar
manualmente unos cuantos registros en la tabla de "articulo" con datos de prueba.
Ahora debo decirle a CodeIgniter que conecte automáticamente, incluyendo siempre las
librerías de conexión con base de datos. Para esto tenemos que editar el archivo de
configuración autoload.php (system/application/config/autoload.php), en el lugar donde se
indica qué librerías queremos cargar siempre.
$autoload['libraries'] = array('database');
Nota: El código que veremos a continuación es PHP 5. PHP 4 tendría alguna diferencia por los nombres de
los constructores, como ya se explicó.
<?php
class Articulo_model extends Model {
function __construct(){
parent::Model();
}
function dame_ultimos_articulos(){
$ssql = "select * from articulo order by id desc limit 5";
return mysql_query($ssql);
}
}
?>
Nota: En este modelo estamos utilizando las propias funciones de acceso a base de datos de MySQL.
Simplemente comentar que en CodeIgniter existe un mecanismo de abstracción de base de datos que se
podría utilizar para escribir código con funciones que sirvan para cualquier tipo de base de datos que
podamos utilizar, y no sólo MySQL.
Nota: El código está comentado y si se encuentran dudas recomendamos releer este Manual de
CodeIgniter. No obstante, en el código anterior hay una cosa que son los "helpers" que no hemos explicado
todavía. Son simplemente librerías de código con funciones que resultarán útiles a la hora de hacer
aplicaciones web con CodeIgniter, que están clasificadas por temática. Nosotros estamos cargando el helper
"url", que contiene unas serie de funciones para trabajar con URLs. En concreto utilizaremos la función
site_url() del helper "url", un poco más adelante.
</body>
</html>
Podemos ver cómo hacemos un recorrido a los registros de últimos artículos traídos desde la
base de datos con ayuda del modelo y enviados a la vista por medio del controlador. Además,
vemos que se está utilizando la función site_url() que pertenece al helper "url" que habíamos
cargado en el controlador.
Nota: Aquí también estamos utilizando directamente funciones de MySQL. Sin embargo, CodeIgniter tiene
algunas librerías que nos ayudarían a hacer esto de otra manera. No obstante, por ahora queremos
limitarlos a lo que conocemos del framework.
Una vez actualizada la vista, podemos acceder a la página raíz de nuestra aplicación, que
debería mostrar los últimos artículos que habían cargados en la base de datos, en la tabla
articulo, con un enlace a varias páginas, donde se muestra cada uno de los artículos (no
creadas todavía). Por supuesto, tenéis que haber insertado algún artículo en la tabla para que
lo muestre.
Tenemos la primera parte de nuestra aplicación con acceso a base de datos, creada en pocos
minutos con CodeIgniter. Pero todavía tenemos que complicarlo un poco más. En el próximo
artículo haremos un poco más grande esta aplicación web.
para atender esta URL) y el número del identificador del artículo que deseamos ver (que es el
parámetro que se enviará a la función muestra() del controlador).
Así pues, tenemos que hacer varias cosas para que esas URL funcionen y muestren el
contenido de los artículos.
function __construct(){
parent::Model();
}
function dame_ultimos_articulos(){
$ssql = "select * from articulo order by id desc limit 5";
return mysql_query($ssql);
}
function dame_articulo($id){
$ssql = "select * from articulo where id=" . $id;
$rs = mysql_query($ssql);
if (mysql_numrows($rs)==0){
return false;
}else{
return mysql_fetch_array($rs);
}
}
}
?>
Como se puede ver, es exactamente el modelo anterior, en el que hemos creado la función
dame_articulo().
function muestra($id){
//cargo el helper de url, con funciones para trabajo con URL del sitio
$this->load->helper('url');
Nos tenemos que fijar en la nueva función creada: muestra(). En esta función cargamos el
helper de URL (aun no hemos hablado de los helpers, pero lo veremos pronto). Luego
cargamos el modelo de artículos y solicitamos el artículo al modelo. Luego comprobamos si
existe el artículo. Si no existe, lanzamos un error 404, con la función show_404() (tampoco
hemos visto aun la gestión de errores). Si existe, llamamos a la vista que debe mostrar el
contenido completo del artículo, enviando el array con los datos del artículo encontrado.
Nos fijamos que la vista que solicitamos "muestra_articulo" no ha sido creada todavía.
</body>
</html>
Como se puede ver, se muestran todos los datos del artículo, con su título, descripción y
cuerpo completo. Luego tenemos un enlace de volver que nos llevará a la portada del sitio,
cuya URL obtenemos con la función site_url() que tenemos disponible al haber cargado el
helper "url" en el controlador.
Ahora podemos comprobar, entrando a la portada del sitio, que los enlaces a los últimos
artículos ya están funcionando. Si los pulsamos accederemos a las páginas que acabamos de
hacer en esta etapa, en la que se nos muestra el contenido de los artículos. Si intentamos
acceder a una URL de un artículo que no existe, como:
http://localhost/codeigniter/index.php/articulos/muestra/923
Podremos visualizar un error 404 de página no encontrada.
Hasta aquí tenemos nuestra aplicación que muestra artículos a sus visitantes, cargados en una
base de datos. Es una aplicación incompleta, puesto que a poco que nos imaginemos, se nos
ocurrirán multitud de cosas para mejorarla. Sin embargo, nuestro objetivo era más bien que
los lectores sean capaces de entender el patrón de desarrollo de CodeIgniter, el MVC.
Quizás penséis que, siguiendo vuestras costumbres habituales de desarrollo en PHP, podríais
haber hecho esta pequeña aplicación en menos tiempo y quizás con menos código fuente. No
obstante, a medio plazo observaremos los beneficios de codificar por medio de los
controladores, vistas y módulos, con los que obtendremos código más claro, organizado, y con
mantenimiento más sencillo, entre diversas ventajas.
Helpers en CodeIgniter
Los helpers son una de las dos bibliotecas de código disponibles en CodeIgniter y la más
sencilla de manejar en un principio, puesto que son funciones que están a nuestra disposición
sin depender de ningún objeto. Lo veremos con detenimiento en este artículo del Manual de
CodeIgniter.
En cualquier framework PHP, como nos podremos imaginar, se pone a nuestra disposición una
biblioteca de funciones que resuelven las cosas típicas que podemos necesitar al realizar una
aplicación web. De hecho, una de las ventajas de usar frameworks es justamento no tener que
programar por nosotros mismos todas las funciones que se utilizan reiteradas veces en la
mayoría de los sitios web profesionales. Así pues, los helpers son una de las bibliotecas de
funciones que supongo esperábamos que CodeIgniter nos proporcionara.
Podemos decir que los helpers son juegos de funciones, ordenados por temática en diferentes
paquetes, que nos ayudan en la realización de tareas habituales en las aplicaciones web.
Existen helpers para muchas cosas distintas, como para trabajo con arrays, fechas, cookies,
emails, URLs, formularios, etc.
Nota: En CodeIgniter disponemos de dos tipos de bibliotecas de códigos, Helper y Class. Los Helpers son
funciones propiamente dichas y las Class son clases de programación orientada a objetos (POO). Su carga y
utilización son ligeramente distinta, así que las veremos por separado. De momento quedémonos con que
los helpers no dependen de programación orientada a objetos, sino que son funciones (de programación
funcional o prodecimental, más tradicional que la POO) que podremos utilizar para solucionar temas
En el código anterior la cadena "mihelper" corresponde con el nombre del helper que se desea
cargar. Este nombre es una palabra como "url", "file", etc. y no el propio archivo del código del
helper. Por ejemplo con el código:
$this->load->helper('url');
Se está cargando el helper con nombre "url" que realmente está en el archivo "url_helper.php".
Pero para cargarlo simplemente tenemos que indicar el nombre del helper y no el nombre del
archivo donde está el helper.
Puedes cargar un helper en cualquier parte del código de tus controladores o incluso de las
vistas (aunque no sea una buena práctica cargar helpers en las vistas), siempre y cuando lo
cargues antes de utilizarlo. En un controlador podrías cargar el helper en el constructor, con lo
que estaría disponible en todas las funciones del mismo, o bien en una de las funciones donde
lo necesites.
Puedes cargar múltiples helpers a través de una única llamada a load().
$this->load->helper( array('cookie', 'file', 'form') );
Para indicar qué helpers queremos cargar tenemos que editar el array $autoload, en su índice
Nota: Para que quede claro hasta que punto es básico este Helper de URL cabe decir que, hasta donde
hemos explicado en este Manual de CodeIgniter, ya lo hemos utilizado en el primer ejemplo de aplicación
sencilla. Ese ejemplo está dividido en tres artículos y en el segundo, titulado Creamos la base de datos y
conectamos desde una página se puede encontrar el uso del helper URL.
Nota: Como se puede ver, el método de realización del constructor es de PHP 5. Recordar que en PHP 4 el
constructor es una función con el mismo nombre que la clase y en PHP 5 el constructor es una función con
el nombre __construct().
Con esta línea invocamos la función site_url() del helper URL, que sirve para obtener una URL
del sitio a partir de una ruta parcial. Esta función es útil porque sirve para saber cómo es la
URL completa con la que hay que enlazar distintas páginas del sitio, que podría variar
dependiendo del lugar donde se haya instalado CodeIgniter, sólo a partir de un segmento que
no puede cambiar. Dicho de otra manera, al enlazar con otras páginas del sitio conviene
componer las URL siempre con la función site_url(), para que esos enlaces sigan funcionando
aunque la aplicación la cambiemos a otro directorio, otro dominio, etc.
Nota: Un detalle que queremos señalar también sobre la función anterior, index(), es que hacemos uso de
la sentencia echo de PHP para escribir cosas en la página directamente con el controlador. Esto no es
recomendable, aunque se pueda hacer en CodeIgniter, pues la salida hacia la página desde nuestros scripts
debería estar siempre en las vistas.
Ahora podemos ver un segundo método del controlador con otro uso de las funciones del
helper URL.
function muestra_base_url(){
//escribo desde el controlador, aunque debería hacerlo desde la vista
echo base_url();
Esa función escribe por pantalla lo que devuelve la función base_url(), que pertenece al helper
de URL y sirve para informar de la ruta raíz de la aplicación CodeIgniter, que también
dependerá del dominio donde estemos trabajando y el directorio donde se haya instalado el
framework.
Luego también escribe un enlace para volver a la página anterior y para crear la ruta del
enlace también utilizamos el helper de URL con la función site_url() relatada anteriormente,
indicando en este caso tan solo el nombre del controlador al que queremos dirigir el enlace.
///////////////////////////////////////////////////////////////////////////
//Constructor
function __construct(){
parent::Controller();
///////////////////////////////////////////////////////////////////////////
//método index, función por defecto del controlador
function index(){
//escribo desde el controlador, aunque debería hacerlo desde la vista
echo "<h1>Probando helper URL</h1>";
///////////////////////////////////////////////////////////////////////////
//funcion muestra_base_url, para mostrar la URL principal de esta aplicación web
function muestra_base_url(){
//escribo desde el controlador, aunque debería hacerlo desde la vista
echo base_url();
///////////////////////////////////////////////////////////////////////////
//funcion muestra_url_actual, para mostrar la URL actual de esta página
function muestra_url_actual(){
//escribo desde el controlador, aunque debería hacerlo desde la vista
echo current_url();
Librerías de CodeIgniter
CodeIgniter, el más accesible de los frameworks PHP populares, tiene bibliotecas de código
para realizar diversas cosas interesantes y útiles. Por un lado tenemos los Helpers, que
implementan juegos de funciones y que ya relatamos en artículos anteriores del Manual de
CodeIgniter. Por otro lado tenemos las librerías, que vamos a tratar en este artículo.
Las librerías en CodeIgniter son clases de programación orientada a objetos (POO) preparadas
para realizar tareas típicas en el desarrollo de páginas web. Implementan clases, de POO, para
resolver problemas muchas veces similares a los que resuelven los Helpers, pero son un poco
más especializadas en temas particulares. Algunos ejemplos de librerías que se dispone en
CodeIgniter son para trabajar con bases de datos, FTP, upload de archivos, sesiones,
calendario, etc.
Así pues, podemos decir que las liberías (libraries en inglés) son uno de los componentes que
más tiempo nos ahorrarán a la hora de desarrollar una web, pues contienen código que
resultará siempre útil. El trabajo con las librerías es bastante simple, como veremos a
continuación.
Carga de librerías
Para cargar una library en CodeIgniter tenemos que indicarlo explícitamente, pues en este
framework no se carga nada por defecto, salvo contadas excepciones, para optimizar el tiempo
de respuesta de PHP al procesar las páginas. Para ello tenemos que invocar el siguiente
código:
$this->load->library('nombre de la clase');
Donde 'nombre de la clase' es el nombre de la librería, o clase de POO, que queremos cargar.
Nota: Realmente todas las librerías no se necesitan cargar, puesto que hay algunas que ya se encuentra por
defecto disposición de nuestros scripts, sin tener que cargarlas explícitamente. Esto es porque algunas
librerías son fundamentales para el funcionamiento del núcleo de CodeIgniter. Por ejemplo, siempre
tendremos disponibles las librerías que implementan las clases de Output, Input o URI.
Por ejemplo, si quisiéramos cargar la librería de Email, que facilita el envío de correos por
medio de PHP, tendríamos que utilizar el siguiente código:
$this->load->library('email');
Ya que son clases de POO, una vez cargada tenemos que utilizar sus métodos para poner en
marcha sus funcionalidades. Dentro de los controladores, para acceder a la clase y sus
métodos utilizamos el nombre de la clase como una propiedad de $this.
Por ejemplo, en el caso de la librería email, para definir quién envía un correo electrónico
utilizamos un código como este:
$this->email->from('[email protected]', 'Nombre del remitente');
En la guía de usuario de CodeIgniter existe una referencia completa sobre cada una de las
clases y su utilización. Nosotros iremos viendo ejemplos de uso en futuros artículos.
En ese archivo encontraremos un array llamado libraries, donde podemos indicar todos los
nombres de las librerías a cargar, por ejemplo:
$autoload['libraries'] = array('database', 'session', 'form_validation');
Para ilustrar cómo se deben utilizar las librerías de CodeIgniter hemos publicado un ejemplo de
uso de la librería Calendar.
}
}
Como se ha visto, tengo el controlador y dentro tengo el constructor que carga la librería
Calendar. Ahora la clase "calendar" estará disponible en todos los métodos de nuestro
controlador.
Nota: Aunque ya hemos dicho esto en muchas partes, merece la pena repetirlo. Todos los echos o funciones
que escriben salida en la página deberían estar en las vistas. Aquí tenemos un echo que escribe en la página
directamente desde el controlador, y aunque CodeIgniter lo permite, no es lo correcto.
Ahora podríamos acceder a ese método con una URL como esta:
http://localhost/index.php/probando_library_calendar/
Al indicar simplemente el nombre del controlador en la URL, se llama siempre al método
index() que lo que hace es escribir el calendario del mes actual.
12 => 'http://www.desarrolloweb.com/javascript',
21 => 'http://www.desarrolloweb.com/css',
);
echo $this->calendar->generate($ano, $mes, $data);
}
Este método pone unos enlaces en días fijos marcados en el array $data. Podríamos acceder a
una página que se procesa con ese método por medio de una URL como esta:
http://localhost/index.php/probando_libraryzx_calendar/calendario_enlaces/2010/2