Según Dzone.com:
- Javascript
- Java
- Python
- PHP
- C
- C++
- Ruby
- C#
- Objective-C
- Perl
- Css 3
- SQL
- Bash
- R
- Scala
- Matlab
- Visual Basic
- Haskell
- Go
- .Net
- Swift
- Clojure
- Groovy
Según Dzone.com:
Por defecto PHP escribe los datos de la sesión en un fichero en disco. La función session_start() bloquea el fichero de la sesión de forma que nadie más puede leerlo. Ese bloqueo durará hasta que se acaba la ejecución del script o hasta que se libere manualmente usando alguna de las siguientes funciones: session_abort(), session_commit(), session_destroy() o session_write_close().
La mayoría de los programadores inician la sesión al principio del script, pero la dejan abierta hasta el final. Eso en entornos con múltiples peticiones sobre la misma sesión (por ejemplo con mucho AJAX) es posible que acabe causando un cuello de botella en momentos putuales. En el momento que una petición tarde demasiado en responder (debido por ejemplo a una query complicada) las demás peticiones no podrán acceder al fichero de sesión que estará bloqueado con el resultado de un tiempo de respuesta significativamente elevado. Pero sólo en momentos puntuales.
Lo más fácil es liberar el fichero de sesión justo después del session_start(). Los datos de sesión seguirán disponibles para lectura a través de la variable superglobal $_SESSION, pero no se podrá encribir nada en la sesión.
<?php // Start the session session_start(); // Session is open to read/write ops $_SESSION['latestRequestTime'] = time(); // Close the session session_write_close(); // Now session is read-only $user = $_SESSION['userNAme'];
Si no es posible cerrar la sesión justo después de abrirla (por ejemplo porque haya que escribir datos después de obtenerlos y/o procesarlos) hay algunas alternativas que pueden utilizarse: Guardar la sesión en una base de datos MySQL, ya que el motor de base de datos no bloquea la sesión, o bien guardar la sesión en algún sistema de caché como Redis, Memcache, etc.
Symfony 2 es uno de los frameworks MVC basados en lenguaje PHP que más de moda están en los últimos tiempos. La documentación oficial de Symfony 2 es muy extensa, pero se hecha en falta una sección dedicada sobre como poner en producción un proyecto ya terminado (o una beta) en un servidor real. Lo que llamamos desplegar el proyecto (del inglés deploy).
Los requisitos de Symfony 2 no son demasiado elevados: Basta un servidor web como Apache o Nginx y PHP 5.3.3 o superior (aunque se recomienda PHP superior a 5.3.16). Siempre es recomendable aunque no obligatorio que sea un servidor dedicado sobre el que tengamos acceso root. Es perfectamente posible desplegar un proyecto Symfony 2 en un servidor compartido aunque eso sí: es necesario tener acceso al shell del servidor (vía SSH típicamente). Symfony 2 no puede desplegarse simplemente subiendo los archivos por FTP.
Cualquier proyecto Symfony 2 está compuesto por una carpeta de código fuente del proyecto (src), una carpeta de librerías externas entre las que se incluye el propio framework (vendors), una carpeta de configuración y recursos globales (app) y una carpeta frontal (web). Todas ellas son necesarias, pero no todas tienen la misma importancia.
Carpetas de un proyecto Symfony
app: Esta carpeta contiene la configuración del proyecto (subcarpeta app/config), pero también los recursos comunes (subcarpeta app/Resources), los logs (subcarpeta app/logs) y también la cache (subcarpeta app/cache), que es donde se crean una serie de clases autogeneradas que aceleran la ejecución del proyecto (es algo similar a tener código compilado sólo que sigue siendo PHP). En la carpeta app también está la consola que es un componente necesario para instalar el proyecto.
src: Esta carpeta contiene el código fuente del proyecto. Internamente el código se divide en bundles y cada bundle puede tener controladores, entidades, vistas, recursos, etc.
vendor: Esta carpeta contiene el código fuente de las librerías externas y bundles que usa el proyecto. Se trata de código es open-source que sus creadores ponen a disposición de los programadores para desarrollar sus propios proyectos.
web: Esta carpeta contiene el controlador frontal de Symfony 2 (programa app.php). Un proyecto Symfony 2 puede tener más de un controlador frontal, según los distintos entornos de ejecución que se definan: app_dev.php, app_test.php, etc. A la hora de ponerlo en explotación bastaría con el controlador frontal del entorno de producción producción. En la carpeta web también se copian automáticamente los assets del proyecto (imágenes, CSS, JS, etc.)
Entornos de un proyecto Symfony
Dentro de un único proyecto Symfony 2 se pueden definir diversos entornos; típicamente son tres, aunque pueden ser más: desarrollo (dev), pruebas (test) y producción (prod). El primero se usa para desarrollar en proyecto, el segundo es para pasar los test unitarios y funcionales y el tercero es para probar el proyecto tal y como debe funcionar en explotación.
Ojo: Nunca han que confundir los entornos de Symfony (dev, test, prod) con los entornos de una organización. Son cosas distintos. A la hora de poner en producción un proyecto Symfony 2 en un servidor real sólo tendremos en cuenta el entorno de producción. Los demás deben descartarse.
Cada entorno Symfony 2 tiene archivos de configuración diferentes en la carpeta app/config:
config.yml: Archivo de configuración común para todos los entornos.
config_dev.yml: Archivo de configuración del entorno de desarrollo de Symfony 2. Modifica la configuración de config.yml para el entorno dev. Permite por ejemplo evitar que se envíen mails al ejecutar los test.
config_test.yml: Archivo de configuración del entorno Symfony 2 de pruebas unitarias.
config_prod.yml: Archivo de configuración específico del entorno de producción.
Además del archivo de configuración puede haber otros archivos con configuración adicional:
security.yml: Configuración de la seguridad del proyecto Symfony 2.
routing.yml: Configuración de las rutas del proyecto Symfony 2.
routing_dev.yml, routing_test.yml, … rutas adicionales por entornos.
Por último existen dos archivos de configuración adicionales:
parameters.yml: Este archivo contiene la configuración dependiente de la instalación y es el único archivo que debería variar de un servidor a otro. Sirve por ejemplo para indicar la base de datos a usar, el servidor del API, el servidor de correo, etc. NUNCA debería distribuirse este archivo en una puesta en explotación.
parameters.yml.dist: Indica los valores por defecto del archivo “parameters.yml” y es usado por “composer.phar” para crear este último.
Por cada entorno Symfony 2 también habrá un controlador frontal en la carpeta web. Es decir que además del controlador app.php podremos tener app_dev.php y app_test.php. Si por ejemplo creamos un archivo config_beta.yml automáticamente se creará un controlador app_beta.php.
Herramientas
composer.phar: Herramienta para resolver dependencias en un proyecto PHP. Usado por Symfony 2 para instalar los vendor y para preparar los entornos.
app/console.php: Herramienta interna de Symfony 2 que permite limpiar la cache, instalar los assets y muchas más cosas.
Punto de partida
Para poner en producción un proyecto Symfony 2 hay dos puntos de partida:
vendor.
Permisos
Debido a que es necesario que las carpetas app/cache y app/logs tengan permiso de escritura se recomienda que el usuario Linux que realice la instalación sea el mismo del servidor web (apache, nginx, etc).
Si esto no fuera posible debería modificarse el propietario de todos los archivos de esas carpetas como paso final de la instalación o bien dar permisos de escritura sobre esas carpetas. Si esto no se hace no funcionará el proyecto.
Pasos a seguir
vendor.
php composer.phar install
rm -f app/config/*_dev.yml
rm -f app/config/*_test.yml
rm -f web/app_dev.yml
rm -f web/app_test.yml
(...)
app/config/parameters.yml específico de esta instalación.
php app/console -e=prod cache:clear
php app/console assets:install web --symlink
php app/console -e=prod assetic:dump
chown -R nginx:nginx app/cache
chown -R nginx:nginx app/logs
chmod -R a+w app/cache
chmod -R a+w app/logs
vendor).
Lo normal es que un proyecto Symfony 2 se despliegue desde un repositorio de fuentes (GIT, SVN, etc), pero en ocasiones esto no es posible. En ese caso habrá que subir manualmente el código fuente al servidor, incluyendo la carpeta vendor.
Pasos a seguir
rm -rf app/cache/*
rm -rf app/logs/*
rm -f app/config/*_dev.yml
rm -f app/config/*_test.yml
rm -f web/app_dev.yml
rm -f web/app_test.yml
(...)
app/config/parameters.yml específico de esta instalación.
php app/console -e=prod cache:clear
php app/console assets:install web --symlink
php app/console -e=prod assetic:dump
chown -R nginx:nginx app/cache
chown -R nginx:nginx app/logs
chmod -R a+w app/cache
chmod -R a+w app/logs
El pasado 29 de noviembre se publicó la nueva versión 2.6 del popular framework PHP Symfony [EN]. Dicha versión incluye multitud de novedades como por ejemplo la inclusión de las llamadas AJAX en la barra de depuración [EN], el nuevo tema para formularios basado en Bootstrap 3 [EN], el nuevo instalador de Symfony [EN] y así hasta 100 cambios, mejoras y correcciones. Puedes consultar la lista completa de cambios de Symfony 2.6 [EN] y las actualizaciones necesarias para pasar de Symfony 2.5 a 2.6 [EN]. Symfony 2.6 se actualizará hasta julio de 2015 y tendrá soporte hasta enero de 2016.
Siguiendo con Symfony recientemente se ha dado a conocer la hoja de ruta para los próximos Symfony 2.7 [EN], con fecha de lanzamiento prevista en mayo de 2015, que será LTS con soporte hasta mayo de 2019 y la última versión de Symfony 2; y el futuro Symfony 3 [EN] que romperá la compatibilidad con las versiones anteriores pero que no supondrá un cambio trágico como lo fue el paso de Symfony 1 a Symfony 2. Las principales novedades que se conocen de Symfony 3 son que se aumentará el requisito de versión de PHP mínimo a PHP 5.5 o PHP 5.6 y que se eliminará código obsoleto, rompiendo compatibilidad con las versiones anteriores.
Muchas aplicaciones Symfony 2 son multiidioma gracias a la capacidad del popular framework para manejar las traducciones. En este contexto la variable locale contendrá el identificador del idioma. Desde el controlador es muy sencillo obtener el locale a partir del request; basta pedirlo: $this->get('request')->getLocale(). En cambio no es tan sencillo inyectar el locale en el constructor de un servicio debido a los diferentes ámbitos (scopes) que pueden tener los servicios.
Sin embargo hay un truco para hacerlo:
<service
id="mylocale"
class="Symfony\Component\HttpFoundation\Request"
factory-service="request"
factory-method="getLocale">
</service>
<service
id="myservice"
class="%myservice.class%">
<argument type="service" id="mylocale" on-invalid="null" />
</service>
Es decir, primero creamos un service factory que acceda al Request para obtener el locale y luego inyectamos el service factory en nuestro servicio. el parámetro on-invalid="null" es muy importante para solucionar aquellos casos en que el Request no existe; como por ejemplo los comandos de consola. Al implementar la clase hay que tener en cuenta que es posible que recibamos null en lugar del locale.
class MyService
{
/**
* @var string
*/
private $locale;
/**
* @param string $locale
*/
public function __construct($locale = null)
{
$this->locale = $locale;
}
// (...)
}
Javascript es un lenguaje muy completo y muy complejo de aprender, sobre todo la parte referente a objetos, clases, herencia, prototipos, etc. Y esto es porque si bien Javascript no soporta de forma nativa esos conceptos de la orientación a objetos que tan claros están en otros lenguajes como Java, C++ o PHP, todos ellos pueden simularse con las funciones nativas del lenguaje.
Por ello voy a iniciar una serie de artículos sobre Javascript Avanzado.
var stack = {
elements: [],
push: function(elem) {
this.elements.push(elem);
},
pop: function() {
var elem = this.elements.pop();
return elem;
}
};
En Javascript se puede usar la notación JSON para crear objetos sin tener que crear antes una clase. En el ejemplo creamos un objeto llamado stack que tiene un array de elementos y dos métodos: push() y pop(). La variable resultante es directamente un objeto. La mayoría de los lenguajes orientados a objeto no permiten crear objetos sin haber creado antes una clase, pero Javascript sí.
NOTA: Es innecesario crear un objeto stack en Javascript pues la clase Array ya tiene las funciones push() y pop() de forma nativa, pero me sirve para ilustrar el ejemplo.
stack.push(1);
stack.push('string');
stack.push({ id: 1, name: 'test' });
console.log(stack.pop());
Como se ve podemos usar directamente los métodos del objeto stack, pero en cambio no podemos crear nuevos objetos stack, ya que stack es un objeto y no una clase. Por lo tanto el siguiente código dará error:
var s = new stack;
Además en este tipo de objetos simples todos los métodos y miembros son públicos, lo cual quiere decir que podríamos acceder directamente a la lista de elementos elements, lo cual no suele ser correcto desde el punto de vista de la programación orientación a objeto.
Javascript, a diferencia de otros lenguajes de programación orientados a objetos más tradicionales permite añadir nuevos miembros y métodos a un objeto simple tras su creación. Por ejemplo:
stack.top = function() {
if(this.elements.length < 1) {
return null;
}
else {
return this.elements[this.elements.length - 1];
}
};
Así añadimos el método top() al objeto stack que funcionará exactamente igual que si lo hubiéramos puesto desde el principio.
En Javascript no podemos crear una clase como tal, pero sí que podemos simularlo mediante una función. Sí, sí... has leído bien: una función. Esa función además funciona como constructor de la clase. Veamoslo con el mismo ejemplo:
var Stack = function() {
var elements = [];
this.push = function(elem) {
elements.push(elem);
},
this.pop = function() {
var elem = elements.pop();
return elem;
}
};
En el constructor de la clase Stack inicializamos un array de elementos y definimos las funciones push() y pop(). Ahora Stack es una clase, no un objeto y por lo tanto no podemos hacer lo siguiente:
Stack.push('elem1');
console.log(Stack.pop());
La forma correcta de hacerlo sería creando primero un objeto de clase Stack.
var st = new Stack;
st.push('elem1');
console.log(st.pop());
Además se da el caso de que ahora el miembro elements es privado lo cual significa que no puede ser accedido desde fuera de la clase.
Anteriormente vimos como añadir métodos a un objeto Javascript. Aquí también podemos añadir miembros y métodos directamente al objeto st, pero como la variable elements no es un miembro de la clase no podremos acceder a ella. Tendríamos que hacer que la variable elements fuera un miembro de la clase
var Stack = function() {
this.elements = [];
this.push = function(elem) {
this.elements.push(elem);
},
this.pop = function() {
return this.elements.pop();
}
};
var st1 = new Stack;
st1.top = function() {
if(this.elements.length < 1) {
return null;
}
else {
return this.elements[this.elements.length - 1];
}
};
st1.push('e1');
console.log(st1.top());
Hemos añadido el método top() al objeto st que funcionará como si se hubiera añadido en la definición de la clase (función constructora). Sin embargo ese método es exclusivo del objeto st y no estará disponible para otros objetos Stack. ¿Y podemos añadir un método a una clase? Sí; a través del prototipo:
Stack.prototype.top = function(){
if(this.elements.length < 1) {
return null;
}
else {
return this.elements[this.elements.length - 1];
}
};
Ahora tanto st1 como cualquier otro objeto de clase Stack creado con posterioridad tendrán top() entre sus métodos.
El concepto de la herencia en Javascript también es extraño si estas acostumbrado a otros lenguajes orientados a objeto. Al no existir clases como tales tampoco hay palabras clave como extends o implements. La herencia se hace asignando el prototipo de una función (clase) a otra. Pero la explicación detallada la vamos a dejar para otro artículo.
El otro día os hablaba de Composer el gestor de dependencias para proyectos en PHP que permite incorporar a nuestros proyecto en PHP multitud de librerías, gestionando sus dependencias de forma magistral. Pues hoy he encontrado el artículo Composer, gestor de dependencias para PHP que amplía la información que yo mismo puse aquí. Os recomiendo su lectura.
Actualización (23/10/2014): Los chicos de desarrolloweb.com han publicado hoy una segunda parte del artículo de Composer llamada Cómo Instalar Composer, donde se detallan las distintas formas de instalar Composer en los más populares sitemas poerativos: Windows, Linux, Max OSX, ...
El título de este artículo lo dice todo: Función javascript para formatear un número de teléfono. Así pues ahí va:
String.prototype.formatPhone = function(sep) {
if(typeof sep == 'undefined') {
sep = ' ';
}
var num = this.replace(/[^\d\+]/g, '');
var len = num.length;
if(len < 7) {
return num;
}
else if(len < 10) {
return num.replace(
/(\d{1,3})(\d{3})(\d{3})/,
'$1' + sep + '$2' + sep + '$3'
);
}
else {
return num.replace(
/(\d+)(\d{3})(\d{3})(\d{3})/,
'$1' + sep + '$2' + sep + '$3' + sep + '$4'
);
}
};
Y para usarlo...
var phone = '[+34] 93 6665544'.formatPhone(' ');
document.write(phone);
Resultado: +34 936 665 544.
Me acabo de enterar a través del fabuloso blog Symfony.es de Javier Eguiluz de la presentación del manual oficial de buenas prácticas para desarrollar aplicaciones en Symfony2. Si estás interesado puedes descargarlo en formato PDF en inglés o en español, aunque el propio Javier advierte que el contenido cambiará en los próximos días pues por ahora sólo se ha publicado una versión preliminar. También puedes consultar on-line el manual en Español.
Se trata de una serie de reglas que configuran un conjunto de buenas prácticas que recomiendan desde SensioLabs y que han sido aprobadas por el propio Fabien Potencier. Puedes estar de acuerdo o no con esta guía por lo que si eres desarrollador experto no es necesario que las sigas. Tampoco es obligatorio modificar un proyecto existente para seguirlas. Sin embargo me parece una gran ayuda especialmente para principiantes y para proyectos nuevos. Personalmente no estoy totalmente de acuerdo con todas pero me parece muy interesante especialmente las recomendaciones sobre como crear el bundle de aplicación, y donde poner los recursos como las vistas o las traducciones.
Composer es una de las herramientas fundamentales para desarrollar aplicaciones y páginas web en lenguaje PHP, ya que permite administrar las dependencias de nuestro proyecto con las distintas librerías externas que necesitemos usar. Composer instala las librerías que el proyecto necesita en una carpeta del propio proyecto. Vamos a ver como funciona con un ejemplo:
Supongamos que nuestro proyecto PHP necesita generar archivos Excel. En lugar de crear todo el código necesario desde cero, miramos en Packagist si alguien ha creado una herramienta open-source que haga lo que necesitamos y vemos que existe una librería llamada PHPExcel. Esa librería a su vez necesitará otras, probáblemente. En lugar de descargar el código fuente de la librería y buscar las dependencias dejamos que sea Composer el que resuelva el problema.
Para ello lo primero será tener instalado Composer en el PC, ya sea de forma global o en el directorio raíz del proyecto. Composer es un programa escrito en php que descargaremos y ejecutaremos.
$ curl -sS https://getcomposer.org/installer | php
Obtendremos un archivo llamado composer.phar que luego para instalarlo globalmente podemos moverlo a un directorio del path como /usr/bin o /usr/local/bin, dándole permisos de ejecución.
$ mv composer.phar /usr/local/bin/composer
$ chmod a+x /usr/local/bin/composer
Una vez tenemos Composer instalado de forma global, creamos el archivo composer.json en la raíz de nuestro proyecto:
{
"require": {
"phpoffice/phpexcel": "dev-master"
}
}
Y entonces usamos composer para que resuelva las dependencias:
$ composer install
La ejecución de composer crea la carpeta vendor y descarga automáticamente la librería phpexcel y las dependencias de ésta si las hay. También crea un archivo llamado autoload.php que será necesario incluir en nuestro proyecto para usar las librerías creadas por composer.
<?php require __DIR__ .'/vendor/autoload.php';
Al ser un programa escrito en PHP Composer es multiplataforma por lo que funciona tanto en Linux como en OSX y en Windows. Necesita una versión de PHP 5.3.2 o superior y puede requerir modificar alguna configuración en php.ini, pero el propio instalador informa de cualquier incompatibilidad. Además es conveniente tener instalado Git, Svn u otras herramientas para el control de código fuente.
Symfony2 es uno de los frameworks para PHP más completos, versátiles y potentes que existen actualmente en el mercado. Pero, ¿Qué ocurre si no necesitamos tanta potencia? ¿Que hacemos si queremos desarrollar una pequeña página corporativa donde la potencia de Symfony2 es más un estorbo que una ayuda? En esos casos en lugar de usar Symfony u otro framework potente como Zend se suele optar por personalizar un Wordpress, un Joomla o cualquier otro CMS. El problema entonces es que perdemos el control del desarrollo en temas como gestión de permisos, teniendo que adaptar nuestros requerimientos a lo que pueda hacer el CMS elegido. Sin embargo existe una tercera vía: El uso de un micro-framework que sin ser tan potente como un Symfony o un Zend nos proporcione la suficiente versatilidad para desarrollar una pequeña página web de forma ágil. Y en este caso la propia SensioLabs y Fabien Potencier, creadores de Symfony, nos dan la solución: Silex.
Silex es un micro-framework para lenguaje PHP basado en componentes de Symfony2. Funciona con PHP 5.3 o superior y tiene licencia MIT (código fuente libre). La gran potencia de Silex es que aprovecha gran parte de los componentes del núcleo de Symfony2, que están sobradamente probados, pero en cambio en mucho más fácil de usar que Symfony2. El paquete básico de Silex permite desarrollar páginas web desde cero, proporcionando un sencillo sistema de definición de rutas propio y poco más. Sin embargo es posible añadir a Silex multitud de componentes externos que también usa Symfony: desde Twig hasta Doctrine, pasando por Swiftmailer y algunos de los componentes más potentes de Symfony como sus formularios, su sistema de validación, su sistema de traducciones, etc.
La documentación de Silex es muy completa, en la línea de los otros productos de SensioLabs.
require_once __DIR__ . '/../vendor/autoload.php';
$app = new Silex\Application();
$app->get('/', function() {
$output = 'Hola mundo.';
return $output;
});
$app->run();
El software a medida es un producto de Ingeniería de Software desarrollado especialmente para un cliente, teniendo en cuenta los requerimientos del mismo y las políticas de su empresa u organización.
El software estándar por su parte está orientado un uso masivo por clientes con necesidades similares. Algunos productos de software estándar permiten también ciento grado de personalización de forma que con un desarrollo particular pueden adaptarse a las necesidades del cliente, aunque es difícil que se adapte exactamente a los requerimientos y políticas del mismo. Un ejemplo serían los diversos CMS (sistemas de gestión de contenidos) como Wordpress, Joomla, Prestashop, Drupal, ... Otros productos de software estándar no permiten ningún tipo de personalización.
A priori el software a medida siempre es más caro porque requiere más trabajo, pero cumple exactamente con las necesidades del cliente. Sin embargo en ocasiones las adaptaciones de software estándar a las necesidades de un cliente pueden costar tanto como hacer el software a medida desde cero. Todo depende de lo que el producto inicial se adapte a los requerimientos del cliente.
Como analogía entre software a medida y estándar se puede usar, con restricciones, el caso de un traje a medida frente a otro comprado en un centro comercial. Muchos clientes tendrán bastante con un traje del centro comercial al que le hacen unos mínimos arreglos. En cambio si el cliente tiene necesidades especiales por ser por ejemplo muy alto es difícil que encuentre un traje que le sirva en el centro comercial y tendrá que pedir a un sastre que se lo confeccione a medida. Otra posibilidad sería comprar el traje más grande del centro comercial y luego pedir a un sastre que se lo alargue. El coste del arreglo generalmente será menor que el traje a medida pero el resultado tampoco será el mismo.
Ventajas del software a medida:
Desventajas del software a medida:
¿Cuando conviene desarrollar software a medida?
Una empresa u organización preferirá desarrollar software a medida cuando las necesidades de sus sistemas de información no se adapten exactamente a ningún producto comercial, personalizable o no, ya sea porque tienen requerimientos especiales o porque no deseen cambiar sus procesos de gestión. Los requerimientos especiales pueden ser cualquier cosa: desde informes especializados hasta procesos de gestión no habituales. La decisión de desarrollar software a medida puede afectar a la competitividad del cliente a medio plazo, por lo que es una decisión que hay que meditar bien antes de tomar una decisión definitiva.
Una closure es una función sin nombre que puede por ejemplo asignarse a una variable o pasarse como parámetro a otra función. PHP soporta closures desde la versión 5.3 con una restricción importante: El ámbito de las variables es totalmente privado. Esto quiere decir que desde dentro de la closure no se puede acceder a variables externas a no ser que sean variables globales y las declares con la palabra clave global. Una excepción a esto son las variables superglobales. Además desde PHP 5.4 se puede acceder a $this si la closure se declara dentro de un método de una clase. Esa restricción no es un problema por si mismo, pero restringe el uso de variables locales cuando declaras la closure dentro de una función o de un método de una clase. Para solucionar eso se usa la palabra clave use. Entonces si queremos hacer una llamada recursiva a la closure tendremos que pasar una referencia a la propia closure a través de la palabra clave use. Por ejemplo (*):
$factorial = function( $n ) use ( &$factorial ) {
if( $n == 1 ) return 1;
return $factorial( $n - 1 ) * $n;
};
(*) Ejemplo sacado de Stack Overflow.
Javascript es un lenguaje de programación que está cada vez más en alza debido a sus enorme flexibilidad y a sus muchas posibilidades. Una característica que los principiantes en este lenguaje no suelen conocer es que se puede añadir y modificar el comportamiento de los métodos de una clase posteriormente a la declaración de la misma. Y esto puede hacerse tanco con clases propias como con clases nativas del lenguaje.
Por ejemplo la clase String, que es nativa de Javascript, tiene muchos métodos útiles como pueden ser trim(), substring(), indexOf() o replace(); pero carece por ejemplo de un método stripTags() que elimine las etiquetas HTML de una cadena de texto. Sin embargo podemos añadirlo fácilmente:
String.prototype.stripTags = function() {
return this.replace(/<(?:.|\n)*?>/gm, '').trim();
}
Una vez declarado podemos hacer lo siguiente:
var x = "<p>Hola <b>mundo</b>.</p>"; x = x.stripTags(); document.write(x);
El resultado será "Hola mundo" sin los tags HTML.
Un IDE (Integrated Development Environment) o entorno de desarrollo integrado es la herramienta que los programadores usamos para programar. En realidad los programadores somos gente simple: lo único que de verdad necesitamos para programar es un buen editor de texto. Luego si queremos probar nuestro desarrollo necesitaremos el compilador o intérprete del lenguaje de programación que estemos usando y dependiendo del caso igual algunas herramientas adicionales como un servidor web o la máquina virtual de Java. Pero de entrada lo único imprescindible es un editor de texto.
Como editor de texto nos vale casi cualquier cosa: desde el inútil bloc de notas de Windows hasta el complejo EMACS de GNU, pasando por el Notepad++ o el Ultra Edit en Windows, el gEdit en Ubuntu o el VI o el Nano en cualquier distribución Linux. Los programadores que ya peinamos canas recordamos aun los tiempos en que los IDE no se habían generalizado y la nuestra única herramienta era un editor de textos.
Un IDE es un conjunto de herramientas integradas en un único paquete que proporciona a los programadores un marco para el desarrollo de aplicaciones informáticas. Un IDE puede servir para programar en un único lenguaje, en varios lenguajes o ser de propósito general (para cualquier lenguaje, generalmente añadiendo plugins).
Un IDE puede tener algunas de las siguientes herramientas (o todas ellas):
Y ahora que ya he explicado que es un IDE, ¿Cual es el mejor para programar en PHP? Pues la pregunta es complicada. Cada programador tendrá sus preferencias, pero personalmente después de haber probado varios tanto en Windows como en Linux me quedo con PhpStorm.
PhpStorm es un IDE comercial multiplataforma de JetBrains que incluye editores para PHP, HTML y JavaScript, análisis de código en tiempo real, prevención de errores y mucho más. A mi me gusta sobre todo porque es muy rápido y bastante intuitivo de usar. He probado otros IDE como Eclipse y NetBeans, ambos gratuitos y open source, pero prefiero la rapidez de PhpStorm.
Este caso es un poco difícil de explicar. Vamos a suponer lo siguiente: Tenemos una entidad Factura y un repositorio FacturaRepository que tiene una función findFacturas(). Dicha función recibe un parámetro obligatorio $usuario de clase Usuario y otro opcional $filtros que por defecto es un array vacío. La mencionada función, que está perfectamente testeada y no desea cambiarse, prepara dinámicamente una query DQL teniendo en cuenta los permisos del usuario y un montón de filtros y devuelve un objeto de clase Query que al ejecutarla devuelve la lista de facturas del usuario.
namespace Company\ContabilidadBundle\Entity;
class Factura {
//...
}
class FacturaRepository {
public function findFacturas(Usuario $usuario, $filtros = array( )) {
//...
return $query;
}
}
Por otro lado, en otra parte de la aplicación, tenemos un formulario en el que necesitamos poder seleccionar una de las facturas del usuario mediante un cuadro de selección (combobox). Para ello lo más lógico es añadir al formulario un campo de tipo entity. El problema es que que no podemos aprovechar la query que tenemos en nuestro repositorio porque los campos entity se cargan con un QueryBuilder.
Hoy me he encontrado con este mismo problema. Quedaba totalmente descartado Convertir en un QueryBuilder una query DQL de dos palmos y medio de largo, perfectamente testeada, por su complejidad (y porque no me daba la gana), así que me he puesto a investigar si había alguna forma de convertir o cargar un objeto Query en un objeto QueryBuilder. No ha sido fácil pero lo he conseguido...
Este es el resultado:
namespace Company\ContabilidadBundle\Form\Type;
class FormularioFormType extends AbstractType {
//...
public function buildForm(FormBuilderInterface $builder, array $options) {
//...
$builder->add(
'factura',
'entity',
array(
'class' => 'CompanyContabilidadBundle:Factura',
'query_builder' => function(EntityRepository $repository) use($usuario) {
$query = $repository->findFacturas($usuario);
$qb = $repository->createQueryBuilder('f');
$qb->where($qb->expr()->in('f', $query->getDql()));
$qb->setParameters($query->getParameters());
return $qb;
}
));
}
}
Veámoslo paso a paso:
Query del repositorio. Dicho objeto estará listo para ser ejecutado devolviendo el resultado que deseamos.Query con las instrucciones $query->getDql() y $query->getParameters().QueryBuilder y simulamos una subquery como esta: SELECT * FROM Facturas f WHERE f IN (...), poniendo la sentencia DQL original en el lugar de los puntos suspensivos.Es rebuscado pero funciona perfectamente.
Esta es la tercera parte del mini-curso de Symfony 2 que empecé hace tiempo. En el último capítulo creamos nuestro primer proyecto Symfony 2. El proyecto recién creado traerá todas las dependencias necesarias para empezar a programar con el framework Symfony. Sin embargo una de las grandes ventajas de Symfony 2 es que es fácilmente ampliable mediante librerías externas programadas por terceros llamadas bundles.
Hay bundles para todos los gustos: unos añaden características nuevas a Symfony 2, otros mejoran su seguridad, otros amplían funcionalidades, etc. La forma de instalar un bundle externo es nuevamente mediante el uso de composer. Para ello hay que añadir las dependencias en el archivo composer.json que encontraremos en la raíz de nuestro proyecto Symfony de la siguiente forma:
{
"require": {
"vendor/package": "version",
}
}
En este caso vendor y package forma el nombre del bundle mientras que version es el número de versión (por ejemplo: 1.2.3 o 1.2.* o >1.2.3 o >1.2.3,<1.3, etc. Para buscar bundles compatibles podemos ir a Packagist, que es el repositorio de paquetes instalables vía Composer.
Vamos a verlo con un ejemplo. Supongamos que queremos añadir el framework CSS Bootstrap a nuestro proyecto Symfony. Podríamos descargarnos la librería de Bootstrap y añadirla manualmente a nuestro proyecto, pero en Symfony siempre que sea posible preferiremos hacerlo vía bundle externo. Buscando en Packagist encontramos que hay varios bundles que añaden Bootstrap a Symfony. Yo he elegido Mopa Bootstrap porque lo conozco de antes, pero además es uno de los que más descargas y mejor valoración tienen en Packagist. Visitamos la página web oficial del proyecto Mopa Bootstrap en Github y allí la sección de instalación nos indica como añadir el bundle a Symfony 2; hay que añadir el siguiente código en el archivo composer.json:
{
"require": {
"mopa/bootstrap-bundle": "v3.0.0-beta3",
"twbs/bootstrap": "v3.0.0"
}
}
Una vez hecho esto hay que ejecutar composer update desde el directorio principal del proyecto para que se actualicen las dependencias y se descarguen las librerías.
$ composer update
Loading composer repositories with package information
Updating dependencies (including require-dev)
- Installing mopa/composer-bridge (v1.3.0)
Downloading: 100%
- Installing mopa/bootstrap-bundle (v3.0.0-beta3)
Downloading: 100%
- Installing twbs/bootstrap (v3.0.0)
Downloading: 100%
Como podemos ver además de los dos bundles indicados nos ha instalado un tercero: mopa/composer-bridge (v1.3.0). Esto es porque Composer sabe que es necesario instalarlo o sino mopa/bootstrap-bundle (v3.0.0-beta3) no podrá funcionar. Ahora ya podemos empezar a usar Bootstrap en nuestro proyecto web. Pero, ¿Como se usa mopa/bootstrap en Symfony? Para saber eso hay que leerse la documentación.
En Doctrine, Las relaciones OneToMany son un mecanismo muy potente para acceder a una lista de objetos hijo. El ejemplo más claro de uso de las relaciones OneToMany sería una factura y las líneas de factura o un pedido y el detalle del pedido; y en general cualquier relación maestro-esclavo o padre-hijo en la que la clave foránea se encuentra en la tabla hija.
Así en los proyectos Symfony 2 que usan Doctrine obtener la lista de objetos hijo desde el padre es tan sencillo como acceder a la propiedad del objeto. Internamente Doctrine convierte eso en una query a la base de datos, pero el resultado obtenido por defecto no viene ordenado. Podemos garantizar el orden añadiendo la cláusula OrderBy a la declaración de la propiedad OneToMany, pero esa ordenación es muy limitada. Veamos un ejemplo:
use Doctrine\ORM\Mapping as ORM;
/**
* @ORM\Entity()
* @ORM\Table(name="facturas")
*/
class Factura
{
/**
* @var integer
*
* @ORM\Id
* @ORM\Column(name="id_factura", type="integer", nullable=false)
*/
private $id;
/**
* @var \DateTime
*
* @ORM\Column(name="fac_fecha", type="text", nullable=false)
*/
private $fecha;
/**
*
* @ORM\OneToMany(targetEntity="Lineas", mappedBy="factura", cascade={"all"})
* @ORM\OrderBy({"id" = "ASC"})
*/
private $lineas;
// ...
}
/**
* @ORM\Entity()
* @ORM\Table(name="lineas_factura")
*/
class Lineas
{
/**
* @var integer
*
* @ORM\Id
* @ORM\Column(name="id_linea", type="integer", nullable=false)
*/
private $id;
/**
* @var \DateTime
*
* @ORM\Column(name="lin_fecha", type="text", nullable=false)
*/
private $fecha;
/**
* @var integer
*
* @ORM\ManyToOne(targetEntity="Factura", inversedBy="lineas")
* @ORM\JoinColumn(name="id_factura", referencedColumnName="id_factura")
*/
private $factura;
/**
* @var integer
*
* @ORM\OneToOne(targetEntity="Producto", cascade={"all"})
* @ORM\JoinColumn(name="id_producto", referencedColumnName="id_producto")
*/
private $producto;
// ...
}
/**
* @ORM\Entity()
* @ORM\Table(name="productos")
*/
class Producto
{
/**
* @var integer
*
* @ORM\Id
* @ORM\Column(name="id_producto", type="integer", nullable=false)
*/
private $id;
/**
* @var string
*
* @ORM\Column(name="prod_nombre", type="text", nullable=false)
*/
private $nombre;
/**
* @var float
*
* @ORM\Column(name="prod_precio", type="float", nullable=false)
*/
private $precio;
// ...
}
En este ejemplo la propiedad lineas de la clase Factura tiene una cláusula OrderBy que hace que la lista resultado se obtenga ordenada por id. ¿Pero que ocurriría si quisiéramos que el resultado viniese ordenado por algún dato del producto asociado como el nombre o el precio? ¿No hay forma de hacerlo con Doctrine?
Pues no, no la hay. Pero algo se puede hacer: podríamos ordenar el resultado después de obtenerlo. Al fin y al cabo se trata de un simple array de objetos. ¿Pero como hacerlo para que esté disponible en toda la aplicación y para cualquier tipo de lista? Sencillo: Con un servicio y más concretamente con una extensión Twig.
class MyExtension extends \Twig_Extension
{
public function getName()
{
return 'MyExtension';
}
public function getFilters()
{
return array(
'sortCollection' => new \Twig_Filter_Method($this, 'sortCollection'),
);
}
public function sortCollection($collection, $properties) {
$objects = $collection->getValues();
if($properties == null) {
return $objects;
}
if(is_string($properties)) {
$property = $properties;
$properties = array( );
$properties[] = $property;
}
if(is_array($properties)) {
usort($objects, function ($a, $b) use ($properties) {
foreach($properties as $property) {
$objA = $a;
$objB = $b;
if(is_string($property)) {
$property = explode('.', $property);
foreach($property as $method) {
if($objA == null || $objB == null) {
break;
}
$getter = 'get' . $method;
if(method_exists($objA, $method)) {
$objA = $objA->$method();
}
elseif(method_exists($objA, $getter)) {
$objA = $objA->$getter();
}
else {
$objA = null;
}
if(method_exists($objB, $method)) {
$objB = $objB->$method();
}
elseif(method_exists($objB, $getter)) {
$objB = $objB->$getter();
}
else {
$objB = null;
}
}
}
if($objA != null && $objB == null) {
return -1;
}
elseif($objA == null && $objB != null) {
return 1;
}
elseif($objA < $objB) {
return -1;
}
elseif($objA > $objB) {
return 1;
}
}
return 0;
});
}
return $objects;
}
}
¿Pero como lo usamos? Pues básicamente en Twig, para obtener una lita de líneas de factura ordenadas por el nombre del producto, haríamos lo siguiente:
<ul>
{% for linea in factura.lineas | sortCollection([ 'producto.nombre' ]) %}
<li>
{{ linea.producto.nombre }}
</li>
{% endfor %}
</ul>
Una extensión Twig, también puede definirse como servicio y por lo tanto, también podríamos ordenar una colección de objetos Doctrine directamente desde el controlador. Por ejemplo podríamos necesitar una lista de líneas de factura ordenadas primero por precio del producto asociado y segundo por el nombre (para productos del mismo precio). Sería como sigue:
$myExtension = $this->get('twig.extension.MyExtension');
$list = $myExtension->sortCollection($factura->getLineas(), array(
'producto.precio',
'producto.nombre'
));
En este segundo capítulo del mini-curso de Symfony 2 explicaré como crear un proyecto Symfony 2 desde cero para entornos Linux. Por supuesto existe la posibilidad de utilizar Symfony 2 en Windows y en Mac OS X, pero yo voy a centrarme en Linux y concretamente en Ubuntu, que es lo que uso habitualmente. La instalación en Mac OS X probablemente sea similar a la de Linux y para Windows seguro que existen otros manuales.
Lo primero y más importante: Vamos a suponer que el usuario dispone de un PC con sistema operativo Linux y que ha instalado tanto el servidor web Apache como el lenguaje PHP. Symfony 2 requiere al menos la versión 5.3.3 de PHP y algunas extensiones específicas. Aquí puede consultar todos los requerimientos de Symfony 2.
Empezaremos por el principio: Instalando Composer.
Composer es una herramienta imprescindible para desarrollar aplicaciones y sitios web en Symfony 2. Los proyectos Symfony utilizan diversas librerías externas (llamadas dependencias) que a su vez puede que usen otras librerías y Composer es la herramienta que se encarga de mantener actualizadas esas dependencias. Por ejemplo cuando queremos cambiar la versión usada de una librería o del propio Symfony, Composer se encarga de comprobar la compatibilidad de las otras librerías del proyecto, descargando si es necesario las versiones compatibles o avisando de las posibles incompatibilidades. A la hora de crear un proyecto Symfony 2, Composer comprueba la lista de dependencias del proyecto, decide qué librerías hay que instalar, qué versiones concretas se instalan y el orden correcto de instalación. Es una herramienta muy potente.
Para instalar Composer globalmente hay que seguir los siguientes pasos:
$ curl -s https://getcomposer.org/installer | php
composer.phar. Para comprobar que se ha instalado correctamente, ejecuta el siguiente comando que muestra el menú de opciones de Composer:$ php composer.phar
composer.phar a un directorio de ejecutables del sistema:$ sudo mv composer.phar /usr/local/bin/composer
composer sin opciones desde cualquier directorio.Con esto habremos instalado Composer de forma global en el ordenador. De esta forma para actualizar la versión de Composer de todos los proyectos bastará con ejecutar el siguiente comando desde un terminal:
$ sudo composer self-update
Una vez hemos instalado Composer, podemos usarlo para crear un proyecto Symfony 2 básico:
$ composer create-project symfony/framework-standard-edition
<carpeta> <version>
En este caso <carpeta> es el directorio raíz del proyecto (por ejemplo "/var/www/vhosts/masquecursos/") y <version> es la versión de Symfony 2 a instalar. En el momento de escribir estas líneas la última versión estable de Symfony es la 2.3.5 y otras versiones disponibles serían la anterior 2.2.8 y la siguiente 2.4.0-BETA1. Más información en la página de instalación de Symfony.
El programa de instalación pedirá algunos datos necesarios para la misma:
pdo_mysql), pero podría ser SQLite (pdo_sqlite), PostgreSQL (pdo_pgsql), Microsoft SQL Server (pdo_sqlsrv), Oracle-PDO (pdo_oci), Oracle-No PDO (oci8), etc.127.0.0.1.null.smtp.127.0.0.1.en.Se pueden dejar los valores por defecto pues más adelante podremos cambiarlos. El programa de instalación creará la estructura básica de directorios de un proyecto Symfony 2 que es la siguiente:
proyecto/
composer.json
composer.lock
app/
check.php
console
cache/
config/
logs/
bin/
src/
vendor/
web/
app.php
app_dev.php
config.php
Cada una de las subcarpetas contiene a su vez otros archivos y carpetas, pero los que aparecen aquí son los más importantes. Más adelante hablaremos de lo que hay en cada carpeta y para que sirve cada archivo. Por ahora basta con saber que Composer nos crea todo esta estructura de carpetas y archivos.
Todo proyecto Symfony 2 viene con un programa que permite comprobar si el ordenador cumple todos los requerimientos necesarios para el correcto funcionamiento del framework. Para ejecutarlo basta con abrir el terminal, entrar en el directorio del proyecto y teclear:
$ php app/check.php
Al ejecutar dicha utilidad, obtendremos una lista de requerimientos indicando en cada caso si tenemos la instalación correcta (OK) o si hay algún error (ERROR) o aviso (WARNING). Los errores (mandatory requirements) es necesario corregirlos antes de nada porque sino probablemente el proyecto no funcionará. Los avisos (optional checks) es conveniente corregirlos, pero no obligatorio.
Una vez comprobado que todos los requisitos están soportados por nuestra instalación se debe ejecutar otra utilidad llamada console.
$ app/console
Si todo es correcto se nos mostrará una lista de opciones de la consola Symfony. Más adelante veremos que esta consola es muy útil y se usa mucho para acciones comunes: limpiar la cache, crear la base de datos, crear entidades Doctrine, crear bundles, etc.
Symfony 2 necesita permisos de escritura sobre dos carpetas del proyecto app/cache/ y app/logs/. Todas las demás carpetas pueden ser de sólo lectura, pero esas dos no. El problema es que el usuario Linux de la consola no es el mismo que el del navegador web (Apache) y ambos necesitan acceso a esos directorios, lo que puede provocar diversos problemas tipo "RuntimeException: Could not create cache directory" y otros similares. Para solucionarlo basta dar permisos de escritura a todos los usuarios para esos dos directorios concretos:
$ sudo chmod -R 777 app/cache/ app/logs/
Siendo puristas habría que dar permisos de escritura sólo al usuario www-data (Apache) o arreglar el tema de permisos vía grupo de trabajo que son las opciones recomendadas para entornos de producción, pero para el entorno de desarrollo sirve el chmod 777. Aquí puedes encontrar más información sobre cómo solucionar el problema de los permisos de Symfony 2.
Para que el entorno de desarrollo sea lo más parecido posible al entorno de producción y aprovechando las características del servidor web Apache, vamos a crear un virtual host para este proyecto. Para ello en Ubuntu crearemos un archivo en la carpeta /etc/apache2/sites-available/ (ojo se necesitan permisos de root) y lo llamaremos como el proyecto (por ejemplo masquecursos). El contenido será el siguiente:
<VirtualHost *:80>
ServerName masquecursos.me
ServerAdmin webmaster@masquecursos.me
DocumentRoot /var/www/vhosts/masquecursos/web
DirectoryIndex app.php
<Directory /var/www/vhosts/masquecursos/web>
AllowOverride All
Allow from All
</Directory>
</VirtualHost>
Cada distribución de Linux es distinta y dicho archivo puede ser necesario crearlo en otra carpeta, aunque el contenido será el mismo. En Ubuntu posteriormente a la creación del archivo en /etc/apache2/sites-available/ es necesario crear un enlace simbólico en /etc/apache2/sites-enabled/. También habrá que editar el archivo /etc/hosts y asociar el nombre del virtual host con la IP 127.0.0.1. Posteriormente será necesario reiniciar el servidor Apache. La secuencia completa sería la siguiente:
$ sudo gedit /etc/apache2/sites-available/masquecursos
$ cd /etc/apache2/sites-enabled/
$ ln -s /etc/apache2/sites-available/masquecursos
$ sudo gedit /etc/hosts
$ sudo service apache2 restart
Con esto habremos configurado el entorno de ejecución y podremos acceder a nuestro sitio web desde http://masquecursos.me/, pero no lo pruebes todavía pues aun no funcionará. Por ahora para ver el contenido del proyecto es necesario usar el controlador de desarrollo http://masquecursos.me/app_dev.php. Más adelante veremos que es eso y porque aun no funciona con el controlador frontal app.php.
Si entramos en nuestro navegador preferido y escribimos http://masquecursos.me/config.php veremos una página web con una bienvenida de Symfony. En caso de que la instalación no cumpla los requerimientos técnicos se mostrará una pantalla de error con la misma información que nos daba el archivo app/check.php. A estas alturas esos errores ya deberían estar corregidos. Desde la pantalla de bienvenida podemos acceder a otra de configuración del entorno desde la que se pueden configurar los mismos parámetros que cuando creamos el proyecto con Composer. En cualquier caso esos parámetros de configuración del entorno están en el archivo app/config/parameters.yml por lo que pueden modificarse a mano de forma sencilla.
¡Y ya está! Ya hemos creado un primer proyecto Symfony 2 vacío. En el siguiente capítulo veremos como crear el primer bundle y haremos el típico Hola Mundo con Symfony.
Llevo algún tiempo trabajando con Symfony 2 y, aunque aun no soy un experto, voy a intentar explicar cual es la estructura global de una aplicación Symfony y cuales son los primeros pasos para desarrollar una página web este popular framework PHP. Voy a dar por supuesto que ya sabéis qué es Symfony. Empezaré por algunos conceptos:
Toda aplicación Symfony 2 está formada por bundles. Básicamente un bundle es una carpeta que contiene tu código fuente PHP, archivos de configuración y otros recursos como imágenes, hojas de estilos CSS, archivos HTML, javascripts, etc. Todo ello dentro de una estructura predeterminada de subcarpetas jerarquizadas.
Una aplicación Symfony 2 debe contener al menos un bundle, pero no hay límite en el número de bundles que se pueden crear. Algunos programadores ponen todo el código en un único bundle gigantesco mientras que otros prefieren crear un bundle por cada división lógica de la aplicación. Por ejemplo se puede crear un MainBundle para la parte principal de la web y un AdminBundle para la parte de administración.
Symfony es un framework PHP que implementa el patrón MVC (Modelo-Vista-Controlador), en el cual toda aplicación de divide en tres capas: modelo, vista y controlador. La primera capa es el modelo y se encarga del manejo y persistencia de los datos de la aplicación. En Symfony la capa del modelo está controlada por una herramienta llamada Doctrine que se encarga precisamente del acceso a los datos y su persistencia. Doctrine hace que nuestra aplicación sea independiente del motor de bases de datos, de forma que no será necesario escribir ni una sola sentencia SQL sino que tendremos que definir una serie de objetos PHP llamados entidades y Doctrine se encargará de lo demás.
A priori puede parece complicado pero es justo lo contrario. Las entidades se guardan como archivos PHP en una carpeta llamada Entity dentro de cada bundle.
En el patrón MVC, la capa vista es la que se encarga de la presentación en pantalla y de la interacción con el usuario. En symfony se utiliza un motor de plantillas llamado Twig que simplifica la creación de las vistas. Aquí puedes consultar más información sobre Twig en Español. Las vistas se guardan como archivos Twig en una carpeta llamada Resources/views dentro de cada bundle.
En el patrón MVC, la capa controlador se encarga de procesar las peticiones, obtener los datos a través del modelo y lanzar las vistas. En symfony 2 los controladores son clases PHP que se derivan de la clase Controller y que se guardan como archivos PHP en una carpeta llamada Controller dentro de cada bundle.
Symfony permite controlar todas las rutas que acepta un sitio web. Cada ruta puede ser estática de tipo /seccion/accion/ o tener parámetros, que se encierran entre corchetes, como /seccion/ver/{param}. Al final cada ruta se corresponde a un método de uno de los controladores y los parámetros serán los argumentos del método. Por ejemplo el sitio MasQueCursos.org podría configurar las siguientes rutas:
/" Página principal./cursos" Lista de cursos./cursos/buscar" Buscador avanzado de cursos./cursos/{nombre}" Detalle de un curso./centros" Lista de centros de formación./centros/{nombre}" Detalle de un centro de formación./temas" Lista de temas disponibles./temas/{nombre}" Lista de cursos de un tema.Además en Symfony cada ruta debe tener un nombre único que lo identifique y estar asociada a un controlador y a una acción (método de la clase). Por ejemplo:
indice", Ruta="/"@MasQueCursosBundle/Controller/DefaultController"indexAction"lista_cursos", Ruta="/cursos"@MasQueCursosBundle/Controller/CursosController"listaAction"buscar_cursos", Ruta="/cursos/buscar"@MasQueCursosBundle/Controller/CursosController"buscarAction"ver_curso", Ruta="/cursos/{nombre}"@MasQueCursosBundle/Controller/CursosController"verAction"
Todo el sistema de rutas se puede configurar en Symfony de dos formas: a través de los archivos de configuración o a través de anotaciones, un sistema directamente heredado de Java, que consiste en poner datos de configuración directamente en los comentarios. Por ejemplo la siguiente clase es un controlador con anotaciones: Hay una anotación @Route a nivel del controlador y otra para cada método de la clase.
namespace Ifraktal\MasQuecursosBundle\Controller;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
/**
* @Route("/cursos")
*/
class CursosController extends Controller {
/**
* @Route("/", name="lista_cursos")
*/
public function listaAction()
{
// ...
}
/**
* @Route("/buscar", name="buscar_cursos")
*/
public function buscarAction()
{
// ...
}
/**
* @Route("/{nombre}", name="ver_curso")
*/
public function verAction($nombre)
{
// ...
}
// ...
}
Hasta aquí la primera entrada. En próximas entradas explicaré la estructura de carpetas de un proyecto symfony; cómo crear un proyecto Symfony 2 desde cero; etc.