programming

Làm cách nào để tiết kiệm nhiều trong Laravel?

Ồ vâng, bây giờ tôi hiểu rồi. đối với trường hợp đó bây giờ @Ilyes512 đã đúng, bạn cần giao dịch. Vì vậy, khi có sự cố xảy ra, cứu đội trưởng, mọi thứ sẽ tự động được khôi phục

Nhưng một lần nữa, không thể lưu cả hai hồ sơ cùng một lúc vào bất kỳ thời điểm nào, con tàu phải được cứu trước trước thuyền trưởng. Nó có ý nghĩa bởi vì, ngay cả trong cuộc sống thực, một con tàu phải tồn tại trước khi thuyền trưởng xuất hiện trên đó

Vì vậy, một cái gì đó như thế này, là những gì tôi đang nghĩ. Tôi chưa thử nhưng tôi nghĩ nó sẽ hoạt động

$ship = new Ship;
$ship->name = 'Enterprise';
$ship->registry = 'ncc-1701D';

$captain = new Captain;
$captain->name = 'jean Luc Picard';

DB::transaction[function[] use [$ship, $captain] {
   $ship = $ship->save[]; //Ship Exists First
   Ship::find[$ship->id]->captain[]->save[$captain];//Captain is saved to existing ship
}];

Bằng cách này, bạn sẽ được đảm bảo theo cả hai cách trong khi lưu, chẳng hạn như trong đoạn mã trên. -

  • Nếu xảy ra sự cố khi cứu tàu, sẽ không có tàu nào được cứu và do đó sẽ không có thuyền trưởng nào được cứu
  • Nếu xảy ra sự cố khi cứu thuyền trưởng, tàu sẽ được cứu và không có thuyền trưởng nào được cứu

Để có thêm quyền kiểm soát khi sử dụng các giao dịch này, hãy thử {}bắt{} các khối như thế này

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];

Eloquent ORM đi kèm với Laravel cung cấp triển khai ActiveRecord đơn giản, đẹp mắt để làm việc với cơ sở dữ liệu của bạn. Mỗi bảng cơ sở dữ liệu có một "Mô hình" tương ứng được sử dụng để tương tác với bảng đó

Trước khi bắt đầu, hãy đảm bảo định cấu hình kết nối cơ sở dữ liệu trong 

class User extends Eloquent {
    protected $table = 'my_users';
13

Sử dụng cơ bản

Để bắt đầu, hãy tạo một mô hình Eloquent. Các mô hình thường nằm trong thư mục 

class User extends Eloquent {
    protected $table = 'my_users';
14, nhưng bạn có thể tự do đặt chúng ở bất kỳ đâu có thể được tải tự động theo tệp 
class User extends Eloquent {
    protected $table = 'my_users';
15 của bạn

Xác định một mô hình hùng biện

class User extends Eloquent {}

Lưu ý rằng chúng tôi đã không cho Eloquent biết bảng nào sẽ được sử dụng cho mô hình 

class User extends Eloquent {
    protected $table = 'my_users';
16 của chúng tôi. Tên viết thường, số nhiều của lớp sẽ được sử dụng làm tên bảng trừ khi một tên khác được chỉ định rõ ràng. Vì vậy, trong trường hợp này, Eloquent sẽ giả sử mô hình 
class User extends Eloquent {
    protected $table = 'my_users';
16 lưu trữ các bản ghi trong bảng 
class User extends Eloquent {
    protected $table = 'my_users';
18. Bạn có thể chỉ định một bảng tùy chỉnh bằng cách xác định thuộc tính 
class User extends Eloquent {
    protected $table = 'my_users';
19 trên mô hình của mình

class User extends Eloquent {
    protected $table = 'my_users';

Ghi chú. Eloquent cũng sẽ giả định rằng mỗi bảng có một cột khóa chính tên là 

class User extends Eloquent {
    protected $table = 'my_users';
20. Bạn có thể xác định thuộc tính 
class User extends Eloquent {
    protected $table = 'my_users';
21 để ghi đè quy ước này. Tương tự, bạn có thể xác định thuộc tính 
class User extends Eloquent {
    protected $table = 'my_users';
22 để ghi đè tên của kết nối cơ sở dữ liệu sẽ được sử dụng khi sử dụng mô hình

Khi một mô hình được xác định, bạn đã sẵn sàng bắt đầu truy xuất và tạo các bản ghi trong bảng của mình. Lưu ý rằng bạn sẽ cần đặt các cột 

class User extends Eloquent {
    protected $table = 'my_users';
23 và 
class User extends Eloquent {
    protected $table = 'my_users';
24 trên bảng của mình theo mặc định. Nếu bạn không muốn các cột này được duy trì tự động, hãy đặt thuộc tính 
class User extends Eloquent {
    protected $table = 'my_users';
25 trên mô hình của bạn thành 
class User extends Eloquent {
    protected $table = 'my_users';
26

Lấy tất cả các mô hình

Truy xuất bản ghi bằng khóa chính

Ghi chú. Tất cả các phương thức có sẵn trên trình tạo truy vấn cũng có sẵn khi truy vấn các mô hình Eloquent

Truy xuất một mô hình bằng khóa chính hoặc ném một ngoại lệ

Đôi khi, bạn có thể muốn đưa ra một ngoại lệ nếu không tìm thấy mô hình, cho phép bạn bắt các ngoại lệ bằng cách sử dụng trình xử lý 

class User extends Eloquent {
    protected $table = 'my_users';
27 và hiển thị trang 404

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
9

Để đăng ký trình xử lý lỗi, hãy lắng nghe 

class User extends Eloquent {
    protected $table = 'my_users';
28

class User extends Eloquent {
    protected $table = 'my_users';
1

Truy vấn bằng Eloquent Models

class User extends Eloquent {
    protected $table = 'my_users';
2

uẩn hùng hồn

Tất nhiên, bạn cũng có thể sử dụng các hàm tổng hợp của trình tạo truy vấn

class User extends Eloquent {
    protected $table = 'my_users';
3

Nếu bạn không thể tạo truy vấn mình cần thông qua giao diện trôi chảy, vui lòng sử dụng 

class User extends Eloquent {
    protected $table = 'my_users';
29

class User extends Eloquent {
    protected $table = 'my_users';
5

Kết quả Chunking

Nếu bạn cần xử lý nhiều [hàng nghìn] bản ghi Eloquent, sử dụng lệnh 

class User extends Eloquent {
    protected $table = 'my_users';
30 sẽ cho phép bạn thực hiện mà không ngốn hết RAM

class User extends Eloquent {
    protected $table = 'my_users';
7

Đối số đầu tiên được truyền cho phương thức là số lượng bản ghi bạn muốn nhận trên mỗi "khối". Đóng được chuyển thành đối số thứ hai sẽ được gọi cho mỗi đoạn được lấy từ cơ sở dữ liệu

Chỉ định kết nối truy vấn

Bạn cũng có thể chỉ định kết nối cơ sở dữ liệu nào sẽ được sử dụng khi chạy truy vấn Eloquent. Đơn giản chỉ cần sử dụng phương pháp 

class User extends Eloquent {
    protected $table = 'my_users';
31

class User extends Eloquent {
    protected $table = 'my_users';
9

chuyển nhượng hàng loạt

Khi tạo một mô hình mới, bạn chuyển một mảng các thuộc tính cho hàm tạo mô hình. Các thuộc tính này sau đó được gán cho mô hình thông qua gán hàng loạt. Điều này là thuận tiện; . Nếu đầu vào của người dùng được đưa vào một mô hình một cách mù quáng, thì người dùng có thể tự do sửa đổi bất kỳ và tất cả các thuộc tính của mô hình. Vì lý do này, tất cả các mẫu Eloquent đều mặc định bảo vệ chống lại việc gán hàng loạt

Để bắt đầu, hãy đặt thuộc tính 

class User extends Eloquent {
    protected $table = 'my_users';
32 hoặc 
class User extends Eloquent {
    protected $table = 'my_users';
33 trên mô hình của bạn

Xác định các thuộc tính có thể điền vào một mô hình

Thuộc tính 

class User extends Eloquent {
    protected $table = 'my_users';
32 chỉ định thuộc tính nào có thể gán hàng loạt. Điều này có thể được đặt ở cấp lớp hoặc cấp độ cá thể

class User extends Eloquent {
    protected $table = 'my_users';
3

Trong ví dụ này, chỉ có ba thuộc tính được liệt kê là có thể gán hàng loạt

Xác định các thuộc tính được bảo vệ trên một mô hình

Nghịch đảo của 

class User extends Eloquent {
    protected $table = 'my_users';
32 là 
class User extends Eloquent {
    protected $table = 'my_users';
33 và đóng vai trò là "danh sách đen" thay vì "danh sách trắng"

class User extends Eloquent {
    protected $table = 'my_users';
0

Ghi chú. Khi sử dụng 

class User extends Eloquent {
    protected $table = 'my_users';
33, bạn vẫn không bao giờ được chuyển 
class User extends Eloquent {
    protected $table = 'my_users';
38 hoặc bất kỳ mảng thô nào của đầu vào do người dùng kiểm soát vào phương thức 
class User extends Eloquent {
    protected $table = 'my_users';
39 hoặc 
class User extends Eloquent {
    protected $table = 'my_users';
40, vì bất kỳ cột nào không được bảo vệ đều có thể được cập nhật

Chặn tất cả các thuộc tính từ chuyển nhượng hàng loạt

Trong ví dụ trên, các thuộc tính 

class User extends Eloquent {
    protected $table = 'my_users';
20 và 
class User extends Eloquent {
    protected $table = 'my_users';
42 có thể không được gán hàng loạt. Tất cả các thuộc tính khác sẽ được gán hàng loạt. Bạn cũng có thể chặn tất cả các thuộc tính khỏi gán hàng loạt bằng cách sử dụng thuộc tính bảo vệ

class User extends Eloquent {
    protected $table = 'my_users';
1

Chèn, cập nhật, xóa

Để tạo một bản ghi mới trong cơ sở dữ liệu từ một mô hình, chỉ cần tạo một phiên bản mô hình mới và gọi phương thức 

class User extends Eloquent {
    protected $table = 'my_users';
39

Lưu một mô hình mới

Ghi chú. Thông thường, các mẫu Eloquent của bạn sẽ có các phím tăng tự động. Tuy nhiên, nếu bạn muốn chỉ định khóa của riêng mình, hãy đặt thuộc tính 

class User extends Eloquent {
    protected $table = 'my_users';
44 trên mô hình của bạn thành 
class User extends Eloquent {
    protected $table = 'my_users';
26

Bạn cũng có thể sử dụng phương pháp 

class User extends Eloquent {
    protected $table = 'my_users';
46 để lưu mô hình mới trong một dòng. Phiên bản mô hình được chèn sẽ được trả về cho bạn từ phương thức. Tuy nhiên, trước khi làm như vậy, bạn cần chỉ định thuộc tính 
class User extends Eloquent {
    protected $table = 'my_users';
32 hoặc 
class User extends Eloquent {
    protected $table = 'my_users';
33 trên mô hình, vì tất cả các mô hình Eloquent đều bảo vệ chống lại việc gán hàng loạt

Sau khi lưu hoặc tạo một mô hình mới sử dụng ID tăng tự động, bạn có thể truy xuất ID bằng cách truy cập thuộc tính 

class User extends Eloquent {
    protected $table = 'my_users';
20 của đối tượng

Đặt các thuộc tính được bảo vệ trên mô hình

class User extends Eloquent {
    protected $table = 'my_users';
2

Sử dụng phương pháp tạo mô hình

class User extends Eloquent {
    protected $table = 'my_users';
3

Cập nhật mô hình đã truy xuất

Để cập nhật một mô hình, bạn có thể truy xuất nó, thay đổi một thuộc tính và sử dụng phương thức 

class User extends Eloquent {
    protected $table = 'my_users';
39

Lưu một mô hình và các mối quan hệ

Đôi khi bạn có thể muốn lưu không chỉ một mô hình mà còn tất cả các mối quan hệ của nó. Để làm như vậy, bạn có thể sử dụng phương pháp 

class User extends Eloquent {
    protected $table = 'my_users';
51

Bạn cũng có thể chạy các bản cập nhật dưới dạng truy vấn đối với một tập hợp các mô hình

class User extends Eloquent {
    protected $table = 'my_users';
4

Ghi chú. Không có sự kiện mô hình nào được kích hoạt khi cập nhật một tập hợp các mô hình thông qua trình tạo truy vấn Eloquent

Xóa một mô hình hiện có

Để xóa một mô hình, chỉ cần gọi phương thức 

class User extends Eloquent {
    protected $table = 'my_users';
52 trên ví dụ

Xóa một mô hình hiện có bằng khóa

class User extends Eloquent {
    protected $table = 'my_users';
5

Tất nhiên, bạn cũng có thể chạy truy vấn xóa trên một tập hợp các mô hình

class User extends Eloquent {
    protected $table = 'my_users';
6

Chỉ cập nhật Dấu thời gian của Người mẫu

Nếu bạn chỉ muốn cập nhật dấu thời gian trên một mô hình, bạn có thể sử dụng phương pháp 

class User extends Eloquent {
    protected $table = 'my_users';
53

Xóa mềm

Khi xóa mềm một mô hình, nó không thực sự bị xóa khỏi cơ sở dữ liệu của bạn. Thay vào đó, dấu thời gian 

class User extends Eloquent {
    protected $table = 'my_users';
54 được đặt trên bản ghi. Để kích hoạt xóa mềm cho một mô hình, hãy áp dụng 
class User extends Eloquent {
    protected $table = 'my_users';
55 cho mô hình

class User extends Eloquent {
    protected $table = 'my_users';
7

Để thêm cột 

class User extends Eloquent {
    protected $table = 'my_users';
54 vào bảng của bạn, bạn có thể sử dụng phương pháp 
class User extends Eloquent {
    protected $table = 'my_users';
57 từ quá trình di chuyển

Bây giờ, khi bạn gọi phương thức 

class User extends Eloquent {
    protected $table = 'my_users';
52 trên mô hình, cột 
class User extends Eloquent {
    protected $table = 'my_users';
54 sẽ được đặt thành dấu thời gian hiện tại. Khi truy vấn một mô hình sử dụng xóa mềm, các mô hình "đã xóa" sẽ không được đưa vào kết quả truy vấn

Buộc các mô hình đã xóa mềm vào kết quả

Để buộc các mô hình đã xóa mềm xuất hiện trong tập hợp kết quả, hãy sử dụng phương pháp 

class User extends Eloquent {

  


    protected $table = 'my_users';
60 trên truy vấn

class User extends Eloquent {
    protected $table = 'my_users';
8

Phương pháp 

class User extends Eloquent {
    protected $table = 'my_users';
60 có thể được sử dụng trên một mối quan hệ xác định

class User extends Eloquent {
    protected $table = 'my_users';
9

Nếu bạn chỉ muốn nhận các mô hình đã xóa mềm trong kết quả của mình, bạn có thể sử dụng phương pháp 

class User extends Eloquent {
    protected $table = 'my_users';
62

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
90

Để khôi phục mô hình đã xóa mềm về trạng thái hoạt động, hãy sử dụng phương pháp 

class User extends Eloquent {
    protected $table = 'my_users';
63

Bạn cũng có thể sử dụng phương pháp 

class User extends Eloquent {
    protected $table = 'my_users';
63 trên một truy vấn

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
91

Giống như với 

class User extends Eloquent {
    protected $table = 'my_users';
60, phương pháp 
class User extends Eloquent {
    protected $table = 'my_users';
63 cũng có thể được sử dụng trên các mối quan hệ

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
92

Nếu bạn thực sự muốn xóa một mô hình khỏi cơ sở dữ liệu, bạn có thể sử dụng phương pháp 

class User extends Eloquent {
    protected $table = 'my_users';
67

Phương pháp 

class User extends Eloquent {
    protected $table = 'my_users';
67 cũng hoạt động trên các mối quan hệ

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
93

Để xác định xem một phiên bản mô hình nhất định đã bị xóa mềm hay chưa, bạn có thể sử dụng phương pháp 

class User extends Eloquent {
    protected $table = 'my_users';
69

Dấu thời gian

Theo mặc định, Eloquent sẽ tự động duy trì các cột 

class User extends Eloquent {
    protected $table = 'my_users';
24 và 
class User extends Eloquent {
    protected $table = 'my_users';
23 trên bảng cơ sở dữ liệu của bạn. Chỉ cần thêm các cột 
class User extends Eloquent {
    protected $table = 'my_users';
72 này vào bảng của bạn và Eloquent sẽ lo phần còn lại. Nếu bạn không muốn Eloquent duy trì các cột này, hãy thêm thuộc tính sau vào mô hình của bạn

Vô hiệu hóa dấu thời gian tự động

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
94

Cung cấp định dạng dấu thời gian tùy chỉnh

Nếu bạn muốn tùy chỉnh định dạng dấu thời gian của mình, bạn có thể ghi đè phương thức 

class User extends Eloquent {
    protected $table = 'my_users';
73 trong mô hình của mình

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
95

Phạm vi truy vấn

Xác định phạm vi truy vấn

Phạm vi cho phép bạn dễ dàng sử dụng lại logic truy vấn trong các mô hình của mình. Để xác định phạm vi, chỉ cần thêm tiền tố vào một phương thức mô hình bằng 

class User extends Eloquent {
    protected $table = 'my_users';
74

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
96

Sử dụng phạm vi truy vấn

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
97

Phạm vi động

Đôi khi bạn có thể muốn xác định một phạm vi chấp nhận các tham số. Chỉ cần thêm các tham số của bạn vào chức năng phạm vi của bạn

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
98

Sau đó truyền tham số vào cuộc gọi phạm vi

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
99

Phạm vi toàn cầu

Đôi khi bạn có thể muốn xác định phạm vi áp dụng cho tất cả các truy vấn được thực hiện trên một mô hình. Về bản chất, đây là cách hoạt động của tính năng "xóa mềm" của Eloquent. Phạm vi toàn cầu được xác định bằng cách sử dụng kết hợp các đặc điểm PHP và triển khai 

class User extends Eloquent {
    protected $table = 'my_users';
75

Đầu tiên, hãy xác định một đặc điểm. Đối với ví dụ này, chúng tôi sẽ sử dụng 

class User extends Eloquent {
    protected $table = 'my_users';
55 đi kèm với Laravel

class User extends Eloquent {
    protected $table = 'my_users';
10

Nếu một mô hình Eloquent sử dụng một đặc điểm có phương thức phù hợp với quy ước đặt tên 

class User extends Eloquent {
    protected $table = 'my_users';
77, thì phương thức đặc điểm đó sẽ được gọi khi mô hình Eloquent được khởi động, giúp bạn có cơ hội đăng ký phạm vi toàn cầu hoặc thực hiện bất kỳ điều gì khác mà bạn muốn. Phạm vi phải triển khai 
class User extends Eloquent {
    protected $table = 'my_users';
78, chỉ định hai phương thức. 
class User extends Eloquent {
    protected $table = 'my_users';
79 và 
class User extends Eloquent {
    protected $table = 'my_users';
80

Phương thức 

class User extends Eloquent {
    protected $table = 'my_users';
79 nhận một đối tượng xây dựng truy vấn 
class User extends Eloquent {
    protected $table = 'my_users';
82 và chịu trách nhiệm thêm bất kỳ mệnh đề 
class User extends Eloquent {
    protected $table = 'my_users';
83 bổ sung nào mà phạm vi muốn thêm vào. Phương thức 
class User extends Eloquent {
    protected $table = 'my_users';
80 cũng nhận một đối tượng 
class User extends Eloquent {
    protected $table = 'my_users';
85 và chịu trách nhiệm đảo ngược hành động được thực hiện bởi 
class User extends Eloquent {
    protected $table = 'my_users';
79. Nói cách khác, 
class User extends Eloquent {
    protected $table = 'my_users';
80 nên xóa mệnh đề 
class User extends Eloquent {
    protected $table = 'my_users';
83 [hoặc bất kỳ mệnh đề nào khác] đã được thêm vào. Vì vậy, đối với 
class User extends Eloquent {
    protected $table = 'my_users';
89 của chúng tôi, các phương thức trông giống như thế này

class User extends Eloquent {
    protected $table = 'my_users';
11

Các mối quan hệ

Tất nhiên, các bảng cơ sở dữ liệu của bạn có thể liên quan đến nhau. Ví dụ: một bài đăng trên blog có thể có nhiều bình luận hoặc một đơn đặt hàng có thể liên quan đến người dùng đã đặt nó. Eloquent giúp việc quản lý và làm việc với các mối quan hệ này trở nên dễ dàng. Laravel hỗ trợ nhiều loại quan hệ

Một Đối Một

Xác định mối quan hệ một đối một

Mối quan hệ một đối một là một mối quan hệ rất cơ bản. Ví dụ, một mô hình 

class User extends Eloquent {
    protected $table = 'my_users';
16 có thể có một 
class User extends Eloquent {
    protected $table = 'my_users';
91. Chúng ta có thể định nghĩa mối quan hệ này trong Eloquent

class User extends Eloquent {
    protected $table = 'my_users';
12

Đối số đầu tiên được truyền cho phương thức 

class User extends Eloquent {
    protected $table = 'my_users';
92 là tên của mô hình liên quan. Khi mối quan hệ được xác định, chúng tôi có thể truy xuất nó bằng các thuộc tính động của Eloquent

class User extends Eloquent {
    protected $table = 'my_users';
13

SQL được thực hiện bởi câu lệnh này sẽ như sau

class User extends Eloquent {
    protected $table = 'my_users';
14

Lưu ý rằng Eloquent giả định khóa ngoại của mối quan hệ dựa trên tên mô hình. Trong trường hợp này, mô hình 

class User extends Eloquent {
    protected $table = 'my_users';
91 được giả sử sử dụng khóa ngoại 
class User extends Eloquent {
    protected $table = 'my_users';
94. Nếu bạn muốn ghi đè quy ước này, bạn có thể chuyển đối số thứ hai cho phương thức 
class User extends Eloquent {
    protected $table = 'my_users';
92. Hơn nữa, bạn có thể chuyển đối số thứ ba cho phương thức để chỉ định cột cục bộ nào sẽ được sử dụng cho liên kết

class User extends Eloquent {
    protected $table = 'my_users';
15

Xác định nghịch đảo của một mối quan hệ

Để xác định nghịch đảo của mối quan hệ trên mô hình 

class User extends Eloquent {
    protected $table = 'my_users';
91, chúng tôi sử dụng phương pháp 
class User extends Eloquent {
    protected $table = 'my_users';
97

class User extends Eloquent {
    protected $table = 'my_users';
16

Trong ví dụ trên, Eloquent sẽ tìm cột 

class User extends Eloquent {
    protected $table = 'my_users';
94 trên bảng 
class User extends Eloquent {
    protected $table = 'my_users';
99. Nếu bạn muốn xác định một cột khóa ngoại khác, bạn có thể chuyển nó làm đối số thứ hai cho phương thức 
class User extends Eloquent {
    protected $table = 'my_users';
97

class User extends Eloquent {
    protected $table = 'my_users';
17

Ngoài ra, bạn chuyển tham số thứ ba chỉ định tên của cột được liên kết trên bảng cha

class User extends Eloquent {
    protected $table = 'my_users';
18

một đến nhiều

Một ví dụ về mối quan hệ một-nhiều là một bài đăng trên blog "có nhiều" nhận xét. Chúng ta có thể mô hình hóa mối quan hệ này như vậy

class User extends Eloquent {
    protected $table = 'my_users';
19

Bây giờ chúng ta có thể truy cập các bình luận của bài đăng thông qua thuộc tính động

class User extends Eloquent {
    protected $table = 'my_users';
20

Nếu bạn cần thêm các ràng buộc khác để lấy nhận xét, bạn có thể gọi phương thức 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
901 và tiếp tục xâu chuỗi các điều kiện

class User extends Eloquent {
    protected $table = 'my_users';
21

Một lần nữa, bạn có thể ghi đè khóa ngoại thông thường bằng cách chuyển đối số thứ hai cho phương thức 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
902. Và, giống như quan hệ 
class User extends Eloquent {
    protected $table = 'my_users';
92, cột cục bộ cũng có thể được chỉ định

class User extends Eloquent {
    protected $table = 'my_users';
22

Xác định nghịch đảo của một mối quan hệ

Để xác định nghịch đảo của mối quan hệ trên mô hình 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
904, chúng tôi sử dụng phương pháp 
class User extends Eloquent {
    protected $table = 'my_users';
97

class User extends Eloquent {
    protected $table = 'my_users';
23

Nhiều nhiều

Quan hệ nhiều-nhiều là loại quan hệ phức tạp hơn. Một ví dụ về mối quan hệ như vậy là một người dùng có nhiều vai trò, trong đó các vai trò này cũng được chia sẻ bởi những người dùng khác. Ví dụ: nhiều người dùng có thể có vai trò "Quản trị viên". Ba bảng cơ sở dữ liệu là cần thiết cho mối quan hệ này. 

class User extends Eloquent {
    protected $table = 'my_users';
18, 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
907 và 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
908. Bảng 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
908 được lấy từ thứ tự bảng chữ cái của các tên kiểu máy có liên quan và phải có các cột 
class User extends Eloquent {
    protected $table = 'my_users';
94 và 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
911

Chúng ta có thể định nghĩa mối quan hệ nhiều-nhiều bằng cách sử dụng phương pháp 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
912

class User extends Eloquent {
    protected $table = 'my_users';
24

Bây giờ, chúng ta có thể truy xuất các vai trò thông qua mô hình 

class User extends Eloquent {
    protected $table = 'my_users';
16

class User extends Eloquent {
    protected $table = 'my_users';
25

Nếu bạn muốn sử dụng tên bảng độc đáo cho bảng tổng hợp của mình, bạn có thể chuyển nó làm đối số thứ hai cho phương thức 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
912

class User extends Eloquent {
    protected $table = 'my_users';
26

Bạn cũng có thể ghi đè các phím liên quan thông thường

class User extends Eloquent {
    protected $table = 'my_users';
27

Tất nhiên, bạn cũng có thể xác định nghịch đảo của mối quan hệ trên mô hình 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
915

class User extends Eloquent {
    protected $table = 'my_users';
28

Có Nhiều Thông Qua

Mối quan hệ "có nhiều thông qua" cung cấp một lối tắt thuận tiện để truy cập các mối quan hệ ở xa thông qua một mối quan hệ trung gian. Ví dụ: mô hình 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
916 có thể có nhiều mô hình 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
917 đến mô hình 
class User extends Eloquent {
    protected $table = 'my_users';
16. Các bảng cho mối quan hệ này sẽ trông như thế này

Mặc dù bảng 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
919 không chứa cột 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
920 nhưng quan hệ 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
921 sẽ cho phép chúng ta truy cập các bài đăng của một quốc gia thông qua 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
922. Hãy xác định mối quan hệ

class User extends Eloquent {
    protected $table = 'my_users';
29

Nếu bạn muốn chỉ định thủ công các khóa của mối quan hệ, bạn có thể chuyển chúng làm đối số thứ ba và thứ tư cho phương thức

class User extends Eloquent {
    protected $table = 'my_users';
30

quan hệ đa hình

Mối quan hệ đa hình cho phép một mô hình thuộc về nhiều mô hình khác, trên một liên kết duy nhất. Ví dụ: bạn có thể có một mẫu ảnh thuộc mẫu nhân viên hoặc mẫu đơn hàng. Chúng tôi sẽ xác định mối quan hệ này như vậy

class User extends Eloquent {
    protected $table = 'my_users';
31

Truy xuất một quan hệ đa hình

Bây giờ, chúng tôi có thể truy xuất ảnh cho nhân viên hoặc đơn hàng

class User extends Eloquent {
    protected $table = 'my_users';
32

Truy xuất chủ sở hữu của một quan hệ đa hình

Tuy nhiên, phép thuật "đa hình" thực sự là khi bạn truy cập nhân viên hoặc đơn đặt hàng từ mẫu 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
923

class User extends Eloquent {
    protected $table = 'my_users';
33

Mối quan hệ 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
924 trên mô hình 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
923 sẽ trả về một thực thể 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
926 hoặc 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
927, tùy thuộc vào loại mô hình nào sở hữu ảnh

Cấu trúc bảng quan hệ đa hình

Để giúp hiểu cách thức hoạt động của điều này, hãy khám phá cấu trúc cơ sở dữ liệu cho mối quan hệ đa hình

Các trường chính cần chú ý ở đây là ________ 1928 và ________ 1929 trên bảng ________ 1930. Trong ví dụ này, ID sẽ chứa giá trị ID của nhân viên sở hữu hoặc đơn đặt hàng, trong khi loại sẽ chứa tên lớp của mô hình sở hữu. Đây là điều cho phép ORM xác định loại mô hình sở hữu nào sẽ trả về khi truy cập vào mối quan hệ 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
924

Nhiều đến nhiều quan hệ đa hình

Cấu trúc bảng quan hệ nhiều hình đa hình

Ngoài quan hệ đa hình truyền thống, bạn cũng có thể chỉ định quan hệ đa hình nhiều-nhiều. Ví dụ: mô hình blog 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
917 và 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
933 có thể chia sẻ mối quan hệ đa hình với mô hình 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
934. Đầu tiên, hãy kiểm tra cấu trúc bảng

Tiếp theo, chúng tôi đã sẵn sàng để thiết lập các mối quan hệ trên mô hình. Cả mô hình 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
917 và 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
933 sẽ có mối quan hệ 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
937 thông qua phương pháp 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
938

class User extends Eloquent {
    protected $table = 'my_users';
34

Mô hình 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
934 có thể định nghĩa một phương thức cho từng mối quan hệ của nó

class User extends Eloquent {
    protected $table = 'my_users';
35

Quan hệ truy vấn

Truy vấn quan hệ khi chọn

Khi truy cập các bản ghi cho một mô hình, bạn có thể muốn giới hạn kết quả của mình dựa trên sự tồn tại của một mối quan hệ. Ví dụ: bạn muốn lấy tất cả các bài đăng trên blog có ít nhất một bình luận. Để làm như vậy, bạn có thể sử dụng phương pháp 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
940

class User extends Eloquent {
    protected $table = 'my_users';
36

Bạn cũng có thể chỉ định toán tử và số đếm

class User extends Eloquent {
    protected $table = 'my_users';
37

Nếu bạn cần thêm sức mạnh, bạn có thể sử dụng các phương pháp 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
941 và 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
942 để đặt điều kiện "ở đâu" cho các truy vấn 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
940 của mình

class User extends Eloquent {
    protected $table = 'my_users';
38

Thuộc tính động

Eloquent cho phép bạn truy cập các mối quan hệ của mình thông qua các thuộc tính động. Eloquent sẽ tự động tải mối quan hệ cho bạn và thậm chí đủ thông minh để biết nên gọi phương thức 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
944 [đối với mối quan hệ một-nhiều] hay 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
945 [đối với mối quan hệ một-đối-một]. Sau đó, nó sẽ có thể truy cập được thông qua một thuộc tính động có cùng tên với quan hệ. Ví dụ với mẫu xe sau 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
946

class User extends Eloquent {
    protected $table = 'my_users';
16

Thay vì lặp lại email của người dùng như thế này

class User extends Eloquent {
    protected $table = 'my_users';
50

Nó có thể được rút ngắn thành đơn giản

Ghi chú. Mối quan hệ trả về nhiều kết quả sẽ trả về một thể hiện của lớp 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
947

háo hức tải

Tải háo hức tồn tại để giảm bớt vấn đề truy vấn N + 1. Ví dụ: xem xét mô hình 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
948 có liên quan đến 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
949. Mối quan hệ được định nghĩa như vậy

class User extends Eloquent {
    protected $table = 'my_users';
51

Bây giờ, hãy xem xét đoạn mã sau

class User extends Eloquent {
    protected $table = 'my_users';
52

Vòng lặp này sẽ thực hiện 1 truy vấn để truy xuất tất cả sách trên bảng, sau đó thực hiện một truy vấn khác cho từng cuốn sách để truy xuất tác giả. Vì vậy, nếu chúng ta có 25 cuốn sách, vòng lặp này sẽ chạy 26 truy vấn

Rất may, chúng tôi có thể sử dụng tải háo hức để giảm đáng kể số lượng truy vấn. Các mối quan hệ nên được tải háo hức có thể được chỉ định thông qua phương pháp 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
950

class User extends Eloquent {
    protected $table = 'my_users';
53

Trong vòng lặp trên, chỉ có hai truy vấn sẽ được thực hiện

class User extends Eloquent {
    protected $table = 'my_users';
54

Sử dụng khôn ngoan tải háo hức có thể tăng đáng kể hiệu suất của ứng dụng của bạn

Tất nhiên, bạn có thể háo hức tải nhiều mối quan hệ cùng một lúc

class User extends Eloquent {
    protected $table = 'my_users';
55

Bạn thậm chí có thể háo hức tải các mối quan hệ lồng nhau

class User extends Eloquent {
    protected $table = 'my_users';
56

Trong ví dụ trên, mối quan hệ 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
951 sẽ được tải háo hức và mối quan hệ 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
952 của tác giả cũng sẽ được tải

Ràng buộc tải háo hức

Đôi khi bạn có thể mong muốn tải một mối quan hệ, nhưng cũng chỉ định một điều kiện cho tải háo hức. Đây là một ví dụ

class User extends Eloquent {
    protected $table = 'my_users';
57

Trong ví dụ này, chúng tôi muốn tải các bài đăng của người dùng, nhưng chỉ khi cột tiêu đề của bài đăng chứa từ "đầu tiên"

Tất nhiên, đóng cửa tải háo hức không bị giới hạn ở "các ràng buộc". Bạn cũng có thể áp dụng các đơn đặt hàng

class User extends Eloquent {
    protected $table = 'my_users';
58

Háo hức tải lười biếng

Cũng có thể háo hức tải các mô hình liên quan trực tiếp từ bộ sưu tập mô hình đã có sẵn. Điều này có thể hữu ích khi quyết định động có tải các mô hình liên quan hay không hoặc kết hợp với bộ nhớ đệm

class User extends Eloquent {
    protected $table = 'my_users';
59

Chèn các mô hình liên quan

Đính kèm một mô hình liên quan

Bạn sẽ thường xuyên cần chèn các mô hình liên quan mới. Ví dụ: bạn có thể muốn chèn nhận xét mới cho bài đăng. Thay vì đặt khóa ngoại 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
953 trên mô hình theo cách thủ công, bạn có thể chèn trực tiếp nhận xét mới từ mô hình 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
917 gốc của nó

class User extends Eloquent {
    protected $table = 'my_users';
70

Trong ví dụ này, trường 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
953 sẽ tự động được đặt trên nhận xét được chèn

Nếu bạn cần lưu nhiều mô hình liên quan

class User extends Eloquent {
    protected $table = 'my_users';
71

Liên Kết Người Mẫu [Thuộc Về]

Khi cập nhật mối quan hệ 

class User extends Eloquent {
    protected $table = 'my_users';
97, bạn có thể sử dụng phương pháp 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
957. Phương pháp này sẽ đặt khóa ngoại trên mô hình con

class User extends Eloquent {
    protected $table = 'my_users';
72

Chèn các mô hình liên quan [Nhiều đến Nhiều]

Bạn cũng có thể chèn các mô hình liên quan khi làm việc với quan hệ nhiều-nhiều. Hãy tiếp tục sử dụng các mô hình 

class User extends Eloquent {
    protected $table = 'my_users';
16 và 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
915 của chúng tôi làm ví dụ. Chúng tôi có thể dễ dàng gắn vai trò mới cho người dùng bằng phương pháp 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
960

Đính kèm nhiều mô hình

class User extends Eloquent {
    protected $table = 'my_users';
73

Bạn cũng có thể chuyển một mảng các thuộc tính sẽ được lưu trữ trên bảng tổng hợp cho mối quan hệ

class User extends Eloquent {
    protected $table = 'my_users';
74

Tất nhiên, đối lập với 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
960 là 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
962

class User extends Eloquent {
    protected $table = 'my_users';
75

Cả 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
960 và 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
962 cũng lấy mảng ID làm đầu vào

class User extends Eloquent {
    protected $table = 'my_users';
76

Sử dụng Đồng bộ hóa để Đính kèm Nhiều Mô hình

Bạn cũng có thể sử dụng phương pháp 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
965 để đính kèm các mô hình liên quan. Phương thức 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
965 chấp nhận một mảng ID để đặt trên bảng tổng hợp. Sau khi thao tác này hoàn tất, chỉ các ID trong mảng sẽ nằm trên bảng trung gian cho mô hình

class User extends Eloquent {
    protected $table = 'my_users';
77

Thêm dữ liệu Pivot khi đồng bộ hóa

Bạn cũng có thể liên kết các giá trị bảng tổng hợp khác với các ID đã cho

class User extends Eloquent {
    protected $table = 'my_users';
78

Đôi khi bạn có thể muốn tạo một mô hình liên quan mới và đính kèm nó trong một lệnh duy nhất. Đối với thao tác này, bạn có thể sử dụng phương pháp 

class User extends Eloquent {
    protected $table = 'my_users';
39

class User extends Eloquent {
    protected $table = 'my_users';
79

Trong ví dụ này, mô hình 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
915 mới sẽ được lưu và đính kèm vào mô hình người dùng. Bạn cũng có thể chuyển một mảng các thuộc tính để đặt trên bảng nối cho thao tác này

class User extends Eloquent {
    protected $table = 'my_users';
90

Chạm vào dấu thời gian của phụ huynh

Khi một mô hình 

class User extends Eloquent {
    protected $table = 'my_users';
97 một mô hình khác, chẳng hạn như một 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
904 thuộc về một 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
917, việc cập nhật dấu thời gian của cha mẹ khi mô hình con được cập nhật thường rất hữu ích. Ví dụ: khi mô hình 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
904 được cập nhật, bạn có thể muốn tự động chạm vào dấu thời gian 
class User extends Eloquent {
    protected $table = 'my_users';
23 của 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
917 sở hữu. Hùng biện làm cho nó dễ dàng. Chỉ cần thêm thuộc tính 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
975 chứa tên của các mối quan hệ vào mô hình con

class User extends Eloquent {
    protected $table = 'my_users';
91

Bây giờ, khi bạn cập nhật một 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
904, thì 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
917 sở hữu sẽ có cột 
class User extends Eloquent {
    protected $table = 'my_users';
23 được cập nhật

class User extends Eloquent {
    protected $table = 'my_users';
92

Làm việc với Pivot Table

Như bạn đã biết, làm việc với quan hệ nhiều-nhiều yêu cầu phải có bảng trung gian. Eloquent cung cấp một số cách rất hữu ích để tương tác với bảng này. Ví dụ: giả sử đối tượng 

class User extends Eloquent {
    protected $table = 'my_users';
16 của chúng ta có nhiều đối tượng 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
915 có liên quan đến. Sau khi truy cập vào mối quan hệ này, chúng tôi có thể truy cập bảng 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
981 trên các mô hình

class User extends Eloquent {
    protected $table = 'my_users';
93

Lưu ý rằng mỗi mô hình 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
915 mà chúng tôi truy xuất được tự động gán một thuộc tính 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
981. Thuộc tính này chứa một mô hình đại diện cho bảng trung gian và có thể được sử dụng như bất kỳ mô hình Eloquent nào khác

Theo mặc định, chỉ các khóa sẽ có mặt trên đối tượng 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
981. Nếu bảng tổng hợp của bạn chứa các thuộc tính bổ sung, bạn phải chỉ định chúng khi xác định mối quan hệ

class User extends Eloquent {
    protected $table = 'my_users';
94

Bây giờ các thuộc tính 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
985 và 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
986 sẽ có thể truy cập được trên đối tượng 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
981 của chúng tôi cho mô hình 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
915

Nếu bạn muốn bảng tổng hợp của mình tự động duy trì dấu thời gian 

class User extends Eloquent {
    protected $table = 'my_users';
24 và 
class User extends Eloquent {
    protected $table = 'my_users';
23, hãy sử dụng phương pháp 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
991 trong định nghĩa mối quan hệ

class User extends Eloquent {
    protected $table = 'my_users';
95

Xóa bản ghi trên bảng Pivot

Để xóa tất cả các bản ghi trên bảng tổng hợp cho một mô hình, bạn có thể sử dụng phương pháp 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
962

class User extends Eloquent {
    protected $table = 'my_users';
96

Lưu ý rằng thao tác này không xóa các bản ghi khỏi bảng 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
907 mà chỉ xóa khỏi bảng tổng hợp

Cập nhật bản ghi trên bảng Pivot

Đôi khi, bạn có thể cần cập nhật bảng tổng hợp của mình nhưng không được tách nó ra. Nếu bạn muốn cập nhật bảng tổng hợp của mình tại chỗ, bạn có thể sử dụng phương pháp 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
994 như vậy

class User extends Eloquent {
    protected $table = 'my_users';
97

Xác định mô hình Pivot tùy chỉnh

Laravel cũng cho phép bạn xác định mô hình Pivot tùy chỉnh. Để xác định một mô hình tùy chỉnh, trước tiên hãy tạo lớp mô hình "Cơ sở" của riêng bạn mở rộng 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
995. Trong các mô hình Eloquent khác của bạn, hãy mở rộng mô hình cơ sở tùy chỉnh này thay vì cơ sở 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
995 mặc định. Trong mô hình cơ sở của bạn, hãy thêm hàm sau để trả về một phiên bản của mô hình Pivot tùy chỉnh của bạn

class User extends Eloquent {
    protected $table = 'my_users';
98

bộ sưu tập

Tất cả các tập hợp nhiều kết quả được trả về bởi Eloquent, thông qua phương thức 

DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
944 hoặc 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
998, sẽ trả về một đối tượng tập hợp. Đối tượng này triển khai giao diện PHP 
DB::beginTransaction[]; //Start transaction!

try{
   //saving logic here
   $ship = $ship->save[];
   Ship::find[$ship->id]->captain[]->save[$captain];
}
catch[\Exception $e]
{
  //failed logic here
   DB::rollback[];
   throw $e;
}

DB::commit[];
999 để nó có thể được lặp lại giống như một mảng. Tuy nhiên, đối tượng này cũng có nhiều phương thức hữu ích khác để làm việc với tập kết quả

Kiểm tra xem một bộ sưu tập có chứa khóa không

Ví dụ: chúng tôi có thể xác định xem tập kết quả có chứa khóa chính đã cho hay không bằng cách sử dụng phương pháp 

class User extends Eloquent {
    protected $table = 'my_users';
100

class User extends Eloquent {
    protected $table = 'my_users';
25

Các bộ sưu tập cũng có thể được chuyển đổi thành một mảng hoặc JSON

class User extends Eloquent {
    protected $table = 'my_users';
30

Nếu một bộ sưu tập được chuyển thành một chuỗi, nó sẽ được trả về dưới dạng JSON

class User extends Eloquent {

  


    protected $table = 'my_users';
31

Bộ sưu tập lặp lại

Các bộ sưu tập Eloquent cũng chứa một số phương thức hữu ích để lặp và lọc các mục mà chúng chứa

class User extends Eloquent {
    protected $table = 'my_users';
32

Bộ sưu tập lọc

Khi lọc các bộ sưu tập, hàm gọi lại được cung cấp sẽ được sử dụng làm hàm gọi lại cho array_filter

class User extends Eloquent {
    protected $table = 'my_users';
33

Ghi chú. Khi lọc một bộ sưu tập và chuyển đổi nó thành JSON, trước tiên hãy thử gọi hàm 

class User extends Eloquent {
    protected $table = 'my_users';
101 để đặt lại các khóa của mảng

Áp dụng gọi lại cho từng đối tượng bộ sưu tập

class User extends Eloquent {
    protected $table = 'my_users';
34

Sắp xếp một bộ sưu tập theo một giá trị

class User extends Eloquent {
    protected $table = 'my_users';
35

Sắp xếp một bộ sưu tập theo một giá trị

class User extends Eloquent {
    protected $table = 'my_users';
36

Trả lại một loại bộ sưu tập tùy chỉnh

Đôi khi, bạn có thể muốn trả về một đối tượng Bộ sưu tập tùy chỉnh bằng các phương thức được thêm vào của riêng bạn. Bạn có thể chỉ định điều này trên mô hình Eloquent của mình bằng cách ghi đè phương thức 

class User extends Eloquent {
    protected $table = 'my_users';
102

class User extends Eloquent {
    protected $table = 'my_users';
37

Bộ truy cập & bộ biến đổi

Định nghĩa một Accessor

Eloquent cung cấp một cách thuận tiện để chuyển đổi các thuộc tính mô hình của bạn khi lấy hoặc thiết lập chúng. Chỉ cần xác định một phương thức 

class User extends Eloquent {
    protected $table = 'my_users';
103 trên mô hình của bạn để khai báo một bộ truy cập. Hãy nhớ rằng các phương thức phải tuân theo trường hợp lạc đà, mặc dù các cột cơ sở dữ liệu của bạn là trường hợp con rắn

class User extends Eloquent {
    protected $table = 'my_users';
38

Trong ví dụ trên, cột 

class User extends Eloquent {
    protected $table = 'my_users';
104 có một bộ truy cập. Lưu ý rằng giá trị của thuộc tính được chuyển đến bộ truy cập

Xác định một Mutator

Người đột biến được khai báo theo cách tương tự

class User extends Eloquent {
    protected $table = 'my_users';
39

Người đột biến ngày

Theo mặc định, Eloquent sẽ chuyển đổi các cột 

class User extends Eloquent {
    protected $table = 'my_users';
24 và 
class User extends Eloquent {
    protected $table = 'my_users';
23 thành các phiên bản của Carbon, cung cấp một loạt các phương thức hữu ích và mở rộng lớp 
class User extends Eloquent {
    protected $table = 'my_users';
107 gốc của PHP

Bạn có thể tùy chỉnh trường nào được thay đổi tự động và thậm chí vô hiệu hóa hoàn toàn thay đổi này bằng cách ghi đè phương thức 

class User extends Eloquent {
    protected $table = 'my_users';
108 của mô hình

class User extends Eloquent {
    protected $table = 'my_users';
00

Khi một cột được coi là ngày, bạn có thể đặt giá trị của nó thành dấu thời gian UNIX, chuỗi ngày [

class User extends Eloquent {
    protected $table = 'my_users';
109], chuỗi ngày-thời gian và tất nhiên là một thể hiện của 
class User extends Eloquent {
    protected $table = 'my_users';
107 / 
class User extends Eloquent {
    protected $table = 'my_users';
111

Để vô hiệu hóa hoàn toàn các thay đổi ngày tháng, chỉ cần trả về một mảng trống từ phương thức 

class User extends Eloquent {
    protected $table = 'my_users';
108

Sự kiện người mẫu

Các mô hình hùng hồn kích hoạt một số sự kiện, cho phép bạn kết nối vào các điểm khác nhau trong vòng đời của mô hình bằng các phương pháp sau. 

class User extends Eloquent {
    protected $table = 'my_users';
113, 
class User extends Eloquent {
    protected $table = 'my_users';
114, 
class User extends Eloquent {
    protected $table = 'my_users';
115, 
class User extends Eloquent {
    protected $table = 'my_users';
116, 
class User extends Eloquent {
    protected $table = 'my_users';
117, 
class User extends Eloquent {
    protected $table = 'my_users';
118, 
class User extends Eloquent {
    protected $table = 'my_users';
119, 
class User extends Eloquent {
    protected $table = 'my_users';
120, 
class User extends Eloquent {
    protected $table = 'my_users';
121, 
class User extends Eloquent {
    protected $table = 'my_users';
122

Bất cứ khi nào một mục mới được lưu lần đầu tiên, sự kiện 

class User extends Eloquent {
    protected $table = 'my_users';
113 và 
class User extends Eloquent {
    protected $table = 'my_users';
114 sẽ kích hoạt. Nếu một mục không phải là mới và phương pháp 
class User extends Eloquent {
    protected $table = 'my_users';
39 được gọi, các sự kiện 
class User extends Eloquent {
    protected $table = 'my_users';
115 / 
class User extends Eloquent {
    protected $table = 'my_users';
116 sẽ kích hoạt. Trong cả hai trường hợp, sự kiện 
class User extends Eloquent {
    protected $table = 'my_users';
117 / 
class User extends Eloquent {
    protected $table = 'my_users';
118 sẽ kích hoạt

Hủy lưu hoạt động thông qua sự kiện

Nếu 

class User extends Eloquent {
    protected $table = 'my_users';
26 được trả về từ các sự kiện 
class User extends Eloquent {
    protected $table = 'my_users';
113, 
class User extends Eloquent {
    protected $table = 'my_users';
115, 
class User extends Eloquent {
    protected $table = 'my_users';
117 hoặc 
class User extends Eloquent {
    protected $table = 'my_users';
119, thì hành động đó sẽ bị hủy

class User extends Eloquent {
    protected $table = 'my_users';
01

Đặt phương pháp khởi động mô hình

Các mô hình Eloquent cũng chứa một phương thức tĩnh 

class User extends Eloquent {
    protected $table = 'my_users';
135, có thể cung cấp một nơi thuận tiện để đăng ký các ràng buộc sự kiện của bạn

class User extends Eloquent {
    protected $table = 'my_users';
02

Người quan sát mô hình

Để củng cố việc xử lý các sự kiện mô hình, bạn có thể đăng ký một người quan sát mô hình. Một lớp người quan sát có thể có các phương thức tương ứng với các sự kiện mô hình khác nhau. Ví dụ: các phương thức 

class User extends Eloquent {
    protected $table = 'my_users';
113, 
class User extends Eloquent {
    protected $table = 'my_users';
115, 
class User extends Eloquent {
    protected $table = 'my_users';
117 có thể nằm trên một người quan sát, ngoài bất kỳ tên sự kiện mô hình nào khác

Vì vậy, ví dụ, một người quan sát mô hình có thể trông như thế này

class User extends Eloquent {
    protected $table = 'my_users';
03

Bạn có thể đăng ký một phiên bản người quan sát bằng phương pháp 

class User extends Eloquent {
    protected $table = 'my_users';
139

class User extends Eloquent {
    protected $table = 'my_users';
04

Chuyển đổi sang mảng/JSON

Chuyển đổi một mô hình thành một mảng

Khi xây dựng API JSON, bạn có thể thường cần chuyển đổi các mô hình và mối quan hệ của mình thành mảng hoặc JSON. Vì vậy, Eloquent bao gồm các phương pháp để làm như vậy. Để chuyển đổi một mô hình và mối quan hệ được tải của nó thành một mảng, bạn có thể sử dụng phương thức 

class User extends Eloquent {
    protected $table = 'my_users';
140

class User extends Eloquent {
    protected $table = 'my_users';
05

Lưu ý rằng toàn bộ bộ sưu tập mô hình cũng có thể được chuyển đổi thành mảng

class User extends Eloquent {
    protected $table = 'my_users';
06

Chuyển đổi một mô hình thành JSON

Để chuyển đổi một mô hình thành JSON, bạn có thể sử dụng phương thức 

class User extends Eloquent {
    protected $table = 'my_users';
141

class User extends Eloquent {
    protected $table = 'my_users';
07

Trả lại một mô hình từ một tuyến đường

Lưu ý rằng khi một mô hình hoặc bộ sưu tập được truyền thành một chuỗi, nó sẽ được chuyển đổi thành JSON, nghĩa là bạn có thể trả về các đối tượng Eloquent trực tiếp từ các route của ứng dụng của mình

class User extends Eloquent {
    protected $table = 'my_users';
08

Ẩn các thuộc tính khỏi mảng hoặc chuyển đổi JSON

Đôi khi, bạn có thể muốn giới hạn các thuộc tính được bao gồm trong mảng hoặc biểu mẫu JSON của mô hình, chẳng hạn như mật khẩu. Để làm như vậy, hãy thêm định nghĩa thuộc tính 

class User extends Eloquent {
    protected $table = 'my_users';
142 vào mô hình của bạn

class User extends Eloquent {
    protected $table = 'my_users';
09

Ghi chú. Khi ẩn các mối quan hệ, hãy sử dụng tên phương thức của mối quan hệ, không phải tên của trình truy cập động

Ngoài ra, bạn có thể sử dụng thuộc tính 

class User extends Eloquent {
    protected $table = 'my_users';
143 để xác định danh sách trắng

class User extends Eloquent {
    protected $table = 'my_users';
10

Đôi khi, bạn có thể cần thêm các thuộc tính mảng không có cột tương ứng trong cơ sở dữ liệu của mình. Để làm như vậy, chỉ cần xác định một bộ truy cập cho giá trị

class User extends Eloquent {
    protected $table = 'my_users';
11

Khi bạn đã tạo bộ truy cập, chỉ cần thêm giá trị vào thuộc tính 

class User extends Eloquent {
    protected $table = 'my_users';
144 trên mô hình

class User extends Eloquent {
    protected $table = 'my_users';
12

Khi thuộc tính đã được thêm vào danh sách 

class User extends Eloquent {
    protected $table = 'my_users';
144, nó sẽ được đưa vào cả dạng mảng và dạng JSON của mô hình. Các thuộc tính trong mảng 
class User extends Eloquent {
    protected $table = 'my_users';
144 tôn trọng cấu hình 
class User extends Eloquent {
    protected $table = 'my_users';
143 và 
class User extends Eloquent {
    protected $table = 'my_users';
142 trên mô hình

Làm cách nào để cập nhật nhiều bản ghi trong laravel?

Làm cách nào để cập nhật nhiều bản ghi trong Laravel? .
ví dụ 1. sử dụng Ứng dụng\Mô hình\Sản phẩm; . .
ví dụ 2. sử dụng Ứng dụng\Mô hình\Sản phẩm; . .
ví dụ 3. đọc thêm. Laravel Tạo bản ghi nếu không tồn tại Ví dụ. sử dụng Ứng dụng\Mô hình\Sản phẩm;

Lưu trong laravel là gì?

Vite là công cụ xây dựng giao diện người dùng hiện đại cung cấp môi trường phát triển cực kỳ nhanh và gói mã của bạn để sản xuất . Khi xây dựng các ứng dụng với Laravel, thông thường bạn sẽ sử dụng Vite để gói các tệp CSS và JavaScript của ứng dụng của bạn thành các nội dung sẵn sàng sản xuất.

Làm cách nào để lấy giá trị từ nhiều hộp nhập liệu và lưu nó vào cơ sở dữ liệu bằng laravel?

Để lưu trữ các giá trị trường đầu vào vào cơ sở dữ liệu, bạn phải kết nối ứng dụng laravel với cơ sở dữ liệu . Điều này có thể được thực hiện bằng cách thêm tên cơ sở dữ liệu, tên người dùng và mật khẩu bên trong. tập tin env.

Bài Viết Liên Quan

Phần còn lại nodejs
Làm cách nào để sử dụng câu lệnh if trong python hiểu danh sách?
Dự án html để thực hành
Làm cách nào để tạo danh mục đầu tư cá nhân bằng html và css?
Mysqld_safe bắt đầu mariadbd daemon với cơ sở dữ liệu từ opt homebrew var mysql
Chạy tập lệnh python từ github
Làm thế nào để bạn thay đổi một chuỗi thành một tệp trong python?
Hàm Python random() trả về cái gì?
Lớp giả css
Gọi một tập lệnh từ một tập lệnh javascript khác
Chuyển đổi chuỗi thành float64 python
Làm thế nào để gc thu thập python làm việc?
Làm cách nào để bật tiện ích mở rộng trong PHP Ubuntu?
Làm cách nào để kiểm tra nhiều tệp được chọn hay không trong PHP?
Tuple thành mảng Python
Leo Horoscope February 2023
Yêu cầu Python lặp lại thông qua phản hồi JSON
Python chuyển đổi tỷ lệ phần trăm thành float
Trực quan mongodb python
Where in France is the World Cup 2023?

Toplist mới

#1
Top 9 tập bản đồ lớp 8 bài 31 2023
6 tháng trước
#2
Top 6 kết quả thi hsg đà nẵng 2022 2023
6 tháng trước
#3
Top 9 tủ nhựa đài loan 4 cánh 3d 2023
6 tháng trước
#4
Top 9 chất khí có thể làm mất màu dung dịch nước brom là: a. so2. b. co2. c. o2. d. hcl. 2023
6 tháng trước
#5
Top 8 tìm việc làm tiện, phay bảo q7 2023
6 tháng trước
#6
Top 3 tôi xuyên thành tiểu kiều the của lão đại phản 2 2023
6 tháng trước
#7
Top 9 đổi mới phong cách, thái độ phục vụ của cán bộ y tế hướng tới sự hài lòng của người bệnh 2023
6 tháng trước
#8
Top 2 bài the dục phát triển chung lớp 6 2022 2023
6 tháng trước
#9
Top 3 bài giảng vũ điệu sắc màu (lớp 4) 2023
6 tháng trước

Bài mới nhất

Top tướng đi mid xanh gánh cả team năm 2024
Baán miếng dán apple watch le văn sỹ năm 2024
Các dang bài tập nâng cao đại 9 kì 2 năm 2024
Top xe 47 chỗ xịn nhất hà nội năm 2024
Cách fix lỗi không thể vào trận trong pupg năm 2024
Bìa sách khi lỗi thuộc về những vì sao năm 2024
Các bài tập toán 4 violet tập 1 năm 2024
Lấy trị tuyệt đối trong tiếng anh là gì năm 2024
Công việc nhiều thì dùng từ nào để diễn tả năm 2024
Bài tập lập công thức hóa học lớp 8 violet năm 2024

Chủ Đề

programming Hỏi Đáp Toplist Là gì Mẹo Hay Địa Điểm Hay Học Tốt mẹo hay Công Nghệ Nghĩa của từ Bao nhiêu Khỏe Đẹp đánh giá Top List bao nhieu bao nhiêu hướng dẫn Xây Đựng So Sánh Bài tập Tiếng anh So sánh Sản phẩm tốt Ngôn ngữ Bài Tập javascript Thế nào Ở đâu Hướng dẫn Dịch Máy tính Tại sao Đại học Món Ngon Khoa Học