10. Relaciones en Eloquent: 1 a 1 (hasOne), 1 a N (hasMany) y N a N (belongsToMany)
Vincula modelos mediante métodos de relación, claves foráneas, tablas pivote intermedias y optimización para evitar el problema de consultas N+1.
Las Relaciones Cardinales de una Base de Datos en Objetos
Las tablas en las bases de datos relacionales rara vez viven aisladas. Eloquent permite definir cómo se conectan los datos mediante métodos simples en los modelos, encargándose de generar los JOINs y claves foráneas en segundo plano.
1. Relación Uno a Uno (1 a 1): hasOne & belongsTo
Ejemplo: Un User tiene un único Profile, y ese Profile pertenece a un User.
// En app/Models/User.php
public function profile()
{
return $this->hasOne(Profile::class);
}
// En app/Models/Profile.php
public function user()
{
return $this->belongsTo(User::class);
}
Uso: $usuario->profile->bio;
2. Relación Uno a Muchos (1 a N): hasMany & belongsTo
Ejemplo: Un Curso tiene muchas Leccion, y cada Leccion pertenece a un Curso.
// En app/Models/Curso.php
public function lecciones()
{
return $this->hasMany(Leccion::class);
}
// En app/Models/Leccion.php
public function curso()
{
return $this->belongsTo(Curso::class);
}
Uso: foreach ($curso->lecciones as $leccion) { echo $leccion->titulo; }
3. Relación Muchos a Muchos (N a N): belongsToMany
Ejemplo: Un User (alumno) puede estar inscrito en muchos Curso, y un Curso tiene muchos User inscritos. Requiere una tabla pivote intermedia (ej: curso_user):
// En User.php:
public function cursos()
{
return $this->belongsToMany(Curso::class, 'curso_user')
->withTimestamps();
}
// Para inscribir a un alumno en un curso:
$user->cursos()->attach($cursoId);
// Para desinscribirlo:
$user->cursos()->detach($cursoId);
El Peligro del Problema N+1 y Eager Loading (with)
Si recorres 50 cursos y dentro del bucle llamas a $curso->instructor->name, Laravel ejecutará 51 consultas a MySQL (1 para los cursos + 50 para cada instructor individual). Esto satura la base de datos.
La solución es el Eager Loading (Carga Ansiosa) con el método with(), reduciendo la operación a exactamente 2 consultas SQL ultra-rápidas:
// MAL: Genera 1 + N consultas
$cursos = Curso::all();
// BIEN (Profesional): Solo 2 consultas SQL en milisegundos
$cursos = Curso::with(['instructor', 'lecciones'])->get();
⚡ Uso de Eager Loading y Relaciones en un Controlador
Ejemplo de consulta optimizada con with() para evitar el problema de N+1 consultas.
<?php
namespace App\Http\Controllers;
use App\Models\Curso;
use Illuminate\View\View;
class CatalogoController extends Controller
{
public function index(): View
{
// Trae los cursos activos precargando sus instructores y conteo de lecciones
// Genera solo 2 consultas SQL optimizadas
$cursos = Curso::with('instructor')
->withCount('lecciones')
->where('is_active', true)
->get();
return view('catalogo.index', compact('cursos'));
}
public function show(int $id): View
{
// Trae el curso con todas sus lecciones ordenadas
$curso = Curso::with(['lecciones' => function ($query) {
$query->orderBy('position', 'asc');
}, 'instructor'])->findOrFail($id);
return view('catalogo.show', compact('curso'));
}
}
Mini-Quiz de Retención
Comprueba tu comprensión antes de pasar a la siguiente lección¿Cómo se previene el grave problema de rendimiento de consultas "N+1" en Eloquent al consultar registros relacionados?
¿Tienes dudas con este tema?
Sócrates AI puede darte analogías y explicarte este código paso a paso.🚀 ¿Quieres dominar Laravel Framework Profesional y crear proyectos reales?
Aprende arquitectura limpia, desarrollo web moderno, buenas prácticas y despliegue en producción con nuestro Bootcamp Fullstack Developer con mentorías en vivo.