Entender Laravel

1

隆Actualizamos este curso!

2

驴Qu茅 es Laravel?

3

Herramientas necesarias para trabajar con PHP y Laravel

4

Entendiendo el ciclo de vida de las solicitudes web

5

Qu茅 es un CRUD y c贸mo implementarlo

6

L贸gica de controladores y vistas con datos de prueba

7

Creando un formulario

Comprender los Fundamentos de Laravel

8

Sistema de rutas y controladores

9

Uso de Middlewares

10

Validaci贸n de datos (rutas, vistas, formularios y controladores)

11

Blade: sistema de plantillas avanzado

12

Trabajando con el componente Laravel/UI

Aprender sobre Eloquent ORM

13

Eloquent: trabajando con este ORM

14

Relaciones de tablas

15

Colecciones y serializaci贸n de datos

16

Formato de valores en tablas y presentaci贸n de datos

Crear PlatziPress

17

Proyecto Blog: presentaci贸n y configuraci贸n inicial

18

Creaci贸n de tablas, entidades y datos de prueba

19

Plantillas de trabajo y entendiendo el login

20

Dise帽o visual con Bootstrap

21

Vista index y botones de acci贸n

22

Implementaci贸n del formulario de creaci贸n

23

Implementaci贸n del guardado

24

Creando la funci贸n de editar un post

25

Actualizando nuestros posts

26

Integrando contenido audiovisual

Construir Proyecto Final: API con TDD (Intermedio)

27

Introducci贸n al testing

28

Metodolog铆a TDD y testing HTTP

29

Proyecto API con TDD: presentaci贸n y configuraci贸n inicial

30

Store con TDD

31

Refactorizaci贸n y validaci贸n en Store

32

Show con TDD

33

Update y validaci贸n con TDD

34

Delete con TDD

35

Index con TDD

36

Protecci贸n de una API con Login

37

Cierre del curso

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Aprende Ingl茅s, Programaci贸n, AI, Ciberseguridad y m谩s a precio especial.

Antes: $249

Currency
$209
Suscr铆bete

Termina en:

2 D铆as
21 Hrs
42 Min
17 Seg
Curso de Introducci贸n a Laravel 6

Curso de Introducci贸n a Laravel 6

Profesor Italo Morales F

Profesor Italo Morales F

Relaciones de tablas

14/37
Recursos

Aportes 44

Preguntas 10

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

Relaciones de tablas


Para crear una relaci贸n con una tabla externa tendremos que escribir el siguiente dentro de la clase de la tabla en el m茅todo up()

// Para que asegurar que el dato siempre sea positivo
$table->unsignedBigInteger('user_id');

// Para crear llaves foraneas y unirse a la siguiente la tabla externa 
$table->foreign('user_id')->references('id')->on('users');

As铆 quedar铆a el c贸digo:

public function up()
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();

            $table->unsignedBigInteger('user_id');
            $table->string('title');

            $table->foreign('user_id')->references('id')->on('users');

            $table->timestamps();
        });
    }

Ahora nos toca refrescar las tablas, para eso vamos a utilizar el siguiente comando:

php artisan migrate:refresh --seed

馃挌 Si les sale este error:

Illuminate\Database\QueryException 

  SQLSTATE[23000]: Integrity constraint violation: 1451 Cannot delete or update a parent row: a foreign key constraint fails (SQL: drop table if exists `users`)

Tendr谩s que proceder poner en la tabla que est谩s creado una relaci贸n el siguiente c贸digo dentro del m茅todo down()

public function down()
    {
        // El siguiente c贸digo:
        Schema::dropIfExists('posts');
        Schema::dropIfExists('users');
    }

馃構 Este error sucede porque para crear de nuevo las tablas, Laravel necesita que primero se borre la tabla hijo antes de borrar la tabla padre. La tabla hijo en este caso ser铆a posts perp como Laravel primero va ha leer la tabla padre debemos poner esta sentencia en esta tabla.

  • rand($min, $max) 鈫 Es una funci贸n que genera aleatoriamente un n煤mero dentro de los dos par谩metros que le damos.

En Laravel 8x, para crear semillas de datos que van ser ejecutados por php artisan migration, tenemos que escribir la sentencia as铆:

public function run()
    {
        \App\Models\User::factory(4)->create();
        \App\Models\Post::factory(12)->create();
        // factory(App\Models\User::class, 3)->create();
        // factory(App\Models\Post::class, 12)->create();
    }

馃挗 Recuerda que la configuraci贸n que hicimos con las migraciones solamente afectaron a la Database, no a nuestro modelo.

Tenemos que ir a los archivos de los modelos de las tablas y especificar que hicimos la relaci贸n entre esas tablas, vamos a su clase y creamos el siguiente m茅todo:

// User.php => Aqu铆 dejaremos una sentencia que significa que
// un usuario tiene muchos posts
public function posts()
{
    return $this->hasMany(Post::class);
}

// Post.php => Aqu铆 dejaremos una sentencia que significa que
// un post le pertence a un usuario.
public function user()
{
    return $this->belongsTo(User::class);
}

Aqu铆 hay m谩s informaci贸n de** todas las relaciones posibles **usando **Eloquent **

https://laravel.com/docs/7.x/eloquent-relationships

  • Relaciones de tablas: trabajaremos sobre el ejemplo creado anteriormente, para ello tenemos que hacer las siguientes modificaciones:

    • En el archivo que se encuentra en la carpeta de migration y que hace referencia a posts a帽adimos lo siguiente:
    public function up()
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('user_id');  //AGREGAMOS ESTE CAMPO PARA NUESTRA LLAVE FOR脕NEA
            $table->string('title');
            /*AQUI AGREGAMOS LA DECLARACI脫N DE LA LLAVE 			
            FORNEA  (user_id) es el campo de mi tabla, id el campo de la tabla donde quiero hacer referencia mi llave foranea y  users es la tabla */
            $table->foreign('user_id')->references('id')->on('users');  
            $table->timestamps();
        });
    }
    

    AQU脥 A脩ADIMOS UN NUEVO CAMPO AL MODELO DE MIGRACI脫N DE NUESTRA TABLA POST

    • Ahora en el archivo que se encuentra dentro de nuestra carpeta factoriesa帽adimos lo siguiente al archivo PostFactory.php
    $factory->define(Post::class, function (Faker $faker) {
        return [
            'user_id' => rand(1,4), //A脩ADIMOS EL CAMPO DE NUESTRA LLAVE FORANEA Y AGREGAMOS LA FUNCION RAND (el cual nos permite generar numeros random que va del 1 al 4)
            'title'=> $faker->sentence
        ];
    });
    
    • Ahora como hicimos modificaciones en nuestro archivo de migraci贸n tenemos que reflejarlo en la base de datos, para ello ejecutamos el comando:
    php artisan migrate:refresh
    

    ejecutar este comando tiene un inconveniente, el cual radica en que si ten铆amos registros en nuestra base de datos estos se borraran. Para evitar esto tenemos que configurar lo siguiente:

    • Para evitar que se borren nuestro registros al ingresar el comando anterior configuramos unas semilla( dentro de la carpeta seeds).

    seeds>DatabaseSeeder.php

    //configuraci贸n inicial semilla
    public function run()
    {
        // $this->call(UserSeeder::class);
        factory(App\User::class,4)->create();
        factory(App\Post::class,30)->create();
    }
    
    • Ahora podemos ejecutar nuevamente el comando para refrescar nuestra base de datos con nuestros cambios, pero debemos agregar una opci贸n m谩s:
    php artisan migrate:refresh --seed
    

    Ahora si tenemos nuestras tablas actualizadas y con datos llenos

  • Todo esto nos ayudo para crear un archivo de migraci贸n que tenga relaci贸n entre dos tablas y que podamos crear registros aleatorios en el, sin embargo laravel a煤n no conoce esta relaci贸n que creamos, para hacer conocer a laravel de estos cambios hacemos lo siguiente :

    • Vamos al modelo Post.php y agregamos la siguiente funci贸n:
     //Un post pertenece a un usuario
     public function user(){
         return $this->belongsTo(User::class);
     }
    
    • Vamos al modelo User.php y agregamos la siguiente funci贸n:
     //Relaci贸n : Un usuario tiene muchos post
     public function posts(){
         return $this->hasMany(Post::class);
     }
    
  • Ahora si podemos empezar a realizar operaciones con nuestras tablas relacionadas (estos ejemplos se lo realiz贸 en el archivo web.php)

    • ejemplo de operaciones en la tabla user:
    use App\User;
    Route::get('users', function () {
        $users = User::get();
        
        foreach($users as $user){
            echo "
            $user->id 
            <strong>{$user->name}</strong>
            {$user->posts->count()} posts
            <br>";
        }
    });
    
    • ejemplo de operaciones en la tabla post:
    Route::get('posts', function () {
        $posts = Post::get();
    
        foreach($posts as $post){
            echo "
            $post->id 
            <strong>{$post->user->name}</strong>
            $post->title 
            <br>";
        }
    });
    

Acabo de crear una tabla con sus campos propios y los de auditoria, siempre estoy acostumbrado a trabajar con CreatedBy, CreatedDate, ModifiedBy, ModifiedDate y IsDeleted. El created_at y updated_at me lo da $table->timestamps(); y el created_by y modified_by los hice de la siguiente forma, que les parece?

	   // Audits fields
            $table->timestamps();
            $table->unsignedBigInteger('created_by');
            $table->unsignedBigInteger('modified_by');
            $table->softDeletes();

            // Foreign keys
            $table->foreign('created_by')->references('id')->on('users');
            $table->foreign('modified_by')->references('id')->on('users');

Estoy utilizando la versi贸n de Laravel 8 y este es el c贸digo que utilice para crear el seeder y poderlo ejecutar desde la consola una vez lo configur贸 como el instructor muestra

<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;
use App\Models\User;
use App\Models\Post;

class DatabaseSeeder extends Seeder
{
    /**
     * Seed the application's database.
     *
     * @return void
     */
    public function run()
    {
        // \App\Models\User::factory(10)->create();
        User::factory(5)->create();        
        Post::factory(30)->create();
    }
}

Ok鈥 Se me hace un tanto curioso que en los comentarios nadie haya puesto este problema, pero el caso es que al acceder a los datos en las rutas:

Route::get('posts', function () {
    $posts = Post::get();

    foreach ($posts as $post) {
        echo "
        $post->id 
        <strong>{$post->user->name}</strong> 
        $post->title <br>";
    }
});

Me saltaba el error trying to get property 'name' of non-object laravel por lo que buscando en internet encontr茅 que ten铆a tambi茅n que especificar el nombre del campo de la clave for谩nea en el belongsTo() del archivo Post.php:

public function user()
    {
        return $this->belongsTo(User::class, 'fk_user_id');
    }

Con esto ya me aparecieron correctamente los registros, desconozco totalmente si esto influya en la versi贸n de Laravel, yo uso la 7.11.0.

Espero les haya servido si a alguien le salt贸 el mismo error, y si saben por qu茅 me pudo haber pasado a mi de esta forma agradecer铆a que me lo dijeran 馃槃

Hola!! Si quieren formar parte de un grupo de estudios de Devs, les dejo un link a un grupo de Telegram que est谩 muy chulo.

https://t.me/HackTzi

Tambi茅n tienen una organizaci贸n de GitHub, 煤nete por aqu铆:

https://github.com/HackTzi

Para crear las relaciones de una llave foranea se usa de la siguiente forma:

// nombre del campo que va a contener el ID de la otra tabla a relacionar
$table->unsignedBigInteger('user_id');  //esto crea un Entero Grande sin signo 
/*
$table->foreign('campo de la table actual')
->references('campo de llave primaria de la otra tabla')
->on('tabla a relacionar');
*/
$table->foreign('user_id')->references('id')->on('users');

me daba error por el use App\User; como usa, pero en la version actual de laravel toca aumentar App\Models\User

use App\Post;



Route::get('eloquent', function () {
    $posts = Post::where('id','>=','10')
    ->orderBy('id','DESC')
    ->take(3)
    ->get();

    foreach ($posts as $post) {
        echo "$post->id $post->title <br>";
    }
});

Route::get('posts', function () {
    $posts = Post::get();

    foreach ($posts as $post) {
        echo "$post->id
        <strong>{$post->user->name} </strong>
        $post->title <br>";
    }
});
use App\User;
Route::get('users', function () {
    $users = User::get();

    foreach ($users as $user) {
        echo "$user->id
        <strong>{$user->name} </strong>
        {$user->posts->count()} posts <br>";
    }
});

La verdad tengo problemas con los comandos y la base de datos porque ningun comando me migra ni me refresca en la base de datos, no da ningun error solo me aparece esto pero no hace absolutamente nada鈥 la base de datos se queda igual. estoy en xampp

Casa@DESKTOP-MBM1C0S MINGW32 /c/xampp/htdocs/laravel/eloquent
$ php artisan migrate:refresh --seed
Nothing to rollback.
Migrating: 2014_10_12_000000_create_users_table

   Illuminate\Database\QueryException

  SQLSTATE[42S01]: Base table or view already exists: 1050 Table 'users' already
 exists (SQL: create table `users` (`id` bigint unsigned not null auto_increment
 primary key, `name` varchar(255) not null, `email` varchar(255) not null, `emai
l_verified_at` timestamp null, `password` varchar(255) not null, `remember_token
` varchar(100) null, `created_at` timestamp null, `updated_at` timestamp null) d
efault character set utf8mb4 collate 'utf8mb4_unicode_ci')

  at C:\xampp\htdocs\laravel\eloquent\vendor\laravel\framework\src\Illuminate\Da
tabase\Connection.php:669
    665|         // If an exception occurs when attempting to run a query, we'll
 format the error
    666|         // message to include the bindings with SQL, which will make th
is exception a
    667|         // lot more helpful to the developer instead of just the databa
se's errors.
    668|         catch (Exception $e) {
  > 669|             throw new QueryException(
    670|                 $query, $this->prepareBindings($bindings), $e
    671|             );
    672|         }
    673|

  1   C:\xampp\htdocs\laravel\eloquent\vendor\laravel\framework\src\Illuminate\D
atabase\Connection.php:463
      PDOException::("SQLSTATE[42S01]: Base table or view already exists: 1050 T
able 'users' already exists")

  2   C:\xampp\htdocs\laravel\eloquent\vendor\laravel\framework\src\Illuminate\D
atabase\Connection.php:463
      PDOStatement::execute()

RESUMEN
1
"database/migrations/_Create_posts_table
$table->unsignedBigInteger("user_id") ; //relacionar con el id de 	table users
$table->foreign("user_id")->references("id")->on("users") ;  
		//relacion          ||campo                ||donde esta el campo

2 "TERMINAL"
php artisan migrate:refresh //esto actualiza los archivos actuales

3
"database/seeds/DatabaseSeeder.php"
"repoblamos la DB cada vez que migramos"
        factory(App\User::class, 4)->create();
        factory(App\Post::class, 30)->create();

4
"database/factories/PostFactory.php"
agregar la columna "user_id" a la fabrica de datos de prueba
"user_id"=> rand(1,4),
"title"=>$faker->sentence

5
"TERMINAL"
volvemos a hacer el refresh pero con el atributo --seed
php artisan migrate:refresh --seed

6
TODO MUY LINDO DESDE LA VISTA DE LA BASE DE DATOS
PERO AHORA HAY QUE AVISARLE A LARAVEL por ende hay que ir a actualizar los models
"User.php"
debemos especificar que tipo de relacion relacion:
-un user puede tener muchos posts
    public function posts(){
        return $this->hasMany(Post::class);
    }

"Post.php
debemos especificar que tipo de relacion relacion:
-cada Post le pertenece a 1 User
 public function user(){
        return $this->belongsTo(User::class);
    }

7
"routes/web.php"
A) IMPRIMIREMOS LOS POSTS SU ID ,EL NOMBRE DE SU USER , SU TITLE

Route::get('/posts', function () {
    $posts = Post::get();

    foreach($posts as $post){
        echo "
        $post->id 
        <strong>{$post->user->name}</strong>  //class||method||user owner name
        $post->title 
        <br/>";
    }
});

B)IMPRIMIREMOS LOS USERS y la cantidad de posts que tienen
Route::get('/users', function () {
    $users = User::all();

    foreach($users as $user){
        echo "
        $user->id 
        $user->name
        {$user->posts->count()} posts //class||method|| contar 
        <br/>";
    }
});


EXPLICACION:t
enemos acceso a estos valores
POST:
{$post->user->name}
USER:
 {$user->posts->count()}

PORQUE EL METODO "user" existe en el model Post 
y el  metodo "posts" existe en el model User


MORALEJA
LOS MODELS SON MUY IMPORTANTES PORQUE SON LA REPRESENTACION DE LA TABLA EN BASE DE DATOS
y con los metodos que usemos podemos listar , eliminar, consultar etc

Excelente clase! Este curso se esta poniendo cada vez mejor 馃槃

para que los seeders funcionene cuando se refresca la BD se debe de usar la opcion 鈥搒eed

php artisan migrate:refresh --seed

Aqui lo correcto hubiera sido haber creado una migraci贸n extra indicando que a la tabla Posts se le agregar谩 el campo user_id.

Buenas , al ejercutar el comado 鈥渕igrate:refresh --seed鈥 , me ha dado el error que la tabla posts ya existia
Alguna idea que hago mal??, la he tenido que borrar y ejecutar el migrate sin refresh
Gracias

Hola, tome estos apuntes hace algun tiempo pero creo aun son utiles, para entender de manera grafica las relaciones, tienen ejemplo de codigo para cada realcion.
.
Notese que en la relacion mucho a muchos la tabla pivote debe tener una nomenclatura clara y en orden alfabetico
.

.

.
En el ejemplo siguiente de acuerdo a la documentacion de laravel, la tabla debe llamarse curso_estudiante
.

.

Para refrescar los nuevos campos que queremos en nuestra base de datos, ejecutamos el siguiente comando:

php artisan migrate:refresh

Cuando usamos este comando, existe un problema, se nos borran los datos.

Sin embargo, gracias a la tecnolog铆a de Tinker, podemos irnos al archivo database/seeds/DatabaseSeeder.php y colocar una cantidad de usuarios por defecto que desear铆a que aparezcan cada vez que refresque. Podemos hacer algo como esto:

    public function run()
    {
        factory(App\User::class, 4)->create();
        factory(App\Post::class, 30)->create();
    }

Usamos el par谩metro de refresh y los datos de semilla.

Para los que le salga error al usar el comando php artisan migrate:refresh
Illuminate\Database\QueryException : SQLSTATE[42S01]: Base table or view already exists: 1050 Table 鈥榩osts鈥 already exists (SQL: create table posts (id bigint unsigned not null auto_increment primary key, user_id bigint unsigned not null, title varchar(255) not null, created_at timestamp null, updated_at timestamp null) default character set utf8mb4 collate 鈥榰tf8mb4_unicode_ci鈥)

a mi me funciono borrando las tablas manualmente en la base de datos.

Cuando usar
hasMany- hasOne // belongsTo- belongsMany

Leyendo la documentaci贸n de laravel y buscando en foros. Encontre que hasMany o hasOne la usamos cuando tenemos nuestros datos en una misma table. Pero cuando la table esta relacionada con otra utilizamos belongsTo- belongsMany

Si uso el Strong me salen mal los datos, me sale un Json Viewer, al eliminar las etiquetas strong se soluciona

Excelente clase, he tomado mis apuntes en ppt, por lo tanto me he tardado varios d铆as ias en hacer este curso, lo que mas me gusta es que me siento con capacidad de solucionar varios fails que se presentan gracias a este curso y al de programaci贸n orientada a objetos con php.

Tomar en cuenta que acceder al User en el Post, se genera una consulta extra por cada Post. Para evitar esto podemos usar Post::all()->load(鈥榰ser鈥) y solamente utilizar谩 una consulta para obtener a todos los users de los posts e internamente Laravel los relacionar谩.

I love laravel and eloquent

Podemos ahorrar lineas de codigo utilizando:

            $table->foreignId('user_id')->constrained('users');

En lugar de

	$table->unsignedBigInteger('user_id');
        $table->foreign('user_id')->references('id')->on('users');

Nota: foreignId es un alias de unsignedBigInteger

// PASO A PASO PARA LA GENERACI脫N DE DOS TABLAS RELACIONADAS, PADRE E HIJO
/*
1. CREAR BD
2. CONECTAR LARAVEL CON BD EN .env
3. GENERAR LOS DOS MODELOS, LOS FACTORIES Y LOS MIGRATIONS DE CADA TABLA

    - php artisan make:model Padre -m -f
    - php artisan make:model Hijo -m -f

    3.1 MODELOS [app/nomModel.php]: se establecen las reglas de relacion entre las tablas
    3.2 FACTORIES [database/factories/nomFactory.php]: Contiene informacion de generacion de contenido generico para las tablas
    3.3. MIGRATIONS [database/migrations/nomMigrations.php]:  estructura de la tabla en php que genera el sql e la misma

4. Modificar los migrations: estructura de las tablas y relaciones. 

        Eje: Padre

        public function up()
        {
            Schema::create('padres', function (Blueprint $table) {
                $table->bigIncrements('id');
                $table->string('name', 120);
                $table->string('phone', 50);
                $table->integer('age');
                $table->timestamps();
            });
        }

        Eje Hijo: 

        public function up()
        {
            Schema::create('hijos', function (Blueprint $table) {
                $table->id();

                // CREAMOS LA LLAVE FORANEA Y LA ENLAZAMOS CON EL PADRE
                $table->unsignedBigInteger('padre_id');
                $table->foreign('padre_id')->references('id')->on('padres'); // Padres es el nombre del esquema

                $table->string('name', 120);
                $table->string('phone', 50);
                $table->integer('age');
                $table->timestamps();
            });
        }

        APLICAMOS ACTUALIZACION EN BD DE LOS CAMBIOS EN LOS /migratiosn/

        php artisan migrate:refresh => Tablas creadas en BD

5. MODIFICAMOS EL /database/seeds/DatabaseSeeder.php PARA EJECUTAR COMANDO QUE GENERE DATOS GENERICOS PARA LAS TABLAS ASI:

        use App\Padre;
        use App\Hijo;

        public function run()
        {
            factory(App\Padre::class, 2)->create();     //  Crea 4 padres
            factory(App\Hijo::class, 12)->create();     //  Crea 12 hijos
        }

6. EDITAMOS LOS FACTORIES PARA GENERACION DE DATOS DE EJEMPLO DE CADA TABLA, EL PASO ANTERIOR IRA A ELLOS Y EJECUTARA EL FACTORY:
   EN ESTOS FACTORY SE ESTABLECE DE QUE TIPO DE DATOS ES CADA CAMPO PARA PODER GENERARLOS DINAMICAMENTE:

        RUTA 1: /database/factories/PadreFactory.php

            $factory->define(Padre::class, function (Faker $faker) {
                return [
                    'name' => $faker->sentence,
                    'phone' => $faker->phoneNumber,
                    'age' => $faker->numberBetween(18, 65)
                ];
            });

        RUTA 2: /database/factories/HijoFactory.php

            $factory->define(Hijo::class, function (Faker $faker) {
                return [
                    'padre_id' => rand(1, 2), //PORQUE SE CREARON SOLO DOS PADRES
                    'name' => $faker->sentence,
                    'phone' => rand(3000000000, 3900000000), 
                    'age'  => rand(1, 18),
                ];
            });

7. EJECUTAMOS COMANDOS PARA COMPILAR LO EDITADO Y GENERAR LOS DATOS PARA LAS TABLAS.

            php artisan migrate:refresh --seed

8. CREAMOS RELACION ENTRE LAS TABLAS EN LOS MODELOS DE CADA UNA [/App/nomModel.php]:

        - AL MODELO DEL PADRE LE DECIMOS QUE PUEDE TENER MUCHOS HIJOS => Agregamos la funcion a /App/Padre.php:
                
                public function hijo()
                {
                    return $this->hasMany(Hijo::class);
                }

        - AL MODELO DEL HIJO LE DECIMOS QUE PERTENECE A UN UNICO PADRE => Agregamos la funcion a /App/Hijo.php:

                public function padre(){
                    return $this->belongsTo(Padre::class);
                }

8. EJECUTAMOS COMANDO PARA GENERAR DATOS ALEATORIOS DEFINIDOS EN FACTORIES PARA CADA TABLA:

        - php artisan migrate:refresh --seed

9. MODIFICAMOS RUTAS EN [routes/web.php] asi:

        // LISTA LOS HIJOS CON EL NOMBRE DE SU PADRE: http://eloquentpersonal.test/hijos
        Route::get('hijos', function () {
            $hijos = Hijo::all();
            
            foreach ($hijos as $hijo) {
                echo "$hijo->id     |   $hijo->name |   $hijo->age  |   $hijo->phone    | <strong>{$hijo->padre->name}</strong></br>";
            }
        });


        // Lista los posts que tiene un usuario:  http://eloquentpersonal.test/padres
        // {$padre->hijo->count()} => debe ser el nombre de la funcion creada en el modelo padre como relacion entre las dos tablas
        use App\Padre;
        Route::get('padres', function () {
            $padres = Padre::all();
            foreach ($padres as $padre) {
                echo "$padre->id     |   <strong>$padre->name</strong>   |   {$padre->hijo->count()} hijos</br>";
            }
        });

*/

Las relaciones que creamos aqu铆 nos permiten tener la consistencia en la BD y realizar las buenas practicas como se debe excelente!!!

para cuando se recrea la BD podemos usar los Seeders para llamar al factory y crear los datos falsos necesarios

Los seeders se encuentran en la ruta:

database > seeds > archivos de seeders

Muy bien explicado la forma en la que se relacionan dos tablas y como se puede consultar la informaci贸n para hacer un sitio web.

Hola, 驴Alguien sabe por qu茅 se muestran esos datos adicionales y los botones de la derecha? Muchas gracias!

.

Me encanta como trabaja las consultas con la base de datos, genial.

Tambi茅n podemos acceder a un id aleatorio directamente del modelo User por ejemplo:

<?php

/** @var \Illuminate\Database\Eloquent\Factory $factory */

use App\User; //Importamos el modelo
use App\Post;
use Faker\Generator as Faker;

$factory->define(Post::class, function (Faker $faker) {
    return [
        'title' => $faker->sentence,
        'user_id' => User::all()->random()->id, //obtenemos el id aleatorio
    ];
});

Compa帽eros alguien que me de una mano y me brinde su asesoria. Tengo un incoveniente al intentar hacer la relacion de las siguientes tablas
Ya que necesito que en usuarios la identificacion NO me quede como un campo auto incremental, para poder enlazar adecuadamente con la otra tabla.

estoy asombrado, cosas como las benditas llaves para pasar a mas de 2 niveles de relacion de clases en donde rayos aprendio eso el profesor??? yo no lo sabia no habia visto eso en ningun lado desde laravel 5

Lo que hace Eloquent es genial porque literal te enlista la relacion con tu modelo original, la pone como si fuera un campo m谩s de etu base de datos, pero en realidad es la otra tabla que ya viene pegada, es simplemente genial:D

Documentaci贸n Laravel Eloquent 8.x

https://laravel.com/docs/8.x/eloquent#introduction

Saludos.

Esto es una consulta. Al usar count() me da este error?

鈥淓rror
Call to a member function count() on null鈥

use App\User;
Route::get(鈥榰sers鈥, function () {
$users = User::all();
foreach ($users as $user){
echo 鈥
$user->id
<strong> $user->name</strong>
{$user->posts->count()} posts <br>鈥;
}
});

Programar en PHP es literalmente mezclar 谩lgebra e ingl茅s en un nuevo idioma

posteando y buscando informaci贸n encontr茅 esto espero sea de ayuda
'user_id' => factory(App\User::class)

En el modelo es una buena practica incluir el metodo SoftDeletes.
dejo el enlace de la documentaci贸n para que se informen mas.
https://laravel.com/docs/8.x/eloquent#soft-deleting

Al correr al recargar la migraci贸n me marc贸 un erro ya que

            $table->foreignBigInteger('user_id');

suele trabajar en conjunto con

            $table->bigIncrements('id');

entonces mi versi贸n de Laravel 7.X me pone las migraciones as铆

            $table->id();

para ello nada mas al poner la llave foranea nada m谩s hay que hacerlo de esta forma

            $table->foreignId('user_id');

Lo dem谩s es igual. Saludos

los metodos unsignedBig, increments donde consigo una lista de esos metodos?v