イントロダクションIntroduction
アプリケーションのテストやデータベースの初期値生成時に、データベースへレコードを挿入する必要がある場合があるでしょう。Laravelでは、各カラムの値を手作業で指定する代わりに、Eloquentモデルそれぞれに対して、モデルファクトリを使用し、デフォルト属性セットを定義できます。When testing your application or seeding your database, you may need to insert a few records into your database. Instead of manually specifying the value of each column, Laravel allows you to define a set of default attributes for each of your Eloquent models[/docs/{{version}}/eloquent] using model factories.
ファクトリの作成方法の例を確認するには、アプリケーションのdatabase/factories/UserFactory.php
ファイルを見てください。このファクトリはすべての新しいLaravelアプリケーションに含まれており、以下のファクトリ定義が含まれています。To see an example of how to write a factory, take a look at the database/factories/UserFactory.php
file in your application. This factory is included with all new Laravel applications and contains the following factory definition:
namespace Database\Factories;
use Illuminate\Support\Str;
use Illuminate\Database\Eloquent\Factories\Factory;
class UserFactory extends Factory
{
/**
* モデルのデフォルト状態の定義
*
* @return array<string, mixed>
*/
public function definition(): array
{
return [
'name' => fake()->name(),
'email' => fake()->unique()->safeEmail(),
'email_verified_at' => now(),
'password' => '$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi', // password
'remember_token' => Str::random(10),
];
}
}
ご覧のとおり、一番基本的な形式では、ファクトリはLaravelの基本ファクトリクラスを拡張し、definition
メソッドを定義するクラスです。definition
メソッドは、ファクトリを使用してモデルを作成するときに適用する必要がある属性値のデフォルトセットを返します。As you can see, in their most basic form, factories are classes that extend Laravel's base factory class and define a definition
method. The definition
method returns the default set of attribute values that should be applied when creating a model using the factory.
fake
ヘルパを使うと、ファクトリでFaker PHPライブラリにアクセスでき、テストやシードのためにさまざまな種類のランダムデータを生成でき、便利です。Via the fake
helper, factories have access to the Faker[https://github.com/FakerPHP/Faker] PHP library, which allows you to conveniently generate various kinds of random data for testing and seeding.
Note:
config/app.php
設定ファイルにfaker_locale
オプションを追加することで、アプリケーションのFakerロケールを設定できます。[!NOTE]
You can set your application's Faker locale by adding afaker_locale
option to yourconfig/app.php
configuration file.
モデルファクトリの定義Defining Model Factories
ファクトリの生成Generating Factories
ファクトリを作成するには、make:factory
Artisanコマンドを実行します。To create a factory, execute the make:factory
Artisan command[/docs/{{version}}/artisan]:
php artisan make:factory PostFactory
新しいファクトリクラスは、database/factories
ディレクトリに配置されます。The new factory class will be placed in your database/factories
directory.
モデルと対応するファクトリの規約Model and Factory Discovery Conventions
ファクトリを定義したら、モデルのファクトリインスタンスをインスタンス化するために、Illuminate\Database\Eloquent\Factories\HasFactory
トレイトが、モデルへ提供しているstaticなfactory
メソッドが使用できます。Once you have defined your factories, you may use the static factory
method provided to your models by the Illuminate\Database\Eloquent\Factories\HasFactory
trait in order to instantiate a factory instance for that model.
HasFactory
トレイトのfactory
メソッドは規約に基づいて、その トレイトが割り当てられているモデルに適したファクトリを決定します。具体的には、Database\Factories
名前空間の中でモデル名と一致するクラス名を持ち、サフィックスがFactory
であるファクトリを探します。この規約を特定のアプリケーションやファクトリで適用しない場合は、モデルのnewFactory
メソッドを上書きし、モデルと対応するファクトリのインスタンスを直接返してください。The HasFactory
trait's factory
method will use conventions to determine the proper factory for the model the trait is assigned to. Specifically, the method will look for a factory in the Database\Factories
namespace that has a class name matching the model name and is suffixed with Factory
. If these conventions do not apply to your particular application or factory, you may overwrite the newFactory
method on your model to return an instance of the model's corresponding factory directly:
use Illuminate\Database\Eloquent\Factories\Factory;
use Database\Factories\Administration\FlightFactory;
/**
* モデルの新ファクトリ・インスタンスの生成
*/
protected static function newFactory(): Factory
{
return FlightFactory::new();
}
次に、対応するファクトリで、model
プロパティを定義します。Then, define a model
property on the corresponding factory:
use App\Administration\Flight;
use Illuminate\Database\Eloquent\Factories\Factory;
class FlightFactory extends Factory
{
/**
* このファクトリに対応するモデル名
*
* @var class-string<\Illuminate\Database\Eloquent\Model>
*/
protected $model = Flight::class;
}
ファクトリの状態Factory States
状態操作メソッドを使用すると、モデルファクトリへ任意の組み合わせで適用できる個別の変更を定義できます。たとえば、Database\Factories\UserFactory
ファクトリに、デフォルトの属性値の1つを変更するsuspended
状態メソッドが含まれているとしましょう。State manipulation methods allow you to define discrete modifications that can be applied to your model factories in any combination. For example, your Database\Factories\UserFactory
factory might contain a suspended
state method that modifies one of its default attribute values.
状態変換メソッドは通常、Laravelの基本ファクトリクラスが提供するstate
メソッドを呼び出します。state
メソッドは、このファクトリ用に定義する素の属性の配列を受け取るクロージャを受け入れ、変更する属性の配列を返す必要があります。State transformation methods typically call the state
method provided by Laravel's base factory class. The state
method accepts a closure which will receive the array of raw attributes defined for the factory and should return an array of attributes to modify:
use Illuminate\Database\Eloquent\Factories\Factory;
/**
* ユーザーが一時停止されていることを示す
*/
public function suspended(): Factory
{
return $this->state(function (array $attributes) {
return [
'account_status' => 'suspended',
];
});
}
「ゴミ箱入り」状態"Trashed" State
Eloquentモデルがソフトデリート可能であれば、組み込み済みの「ゴミ箱入り(trashed
)」状態メソッドを呼び出し、作成したモデルが既に「ソフトデリート済み」と示せます。すべてのファクトリで自動的に利用可能で、trashed
状態を手作業で定義する必要はありません。If your Eloquent model can be soft deleted[/docs/{{version}}/eloquent#soft-deleting], you may invoke the built-in trashed
state method to indicate that the created model should already be "soft deleted". You do not need to manually define the trashed
state as it is automatically available to all factories:
use App\Models\User;
$user = User::factory()->trashed()->create();
ファクトリのコールバックFactory Callbacks
ファクトリコールバックは、afterMaking
メソッドとafterCreating
メソッドを使用して登録し、モデルの作成または作成後に追加のタスクを実行できるようにします。ファクトリクラスでconfigure
メソッドを定義して、これらのコールバックを登録する必要があります。ファクトリがインスタンス化されるときにLaravelが自動的にこのメソッドを呼び出します。Factory callbacks are registered using the afterMaking
and afterCreating
methods and allow you to perform additional tasks after making or creating a model. You should register these callbacks by defining a configure
method on your factory class. This method will be automatically called by Laravel when the factory is instantiated:
namespace Database\Factories;
use App\Models\User;
use Illuminate\Database\Eloquent\Factories\Factory;
class UserFactory extends Factory
{
/**
* モデルファクトリの設定
*/
public function configure(): static
{
return $this->afterMaking(function (User $user) {
// ...
})->afterCreating(function (User $user) {
// ...
});
}
// ...
}
また、state
メソッド内にファクトリ・コールバックを登録し、特定の状態に特化した追加タスクを実行することもできます。You may also register factory callbacks within state methods to perform additional tasks that are specific to a given state:
use App\Models\User;
use Illuminate\Database\Eloquent\Factories\Factory;
/**
* このユーザーが資格停止中かを示す
*/
public function suspended(): Factory
{
return $this->state(function (array $attributes) {
return [
'account_status' => 'suspended',
];
})->afterMaking(function (User $user) {
// ...
})->afterCreating(function (User $user) {
// ...
});
}
ファクトリを使用するモデル生成Creating Models Using Factories
モデルのインスタンス化Instantiating Models
ファクトリを定義したら、そのモデルのファクトリインスタンスをインスタンス化するために、Illuminate\Database\Eloquent\Factories\HasFactory
トレイトにより、モデルが提供する静的なfactory
メソッドを使用できます。モデル作成のいくつかの例を見てみましょう。まず、make
メソッドを使用して、データベースへ永続化せずにモデルを作成します。Once you have defined your factories, you may use the static factory
method provided to your models by the Illuminate\Database\Eloquent\Factories\HasFactory
trait in order to instantiate a factory instance for that model. Let's take a look at a few examples of creating models. First, we'll use the make
method to create models without persisting them to the database:
use App\Models\User;
$user = User::factory()->make();
count
メソッドを使用して多くのモデルのコレクションを作成できます。You may create a collection of many models using the count
method:
$users = User::factory()->count(3)->make();
状態の適用Applying States
状態のいずれかをモデルに適用することもできます。モデルへ複数の状態変換を適用する場合は、状態変換メソッドを直接呼び出すだけです。You may also apply any of your states[#factory-states] to the models. If you would like to apply multiple state transformations to the models, you may simply call the state transformation methods directly:
$users = User::factory()->count(5)->suspended()->make();
属性のオーバーライドOverriding Attributes
モデルのデフォルト値の一部をオーバーライドしたい場合は、値の配列をmake
メソッドに渡してください。指定された属性のみが置き換えられ、残りの属性はファクトリで指定したデフォルト値へ設定したままになります。If you would like to override some of the default values of your models, you may pass an array of values to the make
method. Only the specified attributes will be replaced while the rest of the attributes remain set to their default values as specified by the factory:
$user = User::factory()->make([
'name' => 'Abigail Otwell',
]);
もしくは、state
メソッドをファクトリインスタンスで直接呼び出して、インライン状態変更を実行することもできます。Alternatively, the state
method may be called directly on the factory instance to perform an inline state transformation:
$user = User::factory()->state([
'name' => 'Abigail Otwell',
])->make();
複数代入保護は、ファクトリを使用してのモデル作成時、自動的に無効になります。[!NOTE]
Note:
Mass assignment protection[/docs/{{version}}/eloquent#mass-assignment] is automatically disabled when creating models using factories.
モデルの永続化Persisting Models
create
メソッドはモデルインスタンスをインスタンス化し、Eloquentのsave
メソッドを使用してデータベースへ永続化します。The create
method instantiates model instances and persists them to the database using Eloquent's save
method:
use App\Models\User;
// App\Models\Userインスタンスを1つ生成
$user = User::factory()->create();
// App\Models\Userインスタンスを3つ生成
$users = User::factory()->count(3)->create();
属性の配列をcreate
メソッドに渡すことで、ファクトリのデフォルトのモデル属性をオーバーライドできます。You may override the factory's default model attributes by passing an array of attributes to the create
method:
$user = User::factory()->create([
'name' => 'Abigail',
]);
連続データSequences
モデルを生成するごとに、特定のモデル属性の値を変更したい場合があります。これは、状態変換を連続データとして定義することで実現できます。たとえば、作成されたユーザーごとに、admin
カラムの値をY
とN
の間で交互に変更したいとしましょう。Sometimes you may wish to alternate the value of a given model attribute for each created model. You may accomplish this by defining a state transformation as a sequence. For example, you may wish to alternate the value of an admin
column between Y
and N
for each created user:
use App\Models\User;
use Illuminate\Database\Eloquent\Factories\Sequence;
$users = User::factory()
->count(10)
->state(new Sequence(
['admin' => 'Y'],
['admin' => 'N'],
))
->create();
この例では、admin
値がY
のユーザーが5人作成され、admin
値がN
のユーザーが5人作成されます。In this example, five users will be created with an admin
value of Y
and five users will be created with an admin
value of N
.
必要に応じて、シーケンス値としてクロージャを含めることができます。新しい値をそのシーケンスが必要とするたびにクロージャを呼び出します。If necessary, you may include a closure as a sequence value. The closure will be invoked each time the sequence needs a new value:
use Illuminate\Database\Eloquent\Factories\Sequence;
$users = User::factory()
->count(10)
->state(new Sequence(
fn (Sequence $sequence) => ['role' => UserRoles::all()->random()],
))
->create();
シーケンスクロージャ内では,クロージャへ注入されるシーケンスインスタンスの$index
または$count
プロパティにアクセスできます。$index
プロパティには、これまでに行われたシーケンスの反復回数が格納され、$count
プロパティには、シーケンスが起動された合計回数が格納されます。Within a sequence closure, you may access the $index
or $count
properties on the sequence instance that is injected into the closure. The $index
property contains the number of iterations through the sequence that have occurred thus far, while the $count
property contains the total number of times the sequence will be invoked:
$users = User::factory()
->count(10)
->sequence(fn (Sequence $sequence) => ['name' => 'Name '.$sequence->index])
->create();
使いやすいように、シーケンスは、sequence
メソッドを使用して適用することもできます。このメソッドは、内部的にstate
メソッドを呼び出すだけです。sequence
メソッドには、クロージャまたはシーケンスの属性を表す配列を指定します。For convenience, sequences may also be applied using the sequence
method, which simply invokes the state
method internally. The sequence
method accepts a closure or arrays of sequenced attributes:
$users = User::factory()
->count(2)
->sequence(
['name' => 'First User'],
['name' => 'Second User'],
)
->create();
リレーションのファクトリFactory Relationships
Has ManyリレーションHas Many Relationships
次に、Laravelの流暢(fluent)なファクトリメソッドを使用して、Eloquentモデルのリレーションを構築する方法を見ていきましょう。まず、アプリケーションにApp\Models\User
モデルとApp\Models\Post
モデルがあると想定します。また、User
モデルがPost
とのhasMany
リレーションを定義していると想定しましょう。 Laravelのファクトリが提供するhas
メソッドを使用して、3つの投稿を持つユーザーを作成できます。has
メソッドはファクトリインスタンスを引数に取ります。Next, let's explore building Eloquent model relationships using Laravel's fluent factory methods. First, let's assume our application has an App\Models\User
model and an App\Models\Post
model. Also, let's assume that the User
model defines a hasMany
relationship with Post
. We can create a user that has three posts using the has
method provided by the Laravel's factories. The has
method accepts a factory instance:
use App\Models\Post;
use App\Models\User;
$user = User::factory()
->has(Post::factory()->count(3))
->create();
規約により、Post
モデルをhas
メソッドに渡す場合、LaravelはUser
モデルにリレーションを定義するposts
メソッドが存在していると想定します。必要に応じ、操作するリレーション名を明示的に指定できます。By convention, when passing a Post
model to the has
method, Laravel will assume that the User
model must have a posts
method that defines the relationship. If necessary, you may explicitly specify the name of the relationship that you would like to manipulate:
$user = User::factory()
->has(Post::factory()->count(3), 'posts')
->create();
もちろん、関連モデルで状態を操作することもできます。さらに、状態変更で親モデルへのアクセスが必要な場合は、クロージャベースの状態変換が渡せます。Of course, you may perform state manipulations on the related models. In addition, you may pass a closure based state transformation if your state change requires access to the parent model:
$user = User::factory()
->has(
Post::factory()
->count(3)
->state(function (array $attributes, User $user) {
return ['user_type' => $user->type];
})
)
->create();
マジックメソッドの使用Using Magic Methods
使いやすいように、Laravelのマジックファクトリリレーションメソッドを使用してリレーションを構築できます。たとえば、以下の例では、規約を使用して、User
モデルのposts
リレーションメソッドを介して作成する必要がある関連モデルを決定します。For convenience, you may use Laravel's magic factory relationship methods to build relationships. For example, the following example will use convention to determine that the related models should be created via a posts
relationship method on the User
model:
$user = User::factory()
->hasPosts(3)
->create();
マジックメソッドを使用してファクトリリレーションを作成する場合、属性の配列を渡して、関連モデルをオーバーライドできます。When using magic methods to create factory relationships, you may pass an array of attributes to override on the related models:
$user = User::factory()
->hasPosts(3, [
'published' => false,
])
->create();
状態の変更で親モデルへのアクセスが必要な場合は、クロージャベースの状態変換を提供できます。You may provide a closure based state transformation if your state change requires access to the parent model:
$user = User::factory()
->hasPosts(3, function (array $attributes, User $user) {
return ['user_type' => $user->type];
})
->create();
Belongs ToリレーションBelongs To Relationships
ファクトリを使用して"has many"リレーションを構築する方法を検討したので、逆の関係を調べてみましょう。for
メソッドを使用して、ファクトリが作成したモデルの属する親モデルを定義できます。たとえば、1人のユーザーに属する3つのApp\Models\Post
モデルインスタンスを作成できます。Now that we have explored how to build "has many" relationships using factories, let's explore the inverse of the relationship. The for
method may be used to define the parent model that factory created models belong to. For example, we can create three App\Models\Post
model instances that belong to a single user:
use App\Models\Post;
use App\Models\User;
$posts = Post::factory()
->count(3)
->for(User::factory()->state([
'name' => 'Jessica Archer',
]))
->create();
作成するモデルに関連付ける必要のある親モデルインスタンスがすでにある場合は、モデルインスタンスをfor
メソッドに渡すことができます。If you already have a parent model instance that should be associated with the models you are creating, you may pass the model instance to the for
method:
$user = User::factory()->create();
$posts = Post::factory()
->count(3)
->for($user)
->create();
マジックメソッドの使用Using Magic Methods
便利なように、Laravelのマジックファクトリリレーションシップメソッドを使用して、"belongs to"リレーションシップを定義できます。たとえば、以下の例では、3つの投稿がPost
モデルのuser
リレーションに属する必要があることを規約を使用して決定しています。For convenience, you may use Laravel's magic factory relationship methods to define "belongs to" relationships. For example, the following example will use convention to determine that the three posts should belong to the user
relationship on the Post
model:
$posts = Post::factory()
->count(3)
->forUser([
'name' => 'Jessica Archer',
])
->create();
Many To ManyリレーションMany to Many Relationships
has manyリレーションと同様に、"many to many"リレーションは、has
メソッドを使用して作成できます。Like has many relationships[#has-many-relationships], "many to many" relationships may be created using the has
method:
use App\Models\Role;
use App\Models\User;
$user = User::factory()
->has(Role::factory()->count(3))
->create();
ピボットテーブルの属性Pivot Table Attributes
モデルをリンクするピボット/中間テーブルへ設定する属性を定義する必要がある場合は、hasAttached
メソッドを使用します。このメソッドは、ピボットテーブルの属性名と値の配列を2番目の引数に取ります。If you need to define attributes that should be set on the pivot / intermediate table linking the models, you may use the hasAttached
method. This method accepts an array of pivot table attribute names and values as its second argument:
use App\Models\Role;
use App\Models\User;
$user = User::factory()
->hasAttached(
Role::factory()->count(3),
['active' => true]
)
->create();
状態変更で関連モデルへのアクセスが必要な場合は、クロージャベースの状態変換を指定できます。You may provide a closure based state transformation if your state change requires access to the related model:
$user = User::factory()
->hasAttached(
Role::factory()
->count(3)
->state(function (array $attributes, User $user) {
return ['name' => $user->name.' Role'];
}),
['active' => true]
)
->create();
作成しているモデルへアタッチしたいモデルインスタンスがすでにある場合は、モデルインスタンスをhasAttached
メソッドへ渡せます。この例では、同じ3つの役割が3人のユーザーすべてに関連付けられます。If you already have model instances that you would like to be attached to the models you are creating, you may pass the model instances to the hasAttached
method. In this example, the same three roles will be attached to all three users:
$roles = Role::factory()->count(3)->create();
$user = User::factory()
->count(3)
->hasAttached($roles, ['active' => true])
->create();
マジックメソッドの使用Using Magic Methods
利便性のため、Laravelのマジックファクトリリレーションメソッドを使用して、多対多のリレーションを定義できます。たとえば、次の例では、関連するモデルをUser
モデルのroles
リレーションメソッドを介して作成する必要があることを規約を使用して決定します。For convenience, you may use Laravel's magic factory relationship methods to define many to many relationships. For example, the following example will use convention to determine that the related models should be created via a roles
relationship method on the User
model:
$user = User::factory()
->hasRoles(1, [
'name' => 'Editor'
])
->create();
ポリモーフィックリレーションPolymorphic Relationships
ポリモーフィックな関係もファクトリを使用して作成できます。ポリモーフィックな"morph many"リレーションは、通常の"has many"リレーションと同じ方法で作成します。たとえば、 App\Models\Post
モデルがApp\Models\Comment
モデルとmorphMany
関係を持っている場合は以下のようになります。Polymorphic relationships[/docs/{{version}}/eloquent-relationships#polymorphic-relationships] may also be created using factories. Polymorphic "morph many" relationships are created in the same way as typical "has many" relationships. For example, if an App\Models\Post
model has a morphMany
relationship with an App\Models\Comment
model:
use App\Models\Post;
$post = Post::factory()->hasComments(3)->create();
Morph ToリレーションMorph To Relationships
マジックメソッドを使用してmorphTo
関係を作成することはできません。代わりに、for
メソッドを直接使用し、関係の名前を明示的に指定する必要があります。たとえば、Comment
モデルにmorphTo
関係を定義する commentable
メソッドがあると想像してください。この状況でfor
メソッドを直接使用し、1つの投稿に属する3つのコメントを作成できます。Magic methods may not be used to create morphTo
relationships. Instead, the for
method must be used directly and the name of the relationship must be explicitly provided. For example, imagine that the Comment
model has a commentable
method that defines a morphTo
relationship. In this situation, we may create three comments that belong to a single post by using the for
method directly:
$comments = Comment::factory()->count(3)->for(
Post::factory(), 'commentable'
)->create();
ポリモーフィック多対多リレーションPolymorphic Many to Many Relationships
ポリモーフィック「多対多」(morphToMany
/ morphedByMany
)リレーションは、ポリモーフィックではない「多対多」リレーションと同じように作成できます。Polymorphic "many to many" (morphToMany
/ morphedByMany
) relationships may be created just like non-polymorphic "many to many" relationships:
use App\Models\Tag;
use App\Models\Video;
$videos = Video::factory()
->hasAttached(
Tag::factory()->count(3),
['public' => true]
)
->create();
もちろん、has
マジックメソッドを使用して、ポリモーフィックな「多対多」リレーションを作成することもできます。Of course, the magic has
method may also be used to create polymorphic "many to many" relationships:
$videos = Video::factory()
->hasTags(3, ['public' => true])
->create();
ファクトリ内でのリレーション定義Defining Relationships Within Factories
モデルファクトリ内でリレーションを定義するには、リレーションの外部キーへ新しいファクトリインスタンスを割り当てます。これは通常、belongsTo
やmorphTo
リレーションなどの「逆」関係で行います。たとえば、投稿を作成時に新しいユーザーを作成する場合は、次のようにします。To define a relationship within your model factory, you will typically assign a new factory instance to the foreign key of the relationship. This is normally done for the "inverse" relationships such as belongsTo
and morphTo
relationships. For example, if you would like to create a new user when creating a post, you may do the following:
use App\Models\User;
/**
* モデルのデフォルト状態の定義
*
* @return array<string, mixed>
*/
public function definition(): array
{
return [
'user_id' => User::factory(),
'title' => fake()->title(),
'content' => fake()->paragraph(),
];
}
リレーションのカラムがそれを定義するファクトリに依存している場合は、属性にクロージャを割り当てることができます。クロージャは、ファクトリの評価済み属性配列を受け取ります。If the relationship's columns depend on the factory that defines it you may assign a closure to an attribute. The closure will receive the factory's evaluated attribute array:
/**
* モデルのデフォルト状態の定義
*
* @return array<string, mixed>
*/
public function definition(): array
{
return [
'user_id' => User::factory(),
'user_type' => function (array $attributes) {
return User::find($attributes['user_id'])->type;
},
'title' => fake()->title(),
'content' => fake()->paragraph(),
];
}
リレーションでの既存モデルの再利用Recycling an Existing Model for Relationships
あるモデルが、他のモデルと共通のリレーションを持っている場合、ファクトリが生成するすべてのリレーションで、モデルの単一インスタンスが再利用されるように、recycle
メソッドを使用してください。If you have models that share a common relationship with another model, you may use the recycle
method to ensure a single instance of the related model is recycled for all of the relationships created by the factory.
例えば、Airline
、Flight
、Ticket
モデルがあり、チケット(Ticket)は航空会社(Airline)とフライト(Flight)に所属し、フライトも航空会社に所属しているとします。チケットを作成する際には、チケットとフライトの両方に同じ航空会社を使いたいでしょうから、recycle
メソッドへ航空会社のインスタンスを渡します。For example, imagine you have Airline
, Flight
, and Ticket
models, where the ticket belongs to an airline and a flight, and the flight also belongs to an airline. When creating tickets, you will probably want the same airline for both the ticket and the flight, so you may pass an airline instance to the recycle
method:
Ticket::factory()
->recycle(Airline::factory()->create())
->create();
共通のユーザーやチームに所属するモデルがある場合、recycle
メソッドが特に便利だと感じるでしょう。You may find the recycle
method particularly useful if you have models belonging to a common user or team.
recycle
メソッドは、既存のモデルのコレクションを受け取ることもできます。コレクションをrecycle
メソッドへ渡すと、ファクトリがそのタイプのモデルを必要とするときに、コレクションからランダムにモデルを選びます。The recycle
method also accepts a collection of existing models. When a collection is provided to the recycle
method, a random model from the collection will be chosen when the factory needs a model of that type:
Ticket::factory()
->recycle($airlines)
->create();