If may think that enough tinkering around Laravel’s Collections too much have made you some kind of Collection expert, but Higher Order Messages are one level above in understanding.
One thing I couldn’t grasp, and probably you either if you are reading this, is how they work and what problem they try to solve, but falter not, these are relatively easy to understand when you think about them as proxies to the real methods.
Get off my lawn, you dirty closure!
Higher Order Messages are basically properties that act like you were doing a very short closure. To better exemplify, let’s say we want to filter all users who are not admin.
You can see that Mike and Abby are admins because the is_admin is true, so the first thing you could do to filter them should be to call the filter method of the Collection to return those who are inside another Collection instance.
While that line may work for some, we can make the filter a one line. The filter method as a Higher Order Message by the same name. It will take the value we are using to “get” as the what the closure should return for each item in the collection, being a property or an array key.
And that’s it, it’s very simple.
What about sum, for example?
Some methods do not return collections, and that’s fine. For example, the sum method returns the result of a sum on the value of each item.
In this case, we can sum the users who are admins:
We can make that whole call into one line, since the sum method actually does an additive operation in PHP which is compatible with booleans, where true is 1 and false is 0. So, yes, we can sum booleans without any problem.
Can you use methods? With arguments?
Higher Order Collection are also compatible with methods, including arguments to them. The method you pass will be used for each item, so let’s make an example.
This User class has a convenient method that returns true or false if the age is above to what we’re asking.
Let’s assume we have a collection of these User class instances. The old nasty way to filter them would be using a closure to execute on each of them.
And it gets more verbose when we have to include the age from a variable outside the closure.
Laravel 6.0 đã giới thiệu Lazy Collection. Lazy collection sử dụng PHP generators để cho phép chúng ta làm việc với một tập dữ liệu rất lớn và giữ cho mức sử dụng bộ nhớ ở mức thấp. Ví dụ với 60.000 bản ghi user. Nếu bây giờ chúng ta lấy ra tất cả các bản ghi cùng 1 lúc thì sao? Chúng ta nhận được lỗi 500 do quá tải bộ nhớ, bởi vì tất cả 60.000 user đều được tải vào bộ nhớ cùng lúc.
Và để loại bỏ việc sử dụng bộ nhớ này chúng ta sử dụng method cursor() . Method này cho phép chỉ thực hiện 1 câu truy vấn duy nhất và chỉ 1 Eloquent model được load ra tại 1 thời điểm .
Trong ví dụ này, việc gọi filter sẽ không được thực thi cho đến khi từng user được lặp lại, làm giảm đáng kể việc sử dụng bộ nhớ
Read Large File
Ngoài ra chúng ta có thể sử dụng lazy collection để đọc hàng GB khổng lồ. Method make() dùng để tạo 1 lazy collection class object
Ví dụ, chúng ta lấy 4 bản ghi với method chuck(), load các bản ghi vào LogEntry model và lặp qua các bản ghi đó.
Điểm chú ý ở đây chính là việc ta sử dụng hàm yield của php thay choreturn như Collection. Thay vì dừng thực thi hàm và trả về (return), yield trả về giá trị khi giá trị đó cần sử dụng đến mà không lưu trữ tất cả các giá trị trong bộ nhớ.
collect(['a', 'b', 'c'])->join(', '); // 'a, b, c'
collect(['a', 'b', 'c'])->join(', ', ', and '); // 'a, b, and c'
collect(['a', 'b'])->join(', ', ' and '); // 'a and b'
collect(['a'])->join(', ', ' and '); // 'a'
collect([])->join(', ', ' and '); // ''
use App\Models\User;
use App\Models\Post;
$collection = collect([
new User,
new User,
new Post,
]);
$filtered = $collection->whereInstanceOf(User::class);
$filtered->all();
// [App\Models\User, App\Models\User]
use App\LogEntry;
use Illuminate\Support\LazyCollection;
LazyCollection::make(function () {
$handle = fopen('log.txt', 'r');
while (($line = fgets($handle)) !== false) {
yield $line;
}
})
->chunk(4)
->map(function ($lines) {
return LogEntry::fromLines($lines);
})
->each(function (LogEntry $logEntry) {
// Process the log entry...
});
Tìm hiểu Lazy Collection
Introduction
Lazy Collection là một tính năng mới của Laravel được giới thiệu trong phiên bản 6.0. Đây là một sự bổ sung cho tính năng Collection vô cùng hữu ích đã có trước đó của Laravel cho phép ta giảm thiểu bộ nhớ sử dụng. Vì là một tính năng mới, hiện các tài liệu về Lazy Collection vẫn còn hạn hẹp nên mình xin phép góp vui một bài viết đi vào tìm hiểu về Lazy Collection và có một cái nhìn vào cách nó hoạt động thông qua PHP Generators.
Mục lục
I. Lazy Collection
II. PHP Generators
I. Lazy Collection
1. Giới thiệu
Trong các bài toán thực tế, chúng ta sẽ có thể gặp các tình huống cần làm việc với một lượng lớn các bản ghi như dữ liệu về log hay notifications. Tuy nhiên, việc lấy ra số lượng lớn như vậy để làm việc với Collection thì không khả thi chút nào, đặc biệt với các hệ thống đã chạy lâu năm. Chương trình của chúng ta được triển khai trên một server vật lý với dung lượng RAM giới hạn, việc đọc một lượng lớn các bản ghi sẽ khiến server nhanh chóng quá tải và gây chết trang. Để giảm thiểu vấn đề này, Laravel đã cho ra đời Lazy Collection.
2. Sử dụng
a. Tổng quát
Lazy Collection là một tính năng mới được thêm vào phiên bản Laravel 6.0 cho phép ta làm việc với bộ dữ liệu lớn và duy trì bộ nhớ sử dụng lợi dụng PHP Generators.
b. Khởi tạo Lazy Collection
Tương tự như Collection, để sử dụng LazyCollection ta có thể thêm use Illuminate\Support\LazyCollection vào đầu file.
VD:
use Illuminate\Support\LazyCollection;
LazyCollection::make(function () {
$handle = fopen('log.txt', 'r');
while (($line = fgets($handle)) !== false) {
yield $line;
}
});
Bên cạnh đó, query builder cũng cung cấp cho chúng ta hàm cursor() trả về một LazyCollection cho phép ta làm việc trên nhiều bản ghi nhưng không phải tải toàn bộ vào bộ nhớ cùng lúc.
VD: Giả sử chúng ta có 100,000 bản ghi log hệ thống cần xử lý.
use App\Models\Log;
// không dùng lazy collection, truy vấn thực hiện lấy toàn bộ 100,000 bản ghi vào RAM
Log::all()->map(function ($log, $key) {
return parseMessage($log->message);
});
// sử dụng lazy collection, lần lượt từng model được thêm vào bộ nhớ nhưng chỉ cần 1 query
Log::cursor()->map(function ($log, $key) {
return parseMessage($log->message);
});
c. Các phương thức
Giống với Collection, Lazy Collection implement Illuminate\Support\Enumerable và cung cấp đầy đủ các phương thức thông thường như all(), map(), sort(), where(), v.v... Mọi người có thể xem chi tiết trong tài liệu tham khảo.
Tuy nhiên, bên cạnh đó LazyCollection cũng bao gồm các phương thức mới như:
takeUntilTimeout(DateTimeInterface $timeout): Hàm sẽ thực hiện lấy ra các giá trị tới khi hết thời gian. (LƯU Ý: phương thức này có từ bản 8.x)
tapEach(callable $callback): gần giống với each(), phương thức sẽ thực hiện hàm callback cho từng item nhưng chỉ thực hiện lần lượt cho từng item khi được lấy ra một cách "lazy".
remember(): ghi nhớ các giá trị đã được lấy ra và bỏ qua chúng khi gặp lại.
II. PHP Generators
Như đã nêu trên, để Lazy Collection có thể thực hiện lấy lần lượt các bản ghi vào bộ nhớ chúng ta sử dụng PHP Generator. Một hàm generator nhìn qua không khác so với một PHP function thông thường ngoại trừ việc sử dụng yield thay vì return. Vậy sự khác biệt là gì?
Giả sử ta có một hàm countToMillion() được cài đặt như sau
function countToMillion()
{
for($i = 1; $i <= 1000000; $i++) {
return $i;
}
}
dump(countToMillion());
Output:
1
Hàm thực hiện trả về giá trị đầu tiên và dừng hoàn toàn countToMillion(). Nếu ta thay đổi từ khóa return sang yield, ta sẽ có như sau:
function countToMillion()
{
for($i = 1; $i <= 1000000; $i++) {
yield $i;
}
}
dump(countToMillion());
Output:
Generator {#1534 ▼
executing: {
...
}
closed: false
}
Như ta thấy, từ khóa yield sẽ trả về một Generator object thay vì giá trị "1". Vậy Generator object này có gì đặc biệt?
Tìm hiểu tiếp theo ta sẽ thử thực hiện in lần lượt từng số đếm tới 1 triệu. Để làm được điều đó sử dụng return chúng ta sẽ cần phải lưu lại 1,000,000 bản ghi vào một biến số trước khi trả về.
function countToMillion()
{
$data = [];
for($i = 1; $i <= 1000000; $i++) {
$data[] = $i;
}
return $data;
}
foreach (countToMillion() as $number) {
dump($number);
}
Output:
1
2
3
...
1000000
Điều này gây tốn rất nhiều bộ nhớ. Nhưng khác với return, yield không thực sự dừng hoàn toàn phương thức của chúng ta mà thay vào đó tạm dừng ở vị trí đang đứng. Sử dụng Generator object chúng ta có thể thực hiện lặp qua từng yield để lấy giá trị tiếp theo trả về và giải phóng bộ nhớ sau khi hoàn thành.
// count with yield
...
foreach (countToMillion() as $number) {
dump($number);
}
Output:
1
2
3
...
1000000
Dựa trên ý tưởng này, Laravel Lazy Collection thực hiện xử lý lần lượt các item trong Collection thay vì lưu tất cả vào bộ nhớ.
Tổng kết
Vậy qua bài viết trên chúng ta đã hiểu được cách sử dụng của Lazy Collection và có một cái nhìn sâu hơn về cách nó hoạt động thông qua PHP Generators.
