02 -Rutas en Laravel

 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
Copy
Download
Route::get('/saludo', function () {
    return '¡Hola Mundo!';
});

Cuando se visita /saludo en el navegador, se mostrará "¡Hola Mundo!".

2. Rutas con parámetros

php
Copy
Download
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
Copy
Download
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
Copy
Download
Route::get('/user/{id}', function ($id) {
    // Solo se ejecutará si {id} es numérico
})->where('id', '[0-9]+');

5. Rutas con nombre

php
Copy
Download
Route::get('/perfil', function () {
    // ...
})->name('perfil');

Puedes generar URLs a esta ruta usando route('perfil').

Rutas hacia controladores

php
Copy
Download
Route::get('/productos', 'ProductoController@index');

Esto dirigirá las solicitudes GET a /productos al método index de ProductoController.

Grupos de rutas

php
Copy
Download
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

ComandoExplicación
Route::get($uri, $callback)Define una ruta que responde a solicitudes GET
Route::post($uri, $callback)Define una ruta que responde a solicitudes POST
Route::put($uri, $callback)Define una ruta que responde a solicitudes PUT
Route::patch($uri, $callback)Define una ruta que responde a solicitudes PATCH
Route::delete($uri, $callback)Define una ruta que responde a solicitudes DELETE
Route::any($uri, $callback)Responde a cualquier método HTTP
Route::match(['get', 'post'], $uri, $callback)Responde solo a los métodos especificados
Route::redirect($from, $to)Redirige una URI a otra
Route::view($uri, $view)Devuelve una vista sin necesidad de controlador
Route::resource($name, $controller)Genera todas las rutas RESTful para un recurso
->name($name)Asigna un nombre a la ruta
->middleware($middleware)Aplica middleware a la ruta
->where($param, $regex)Aplica restricciones a los parámetros de ruta
Route::prefix($prefix)->group()Agrupa rutas con un prefijo común
Route::namespace($namespace)->group()Agrupa rutas bajo un namespace específico

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
Copy
Download
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
Copy
Download
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:

Método HTTPRutaControladorNombre de ruta
GET/tasksindex()tasks.index
GET/tasks/createcreate()tasks.create
POST/tasksstore()tasks.store
GET/tasks/{task}show()tasks.show
GET/tasks/{task}/editedit()tasks.edit
PUT/PATCH/tasks/{task}update()tasks.update
DELETE/tasks/{task}destroy()tasks.destroy

3. Rutas apiResource (para APIs)

Si estás construyendo una API, usa apiResource para excluir las rutas de vistas como create y edit:

php
Copy
Download
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
Copy
Download
use App\Http\Controllers\TaskController;

Consejo adicional

Si quieres ver todas las rutas definidas en tu proyecto, ejecuta:

bash
Copy
Download
php artisan route:list

Esto mostrará una tabla con todas las rutas, métodos y controladores asociados.

Tips Importantes

  1. Redirecciones:

    php
    return redirect()->route('tasks.index'); // Redirige a la lista de tareas
return redirect()->back(); // Redirige a la página anterior

  2. Mensajes de sesión:

    php
    return redirect()->route('tasks.index')->with('success', 'Tarea creada!');

En Laravel, puedes pasar variables y arreglos de la ruta a la vista de varias maneras:

1. Usando with() encadenado

php
Route::get('/usuario/{id}', function ($id) {
    $nombre = "Juan";
    $datos = ['email' => 'juan@email.com', 'edad' => 30];
    
    return view('perfil')->with('id', $id)
                         ->with('nombre', $nombre)
                         ->with('datos', $datos);
});

1. Usando with() - Pasando el arreglo completo

php
Route::get('/usuario/{id}', function ($id) {
    // Creas un arreglo con todos los datos
    $datosUsuario = [
        'id' => $id,
        'nombre' => 'Juan',
        'email' => 'juan@email.com',
        'edad' => 30,
        'direccion' => 'Calle Principal 123'
    ];
    
    return view('perfil')->with('usuario', $datosUsuario);
});

2. Usando arreglo asociativo en segundo parámetro

php
Route::get('/usuario/{id}', function ($id) {
    $nombre = "Juan";
    $datos = ['email' => 'juan@email.com', 'edad' => 30];
    
    return view('perfil', [
        'id' => $id,
        'nombre' => $nombre,
        'datos' => $datos
    ]);
});

2. Usando arreglo asociativo - Pasando el arreglo completo

php
Route::get('/usuario/{id}', function ($id) {
    $usuario = [
        'id' => $id,
        'nombre' => 'Juan',
        'email' => 'juan@email.com',
        'edad' => 30
    ];
    
    return view('perfil', ['usuario' => $usuario]);
});

3. Usando compact()

php
Route::get('/usuario/{id}', function ($id) {
    $nombre = "Juan";
    $datos = ['email' => 'juan@email.com', 'edad' => 30];
    
    return view('perfil', compact('id', 'nombre', 'datos'));
});

3. Usando compact() - Pasando el arreglo completo

php
Route::get('/usuario/{id}', function ($id) {
    $usuario = [
        'id' => $id,
        'nombre' => 'Juan',
        'email' => 'juan@email.com',
        'edad' => 30,
        'hobbies' => ['leer', 'nadar', 'programar']
    ];
    
    return view('perfil', compact('usuario'));
});

En la vista:

blade
<h1>Dashboard</h1>
<p>Usuario: {{ $datosCompletos['usuario']['nombre'] }}</p>
<p>Tema: {{ $datosCompletos['configuracion']['tema'] }}</p>
<p>Visitas: {{ $datosCompletos['estadisticas']['visitas'] }}</p>

4. Desde un controlador

php
// En web.php
Route::get('/usuario/{id}', [UserController::class, 'show']);

// En UserController.php
public function show($id)
{
    $nombre = "Juan";
    $datos = ['email' => 'juan@email.com', 'edad' => 30];
    
    return view('perfil', [
        'id' => $id,
        'nombre' => $nombre,
        'datos' => $datos
    ]);
}

5. En la vista (perfil.blade.php)

blade
<h1>Perfil de usuario</h1>
<p>ID: {{ $id }}</p>
<p>Nombre: {{ $nombre }}</p>

<h2>Datos del usuario:</h2>
<ul>
    <li>Email: {{ $datos['email'] }}</li>
    <li>Edad: {{ $datos['edad'] }}</li>
</ul>

{{-- O si es un array indexado --}}
@foreach($datos as $key => $value)
    <li>{{ $key }}: {{ $value }}</li>
@endforeach

Ejemplo con múltiples parámetros en la ruta

php
// Ruta con múltiples parámetros
Route::get('/producto/{categoria}/{id}', function ($categoria, $id) {
    $producto = ['nombre' => 'Laptop', 'precio' => 1000];
    $caracteristicas = ['RAM' => '8GB', 'SSD' => '256GB'];
    
    return view('producto', compact('categoria', 'id', 'producto', 'caracteristicas'));
});

La opción más común y recomendada es usar compact() o el arreglo asociativo directo, ya que son más limpios y fáciles de leer.


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
Copy
Download
php artisan route:list

Esto mostrará una salida similar a:

Copy
Download
+--------+----------+-------------------+------+---------+--------------+
| 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
Copy
Download
# 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

ComandoExplicación
php artisan route:listMuestra una tabla con todas las rutas registradas, sus métodos, URIs, nombres y acciones
Route::get($uri, $callback)Define una ruta que responde a solicitudes GET
Route::post($uri, $callback)Define una ruta que responde a solicitudes POST
Route::put($uri, $callback)Define una ruta que responde a solicitudes PUT
Route::patch($uri, $callback)Define una ruta que responde a solicitudes PATCH
Route::delete($uri, $callback)Define una ruta que responde a solicitudes DELETE
Route::any($uri, $callback)Responde a cualquier método HTTP
Route::match(['get', 'post'], $uri, $callback)Responde solo a los métodos especificados
Route::redirect($from, $to)Redirige una URI a otra
Route::view($uri, $view)Devuelve una vista sin necesidad de controlador
Route::resource($name, $controller)Genera todas las rutas RESTful para un recurso
->name($name)Asigna un nombre a la ruta
->middleware($middleware)Aplica middleware a la ruta
->where($param, $regex)Aplica restricciones a los parámetros de ruta
Route::prefix($prefix)->group()Agrupa rutas con un prefijo común
Route::namespace($namespace)->group()Agrupa rutas bajo un namespace específico

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

Entradas más populares de este blog

01-04-convencion nombres

 En Laravel, existen convenciones y buenas prácticas para nombrar controladores, modelos, métodos, variables y tablas de la base de datos. Estas convenciones ayudan a mantener la consistencia en el código y aprovechar al máximo las características de Laravel, como la inyección de dependencias y el ORM Eloquent.   Te explico las convenciones de nomenclatura en Laravel con énfasis en la estructura Verbo + Sustantivo : estructura para controladores: 📝 Controladores - Estructura Correcta Nombres de Clases (Controladores) Caso: PascalCase Estructura: Sujeto/Objeto (Sustantivo) + Controller Sufijo: Controller Número: Sustantivo en Plural (representa la colección que maneja) ✅ Ejemplos Correctos: php // Controlador para manejar usuarios (colección de usuarios) class UsersController extends Controller {}   // Sujeto: Users // Controlador para manejar productos (colección de productos)   class ProductsController extends Controller {} // Sujeto: Products // Cont...
Leer más

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 , 'no...
Leer más