PHP Academy · Lección

Relaciones de Eloquent

Defina relaciones hasOne, hasMany, belongsTo y de muchos a muchos.

Relaciones de Eloquent es una lección gratuita de PHP Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de PHP Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de PHP Academy incluye 4 lecciones en total.

¿Por qué usar relaciones?

Las relaciones de Eloquent permiten consultar modelos relacionados mediante un PHP expresivo en lugar de usar JOINs SQL sin procesar.

hasOne

Un User tiene un Profile. Defínalo en el modelo propietario.

<?php
class User extends Model {
    public function profile(): \Illuminate\Database\Eloquent\Relations\HasOne {
        return $this->hasOne(Profile::class);
    }
}
// Access:
$profile = $user->profile;

belongsTo

Un Profile pertenece a un User. Defínalo en el modelo que contiene la clave foránea.

<?php
class Profile extends Model {
    public function user(): \Illuminate\Database\Eloquent\Relations\BelongsTo {
        return $this->belongsTo(User::class);
    }
}
// Access:
$user = $profile->user;

hasMany

Un User tiene muchos Posts. Es una relación de uno a muchos desde el lado del modelo principal.

<?php
class User extends Model {
    public function posts(): \Illuminate\Database\Eloquent\Relations\HasMany {
        return $this->hasMany(Post::class);
    }
}
// Access:
$posts = $user->posts; // Collection

belongsTo (lado de muchos)

Cada Post pertenece a un User.

<?php
class Post extends Model {
    public function author(): \Illuminate\Database\Eloquent\Relations\BelongsTo {
        return $this->belongsTo(User::class, "user_id");
    }
}

Muchos a muchos (belongsToMany)

Un Post tiene muchos Tags y un Tag pertenece a muchos Posts; están vinculados mediante una tabla intermedia.

<?php
class Post extends Model {
    public function tags() {
        return $this->belongsToMany(Tag::class);
    }
}
// Pivot table: post_tag (post_id, tag_id)
$tags = $post->tags;
$post->tags()->attach($tagId);
$post->tags()->detach($tagId);
$post->tags()->sync([1, 2, 3]);

hasManyThrough

Acceda a modelos relacionados de forma indirecta: un Country tiene muchos Posts a través de Users.

<?php
class Country extends Model {
    public function posts() {
        return $this->hasManyThrough(Post::class, User::class);
    }
}

Relaciones polimórficas

Un modelo Comment que puede pertenecer a un Post o a un Video mediante relaciones polimórficas.

<?php
class Comment extends Model {
    public function commentable() {
        return $this->morphTo();
    }
}
class Post extends Model {
    public function comments() {
        return $this->morphMany(Comment::class, "commentable");
    }
}

Consultas sobre existencia de relaciones

Consulte modelos según la existencia de una relación.

<?php
// Posts that have at least one comment:
$commented = Post::has("comments")->get();
// Posts with >= 3 comments:
$popular = Post::has("comments", ">=", 3)->get();

whereHas

Filtre según las condiciones de una relación.

<?php
$phpPosts = Post::whereHas("tags", function ($q) {
    $q->where("name", "PHP");
})->get();

Métodos de relación frente a propiedades dinámicas

$user->posts() devuelve el generador de consultas, por lo que puede encadenarlo. $user->posts devuelve la colección cargada.

Resumen

Defina las relaciones como métodos que devuelvan hasOne, hasMany, belongsTo o belongsToMany. Acceda a ellas como propiedades dinámicas o encadene consultas a partir de la llamada al método.

Comprobación rápida

¿Qué tipo de relación utiliza una tabla intermedia?

Preguntas frecuentes

¿La lección «Relaciones de Eloquent» es gratis?

Sí — el texto completo de «Relaciones de Eloquent» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de PHP Academy, actualiza a CoddyKit PRO. El curso de PHP Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Relaciones de Eloquent»?

Defina relaciones hasOne, hasMany, belongsTo y de muchos a muchos. Practicas PHP Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar PHP Academy?

No se requiere experiencia previa. PHP Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Relaciones de Eloquent»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de PHP Academy?

Sí. Cada lección de PHP Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a PHP Academy