Eloquent ORM

简介

Laravel 自带的 Eloquent ORM 为您的数据库提供了一个优雅的、简单的 ActiveRecord 实现。每一个数据库的表有一个对应的 "Model" 用来与这张表交互。

在开始之前,确认已在 app/config/database.php 文件中配置好数据库连接。

基本用法

首先,创建一个 Eloquent 模型。模型通常在 app/models 目录,但是您可以自由地把它们放在任何地方,只要它能根据您的 composer.json 文件自动加载。

定义一个 Eloquent 模型

class User extends Eloquent {}

注意我们并没有告诉 Eloquent 我们为 User 模型使用了哪一张表。类名的小写、复数的形式将作为表名,除非它被显式地指定。所以,在这种情况下,Eloquent 将假设 User 模型在 users 表中保存记录。您可以在模型中定义一个 table 属性来指定一个自定义的表名:

class User extends Eloquent {

    protected $table = 'my_users';

}

注意: Eloquent 将假设每张表有一个名为 id 的主键。您可以定义 primaryKey 属性来覆盖这个约定。同样,您可以定义一个 connection 属性来覆盖在使用这个模型时所用的数据库连接。

一旦模型被定义,您可以开始在表中检索和创建记录。注意在默认情况下您将需要在表中定义 updated_atcreated_at 字段。如果您不希望这些列被自动维护,在模型中设置 $timestamps 属性为 false

获取所有记录

$users = User::all();

根据主键获取一条记录

$user = User::find(1);

var_dump($user->name);

注意: 所有在 [查询构建器] 中适用的函数在 Eloquent 模型的查询中同样适用。

根据主键获取一条记录或者抛出一个异常

有时您可能希望当记录没有被找到时抛出一个异常,允许您使用 App::error 处理器捕捉这些异常并显示404页面。

$model = User::findOrFail(1);

$model = User::where('votes', '>', 100)->firstOrFail();

注册错误处理器,请监听 ModelNotFoundException

use Illuminate\Database\Eloquent\ModelNotFoundException;

App::error(function(ModelNotFoundException $e)
{
    return Response::make('Not Found', 404);
});

使用 Eloquent 模型查询

$users = User::where('votes', '>', 100)->take(10)->get();

foreach ($users as $user)
{
    var_dump($user->name);
}

当然,您也可以使用查询构建器的统计函数。

Eloquent 统计

$count = User::where('votes', '>', 100)->count();

如果您无法通过通过连贯的接口产生查询,可以使用 whereRaw

$users = User::whereRaw('age > ? and votes = 100', array(25))->get();

指定查询的数据库连接

您可能需要在运行一个 Eloquent 查询的时候指定数据库连接,只需要使用 on 函数:

$user = User::on('connection-name')->find(1);

集体赋值

当创建一个新的模型,您可以传递属性的数组到模型的构造函数。这些属性将通过集体赋值分配给模型。这是很方便的,但把用户的输入盲目地传给模型可能是一个严重的安全问题。如果把用户输入盲目地传递给模型,用户可以自由地修改任何或者全部模型的属性。基于这个原因,默认情况下所有 Eloquent 模型将防止集体赋值。

首先,在模型中设置 fillableguarded 属性。

fillable 属性指定哪些属性可以被集体赋值。这可以在类或接口层设置。

在模型中定义 Fillable 属性

class User extends Eloquent {

    protected $fillable = array('first_name', 'last_name', 'email');

}

在这个例子中,只有三个被列出的属性可以被集体赋值。

fillable 的反义词是 guarded,将做为一个黑名单而不是白名单:

在模型中定义 Guarded 属性

class User extends Eloquent {

    protected $guarded = array('id', 'password');

}

在这个例子中,idpassword 属性将被允许集体赋值。所有其他属性将被允许集体赋值。您可以使用 guard 方法阻止所有属性被集体赋值:

阻止所有属性集体赋值

protected $guarded = array('*');

插入、更新、删除

为了从模型中向数据库中创建一个新的记录,简单地创建一个模型实例并调用 save 函数。

保存一个新的模型

$user = new User;

$user->name = 'John';

$user->save();

注意: 通常您的 Eloquent 模型将有自动递增的键。然而,如果您希望指定您自定义的键,在模型中设置 incrementing 属性为 false

您也可以使用 create 函数在一行代码中保存一个新的模型。被插入的模型实例将从函数中返回。但是,在您这样做之前,您需要在模型中指定 fillable 或者 guarded 属性,因为所有 Eloquent 模型默认阻止集体赋值。

在保存或创建一个使用自增ID的新模型之后,可以通过对象的 id 属性获取此自增ID:

$insertedId = $user->id;

在模型中设置 Guarded 属性

class User extends Eloquent {

    protected $guarded = array('id', 'account_id');

}

使用模型的 Create 函数

$user = User::create(array('name' => 'John'));

为了更新一个模型,您可以检索它,改变一个属性,然后使用 save 函数:

更新一个检索到的模型

$user = User::find(1);

$user->email = 'john@foo.com';

$user->save();

有时您可能希望不仅保存模型,还有它的所有关系。为此,您可以使用 push 函数:

保存一个模型和关系

$user->push();

您也可以在一组模型上运行更新:

$affectedRows = User::where('votes', '>', 100)->update(array('status' => 2));

删除一个模型,在实例中调用 delete 函数:

删除一个存在的模型

$user = User::find(1);

$user->delete();

根据主键删除一个模型

User::destroy(1);

User::destroy(array(1, 2, 3));

User::destroy(1, 2, 3);

当然,您可以在一组模型中运行删除查询:

$affectedRows = User::where('votes', '>', 100)->delete();

如果您希望简单的在一个模型中更新时间戳,可以使用 touch 函数:

只更新模型的时间戳

$user->touch();

软删除

当软删除一个模型,它并没有真的从数据库中删除。相反,一个 deleted_at 时间戳在记录中被设置。为一个模型开启软删除,在模型中指定 softDelete 属性:

class User extends Eloquent {

    protected $softDelete = true;

}

为了在您的表中添加一个 deleted_at 字段,您可以在迁移中使用 softDeletes 函数:

$table->softDeletes();

现在,当您在一个模型中调用 delete 函数,deleted_at 字段将被设置为当前的时间戳。在使用软删除的模型中查询,被软删除的模型将不被包含进查询结果中。为了强制已删除的模型出现在结果集中,在查询中使用 withTrashed 函数:

强制软删除的模型到结果集中

$users = User::withTrashed()->where('account_id', 1)->get();

如果您希望在结果集中包含软删除的模型,您可以使用 onlyTrashed 函数:

$users = User::onlyTrashed()->where('account_id', 1)->get();

恢复一个已被软删除的记录,使用 restore 函数:

$user->restore();

您也可以在查询中使用 restore 函数:

User::withTrashed()->where('account_id', 1)->restore();

restore 函数也可以在关系中被使用:

$user->posts()->restore();

如果您希望从数据库中真正删除一个模型,您可以使用 forceDelete 函数:

$user->forceDelete();

forceDelete 函数也可以在关系中被使用:

$user->posts()->forceDelete();

检测一个给定的模型实例是否被软删除,可以使用 trashed 函数:

if ($user->trashed())
{
    //
}

时间戳

默认情况下,Eloquent 在数据的表中自动地将维护 created_atupdated_at 字段。只需简单的添加这些 timestamp 字段到表中,Eloquent 将为您做剩余的工作。如果您不希望 Eloquent 维护这些字段,在模型中添加以下属性:

禁止自动时间戳

class User extends Eloquent {

    protected $table = 'users';

    public $timestamps = false;

}

如果您希望定制时间戳的格式,可以在模型中重写 getDateFormat 函数:

提供一个定制的时间戳格式

class User extends Eloquent {

    protected function getDateFormat()
    {
        return 'U';
    }

}

查询范围

范围允许您容易在模型中重用查询逻辑。定义一个范围,简单的用 scope 为模型添加前缀:

定义一个查询范围

class User extends Eloquent {

    public function scopePopular($query)
    {
        return $query->where('votes', '>', 100);
    }

    public function scopeWomen($query)
    {
        return $query->whereGender('W');
    }

}

使用一个查询范围

$users = User::popular()->women()->orderBy('created_at')->get();

动态范围

有时您可能希望定义一个接受参数的范围。只需要添加您的参数到您的范围函数:

class User extends Eloquent {

    public function scopeOfType($query, $type)
    {
        return $query->whereType($type);
    }

}

然后在范围函数调用中传递参数:

$users = User::ofType('member')->get();

关系

当然,您的数据库可能是彼此相关的。比如,一篇博客文章可能有许多评论,或者一个订单与下订单的用户相关。Eloquent 使得管理和处理这些关系变得简单。Laravel 提供了四种类型的关系:

一对一

一个一对一关系是一种非常基础的关系。比如,一个 User 模型可以有一个 Phone`。我们可以在 Eloquent 中定义这个关系:

定义一个一对一关系

class User extends Eloquent {

    public function phone()
    {
        return $this->hasOne('Phone');
    }

}

传递给 hasOne 函数的第一个参数是相关模型的名字。一旦这个关系被定义,我们可以使用 Eloquent 的 [动态属性] 获取它:

$phone = User::find(1)->phone;

这条语句所产生的 SQL 语句如下:

select * from users where id = 1

select * from phones where user_id = 1

注意 Eloquent 假设关系的外键基于模型的名字。在这个例子中假设 Phone 模型使用一个 user_id 外键。如果您希望覆盖这个惯例,您可以为传递 hasOne 函数传递第二个参数:

return $this->hasOne('Phone', 'custom_key');

Phone 模型定义逆向关系,我们使用 belongsTo 函数:

定义一个逆向关系

class Phone extends Eloquent {

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

}

在上面的例子中,Eloquent 将在 phones 表中寻找 user_id 字段。如果您想定义一个不同的外键字段,您可以通过 belongsTo 函数的第二个参数传递它:

class Phone extends Eloquent {

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

}

一对多

一个一对多关系的例子是一篇博客文章有许多评论。我们可以像这样定义关系模型:

class Post extends Eloquent {

    public function comments()
    {
        return $this->hasMany('Comment');
    }

}

现在我们可以通过 动态属性 访问文章的评论:

$comments = Post::find(1)->comments;

如果您需要添加进一步的约束检索哪些评论,我们可以调用 comments 函数连接链式条件:

$comments = Post::find(1)->comments()->where('title', '=', 'foo')->first();

再次,如果您想覆盖默认的外键,可以给 hasMany 函数传递第二个参数:

return $this->hasMany('Comment', 'custom_key');

Comment 模型中定义逆向关系,我们使用 belongsTo 函数:

定义逆向关系

class Comment extends Eloquent {

    public function post()
    {
        return $this->belongsTo('Post');
    }

}

多对多

多对多关系更复杂的关系类型。这种关系的一个例子是一个用户和角色,这个角色也可被其他用户共享。比如,许多用户有 "Admin" 的角色。这个关系需要三个表:users, roles 以及 role_userrole_user 表来源于相关的角色名,并且有 user_idrole_id 字段。

我们可以使用 belongsToMany 函数定义一个多对多关系:

class User extends Eloquent {

    public function roles()
    {
        return $this->belongsToMany('Role');
    }

}

现在,我们可以通过 User 模型获取角色:

$roles = User::find(1)->roles;

如果您想使用一个非常规的表名作为关系表,您可以传递它作为第二个参数给 belongsToMany 函数:

return $this->belongsToMany('Role', 'user_roles');

您也可以覆盖相关的键:

return $this->belongsToMany('Role', 'user_roles', 'user_id', 'foo_id');

当然,您也可以定义在 Role 模型中定义逆向关系:

class Role extends Eloquent {

    public function users()
    {
        return $this->belongsToMany('User');
    }

}

多态关系

多态关系允许在一个关联中一个模型属于多于一个的其他模型。比如,您可能有一个 photo 模型属于一个员工模型或者一个订单模型。我们可以定义像这样定义这个关系:

class Photo extends Eloquent {

    public function imageable()
    {
        return $this->morphTo();
    }

}

class Staff extends Eloquent {

    public function photos()
    {
        return $this->morphMany('Photo', 'imageable');
    }

}

class Order extends Eloquent {

    public function photos()
    {
        return $this->morphMany('Photo', 'imageable');
    }

}

现在,我们可以为一个员工或者一个订单获取照片:

获取一个多态关系

$staff = Staff::find(1);

foreach ($staff->photos as $photo)
{
    //
}

然而,"polymorphic" 的真正魔力是当您从 Photo 模型中访问员工或者订单的时候:

获取多态关系的属主

$photo = Photo::find(1);

$imageable = $photo->imageable;

Photo 模型的 imageable 关系将返回一个 Staff 或者 Order 实例,依赖于那种类型的模型拥有这个照片。

帮助理解这是怎样工作的,让我们探讨一个多态关系的数据库结构:

多态关系的数据库结构

staff
    id - integer
    name - string

orders
    id - integer
    price - integer

photos
    id - integer
    path - string
    imageable_id - integer
    imageable_type - string

这里需要注意的键字段是表 photosimageable_idimageable_type 字段。ID 将包含所属员工或订单的 ID,类型将包含所属模型的类名。当访问 imageable 关系的时候将允许 ORM 检测所属模型的类型。

查询关系

当为一个模型获取记录的时候,您可能希望基于一个已存在的关系限制结果集的数目。比如,您希望获取至少有一条评论的文章。为此,您可以使用 has 函数:

查询时检查关系

$posts = Post::has('comments')->get();

您也可以指定一个操作符和数量:

$posts = Post::has('comments', '>=', 3)->get();

动态属性

Eloquent 允许您通过动态属性访问关系。Eloquent 将为您自动加载关系,并且足够聪明到知道是否调用 get (为一对多关系)或者 first (为一对一关系)。然后,它将通过动态属性访问作为关系。比如,使用下面的 Phone 模型:

class Phone extends Eloquent {

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

}

$phone = Phone::find(1);

不需要像这样打印用户的电子邮件:

echo $phone->user()->first()->email;

它可以简化为:

echo $phone->user->email;

注意: 返回多个结果的关系,其本质是返回了 Illuminate\Database\Eloquent\Collection 类的一个实例。

预先加载

预先加载的存在是为了缓解 N + 1 查询问题。比如,考虑一个 Author 相关的 Book 模型。关系定义是这样的:

class Book extends Eloquent {

    public function author()
    {
        return $this->belongsTo('Author');
    }

}

现在,考虑下面的代码:

foreach (Book::all() as $book)
{
    echo $book->author->name;
}

此循环将执行一个查询获取表中的所有书籍,然后另一个查询为每本书获取作者。所以,如果我们有 25 本书,这个循环将允许 26 个查询。

值得庆幸的是,我们可以使用预先加载来减少查询的数量。这个关系应该被预先加载通过 with 函数指定:

foreach (Book::with('author')->get() as $book)
{
    echo $book->author->name;
}

在上面的循环中,只有两个查询被执行:

select * from books

select * from authors where id in (1, 2, 3, 4, 5, ...)

明智的使用预先加载可以大大提高应用程序的性能。

当然,您可以一次性预先加载多个关系:

$books = Book::with('author', 'publisher')->get();

您甚至可以预先加载嵌套关系:

$books = Book::with('author.contacts')->get();

在上面的例子中,author 关系将被预先加载,而且作者的 contacts 关系也将被加载。

预先加载约束

有时您可能希望预先加载一个关系,但也为预先加载指定一个条件。这里是一个例子:

$users = User::with(array('posts' => function($query)
{
    $query->where('title', 'like', '%first%');
}))->get();

在这个例子中,我们预先加载用户的文章,但只限于文章的 title 字段中包含单词 "first" 的文章:

延迟预先加载

从一个已存在的模型中直接预先加载相关的模型也是可能的。这在动态的决定是否加载相关模型或与缓存结合时可能有用。

$books = Book::all();

$books->load('author', 'publisher');

插入相关模型

您会经常需要插入新的相关模型。比如,你可能希望为一篇文章插入一条新的评论。不需要在模型中手动设置 post_id 外键,您可以直接从它的父模型 Post 中插入新的评论:

附加一个相关的模型

$comment = new Comment(array('message' => 'A new comment.'));

$post = Post::find(1);

$comment = $post->comments()->save($comment);

在这个例子中,所插入评论的 post_id 字段将自动设置。

相关模型 (属于)

当更新一个 belongsTo 关系,您可以使用 associate 函数,这个函数将为子模型设置外键:

$account = Account::find(10);

$user->account()->associate($account);

$user->save();

插入相关模型 (多对多)

当处理多对多关系时,您也可以插入相关模型。让我们继续使用我们的 UserRole 模型作为例子。我们能够轻松地使用 attach 函数为一个用户附加新的角色:

附加多对多模型

$user = User::find(1);

$user->roles()->attach(1);

您也可以传递一个属性的数组,存在关系的表中:

$user->roles()->attach(1, array('expires' => $expires));

当然,attach 的反义词是 detach

$user->roles()->detach(1);

您也可以使用 sync 函数附加相关的模型。sync 函数接受一个 IDs 数组。当这个操作完成,只有数组中的 IDs 将会为这个模型存在关系表中:

使用 Sync 附加多对多关系

$user->roles()->sync(array(1, 2, 3));

您也可以用给定的 IDs 关联其他关系表中的值:

同步时添加关系数据

$user->roles()->sync(array(1 => array('expires' => true)));

有时您可能希望创建一个新的相关的模型,并且在一行中附加它。对于此操作,您可以使用 save 函数:

$role = new Role(array('name' => 'Editor'));

User::find(1)->roles()->save($role);

在这个例子中,新的 Role 模型将被保存并附加到用户模型。您也可以传递一个属性的数组加入到在这个操作中所连接的表:

User::find(1)->roles()->save($role, array('expires' => $expires));

触发父模型时间戳

当一个模型 belongsTo 另一个模型,比如一个 Comment 属于一个 Post,当更新子模型时更新父模型的时间戳通常是有用的。比如,当一个 Comment 模型更新,您想自动更新所属 Postupdated_at 时间戳。Eloquent 使之变得容易,只需要在子模型中添加 touches 属性包含关系的名字:

class Comment extends Eloquent {

    protected $touches = array('post');

    public function post()
    {
        return $this->belongsTo('Post');
    }

}

现在,当您更新一个 Comment,所属的 Postupdated_at 字段也将被更新:

$comment = Comment::find(1);

$comment->text = 'Edit to this comment!';

$comment->save();

与数据透视表工作

正如您已经了解到,使用多对多关系需要一个中间表的存在。Eloquent 提供了一些非常有用与这个表交互的方式。比如,让我们假设我们的 User 对象有很多相关的 Role 对象,在访问这个关系时,我们可以在这些模型中访问数据透视表:

$user = User::find(1);

foreach ($user->roles as $role)
{
    echo $role->pivot->created_at;
}

注意每一个我们检索的 Role 模型将自动赋值给一个 pivot 属性。这个属性包含一个代表中间表的模型,并且可以像其他 Eloquent 模型使用。

默认情况下,在 pivot 对象中只有键,如果您的数据透视表包含其他的属性,您必须在定义关系时指定它们:

return $this->belongsToMany('Role')->withPivot('foo', 'bar');

现在,foobar 属性将可以通过 Role 模型的 pivot 对象中访问。

如果您想您的数据透视表有自动维护的 created_atupdated_at 时间戳,在关系定义时使用 withTimestamps 方法:

return $this->belongsToMany('Role')->withTimestamps();

为一个模型在数据透视表中删除所有记录,您可以使用 detach 函数:

在一个数据透视表中删除记录

User::find(1)->roles()->detach();

注意这个操作并不从 roles 删除记录,只从数据透视表中删除。

集合

所有通过 get 方法或一个relationship由Eloquent返回的多结果集都是一个集合对象。这个对象实现了 IteratorAggregate PHP 接口,所以可以像数组一样进行遍历。然而,这个对象也有很多其他的函数来处理结果集。

比如,我们可以使用 contains 检测一个结果集是否包含指定的主键:

检测一个集合是否包含一个键

$roles = User::find(1)->roles;

if ($roles->contains(2))
{
    //
}

集合也可以被转换为一个数组或JSON:

$roles = User::find(1)->roles->toArray();

$roles = User::find(1)->roles->toJson();

如果一个集合被转换为一个字符转,它将以JSON格式返回:

$roles = (string) User::find(1)->roles;

Eloquent 集合也包含一些方法来遍历和过滤所包含的项:

遍历集合

$roles = $user->roles->each(function($role)
{
    //
});

过滤集合

过滤集合时,你所提供的回调函数将被作为 array_filter 的回调函数使用。

$users = $user->filter(function($user)
{
    if($user->isAdmin())
    {
        return $user;
    }
});

注意: 当过滤集合并转化为JSON格式时,应首先调用 values 函数重置数组内所有的键(key)。

对每个集合项应用回调函数

$roles = User::find(1)->roles;

$roles->each(function($role)
{
    //  
});

根据一个值排序集合

$roles = $roles->sortBy(function($role)
{
    return $role->created_at;
});

有时,您可能希望返回一个自定义的集合以及自己添加的函数。您可以通过在 Eloquent 模型中重写 newCollection 函数指定这些:

返回一个自定义集合类型

class User extends Eloquent {

    public function newCollection(array $models = array())
    {
        return new CustomCollection($models);
    }

}

访问器和调整器

Eloquent 为获取和设置模型的属性提供了一种便利的方式。简单的在模型中定义一个 getFooAttribute 函数声明一个访问器。记住,这个函数应该遵循 "camel-casing" 拼写格式,即使您的数据库使用 "snake-case":

定义一个访问器

class User extends Eloquent {

    public function getFirstNameAttribute($value)
    {
        return ucfirst($value);
    }

}

在上面的例子中,first_name 字段有一个访问器。注意属性的值被传递到访问器。

调整器以类似的方式声明:

定义一个调整器

class User extends Eloquent {

    public function setFirstNameAttribute($value)
    {
        $this->attributes['first_name'] = strtolower($value);
    }

}

日期调整器

默认情况下,Eloquent 将转换 created_atupdated_at 以及 deleted_at 字段为 Carbon 的实例,它提供了各种有用的函数,并且继承自原生 PHP 的 DateTime 类。

您可以指定哪些字段自动调整,设置禁用调整,通过在模型中重写 getDates 函数:

public function getDates()
{
    return array('created_at');
}

当一个字段被认为是一个日期,您可以设置它的值为一个 UNIX 时间戳,日期字符串 (Y-m-d),日期时间字符串,当然也可以是一个 DateTimeCarbon 实例。

完全禁用日期调整,从 getDates 函数中返回一个空数组:

public function getDates()
{
    return array();
}

模型事件

Eloquent 模型触发一些事件,允许您使用以下函数在模型的生命周期内的许多地方插入钩子:creatingcreatedupdatingupdatedsavingsaveddeletingdeletedrestoringrestored

每当一个新的项目第一次被保存,creatingcreated 事件将被触发。如果一个项目不是新的并且 save 函数被调用, updating/updated 事件将被触发。在这两种情况下,saving/saved 事件都将被触发。

如果从 creating, updating 或者 saving 返回 false ,该操作将被取消:

通过事件取消保存操作

User::creating(function($user)
{
    if ( ! $user->isValid()) return false;
});

Eloquent 模型也包含一个静态的 boot 函数,它可以提供一个方便的地方注册事件绑定。

设置一个模型 Boot 函数

class User extends Eloquent {

    public static function boot()
    {
        parent::boot();

        // Setup event bindings...
    }

}

模型观察者

为加强处理模型事件,您可以注册一个模型观察者。一个观察者类可以包含很多函数对应于很多模型事件。比如,creating, updating, saving 函数可以在一个观察者中,除其他模型事件名之外。

因此,比如,一个模型观察者可以像这样:

class UserObserver {

    public function saving($model)
    {
        //
    }

    public function saved($model)
    {
        //
    }

}

您可以使用 observe 函数注册一个观察者实例:

User::observe(new UserObserver);

转为数组或JSON

当构建JSON APIs,您可能经常需要转换您的模型和关系为数组或JSON字符串。所以,Eloquent 包含这些方法。转换一个模型和它加载的关系为一个数组,您可以使用 toArray 函数:

转换一个模型为数组

$user = User::with('roles')->first();

return $user->toArray();

注意模型的全部集合也可以被转为数组:

return User::all()->toArray();

转换一个模型为JSON字符串,您可以使用 toJson 函数:

转换一个模型为JSON字符串

return User::find(1)->toJson();

注意当一个模型或集合转换为一个字符串,它将转换为JSON,这意味着您可以直接从应用程序的路由中返回 Eloquent 对象!

从路由中返回一个模型

Route::get('users', function()
{
    return User::all();
});

有时您可能希望限制包含在模型数组或JSON中的属性,比如密码,为此,在模型中添加一个隐藏属性:

从数组或JSON转换中隐藏属性

class User extends Eloquent {

    protected $hidden = array('password');

}

注意: 如果关系被隐藏了,请使用关系的 method 名称,而不是动态的访问名称。

或者,您可以使用 visible 属性定义一个白名单:

protected $visible = array('first_name', 'last_name');

某些时候,你可能需要向数据库添加一组属性,而这组属性并在数据库中没有对应的字段。为了能够实现这一需求,可以简单的为每个属性定义一个访问器:

public function getIsAdminAttribute()
{
    return $this->attributes['admin'] == 'yes';
}

一旦创建了访问器,只需将属性添加到模型的appends属性中:

protected $appends = array('is_admin');

一旦将属性添加到appends列表中,它就将被包含在模型和JSON表单中。