How to use Laravel's fill data function

Laravel is a popular PHP framework that provides many useful functions and tools, one of the important features is filling data. Filling data refers to filling the data in the database table with some predefined values ​​for testing and development. This article will introduce how to use Laravel's fill data function.

1. Preparation

Before using Laravel's data filling function, you need to create a database table and an Eloquent model. The following is a simple example:

php artisan make:model User -m

The above command will create a User model and a database migration file xxxx_xx_xx_xxxxxx_create_users_table.php# in the app directory. ##. We need to define the table structure in the migration file:

public function up()
{
    Schema::create('users', function (Blueprint $table) {
        $table->bigIncrements('id');
        $table->string('name');
        $table->string('email')->unique();
        $table->timestamp('email_verified_at')->nullable();
        $table->string('password');
        $table->rememberToken();
        $table->timestamps();
    });
}

Then run the database migration:

php artisan migrate

This will create a data table named

users.

2. Filling data

Laravel provides a

db:seed command for filling data. We can create a Seeder class in the database/seeds directory, inherit the Illuminate\Database\Seeder class, and implement the run method.

The following is a simple example

UserSeeder.php:

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

class UserSeeder extends Seeder
{
    public function run()
    {
        factory(User::class, 50)->create();
    }
}

The above code uses Laravel’s factory pattern to generate 50

User models, and store them into the database.

In the

run method, we can use Laravel's query builder and Eloquent model to operate the database. In this example, we use the factory function to create 50 User model instances and save them to the database.

3. Call Seeder

After creating the Seeder class, we need to call it to fill in the data. We can call all the data that needs to be filled in the

database/seeds/DatabaseSeeder.php file. This class is a main seeder, which is used to call other seeder classes.

use Illuminate\Database\Seeder;

class DatabaseSeeder extends Seeder
{
    public function run()
    {
        $this->call(UserSeeder::class);
    }
}

After calling the

UserSeeder class, we can execute the db:seed command through the command line to fill in the data:

php artisan db:seed

This command will be found automatically All defined

Seeder classes and run their run methods.

4. Using Factory

In the above example, we used Laravel's factory pattern to generate 50

User model instances. Laravel's factory pattern can help us easily generate the data required for testing and development.

We can create models using the

make and create methods. The make method is used to create a temporary model instance that is not saved to the database, and the create method is used to create a model instance that is saved to the database.

In Laravel, we can use the

Factory class to define, register and use factories. The use of the Factory class is very simple. We only need to create a factory file in the database/factories directory and define a model and its attributes through the define method. Here is a simple example UserFactory.php:

use Faker\Generator as Faker;
use App\User;

$factory->define(User::class, function (Faker $faker) {
    return [
        'name' => $faker->name,
        'email' => $faker->unique()->safeEmail,
        'password' => bcrypt('password'),
    ];
});

In this example, we use the

Faker class to generate random model data and simulate real users data. This factory defines three attributes: name, email, and password.

When we need to use this factory, we can use the following code:

use App\User;

$user = factory(User::class)->create();

This will create a new

User model instance and save it to the database . We can also use the make method to create a model instance that is not saved to the database:

use App\User;

$user = factory(User::class)->make();

This model instance will contain randomly generated attribute values, which we can use in testing and development .

5. Summary

Laravel provides a convenient data filling function. We can use Seeder to generate test data and use factory mode to generate model instances. With this feature, we can easily populate database tables for easy testing and development.

The above is the detailed content of How to use Laravel's fill data function. For more information, please follow other related articles on the PHP Chinese website!