3-Rutas
Rutas en Laravel: Explicación y Ejemplos
Las rutas en Laravel son el mecanismo que permite definir cómo responde tu aplicación a las solicitudes HTTP entrantes. Todas las rutas de Laravel se definen en los archivos dentro del directorio routes/.
Tipos básicos de rutas
1. Rutas básicas
php
Route::get('/saludo', function () {
return '¡Hola Mundo!';
});
Cuando se visita /saludo en el navegador, se mostrará "¡Hola Mundo!".
1.1 Devolver un arreglo directamente (JSON automático)
Laravel convierte automáticamente a JSON cualquier array o colección que devuelvas desde una ruta o controlador.
Route::get('/tareas', function () {
$tareas = [
['id' => 1, 'nombre' => 'Comprar pan'],
['id' => 2, 'nombre' => 'Estudiar Laravel'],
['id' => 3, 'nombre' => 'Hacer ejercicio'],
];
return $tareas; // Laravel lo convierte a JSON automáticamente
});
Al visitar /tareas verás en el navegador (o en tu cliente HTTP) algo como:
json
[
{"id":1,"nombre":"Comprar pan"},
{"id":2,"nombre":"Estudiar Laravel"},
{"id":3,"nombre":"Hacer ejercicio"}
]
2. Rutas con parámetros
php
Route::get('/usuario/{id}', function ($id) {
return 'Usuario '.$id;
});
Esta ruta capturará el ID de la URL y lo pasará a la función.
3. Rutas con parámetros opcionales
php
Route::get('/post/{titulo?}', function ($titulo = 'Título por defecto') {
return $titulo;
});
El parámetro titulo es opcional y tiene un valor por defecto.
4. Rutas con restricciones
php
Route::get('/user/{id}', function ($id) {
// Solo se ejecutará si {id} es numérico
})->where('id', '[0-9]+');
5. Rutas con nombre
php
Route::get('/perfil', function () {
// ...
})->name('perfil');
Puedes generar URLs a esta ruta usando route('perfil').
6-Rutas hacia controladores
php
Route::get('/productos', 'ProductoController@index');
Esto dirigirá las solicitudes GET a /productos al método index de ProductoController.
6.1. Rutas hacia vistas: Route::view()
Laravel tiene un método específico para esto que es muy legible:
php
Route::view('/productos', 'productos.index');
¿Qué hace?
Cuando visites /productos, Laravel cargará directamente la vista que se encuentra en resources/views/productos/index.blade.php.
¿Y si quiero pasar datos estáticos a la vista?
El tercer parámetro de Route::view() acepta un arreglo de datos:
php
Route::view('/productos', 'productos.index', [
'titulo' => 'Lista de Productos',
'categoria' => 'Electrónicos'
]);
Luego en tu vista index.blade.php puedes usar {{ $titulo }} y {{ $categoria }}.
7-Grupos de rutas
php
Route::prefix('admin')->group(function () {
Route::get('/usuarios', function () {
// Ruta: /admin/usuarios
});
Route::get('/config', function () {
// Ruta: /admin/config
});
});
Tabla de comandos comunes de rutas
Las rutas son fundamentales en Laravel y ofrecen muchas más posibilidades como middleware, binding de modelos, subdominios, etc. Esta es solo una introducción básica.
1. Rutas individuales (manualmente)
php
use App\Http\Controllers\TaskController;
use Illuminate\Support\Facades\Route;
Route::get('/tasks', [TaskController::class, 'index'])->name('tasks.index');
Route::get('/tasks/create', [TaskController::class, 'create'])->name('tasks.create');
Route::post('/tasks', [TaskController::class, 'store'])->name('tasks.store');
Route::get('/tasks/{task}', [TaskController::class, 'show'])->name('tasks.show');
Route::get('/tasks/{task}/edit', [TaskController::class, 'edit'])->name('tasks.edit');
Route::put('/tasks/{task}', [TaskController::class, 'update'])->name('tasks.update');
Route::delete('/tasks/{task}', [TaskController::class, 'destroy'])->name('tasks.destroy');
2. Rutas agrupadas con resource (recomendado)
Laravel permite generar todas las rutas CRUD automáticamente con Route::resource:
php
use App\Http\Controllers\TaskController;
use Illuminate\Support\Facades\Route;
Route::resource('tasks', TaskController::class);
Esto crea las mismas rutas que el método anterior, pero en una sola línea.
Rutas generadas por Route::resource:
3. Rutas apiResource (para APIs)
Si estás construyendo una API, usa apiResource para excluir las rutas de vistas como create y edit:
php
Route::apiResource('tasks', TaskController::class);
¿Dónde colocar estas rutas?
Rutas web: En routes/web.php (para aplicaciones con vistas).
Rutas API: En routes/api.php (si es una API RESTful).
Si usas Laravel 9+, asegúrate de importar el controlador:
php
use App\Http\Controllers\TaskController;
Consejo adicional
Si quieres ver todas las rutas definidas en tu proyecto, ejecuta:
bash
php artisan route:list
Esto mostrará una tabla con todas las rutas, métodos y controladores
asociados.
Tips Importantes
Redirecciones:
php
return redirect()->route('tasks.index'); // Redirige a la lista de tareas
return redirect()->back(); // Redirige a la página anterior
Mensajes de sesión:
php
return redirect()->route('tasks.index')->with('success', 'Tarea creada!');
Comando route:list en Laravel
El comando route:list es una herramienta muy útil que muestra una tabla con todas las rutas registradas en tu aplicación Laravel, incluyendo sus métodos HTTP, URIs, nombres (si los tienen), acciones y middlewares aplicados.
Ejemplo de uso
Para ver la lista de rutas, ejecuta en tu terminal:
bash
php artisan route:list
Esto mostrará una salida similar a:
+--------+----------+-------------------+------+---------+--------------+
| Method | URI | Name | Action | Middleware |
+--------+----------+-------------------+------+---------+--------------+
| GET | / | | Closure | web |
| GET | saludo | | Closure | web |
| GET | usuario/{id} | | Closure | web |
| GET | perfil | perfil | Closure | web |
| GET | productos | | ProductoController@index | web |
+--------+----------+-------------------+------+---------+--------------+
Opciones útiles del comando
Puedes usar varias opciones para filtrar o formatear la salida:
bash
# Mostrar solo rutas con nombre
php artisan route:list --name=perfil
# Mostrar rutas que coincidan con un URI específico
php artisan route:list --path=usuario
# Mostrar en formato JSON
php artisan route:list --json
# Mostrar más detalles (incluyendo middlewares)
php artisan route:list -v
Tabla actualizada con el comando route:list
El comando route:list es especialmente útil para:
Depurar problemas de rutas
Verificar que todas las rutas estén correctamente definidas
Comprobar los middlewares aplicados a cada ruta
Identificar conflictos entre rutas
Documentar tu API o sistema de rutas
Comentarios
Publicar un comentario