4.2Laravel : rutas, Blade, Eloquent (ORM), migraciones
Lo esencial en 30 segundos
- Enrutamiento + controladores :
Route::get('/produits', [ProduitController::class, 'index'])dirige la URL hacia la acción ; Artisan genera el código. - Blade + Eloquent : plantillas
{{ }}con escape automático (anti-XSS), y base manipulada en objetos (Produit::where(...)->get()) con consultas preparadas automáticas. - Reflejo de Riad : versionar la base en migraciones y entender el SQL generado (cuidado con el N+1) en lugar de sufrir el ORM.
Minicaso seguido — Riad pasa su catálogo a Laravel
El catálogo MVC de Riad (4.1) crece : lo porta a Laravel en Constantine. Declara sus rutas hacia un ProduitController, muestra con una vista Blade que escapa por defecto, lee la base vía Eloquent sin escribir SQL, y describe la tabla produits en una migración versionada con Git. Cuando un colega recupera el proyecto, un comando instala, otro migra — y la base es idéntica. Segundo hito del hilo : productivo, estructurado y seguro por defecto.
Continuación del caso 4.1 — Riad industrializa su MVC con un framework.
1. Enrutamiento, controladores, Artisan
Laravel implementa el MVC con herramientas elegantes. El enrutamiento asocia URL y acciones : Route::get('/produits', [ProduitController::class, 'index']) envía los GET hacia el método index — expresivo (GET/POST, parámetros, grupos, middlewares). Los controladores tratan las peticiones (reciben, llaman a los modelos, devuelven vista o respuesta). La línea de comandos Artisan genera controladores y modelos, lanza las migraciones : Riad crea la base en segundos en lugar de copiar-pegar.
2. Blade : las vistas seguras
Blade es el motor de plantillas : {{ $variable }} para mostrar, @foreach y @if para la lógica de presentación, layouts reutilizables por herencia. Su gran ventaja : el escape automático — los datos se escapan por defecto, lo que protege del XSS sin pensarlo. Riad sustituye su mezcla bruta de PHP/HTML por plantillas legibles y seguras.
3. Eloquent y migraciones : los datos
Eloquent es el ORM : las tablas se convierten en clases, las filas en objetos — Produit::all(), Produit::find($id), Produit::where('prix', '>', 100)->get(), $produit->save() — con consultas preparadas automáticas (anti-inyección) y relaciones elegantes. Las migraciones versionan la estructura de la base en código PHP : reproducible, trazable, esencial en equipo y en despliegue. Riad retiene dos vigilancias : entender el SQL generado y evitar el N+1 con carga anticipada (with()). Laravel añade auth, validación, CSRF automático, sesiones seguras : una excelente inversión, el framework más demandado.
🔎 Ejemplo concreto — 🔎 Ejemplo concreto — Catálogo de productos con Laravel
Los cuatro gestos de Riad, con las API reales :
Route::get('/produits', [ProduitController::class, 'index']);
$produits = Produit::where('prix', '>', 100)->get(); // all(), find($id)
return view('produits.index', ['produits' => $produits]);
Blade : {{ $p->nom }} + @foreach ($produits as $p) ... @endforeachLectura : ruta, petición objeto, vista, plantilla — cada uno en su lugar.
Lección : el framework aplica el MVC y la seguridad por defecto.
Vocabulario de la sección
- Laravel
- El framework PHP más popular (elegante, productivo, vasto ecosistema) ; implementa el MVC con las buenas prácticas. La referencia del PHP moderno.
Ejemplo sencillo: Riad porta allí su catálogo para ir rápido sin sacrificar la estructura.
Lo que no es: una pila de scripts sin enrutamiento ni ORM.
Reflejo: pensar rutas, controladores, Blade, Eloquent, migraciones.
- Enrutamiento / controladores / Artisan
- Enrutamiento : URL → acciones (Route::get). Controladores : tratan las peticiones. Artisan : CLI que genera código y lanza las migraciones.
Ejemplo sencillo: La ruta /produits de Riad apunta hacia ProduitController@index, generado por Artisan.
Lo que no es: un archivo PHP por URL hecho a mano.
Reflejo: una URL = una ruta nombrada hacia una acción clara.
- Blade (plantillas)
- Motor de plantillas Laravel : {{ }}, @foreach, @if, layouts — con ESCAPE AUTOMÁTICO (anti-XSS por defecto).
Ejemplo sencillo: Riad muestra {{ $p->nom }} sin temer la inyección de HTML.
Lo que no es: echo PHP entremezclados con el HTML sin escape.
Reflejo: {{ }} por defecto ; {!! !!} solo con conocimiento de causa.
- Eloquent (ORM)
- ORM Laravel : tablas ↔ clases, filas ↔ objetos ; base manipulada en objetos/métodos, consultas preparadas automáticas, relaciones elegantes.
Ejemplo sencillo: Riad lee Produit::where('prix', '>', 100)->get() en lugar de escribir el SELECT.
Lo que no es: SQL concatenado con variables no escapadas.
Reflejo: verificar el SQL generado y cazar el N+1 con with().
- Migraciones
- Estructura de la base versionada en código PHP (con Git) : reproducible, trazable — esencial en equipo y en despliegue.
Ejemplo sencillo: La tabla produits de Riad nace de una migración, repetida en todas partes de forma idéntica.
Lo que no es: ALTER TABLE hechos a mano en producción.
Reflejo: nunca estructura modificada fuera de migración.
En la práctica — En la práctica — Construir con Laravel
- Cread un proyecto Laravel (vía Composer), explorad rutas, controladores, modelos, vistas Blade y la CLI Artisan.
- Definid rutas (Route::get/post) hacia controladores ; cread una vista Blade con {{ }} y @foreach (escape automático).
- Usad Eloquent : modelo + CRUD en objetos (all/find/where/save) sin SQL, consultas preparadas automáticas.
- Cread una migración para versionar una tabla ; activad la auth, la validación y la protección CSRF incluidas.
Guion listo para decir — defender el paso a Laravel (30 s)
« Soy Riad : con Laravel, nuestras rutas son explícitas, nuestras vistas Blade escapan por defecto, Eloquent prepara nuestras consultas y nuestras migraciones versionan la base. Entregamos más rápido, con la seguridad integrada en lugar de improvisarla. »
Para decir en punto técnico ; mostrad ruta + Blade + migración.
Modelo copiar-pegar — CRUD Laravel (código probado)
', 100)->get();
return view('produits.index', ['produits' => $produits]);
}
public function store(Request $request) {
$valide = $request->validate(['nom' => 'required|string|max:255', 'prix' => 'required|numeric|min:0']);
$produit = Produit::create($valide);
return response()->json($produit, 201);
}
}
// resources/views/produits/index.blade.php
// @foreach ($produits as $p) {{ $p->nom }} — {{ $p->prix }} DA @endforeach
// database/migrations/xxxx_create_produits_table.php (extracto)
// Schema::create('produits', function (Blueprint $t) {
// $t->id(); $t->string('nom'); $t->decimal('prix', 10, 2); $t->timestamps();
// });
Pequeño sitio escaparate
Rutas + Blade bastan : reservad Eloquent para lo que merezca una base, sin sobremodelar.
Aplicación real
Como Riad : rutas nombradas, controladores recurso, Eloquent con carga anticipada, todo en migraciones.
Lista que va lenta (N+1)
Cargad las relaciones de una vez (with('categorie')) : una consulta en lugar de una por línea.
Equipo que empieza
Prohibid el SQL concatenado y el HTML no escapado : el framework ya hace ambas cosas.
validate()), dejad que Blade escape por defecto y guardad los secretos en .env, nunca en duro. Contenido pedagógico, ejemplos con datos ficticios.✓ Buenas prácticas
- Respetar el MVC impuesto por el framework.
- Entender el SQL generado por Eloquent.
- Versionar la base en migraciones.
✗ Errores frecuentes
- Poner lógica en las plantillas Blade.
- Ignorar el N+1 (ORM caja negra).
- Recodificar auth/validación/CSRF ya incluidos.
Puntos clave
- LARAVEL = framework PHP más POPULAR : MVC, productividad, seguridad integrada. La referencia.
- ENRUTAMIENTO (Route::get → acciones), CONTROLADORES, ARTISAN (generar, migrar).
- BLADE : {{ }}, @foreach, ESCAPE AUTOMÁTICO (anti-XSS). ELOQUENT : objetos en lugar de SQL, preparadas automáticas, relaciones.
- MIGRACIONES : base versionada = reproducible y trazable. Más auth, validación, CSRF automático.
Desafío 48h — aplicad mañana
Entregad 1 recurso CRUD con Laravel : 2 rutas + 1 vista Blade + Eloquent + 1 migración, sin una línea de SQL a mano.
- Puedo citar rutas, Blade, Eloquent, migraciones.
- Sé explicar el escape automático y las preparadas automáticas.
- Tengo 1 CRUD Laravel funcionando.
Preguntas frecuentes
¿Qué aporta un framework como Laravel frente a PHP « a mano »?
Estructura MVC impuesta (fin del espagueti), productividad (ORM, plantillas, enrutamiento, Artisan, decenas de funciones listas), seguridad integrada por defecto (escape Blade anti-XSS, preparadas Eloquent anti-inyección, CSRF automático, hash, auth robusta) y funciones probadas (auth, validación, sesiones, correos, archivos, tests, migraciones). Construimos aplicaciones completas mucho más rápido, con menos errores — de ahí su estatus de imprescindible pro.
¿Qué es un ORM como Eloquent — y hay que conocer el SQL igualmente?
Un ORM mapea objetos ↔ tablas (tablas ↔ clases, filas ↔ objetos, columnas ↔ propiedades) : Produit::all() en lugar de SELECT *. Aportes : productividad, seguridad (preparadas automáticas), legibilidad, relaciones elegantes ($utilisateur->commandes). Pero SÍ, el SQL sigue indispensable : para entender y optimizar lo que el ORM genera (N+1, índices, joins) y para las consultas complejas. Eloquent + bases SQL = el buen dúo.
¿Qué aporta Eloquent frente a SQL escrito a mano?