Symfony

Symfony logoSymfony es el framework full-stack de desarrollo PHP más activo en la comunidad. Llamado full-stack porque abarca tanto el frontend como el backend. Es un framework, que simple y llanamente, ha ido recopilando las mejores técnicas de desarrollo de software de muchos frameworks y lenguajes. Y ha englobado todas éstas técnicas en un sólo framework.

Esto hace que la curva de aprendizaje inicial sea muy pronunciada. Es un framework complicado para que un principiante empieze a desarrollar aplicaciones web. Pero una vez alcanzada la cumbre inicial, proporciona una productividad impresionante al desarrollador. Con muy pocas líneas de código fuente se crean gran cantidad de acciones. Las modificaciones son muy rápidas, y los resultados son de la máxima calidad y robustez.

La seguridad, una de las máximas prioridades.
Enrutamiento, excelente mapeado de los datos de las peticiones.
Diseño modelo-vista-controlador (MVC).
Generación dinámica de formularios.
Creación de objetos/modelos de datos automatizado.
Guardado, listado, editado y borrado de objetos de datos simplificado.
Independización de la base de datos con ORM.
Generación de vistas usando Twig.
Internacionalización.
Tests te integración unitarios y funcionales, puenteando hacia PHPUnit.
Simulador de navegador.
Crawler del DOM.
Herramienta visual de desarrollo y depuración.
Generador de CRUDs.
Interfaz de consola, para línea de comandos.
Cacheado.
Y un largo etcétera..

100% integrado con el gran Composer, el gestor de dependencias que ha revolucionado el trabajo en PHP. Gracias a esto, su instalación, mantenimiento, actualización y adición de nuevas funcionalidades es realmente sencillo. Todo esto no es más que la punta del iceberg. Symfony es la apuesta segura. Destapa el porqué, poco a poco, tantos proyectos web se están reconstruyendo completa o parcialmente mediante Symfony:

phpBB, Drupal, Prestashop, Joomla, Magento, API Platform, eZ Platform, Thelia, Sylius, Dailymotion, OroCRM, Yahoo! Answers..

Tutoriales de iniciación a Symfony y Symfony Flex.

Symfony: tutorial 8: los assets

2018-10-30 - Categorías: PHP / Symfony

Symfony Assets

Otro día más, otro post más, siguiendo con la serie de tutoriales de iniciación a Symfony. Ahora estamos repasando en Symfony cómo incluimos los ficheros en las páginas web. Es decir, los assets son los ficheros CSS, Javascript e imágenes que usamos en el front-end. Ahora se ha simplificado un poco más todo el manejo de éstos.

Podemos evitarnos el cacheado en los navegadores dándoles un número o nombre de versión a todos los assets. Así con cada despliegue, configuramos un número nuevo de versión de assets, y se le añadirá la coletilla a los ficheros assets incluidos en toda la web. Esto forzará a los navegadores a descargarse la nueva versión de estos assets. Continuar leyendo..


Cómo filtrar el acceso a los elementos de la API Platform para Symfony

2018-10-15 - Categorías: PHP / Symfony
API Platform filtering

Vengo a traer un pequeño truco que es algo complicado de encontrar. Es decir, traigo un HOWTO para una configuración en concreto de una joya del software. Se trata de la API Platform para Symfony, con la que implementamos en muy poco tiempo una API web en un proyecto completo.

Con esta API Platform tendremos acceso remoto, mediante las clásicas llamadas GET, POST, PUT, DELETE a las entidades del proyecto. Podemos limitar el acceso a cada usuario a cada elemento de una entidad de la que sea propietario.

Continuar leyendo..

Symfony: tutorial 7: depurando todo con lupa, el profiler

2018-10-04 - Categorías: PHP / Symfony

Symfony web profiler

En este post de la serie de iniciación a Symfony, traigo una review del perfilador de Symfony, el profiler. Es una gran herramienta de desarrollo web que nos brinda Symfony. Podemos ver muchos datos internos de cómo funciona todo por dentro: la petición y respuesta, rendimiento, envío de formularios, validaciones, datos de las excepciones, logs… pasando por Doctrine, enrutamiento.. Continuar leyendo..


Symfony: cómo montar un gestor de archivos web en menos de 1 hora

2018-09-21 - Categorías: PHP / Symfony
Symfony FMElfinder gestor de archivos

Hoy de nuevo vengo con otro CODE-KATA o HOWTO, esta vez para montar un gestor de archivos web. Recopilando joyas de la informática vengo a traer el FMElfinderBundle. Subir ficheros a una web, renombrarlos, editarlos es una tarea compleja. Si usamos este bundle, que es un vendor de Composer preparado para Symfony Flex, nos podremos olvidar de construir todo esto haciéndonos la vida mucho más fácil.

Es decir, que tenemos un bundle o vendor para Symfony, que nos permite gestionar archivos mediante el navegador. Así podemos subir ficheros de imagen para luego usarlos en la web. También permite otro tipo de ficheros una vez configurado. Incluso te permite editarlos si son de texto dentro del mismo gestor de archivos.

Continuar leyendo..

Symfony: cómo montar un blog con editor WYSIWYG

2018-09-20 - Categorías: PHP / Symfony
Symfony WYSIWYG

De nuevo traigo otro CODE-KATA, para montar un blog en Symfony Flex, Symfony 4. Así en unos pocos minutos tenemos el esqueleto de lo que puede ser un blog. También valdría para hacer páginas corporativas, incluso si lo que queremos es un editor de fichas de productos también. Es decir, este es un pequeño tutorial para arrancar un nuevo proyecto en Symfony, creando es esqueleto de una aplicación web que va a ser un blog, con un editor de texto avanzado del tipo WYSIWYG.

WYSIWYG quiere decir What You See Is What You Get. Es decir, estos editores de texto son como los que tienen WordPress, Magento, Prestashop.. en donde se editan las páginas visualmente dentro del mismo navegador. Con este tipo de editores puedes organizar los textos, darles tamaño a las letras, alineación, subrayados, colores, etcétera.

Continuar leyendo..

Symfony: tutorial 6: las vistas, cómo se trabajan las plantillas con Twig

2018-09-17 - Categorías: PHP / Symfony

Symfony tutorial templating

Recordando mientras que nos actualizamos con Symfony, traigo aquí otro code-kata o howto, esta vez, sobre plantillas. El sistema de plantillas de Symfony Flex, Symfony 4, desde hace tiempo que se basa en Twig. Es una de las mejoras cosas que le han pasado al mundo del PHP con respecto al desarrollo del frontend. Twig viene a añadir una sintaxis nueva: una serie de instrucciones a las plantillas: extends, block, for, if, etcétera..

Este es un post de la serie de tutoriales (o codekatas) de iniciación a Symfony.

Por un lado, Twig simplifica mucho el código fuente, queda mucho más limpio. Si eres un frontender, o un desarrollador web, te hará la vida mucho más fácil cuando te pongas a escribir códigos fuentes. Por otro lado, te ayuda a reutilizar las plantillas, no teniendo nunca que repetir el mismo código en plantillas distintas. Si estás repitiendo un código en una plantilla Twig, es que hay que refactorizar y reutilizar. Continuar leyendo..


Symfony: tutorial 5: los controladores y el enrutamiento

2018-09-10 - Categorías: PHP / Symfony

Symfony tutorial controladores

Siguiendo los tutoriales de iniciación a Symfony, aquí extendemos uno de los tutoriales anteriores sobre el enrutamiento. Lo desarrollaremos un poco más, y generaremos un controlador CRUD con el maker de Symfony. Las peticiones CRUD son el Create, Retrieve, Update y Delete. Estas peticiones las podemos recibir, y controlar, para hacer lo que necesitemos. Las operaciones CRUD son las operaciones básicas que toda unidad de información necesita gestionarse, y ¡Symfony nos trae un generador de código fuente para los CRUDs!

Con Symfony Flex se ha mejorado de nuevo otra de sus herramientas, el enrutamiento. Todo el enrutamiento se puede configurar dentro de los controladores con las últimas versiones: URLs, parámetros, tipo de petición.. dentro de los mismos ficheros de controladores. Esto es realmente cómodo en el día a día, porque así cuando hay que tocar un controlador, estará todo en el mismo sitio. También, tenemos un comando para listar tanto rutas como nombres y sus propiedades mediante la línea de comandos, así será más fácil trabajarlos.

En estas últimas versiones 4 y 5 del enrutador de Symfony, según rankings independientes a Symfony, disponemos de un enrutamiento 75 veces más rápido que en la versión anterior. Es el enrutador PHP más rápido que hay, de nuevo, otro referente en el mundo del PHP. Continuar leyendo..


Popup de Mailchimp para WordPress

2018-08-27 - Categorías: Magento / Prestashop / Symfony / WordPress
Popup de Mailchimp de jnjsite.com

He tenido problemas para poner un popup de Mailchimp en esta web. Así que aquí estoy compartiendo la solución. He tratado de usar la utilidad que viene en el panel de control de Mailchimp. Pero todo apunta a que tengo algún conflicto entre los Javascripts de Mailchimp, los Javascripts de mi plantilla, algún plugin de cacheado o del minificado del código fuente. En fin, que no funcionaba y he terminado antes haciendo el popup artesanal que se puede ver en la barra lateral derecha de la web.

Si has tenido el mismo problema, aquí dejo mi solución, que espero que funcione en el 100% de las webs. Simplemente necesitas tener instalado en la web jQuery, el resto viene todo en el código de abajo. Se puede copiar y pegar en el widget de WordPress donde lo quieras y adaptarlo para tu web.

Continuar leyendo..

Symfony: creando, listando, editando y borrando datos de la BD

2018-08-22 - Categorías: Symfony
Symfony Flex, Symfony 4, Doctrine

De nuevo continuando con el post anterior sobre cómo trabajar modificaciones en la base de datos, vengo hoy con otro HOWTO para modificar los datos de nuestra aplicación web que tenemos en la BD. Es decir, no para modificar la estructura de la BD como en el post anterior, sino para crear, listar, modificar o borrar los datos con Doctrine. Para los nuevos, Doctrine es la herramienta que viene con Symfony Flex, Symfony 4 para trabajar la persistencia de los datos.

Así que, continuando con el ejemplo del post anterior..

Continuar leyendo..

Symfony: tutorial 4: el día a día con las bases de datos

2018-08-14 - Categorías: PHP / Symfony
Symfony4 Doctrine Migrations

Otra vez más traigo de nuevo otro HOWTO de la serie de tutoriales de iniciación a Symfony, esta vez trabajando día a día con bases de datos en Symfony. En el tutorial anterior empecé con cómo empezar a crear una base de datos. Ahora lo extiendo ya que trabajar con la base de datos es un tema muy extenso.

En este minitutorial me centro más en cómo modificar la base de datos, cómo es el día a día. Cómo desplegar estos cambios en producción sin temor a dejar sin servicio todo el sistema por haber hecho un cambio inesperado. Es importante que tengas un plan B por si lo último modificado rompe producción, y así puedas hechar atrás los últimos cambios de la base de datos.

Continuar leyendo..

Symfony: tutorial 3: los modelos y las entidades, almacenando datos en BDs

2018-06-25 - Categorías: PHP / Symfony
Symfony tutorial 3 Doctrine

Recorriendo todas las funcionalidades de Symfony, traigo de nuevo otro HOWTO para trabajar con el guardado de los datos. Symfony basa el guardado de los datos, la persistencia de los datos, en Doctrine. Es decir, tenemos un módulo llamado Doctrine, mejor dicho varios, que te independizan de la base de datos añadiendo una capa intermedia entre los controladores, plantillas, servicios.. de tu aplicación Symfony y la base de datos. En esta capa intermedia se definen lo que se llaman entidades, y Doctrine se encarga de hacer todo.

Siguiendo este tutorial veremos cómo en poco tiempo podemos arrancar proyectos que antes podíamos tardar días o semanas, ahora en pocas horas. Es decir, en muy pocos comandos de consola, y con muy poco esfuerzo, podemos montar grandes estructuras en bases de datos, o editarlas. Y nos podemos casi olvidar de hacer muchas consultas directamente a la Base de Datos.

Este tutorial se complemente con el siguiente:
https://jnjsite.com/symfony-tutorial-4-el-dia-a-dia-con-las-bases-de-datos/

También con este otro code-kata que extiende un poco más el tema:
https://jnjsite.com/disenando-bds-con-el-creador-de-entidades-de-symfony-para-doctrine/

Las bases de datos dan mucho trabajo. Si queremos ser realmente productivos, es importante practicar con esta capa de software en las aplicaciones Symfony.

Un poco de teoría

Symfony es un framework que sigue el modelo MVC que significa Modelo-Vista-Controlador. En un post anterior hemos visto cómo trabajar con los controladores y un poco de las vistas, que también tienen mucho juego. Ahora vamos a ver el tema de los modelos, sinónimo de entidades. Es decir, en este framework la mayoría de los datos, o casi la mayoría, se guardan usando objetos de PHP que llamamos entidades.

Doy por supuesto de que trabajamos con Mysql o similar, usando Doctrine como ORM. Entonces, todas estas entidades se representan y se graban en Symfony 5 bajo el directorio:

 src/Entity/

Bajo este directorio tendremos entonces todas las entidades de nuestra aplicación. Simplemente serán unas clases de PHP con sus getters y setters, pero con unas cuantas anotaciones a modo de comentarios que hacen muchas cosas de forma automática. Esta abstracción de los datos te permitirá listar, almacenar, editar y borrar datos de forma muy fácil y en muy pocas líneas de código. A Doctrine le diremos, «toma estos objetos y guárdalos en la base de datos», «dame todos los objetos con estas características», podremos obtener un objeto en concreto, modificarlo y decirle a Doctrine: «guarda este objeto modificado». Todo esto en muy pocas líneas de código fuente, gracias a usar estas clases en PHP.

Puedes seguir usando el SQL tradicional, pero perderás toda la productividad que te sirve en bandeja Symfony. Por otro lado, a veces Doctrine no alcanza a todo lo que necesitamos, pero es raro que necesitemos saltarnos a Doctrine. Si nos estamos saltando continuamente Doctrine, o no lo estamos usando en nuestras aplicaciones Symfony, da por hecho que algo muy malo estamos haciendo, y nos estamos perdiendo una de las mejores herramientas que proporciona Symfony.

Creando el proyecto del ejemplo

En las versiones anteriores a Symfony 5, podíamos hacer lo siguiente con Composer en nuestro directorio desastre:

composer create-project symfony/skeleton symfony-tutorial-3

Ahora a partir de la versión de Symfony 5, tendremos el comando siguiente si ya lo hemos instalado:

symfony new symfony-tutorial-3

..y esperamos. Si todo ha ido bien ya tenemos un directorio nuevo symfony-tutorial-3 con el esqueleto de Symfony Flex listo para trabajar.

Symfony tutorial 3 Doctrine

Lo siguiente es a añadir los módulos en Symfony que vamos a usar en este proyecto ejecutando:

cd symfony-tutorial-3
composer require maker --dev
composer require doctrine

Si todo ha ido bien ya tenemos lo básico para hacer unas pruebas.

Creando unas entidades

Entonces, a partir de ahora, también nos olvidamos de trabajar directamente los ficheros de entidades ? Estos ficheros podemos generarlos con el maker de Symfony. Muy pocas veces es necesario programar estos ficheros directamente, aparte de que sólo tienen que usarse para los getters, setters y colecciones.

Como ya decía anteriormente, si quieres ser más productivo, debes usar de nuevo los comandos de consola.

De esta forma, vamos a crear un prototipo de aplicación web de gestión de pedidos. Reduciremos todo a las siguientes entidades:

Cliente con dni, email y nombre.
Producto con referencia, nombre y precio.
Pedido con referencia, que va a ser de un cliente y va a tener unos productos.

EER ClientePedidoProducto

Una cosa importante a tener en cuenta es que Doctrine generará de forma automática un campo identificador para cada entidad llamado id. Este campo será un entero autonumérico. Entonces no tendremos que crear este campo id, además de que luego también se puede generar otros campos que identifiquen a las entidades.

Este ejemplo se podría extender a un eCommerce, un marketplace, o un complejo ERP, no hay límites y la forma de trabajarlo siempre es la misma. Simplemente tenemos clientes que hacen pedidos y estos pedidos tienen productos. Un producto puede haberse pedido N veces, y un pedido puede tener N productos. En este caso un cliente puede hacer N pedidos y cada pedido sólo corresponde a 1 único cliente.

Para esto ejecutamos los siguientes comandos, siguiendo las instrucciones que se indican por pantalla:

php bin/console make:entity Cliente

..creamos 3 campos de tipo string, para simplificar, simplemente siguiendo las instrucciones. Ahora ejecutamos:

php bin/console make:entity Pedido

..y creamos sólo un campo de tipo string para la referencia de pedido, luego vemos cómo relacionamos los campos. Ahora nos queda hacer lo mismo:

php bin/console make:entity Producto

..y creamos el campo referencia y nombre de tipo string, y el campo precio de tipo decimal. Conviene crear y borrar las entidades que se van creando en el directorio src/Entity/* sin miedo. Podemos borrar estos ficheros cuantas veces queramos cuando estamos empezando un proyecto. Conviene jugar mucho con esto, borrando los ficheros creados, viendo lo que se crea, para coger práctica. Además el maker de Symfony también te permite modificar las entidades ya creadas, no tienes que crearlas con todos los campos de una vez. Si no tienes soltura con esto te conviene coger mucha soltura, ya que te va a ahorrar horas y horas.. pero muchas horas y horas.. comparando con los métodos tradicionales de hacer esto.

Para modificar una entidad que existe, sólo tenemos que volver a lanzar el comando de crear sobre la misma entidad. Symfony detectará que ya existe, y en vez de crearla de nuevo, la modificará.

Guardando esta estructura en la base de datos

Ya tenemos unos modelos hechos, que nos van a permitir trabajar con pedidos de clientes que tienen ciertos productos en PHP. Querremos guardar toda esta información en la base de datos, pero antes deben crearse las tablas y la base de datos.

Y otra vez, no crees la base de datos manualmente, Symfony también se encarga de esto. Antes de esto, configuramos el fichero .env y ponemos la base de datos que estemos usando, en mi caso es esta:

DATABASE_URL=mysql://root@127.0.0.1:3306/tutorial3

..y ejecutamos para crear la base datos:

php bin/console doctrine:database:create

..luego creamos las tablas con:

php bin/console doctrine:schema:create

..a continuación, cada vez que querramos actualizar las tablas, tendremos que ejecutar esto en el entorno de desarrollo:

php bin/console doctrine:schema:update --dump-sql [--force]

Si estamos seguros de la modificación, le pondremo el force. ¡OJO! no es la forma correcta, pero para desarrollar nos sirve. Lo ideal es usar el nuevo módulo de Doctrine Migrations que ha sido integrado dentro del pack. Este Doctrine Migrations se encarga de preparar ficheros de actualización de la base de datos, pudiendo incluso volver a atrás los pasos a producción, o añadiendo tratamientos sobre los datos de producción si fuera necesario. Esto tiene mucho juego, y en el día a día de una aplicación web en producción es muy importante, así que de nuevo, tenemos a Symfony haciéndonos la vida mucho más fácil 😉

Añadiendo relaciones entre entidades

Hasta aquí tenemos 3 entidades no relacionadas que guardan unos datos. Es decir, tenemos en la base de datos 3 tablas con ciertas columnas. Pero no hemos relacionado pedidos con los clientes, ni pedidos con los productos. Esta relación tradicionalmente se haría a base de claves ajenas.

Ahora bien, en Symfony de nuevo, gracias a Doctrine, vamos a ahorrarnos este trabajo. Vamos a editar la entidad Pedido y le vamos a añadir 2 campos nuevos: cliente y productos. Estos campos van a relacionar, y además bidireccionalmente, un cliente con todos sus pedidos, un pedido con su cliente, un pedido con sus productos, y también, un producto con todos sus pedidos. ¿Mucho mejor que con SQL tradicional verdad?

php bin/console make:entity Pedido
Doctrine make entity relation

Fíjate en la imagen, estoy editando Pedido, añadiendo el campo cliente, que relaciona un pedido con su cliente. Siguiendo las instrucciones, tenemos una relación ManyToOne, porque un pedido sólo es de un cliente, y un cliente puede tener varios pedidos. Recordemos la definición de la base de datos en el EER:

EER ClientePedidoProducto

Terminando esto, tendremos creadas las siguientes funciones en PHP:

// dado un cliente obtenemos sus pedidos
$pedidos = $cliente->getPedidos();
// dado un pedido obtenemos el cliente asociado
$cliente = $pedido->getCliente();
// dado un pedido obtenemos sus productos
$productos = $pedido->getProductos();
// dado un producto obtenemos los pedidos que se han hecho
$pedidos = $product->getPedidos();

..con esto podremos navegar por los datos, haciendo lo que necesitemos. Todo esto sin escribir ninguna engorrosa consulta en lenguaje de la base de datos. Hacemos la otra relación de igual manera entre Pedido <-> Producto y lanzamos esto para actualizar la base de datos:

php bin/console doctrine:schema:update --dump-sql --force

Almacenando datos

Esto es todo lo necesario para crear toda la estructura de la base de datos en un proyecto Symfony. Para terminar sólo nos queda guardar unos datos en la base de datos, a modo de comprobación. Si estas siguiendo todo el tutorial, vamos a hacer un controlador que simplemente guarde unos datos en la base de datos. Y si mirando el contenido de la base de datos, ves los datos guardados, es que ¡has conseguido aprender los fundamentos de Doctrine!

Creando el controlador:

php bin/console make:controller home

Abrimos el fichero src/Controller/HomeController.php y ponemos lo siguiente:

<?php

namespace App\Controller;

use Symfony\Component\Routing\Annotation\Route;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use App\Entity\Cliente;
use App\Entity\Pedido;
use App\Entity\Producto;

class HomeController extends AbstractController
{
    /**
    * @Route("/home", name="home")
    */
    public function index()
    {
        $entityManager = $this->getDoctrine()->getManager();

        $cliente = new Cliente();
        $cliente->setDni('DNI1');
        $cliente->setNombre('NombreCliente1');
        $cliente->setEmail('email1@email1.com');
        $entityManager->persist($cliente);

        $pedido = new Pedido();
        $pedido->setCliente($cliente);
        $pedido->setReferencia('ReferenciaPedido1');
        $entityManager->persist($pedido);

        $product = new Producto();
        $product->setReferencia('ReferenciaProducto1');
        $product->setNombre('NombreProducto1');
        $product->setPrecio(123.12);
        $entityManager->persist($product);

        $entityManager->flush();

        return $this->json([
            'message' => 'Welcome to your new controller!',
            'path' => 'src/Controller/HomeController.php',
        ]);
    }
}

Marco en negrita las líneas que he añadido. A continuación ejecutamos desde línea de comandos lo siguiente para arrancar el servidor de desarrollo:

symfony server:start

..recuerda que si estás en un proyecto anterior a Symfony 5, y tienes el server de desarrollo dentro del proyecto, lo puedes arrancar con:

php bin/console server:start

Y vamos con el navegador a la siguiente URL:

http://localhost:8000/home

Esto es todo, ya sólo queda ir a la base de datos a ver si realmente tenemos los datos de prueba generados en el controlador.

Symfony 4 tutorial 3 Doctrine base de datos

Espero haberme explicado bien, que menudo testamento me está quedando 😀 sino un comentario abajo y contesto gustoso a cualquier pregunta sobre esto. De todas formas, esto no es más que el comienzo de la persistencia de los datos con Doctrine.

De verdad que Doctrine es muy grande, es una joya de la programación PHP, así que trataré de traer a menudo code-katas relacionados. Úsalo mucho ?

Si has llegado hasta aquí, te recuerdo que este code-kata se complemente con el siguiente:
https://jnjsite.com/symfony-tutorial-4-el-dia-a-dia-con-las-bases-de-datos/

..y también con este otro:
https://jnjsite.com/disenando-bds-con-el-creador-de-entidades-de-symfony-para-doctrine/

Tienes los códigos fuentes de este post también aquí:
https://github.com/jaimenj/symfony-starter-tutorials

¡Un saludo!


Symfony: tutorial 2: los comandos de consola

2018-05-31 - Categorías: PHP / Symfony

Symfony Flex comandos

Una respuesta a porqué Symfony es tan productivo son los comandos de consola. Con simples comandos podemos crear un proyecto nuevo, añadir nuevos componentes, lanzar un servidor de pruebas, chequear las URLs, crear entidades que vamos a guardar en base de datos, probar el envío de emails. También podemos modificar las tablas de datos, añadir nuevos elementos, editar los existentes, actualizar la base de datos, preparar nuevos elementos para almacenar, generar pantallas de listado de datos, ediciones de datos, borrados o creaciones. Generamos formularios automáticamente, con recepción de sus datos y guardado de dichos formularios en bases de datos. Podemos importar una base de datos de otro proyecto, generando todo el código fuente de una aplicación web que consulte los datos de dicha BD en apenas un rato. Podemos crear controladores, estructurando todas las zonas de la web, con sus plantillas, rutas, y URLs en poco tiempo. Y mucho más..

No tenemos que gastar tiempo en tediosas tareas repetitivas de construcción, y podremos centrarnos en lo especial de la aplicación web que estemos creando. Todas estas herramientas de generación de código las tenemos mediante comandos de consola. Cuantos más módulos añadas probablemente más comandos tendrás que te harán mucho más productivo. Te ahorrarán muchísimo tiempo, pero tienes que saber que estan ahí, saber cómo funcionan, y usarlos siempre que puedas. Hay que coger práctica con los comandos para aprovechar la productividad que te da Symfony. Continuar leyendo..

© 2024 JnjSite.com - MIT license

Sitio hecho con WordPress, diseño y programación del tema por Jnj.