Việc sử dụng phương thức firstwhere() trong Laravel là gì?

Trình tạo truy vấn cơ sở dữ liệu trong Laravel cung cấp một giao diện đơn giản, trực quan để tạo và thực hiện các truy vấn cơ sở dữ liệu. Nó hoạt động với mọi hệ thống cơ sở dữ liệu được Laravel hỗ trợ và có thể được sử dụng để thực hiện hầu hết các thao tác trên cơ sở dữ liệu trong ứng dụng của bạn

Mảng AutoCAD. Cách sử dụng Path Au

Vui lòng bật JavaScript

Mảng AutoCAD. Làm thế nào để sử dụng lệnh Path AutoCAD Array?

Trong ví dụ này, tôi sẽ hướng dẫn bạn cách sử dụng các phương thức first[] và firstWhere[] để xây dựng Bộ sưu tập Laravel 8. Khi làm project Laravel chúng ta nên tận dụng Laravel collection để xử lý dữ liệu mảng dễ dàng hơn. Để tạo một thể hiện bộ sưu tập mới từ mảng của chúng tôi, chúng tôi sẽ sử dụng chức năng trợ giúp thu thập của Laravel.
Và có những lúc bạn cần lấy phần tử đầu tiên hoặc sử dụng truy vấn điều kiện để hiển thị kết quả bộ sưu tập Laravel đầu tiên. Sẽ dễ dàng hơn cho chúng ta nếu chúng ta sử dụng các phương thức first[] và firstWhere[].

ví dụ 1. Laravel Collection first[] Ví dụ về phương thức

public function index[]
{
    $collection = collect[[
        ['id'=>	1, 'name'=>'Juan Dela Cruz', 'age' => 25],
        ['id'=>	2, 'name'=>'Juana Vasquez', 'age' => 31],
        ['id'=>	3, 'name'=>'Jason Reyes', 'age' => 27],
        ['id'=>	4, 'name'=>'Jake Ramos', 'age' => 43],
    ]];
   $first = $collection->first[];
   dd[$first];
}

 

ví dụ 2. Laravel Collection first[] Ví dụ về phương thức

public function index[]
{
    $collection = collect[[
        ['id'=>	1, 'name'=>'Juan Dela Cruz', 'age' => 25, 'gender' => 'Male'],
        ['id'=>	2, 'name'=>'Juana Vasquez', 'age' => 31, 'gender' => 'Female'],
        ['id'=>	3, 'name'=>'Jason Reyes', 'age' => 27, 'gender' => 'Male'],
        ['id'=>	4, 'name'=>'Jake Ramos', 'age' => 43, 'gender' => 'Male'],
    ]];
   $first = $collection->firstWhere['name', 'Juan Dela Cruz'];
   dd[$first];
}

Tôi hy vọng bạn sẽ thích nội dung này và nó sẽ giúp bạn tìm hiểu Bộ sưu tập Laravel 8 với Phương thức first[] và firstWhere[] Ví dụ
Nếu bạn thích nội dung này, hãy chia sẻ.

Trong ví dụ này, mình sẽ hướng dẫn bạn cách sử dụng firstwhere trong laravel 7/6. bạn có thể đơn giản và dễ dàng sử dụng firstwhere trong laravel 7/6

Phương thức firstWhere trả về bản ghi đầu tiên cho bảng vào cơ sở dữ liệu. tôi sẽ sử dụng email như abc@gmail. com nơi nhận các bản ghi bằng nhau vào cơ sở dữ liệu như ví dụ dưới đây

cú pháp

firstWhere['colume name','value'];

Thí dụ

Nếu chúng ta sử dụng firstWhere[] thì chúng ta có thể bỏ qua điều kiện where. Bạn có thể thấy điều kiện và bản ghi đầu tiên dưới đây của tôi và bạn cũng có thể thấy bằng cách sử dụng firstWhere[]

Laravel hùng hồn firstWhere[] ví dụ. Trong hướng dẫn này, bạn sẽ tìm hiểu về phương thức firstWhere[] của laravel với các ví dụ

Và hướng dẫn này sẽ giúp bạn một cách đơn giản về cách sử dụng laravel eloquent firstwhere[]

Lưu ý rằng, Phương thức 

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

01 trả về phần tử đầu tiên trong bộ sưu tập với cặp khóa/giá trị đã cho

Đôi khi, bạn cần lấy dữ liệu từ id thì bạn có thể dễ dàng tìm nạp từ phương thức find[], nhưng khi bạn cần lấy dữ liệu từ danh mục, tuổi, tên thì bạn phải sử dụng phương thức first[]. Nhưng laravel eloquent cung cấp phương thức firstWhere[] sẽ giúp bạn dễ dàng tìm nạp bản ghi đầu tiên phù hợp

Lớp

$collection = collect[[1, 2, 3]];

99 cung cấp một trình bao bọc thông thạo, thuận tiện để làm việc với các mảng dữ liệu. Ví dụ: kiểm tra đoạn mã sau. Chúng ta sẽ sử dụng trình trợ giúp

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

00 để tạo một thể hiện bộ sưu tập mới từ mảng, chạy hàm

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

01 trên từng phần tử, sau đó xóa tất cả các phần tử trống

$collection = collect[['taylor', 'abigail', null]]->map[function [$name] {
}]->reject[function [$name] {

Như bạn có thể thấy, lớp

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

02 cho phép bạn xâu chuỗi các phương thức của nó để thực hiện ánh xạ trôi chảy và rút gọn mảng bên dưới. Nói chung, các bộ sưu tập là bất biến, nghĩa là mọi phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

02 đều trả về một thể hiện

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

02 hoàn toàn mới

Tạo bộ sưu tập

Như đã đề cập ở trên, trình trợ giúp

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

00 trả về một phiên bản

$collection = collect[[1, 2, 3]];

99 mới cho mảng đã cho. Vì vậy, việc tạo một bộ sưu tập cũng đơn giản như

$collection = collect[[1, 2, 3]];

Lưu ý
Kết quả của truy vấn Eloquent luôn được trả về dưới dạng phiên bản

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

02.

Mở rộng bộ sưu tập

Các bộ sưu tập là "có thể điều chỉnh được", cho phép bạn thêm các phương thức bổ sung vào lớp

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

02 trong thời gian chạy. Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

10 của lớp

$collection = collect[[1, 2, 3]];

99 chấp nhận một bao đóng sẽ được thực thi khi macro của bạn được gọi. Việc đóng macro có thể truy cập các phương thức khác của bộ sưu tập thông qua

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

11, giống như thể nó là một phương thức thực sự của lớp bộ sưu tập. Ví dụ: đoạn mã sau thêm phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

12 vào lớp

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

02

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

Thông thường, bạn nên khai báo các macro thu thập trong phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

14 của nhà cung cấp dịch vụ

Đối số vĩ mô

Nếu cần, bạn có thể xác định các macro chấp nhận các đối số bổ sung

firstWhere['colume name','value'];

2

phương pháp có sẵn

Đối với phần lớn các tài liệu về bộ sưu tập còn lại, chúng ta sẽ thảo luận về từng phương thức có sẵn trên lớp

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

02. Hãy nhớ rằng, tất cả các phương thức này có thể được xâu chuỗi để thao tác thành thạo mảng bên dưới. Hơn nữa, hầu hết mọi phương thức đều trả về một phiên bản

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

02 mới, cho phép bạn giữ lại bản gốc của bộ sưu tập khi cần thiết

Danh sách phương pháp

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

17

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

18 trả về mảng cơ bản được đại diện bởi bộ sưu tập

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

19

Bí danh cho phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

20

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

21

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

20 trả về giá trị trung bình của một khóa đã cho

$collection = collect[[1, 2, 3]];

1

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

23

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

24 chia bộ sưu tập thành nhiều bộ sưu tập nhỏ hơn với kích thước nhất định

$collection = collect[[1, 2, 3]];

4

Phương pháp này đặc biệt hữu ích trong các khung nhìn khi làm việc với hệ thống lưới như Bootstrap. Ví dụ: hãy tưởng tượng bạn có một bộ sưu tập các mô hình Eloquent mà bạn muốn hiển thị dưới dạng lưới

$collection = collect[[1, 2, 3]];

5

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

25

Phương pháp

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

26 chia bộ sưu tập thành nhiều bộ sưu tập nhỏ hơn dựa trên đánh giá của cuộc gọi lại đã cho. Biến

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

27 được truyền cho bao đóng có thể được sử dụng để kiểm tra phần tử trước đó

$collection = collect[[1, 2, 3]];

9

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

28

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

29 thu gọn một tập hợp các mảng thành một tập hợp phẳng duy nhất

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

2

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

30

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

00 trả về một phiên bản

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

02 mới với các mục hiện có trong bộ sưu tập

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

6

Phương pháp

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

00 chủ yếu hữu ích để chuyển đổi các bộ sưu tập lười biếng thành các phiên bản

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

02 tiêu chuẩn

$collection = collect[[1, 2, 3]];

0

Lưu ý
Phương pháp

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

00 đặc biệt hữu ích khi bạn có một phiên bản của

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

36 và cần một phiên bản bộ sưu tập không lười biếng. Vì

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

30 là một phần của hợp đồng

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

36, nên bạn có thể yên tâm sử dụng nó để lấy phiên bản

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

02.

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

40

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

41 kết hợp các giá trị của bộ sưu tập, dưới dạng các khóa, với các giá trị của một mảng hoặc bộ sưu tập khác

$collection = collect[[1, 2, 3]];

1

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

42

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

43 nối các giá trị của

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

44 hoặc bộ sưu tập đã cho vào phần cuối của bộ sưu tập khác

$collection = collect[[1, 2, 3]];

2

Phương pháp

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

43 lập chỉ mục lại các khóa bằng số cho các mục được nối với bộ sưu tập gốc. Để duy trì các khóa trong bộ sưu tập kết hợp, hãy xem phương pháp hợp nhất

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

46

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

47 xác định xem bộ sưu tập có chứa một mục nhất định hay không. Bạn có thể chuyển một bao đóng cho phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

47 để xác định xem một phần tử có tồn tại trong bộ sưu tập khớp với một bài kiểm tra sự thật đã cho hay không

$collection = collect[[1, 2, 3]];

3

Ngoài ra, bạn có thể chuyển một chuỗi tới phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

47 để xác định xem bộ sưu tập có chứa giá trị mục đã cho hay không

$collection = collect[[1, 2, 3]];

4

Bạn cũng có thể chuyển một cặp khóa/giá trị cho phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

47, phương thức này sẽ xác định xem cặp đã cho có tồn tại trong bộ sưu tập hay không

$collection = collect[[1, 2, 3]];

5

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];

  

$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

47 sử dụng so sánh "lỏng lẻo" khi kiểm tra giá trị mục, nghĩa là một chuỗi có giá trị nguyên sẽ được coi là bằng với một số nguyên có cùng giá trị. Sử dụng phương pháp

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

52 để lọc bằng cách so sánh "nghiêm ngặt"

Đối với nghịch đảo của

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

47, hãy xem phương thức khôngContain

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

54

Phương pháp

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

55 xác định xem bộ sưu tập có chứa một mục hay không

$collection = collect[[1, 2, 3]];

6

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

56

Phương thức này có cùng chữ ký với phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

47;

Lưu ý
Hành vi của phương thức này được sửa đổi khi sử dụng Bộ sưu tập Eloquent.

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

58

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

59 trả về tổng số mục trong bộ sưu tập

$collection = collect[[1, 2, 3]];

7

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

60

Phương pháp

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

61 đếm số lần xuất hiện của các giá trị trong bộ sưu tập. Theo mặc định, phương thức đếm số lần xuất hiện của mọi phần tử, cho phép bạn đếm một số "loại" phần tử nhất định trong bộ sưu tập

$collection = collect[[1, 2, 3]];

8

Bạn chuyển một lần đóng cho phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

61 để đếm tất cả các mục theo một giá trị tùy chỉnh

$collection = collect[[1, 2, 3]];

9

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

63

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

64 kết hợp chéo các giá trị của tập hợp giữa các mảng hoặc tập hợp đã cho, trả về một tích Descartes với tất cả các hoán vị có thể

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

0

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

65

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

66 kết xuất các mục của bộ sưu tập và kết thúc thực thi tập lệnh

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

1

Nếu bạn không muốn dừng thực thi tập lệnh, hãy sử dụng phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

67 để thay thế

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

68

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

69 so sánh bộ sưu tập với một bộ sưu tập khác hoặc một PHP

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

44 đơn giản dựa trên các giá trị của nó. Phương thức này sẽ trả về các giá trị trong bộ sưu tập ban đầu không có trong bộ sưu tập đã cho

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

2

Lưu ý
Hành vi của phương thức này được sửa đổi khi sử dụng Bộ sưu tập Eloquent.

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

71

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

72 so sánh bộ sưu tập với một bộ sưu tập khác hoặc một PHP

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

44 đơn giản dựa trên các khóa và giá trị của nó. Phương thức này sẽ trả về các cặp khóa/giá trị trong bộ sưu tập ban đầu không có trong bộ sưu tập đã cho

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

3

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

74

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

75 so sánh bộ sưu tập với một bộ sưu tập khác hoặc một PHP

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

44 đơn giản dựa trên các khóa của nó. Phương thức này sẽ trả về các cặp khóa/giá trị trong bộ sưu tập ban đầu không có trong bộ sưu tập đã cho

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

4

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

77

Phương pháp

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

78 xác định xem bộ sưu tập không chứa một mục nhất định. Bạn có thể chuyển một bao đóng cho phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

78 để xác định xem một phần tử không tồn tại trong bộ sưu tập có khớp với một bài kiểm tra sự thật đã cho hay không

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

5

Ngoài ra, bạn có thể chuyển một chuỗi tới phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

78 để xác định xem bộ sưu tập có chứa giá trị mục đã cho hay không

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

6

Bạn cũng có thể chuyển một cặp khóa/giá trị cho phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

78, phương thức này sẽ xác định xem cặp đã cho không tồn tại trong bộ sưu tập

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

7

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

78 sử dụng phép so sánh "lỏng lẻo" khi kiểm tra giá trị mục, nghĩa là một chuỗi có giá trị nguyên sẽ được coi là bằng một số nguyên có cùng giá trị

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

83

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

67 kết xuất các mục của bộ sưu tập

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

1

Nếu bạn muốn dừng thực thi tập lệnh sau khi kết xuất bộ sưu tập, hãy sử dụng phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

66 để thay thế

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

86

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

87 truy xuất và trả về các giá trị trùng lặp từ bộ sưu tập

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

9

Nếu bộ sưu tập chứa các mảng hoặc đối tượng, bạn có thể chuyển khóa của các thuộc tính mà bạn muốn kiểm tra các giá trị trùng lặp

firstWhere['colume name','value'];

20

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

88

Phương thức này có cùng chữ ký với phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

87;

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

90

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

91 lặp lại các mục trong bộ sưu tập và chuyển từng mục đến một bao đóng

firstWhere['colume name','value'];

21

Nếu bạn muốn ngừng lặp qua các mục, bạn có thể trả lại

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

92 từ lần đóng của mình

firstWhere['colume name','value'];

21

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

93

Phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

94 lặp lại các mục của bộ sưu tập, chuyển từng giá trị mục được lồng vào hàm gọi lại đã cho

firstWhere['colume name','value'];

23

Bạn có thể ngừng lặp qua các mục bằng cách trả lại

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

92 từ cuộc gọi lại

firstWhere['colume name','value'];

24

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

96

Phương pháp

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

97 có thể được sử dụng để xác minh rằng tất cả các phần tử của bộ sưu tập đều vượt qua một bài kiểm tra sự thật nhất định

firstWhere['colume name','value'];

25

Nếu bộ sưu tập trống, phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];

  

$upper = $collection->toUpper[];

97 sẽ trả về true

firstWhere['colume name','value'];

26

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

99

Phương thức

firstWhere['colume name','value'];

200 trả về tất cả các mục trong bộ sưu tập ngoại trừ những mục có khóa được chỉ định

firstWhere['colume name','value'];

27

Đối với nghịch đảo của

firstWhere['colume name','value'];

200, hãy xem phương pháp duy nhất

Lưu ý
Hành vi của phương thức này được sửa đổi khi sử dụng Bộ sưu tập Eloquent.

firstWhere['colume name','value'];

202

Phương pháp

firstWhere['colume name','value'];

203 lọc bộ sưu tập bằng cách sử dụng lệnh gọi lại đã cho, chỉ giữ lại những mục vượt qua bài kiểm tra độ tin cậy nhất định

firstWhere['colume name','value'];

28

Nếu không cung cấp lệnh gọi lại, tất cả các mục nhập của bộ sưu tập tương đương với

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

92 sẽ bị xóa

firstWhere['colume name','value'];

29

Đối với nghịch đảo của

firstWhere['colume name','value'];

203, hãy xem phương pháp từ chối

firstWhere['colume name','value'];

206

Phương thức

firstWhere['colume name','value'];

207 trả về phần tử đầu tiên trong bộ sưu tập vượt qua bài kiểm tra sự thật nhất định

$collection = collect[[1, 2, 3]];

10

Bạn cũng có thể gọi phương thức

firstWhere['colume name','value'];

207 không có đối số để lấy phần tử đầu tiên trong tập hợp. Nếu bộ sưu tập trống,

firstWhere['colume name','value'];

209 được trả về

$collection = collect[[1, 2, 3]];

11

firstWhere['colume name','value'];

210

Phương pháp

firstWhere['colume name','value'];

211 giống với phương pháp

firstWhere['colume name','value'];

207;

$collection = collect[[1, 2, 3]];

12

Bạn cũng có thể gọi phương thức

firstWhere['colume name','value'];

211 không có đối số để lấy phần tử đầu tiên trong tập hợp. Nếu bộ sưu tập trống, một ngoại lệ

firstWhere['colume name','value'];

213 sẽ được đưa ra

$collection = collect[[1, 2, 3]];

13

firstWhere['colume name','value'];

216

Phương thức

firstWhere['colume name','value'];

217 trả về phần tử đầu tiên trong bộ sưu tập với cặp khóa/giá trị đã cho

$collection = collect[[1, 2, 3]];

14

Bạn cũng có thể gọi phương thức

firstWhere['colume name','value'];

217 với toán tử so sánh

$collection = collect[[1, 2, 3]];

15

Giống như phương thức where, bạn có thể truyền một đối số cho phương thức

firstWhere['colume name','value'];

217. Trong trường hợp này, phương thức

firstWhere['colume name','value'];

217 sẽ trả về mục đầu tiên có giá trị của khóa mục đã cho là "trung thực"

$collection = collect[[1, 2, 3]];

16

firstWhere['colume name','value'];

221

Phương thức

firstWhere['colume name','value'];

222 lặp qua bộ sưu tập và chuyển từng giá trị cho bao đóng đã cho. Việc đóng cửa có thể tự do sửa đổi mục và trả lại, do đó tạo thành một bộ sưu tập mới gồm các mục đã sửa đổi. Sau đó, mảng được san bằng một cấp

$collection = collect[[1, 2, 3]];

17

firstWhere['colume name','value'];

223

Phương pháp

firstWhere['colume name','value'];

224 làm phẳng một tập hợp nhiều chiều thành một chiều duy nhất

$collection = collect[[1, 2, 3]];

18

Nếu cần, bạn có thể chuyển đối số "độ sâu" cho phương thức

firstWhere['colume name','value'];

224

$collection = collect[[1, 2, 3]];

19

Trong ví dụ này, việc gọi

firstWhere['colume name','value'];

224 mà không cung cấp độ sâu cũng sẽ làm phẳng các mảng lồng nhau, dẫn đến kết quả là

firstWhere['colume name','value'];

227. Cung cấp độ sâu cho phép bạn chỉ định số lượng các mảng lồng nhau sẽ được làm phẳng

firstWhere['colume name','value'];

228

Phương thức

firstWhere['colume name','value'];

229 hoán đổi các khóa của bộ sưu tập với các giá trị tương ứng của chúng

$collection = collect[[1, 2, 3]];

40

firstWhere['colume name','value'];

230

Phương pháp

firstWhere['colume name','value'];

231 xóa một mục khỏi bộ sưu tập bằng khóa của nó

$collection = collect[[1, 2, 3]];

41

Cảnh báo
Không giống như hầu hết các phương pháp thu thập khác,

firstWhere['colume name','value'];

231 không trả về một bộ sưu tập mới đã sửa đổi; .

firstWhere['colume name','value'];

233

Phương thức

firstWhere['colume name','value'];

234 trả về một bộ sưu tập mới chứa các mục sẽ có trên một số trang nhất định. Phương thức chấp nhận số trang làm đối số đầu tiên và số lượng mục hiển thị trên mỗi trang làm đối số thứ hai

$collection = collect[[1, 2, 3]];

42

firstWhere['colume name','value'];

235

Phương thức

firstWhere['colume name','value'];

236 trả về mục tại một khóa nhất định. Nếu khóa không tồn tại,

firstWhere['colume name','value'];

209 được trả về

$collection = collect[[1, 2, 3]];

43

Bạn có thể tùy chọn chuyển một giá trị mặc định làm đối số thứ hai

$collection = collect[[1, 2, 3]];

44

Bạn thậm chí có thể chuyển một cuộc gọi lại làm giá trị mặc định của phương thức. Kết quả của cuộc gọi lại sẽ được trả về nếu khóa được chỉ định không tồn tại

$collection = collect[[1, 2, 3]];

45

firstWhere['colume name','value'];

238

Phương pháp

firstWhere['colume name','value'];

239 nhóm các mục của bộ sưu tập theo một khóa nhất định

$collection = collect[[1, 2, 3]];

46

Thay vì chuyển một chuỗi

firstWhere['colume name','value'];

240, bạn có thể chuyển một cuộc gọi lại. Cuộc gọi lại sẽ trả về giá trị bạn muốn khóa nhóm theo

$collection = collect[[1, 2, 3]];

47

Nhiều tiêu chí nhóm có thể được thông qua dưới dạng một mảng. Mỗi phần tử của mảng sẽ được áp vào mức tương ứng trong mảng nhiều chiều

$collection = collect[[1, 2, 3]];

48

firstWhere['colume name','value'];

241

Phương thức

firstWhere['colume name','value'];

242 xác định xem một khóa đã cho có tồn tại trong bộ sưu tập hay không

$collection = collect[[1, 2, 3]];

49

firstWhere['colume name','value'];

243

Phương thức

firstWhere['colume name','value'];

244 xác định xem có bất kỳ khóa nào trong số các khóa đã cho tồn tại trong bộ sưu tập hay không

$collection = collect[[1, 2, 3]];

50

firstWhere['colume name','value'];

245

Phương thức

firstWhere['colume name','value'];

246 tham gia các mục trong một bộ sưu tập. Đối số của nó phụ thuộc vào loại mục trong bộ sưu tập. Nếu bộ sưu tập chứa các mảng hoặc đối tượng, bạn nên chuyển khóa của các thuộc tính mà bạn muốn tham gia và chuỗi "keo" mà bạn muốn đặt giữa các giá trị

$collection = collect[[1, 2, 3]];

51

Nếu bộ sưu tập chứa các chuỗi đơn giản hoặc giá trị số, bạn nên chuyển "keo" làm đối số duy nhất cho phương thức

$collection = collect[[1, 2, 3]];

52

Bạn có thể chuyển một bao đóng cho phương thức

firstWhere['colume name','value'];

246 nếu bạn muốn định dạng các giá trị được ẩn

$collection = collect[[1, 2, 3]];

53

firstWhere['colume name','value'];

248

Phương pháp

firstWhere['colume name','value'];

249 loại bỏ bất kỳ giá trị nào khỏi bộ sưu tập ban đầu không có trong

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

44 hoặc bộ sưu tập đã cho. Bộ sưu tập kết quả sẽ bảo toàn các khóa của bộ sưu tập gốc

$collection = collect[[1, 2, 3]];

54

Lưu ý
Hành vi của phương thức này được sửa đổi khi sử dụng Bộ sưu tập Eloquent.

firstWhere['colume name','value'];

251

Phương pháp

firstWhere['colume name','value'];

252 loại bỏ bất kỳ khóa nào và các giá trị tương ứng của chúng khỏi bộ sưu tập ban đầu không có trong

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

44 hoặc bộ sưu tập đã cho

$collection = collect[[1, 2, 3]];

55

firstWhere['colume name','value'];

254

Phương thức

firstWhere['colume name','value'];

255 trả về

firstWhere['colume name','value'];

256 nếu bộ sưu tập trống;

firstWhere['colume name','value'];

258

Phương thức

firstWhere['colume name','value'];

259 trả về

firstWhere['colume name','value'];

256 nếu bộ sưu tập không trống;

$collection = collect[[1, 2, 3]];

56

firstWhere['colume name','value'];

262

Phương thức

firstWhere['colume name','value'];

263 kết hợp các giá trị của bộ sưu tập với một chuỗi. Sử dụng đối số thứ hai của phương thức này, bạn cũng có thể chỉ định cách thêm phần tử cuối cùng vào chuỗi

$collection = collect[[1, 2, 3]];

57

firstWhere['colume name','value'];

264

Phương thức

firstWhere['colume name','value'];

265 khóa bộ sưu tập theo khóa đã cho. Nếu nhiều mục có cùng khóa, chỉ mục cuối cùng sẽ xuất hiện trong bộ sưu tập mới

$collection = collect[[1, 2, 3]];

58

Bạn cũng có thể chuyển một cuộc gọi lại cho phương thức. Cuộc gọi lại sẽ trả về giá trị để khóa bộ sưu tập theo

$collection = collect[[1, 2, 3]];

59

firstWhere['colume name','value'];

266

Phương thức

firstWhere['colume name','value'];

267 trả về tất cả các khóa của bộ sưu tập

$collection = collect[[1, 2, 3]];

90

firstWhere['colume name','value'];

268

Phương thức

firstWhere['colume name','value'];

269 trả về phần tử cuối cùng trong bộ sưu tập vượt qua bài kiểm tra sự thật đã cho

$collection = collect[[1, 2, 3]];

91

Bạn cũng có thể gọi phương thức

firstWhere['colume name','value'];

269 không có đối số để lấy phần tử cuối cùng trong tập hợp. Nếu bộ sưu tập trống,

firstWhere['colume name','value'];

209 được trả về

$collection = collect[[1, 2, 3]];

92

firstWhere['colume name','value'];

272

Phương thức

firstWhere['colume name','value'];

273 trả về một phiên bản

firstWhere['colume name','value'];

274 mới từ mảng các mục bên dưới

$collection = collect[[1, 2, 3]];

93

Điều này đặc biệt hữu ích khi bạn cần thực hiện các phép biến đổi trên một

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

02 khổng lồ chứa nhiều mục

$collection = collect[[1, 2, 3]];

94

Bằng cách chuyển đổi bộ sưu tập thành

firstWhere['colume name','value'];

274, chúng tôi tránh phải phân bổ nhiều bộ nhớ bổ sung. Mặc dù bộ sưu tập ban đầu vẫn giữ các giá trị của nó trong bộ nhớ, các bộ lọc tiếp theo sẽ không. Do đó, hầu như không có bộ nhớ bổ sung nào được phân bổ khi lọc kết quả của bộ sưu tập

firstWhere['colume name','value'];

277

Phương thức tĩnh

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

10 cho phép bạn thêm các phương thức vào lớp

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

02 trong thời gian chạy. Tham khảo tài liệu về mở rộng bộ sưu tập để biết thêm thông tin

firstWhere['colume name','value'];

280

Phương thức tĩnh

firstWhere['colume name','value'];

281 tạo một thể hiện bộ sưu tập mới. Xem phần Tạo bộ sưu tập

firstWhere['colume name','value'];

282

Phương thức

firstWhere['colume name','value'];

283 lặp qua bộ sưu tập và chuyển từng giá trị cho cuộc gọi lại đã cho. Cuộc gọi lại có thể tự do sửa đổi mục và trả lại mục đó, do đó tạo thành một bộ sưu tập mới gồm các mục đã sửa đổi

$collection = collect[[1, 2, 3]];

95

Cảnh báo
Giống như hầu hết các phương pháp thu thập khác,

firstWhere['colume name','value'];

283 trả về một phiên bản thu thập mới; . Nếu bạn muốn chuyển đổi bộ sưu tập ban đầu, hãy sử dụng phương pháp

firstWhere['colume name','value'];

285.

firstWhere['colume name','value'];

286

Phương thức

firstWhere['colume name','value'];

286 lặp lại bộ sưu tập, tạo một thể hiện mới của lớp đã cho bằng cách chuyển giá trị vào hàm tạo

$collection = collect[[1, 2, 3]];

96

firstWhere['colume name','value'];

288

Phương thức

firstWhere['colume name','value'];

289 lặp lại các mục của bộ sưu tập, chuyển từng giá trị mục lồng nhau vào bao đóng đã cho. Việc đóng cửa có thể tự do sửa đổi mục và trả lại, do đó tạo thành một bộ sưu tập mới gồm các mục đã sửa đổi

$collection = collect[[1, 2, 3]];

97

firstWhere['colume name','value'];

290

Phương pháp

firstWhere['colume name','value'];

291 nhóm các mục của bộ sưu tập theo cách đóng đã cho. Việc đóng sẽ trả về một mảng kết hợp chứa một cặp khóa/giá trị duy nhất, do đó tạo thành một tập hợp các giá trị được nhóm mới

$collection = collect[[1, 2, 3]];

98

firstWhere['colume name','value'];

292

Phương thức

firstWhere['colume name','value'];

293 lặp qua bộ sưu tập và chuyển từng giá trị cho cuộc gọi lại đã cho. Cuộc gọi lại sẽ trả về một mảng kết hợp chứa một cặp khóa/giá trị

$collection = collect[[1, 2, 3]];

99

firstWhere['colume name','value'];

294

Phương thức

firstWhere['colume name','value'];

295 trả về giá trị lớn nhất của một khóa đã cho

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

20

firstWhere['colume name','value'];

296

Phương thức

firstWhere['colume name','value'];

297 trả về giá trị trung bình của một khóa đã cho

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

21

firstWhere['colume name','value'];

298

Phương thức

firstWhere['colume name','value'];

299 hợp nhất mảng hoặc bộ sưu tập đã cho với bộ sưu tập ban đầu. Nếu khóa chuỗi trong các mục nhất định khớp với khóa chuỗi trong bộ sưu tập ban đầu, thì giá trị của mục đã cho sẽ ghi đè lên giá trị trong bộ sưu tập ban đầu

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

22

Nếu các khóa của mục nhất định là số, các giá trị sẽ được thêm vào cuối bộ sưu tập

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

23

$collection = collect[[1, 2, 3]];

100

Phương thức

$collection = collect[[1, 2, 3]];

101 kết hợp đệ quy mảng hoặc bộ sưu tập đã cho với bộ sưu tập ban đầu. Nếu một khóa chuỗi trong các mục đã cho khớp với một khóa chuỗi trong bộ sưu tập ban đầu, thì các giá trị cho các khóa này sẽ được hợp nhất với nhau thành một mảng và điều này được thực hiện theo cách đệ quy

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

24

$collection = collect[[1, 2, 3]];

102

Phương thức

$collection = collect[[1, 2, 3]];

103 trả về giá trị tối thiểu của một khóa đã cho

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

25

$collection = collect[[1, 2, 3]];

104

Phương thức

$collection = collect[[1, 2, 3]];

105 trả về giá trị chế độ của một khóa đã cho

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

26

$collection = collect[[1, 2, 3]];

106

Phương thức

$collection = collect[[1, 2, 3]];

107 tạo một bộ sưu tập mới bao gồm mọi phần tử thứ n

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

27

Bạn có thể tùy ý chuyển phần bù bắt đầu làm đối số thứ hai

$collection = collect[[1, 2, 3]];

108

Phương thức

$collection = collect[[1, 2, 3]];

109 trả về các mục trong bộ sưu tập với các khóa được chỉ định

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

28

Đối với nghịch đảo của

$collection = collect[[1, 2, 3]];

109, hãy xem phương pháp ngoại trừ

Lưu ý
Hành vi của phương thức này được sửa đổi khi sử dụng Bộ sưu tập Eloquent.

$collection = collect[[1, 2, 3]];

111

Phương thức

$collection = collect[[1, 2, 3]];

112 sẽ điền vào mảng với giá trị đã cho cho đến khi mảng đạt đến kích thước đã chỉ định. Phương thức này hoạt động giống như hàm Array_pad PHP

Để đệm sang trái, bạn nên chỉ định kích thước âm. Sẽ không có phần đệm nào diễn ra nếu giá trị tuyệt đối của kích thước đã cho nhỏ hơn hoặc bằng độ dài của mảng

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

29

$collection = collect[[1, 2, 3]];

113

Phương thức

$collection = collect[[1, 2, 3]];

114 có thể được kết hợp với việc phá hủy mảng PHP để phân tách các phần tử vượt qua bài kiểm tra sự thật đã cho với những phần tử không

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

60

$collection = collect[[1, 2, 3]];

115

Phương thức

$collection = collect[[1, 2, 3]];

116 chuyển bộ sưu tập tới bao đóng đã cho và trả về kết quả của bao đóng đã thực hiện

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

61

$collection = collect[[1, 2, 3]];

117

Phương thức

$collection = collect[[1, 2, 3]];

118 tạo một thể hiện mới của lớp đã cho và chuyển bộ sưu tập vào hàm tạo

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

62

$collection = collect[[1, 2, 3]];

119

Phương thức

$collection = collect[[1, 2, 3]];

120 chuyển bộ sưu tập tới mảng các lần đóng đã cho và trả về kết quả của các lần đóng đã thực hiện

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

63

$collection = collect[[1, 2, 3]];

121

Phương thức

$collection = collect[[1, 2, 3]];

122 truy xuất tất cả các giá trị cho một khóa đã cho

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

64

Bạn cũng có thể chỉ định cách bạn muốn bộ sưu tập kết quả được khóa

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

65

Phương thức

$collection = collect[[1, 2, 3]];

122 cũng hỗ trợ truy xuất các giá trị lồng nhau bằng cách sử dụng ký hiệu "dấu chấm"

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

66

Nếu tồn tại các khóa trùng lặp, phần tử phù hợp cuối cùng sẽ được chèn vào bộ sưu tập đã chọn

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

67

$collection = collect[[1, 2, 3]];

124

Phương thức

$collection = collect[[1, 2, 3]];

125 loại bỏ và trả về mục cuối cùng từ bộ sưu tập

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

68

Bạn có thể chuyển một số nguyên cho phương thức

$collection = collect[[1, 2, 3]];

125 để xóa và trả lại nhiều mục từ phần cuối của bộ sưu tập

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

68

$collection = collect[[1, 2, 3]];

127

Phương pháp

$collection = collect[[1, 2, 3]];

128 thêm một mục vào đầu bộ sưu tập

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];

  

$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

68

Bạn cũng có thể chuyển đối số thứ hai để chỉ định khóa của mục được thêm vào trước

$collection = collect[[1, 2, 3]];

01

$collection = collect[[1, 2, 3]];

129

Phương thức

$collection = collect[[1, 2, 3]];

130 loại bỏ và trả về một mục từ bộ sưu tập bằng khóa của nó

$collection = collect[[1, 2, 3]];

02

$collection = collect[[1, 2, 3]];

131

Phương thức

$collection = collect[[1, 2, 3]];

132 nối thêm một mục vào cuối bộ sưu tập

$collection = collect[[1, 2, 3]];

7

$collection = collect[[1, 2, 3]];

133

Phương thức

$collection = collect[[1, 2, 3]];

134 đặt khóa và giá trị đã cho trong bộ sưu tập

$collection = collect[[1, 2, 3]];

04

$collection = collect[[1, 2, 3]];

135

Phương thức

$collection = collect[[1, 2, 3]];

136 trả về một mục ngẫu nhiên từ bộ sưu tập

$collection = collect[[1, 2, 3]];

05

Bạn có thể chuyển một số nguyên tới

$collection = collect[[1, 2, 3]];

136 để chỉ định số lượng mục bạn muốn truy xuất ngẫu nhiên. Một bộ sưu tập các mặt hàng luôn được trả về khi chuyển rõ ràng số lượng mặt hàng bạn muốn nhận

$collection = collect[[1, 2, 3]];

06

Nếu thể hiện bộ sưu tập có ít mục hơn so với yêu cầu, phương thức

$collection = collect[[1, 2, 3]];

136 sẽ đưa ra một

$collection = collect[[1, 2, 3]];

139

Phương thức

$collection = collect[[1, 2, 3]];

136 cũng chấp nhận một bao đóng, sẽ nhận thể hiện bộ sưu tập hiện tại

$collection = collect[[1, 2, 3]];

07

$collection = collect[[1, 2, 3]];

141

Phương thức

$collection = collect[[1, 2, 3]];

142 trả về một tập hợp chứa các số nguyên nằm trong phạm vi đã chỉ định

$collection = collect[[1, 2, 3]];

08

$collection = collect[[1, 2, 3]];

143

Phương pháp

$collection = collect[[1, 2, 3]];

144 giảm bộ sưu tập thành một giá trị duy nhất, chuyển kết quả của mỗi lần lặp vào lần lặp tiếp theo

$collection = collect[[1, 2, 3]];

09

Giá trị của

$collection = collect[[1, 2, 3]];

145 trong lần lặp đầu tiên là

firstWhere['colume name','value'];

209;

$collection = collect[[1, 2, 3]];

10

Phương thức

$collection = collect[[1, 2, 3]];

144 cũng chuyển các khóa mảng trong các bộ sưu tập kết hợp tới hàm gọi lại đã cho

$collection = collect[[1, 2, 3]];

11

$collection = collect[[1, 2, 3]];

149

Phương thức

$collection = collect[[1, 2, 3]];

150 rút gọn bộ sưu tập thành một mảng giá trị, chuyển kết quả của mỗi lần lặp vào lần lặp tiếp theo. Phương pháp này tương tự như phương pháp

$collection = collect[[1, 2, 3]];

144;

$collection = collect[[1, 2, 3]];

12

$collection = collect[[1, 2, 3]];

152

Phương thức

$collection = collect[[1, 2, 3]];

153 lọc bộ sưu tập bằng cách sử dụng bao đóng đã cho. Việc đóng sẽ trả về

firstWhere['colume name','value'];

256 nếu mục này sẽ bị xóa khỏi bộ sưu tập kết quả

$collection = collect[[1, 2, 3]];

13

Đối với nghịch đảo của phương pháp

$collection = collect[[1, 2, 3]];

153, xem phương pháp

firstWhere['colume name','value'];

203

$collection = collect[[1, 2, 3]];

157

Phương thức

$collection = collect[[1, 2, 3]];

158 hoạt động tương tự như

firstWhere['colume name','value'];

299;

$collection = collect[[1, 2, 3]];

14

$collection = collect[[1, 2, 3]];

161

Phương thức này hoạt động giống như

$collection = collect[[1, 2, 3]];

158, nhưng nó sẽ lặp lại thành các mảng và áp dụng quy trình thay thế tương tự cho các giá trị bên trong

$collection = collect[[1, 2, 3]];

15

$collection = collect[[1, 2, 3]];

163

Phương pháp

$collection = collect[[1, 2, 3]];

164 đảo ngược thứ tự các mục của bộ sưu tập, giữ nguyên các khóa ban đầu

$collection = collect[[1, 2, 3]];

16

$collection = collect[[1, 2, 3]];

165

Phương thức

$collection = collect[[1, 2, 3]];

166 tìm kiếm bộ sưu tập cho giá trị đã cho và trả về khóa của nó nếu tìm thấy. Nếu mục không được tìm thấy,

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

92 được trả lại

$collection = collect[[1, 2, 3]];

17

Việc tìm kiếm được thực hiện bằng cách so sánh "lỏng lẻo", nghĩa là một chuỗi có giá trị nguyên sẽ được coi là bằng một số nguyên có cùng giá trị. Để sử dụng phép so sánh "nghiêm ngặt", hãy chuyển

firstWhere['colume name','value'];

256 làm đối số thứ hai cho phương thức

$collection = collect[[1, 2, 3]];

18

Ngoài ra, bạn có thể cung cấp cách đóng của riêng mình để tìm kiếm mục đầu tiên vượt qua bài kiểm tra độ tin cậy nhất định

$collection = collect[[1, 2, 3]];

19

$collection = collect[[1, 2, 3]];

169

Phương thức

$collection = collect[[1, 2, 3]];

170 loại bỏ và trả về mục đầu tiên từ bộ sưu tập

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

68

Bạn có thể chuyển một số nguyên cho phương thức

$collection = collect[[1, 2, 3]];

170 để xóa và trả lại nhiều mục từ đầu bộ sưu tập

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

68

$collection = collect[[1, 2, 3]];

172

Phương pháp

$collection = collect[[1, 2, 3]];

173 xáo trộn ngẫu nhiên các mục trong bộ sưu tập

$collection = collect[[1, 2, 3]];

22

$collection = collect[[1, 2, 3]];

174

Phương thức

$collection = collect[[1, 2, 3]];

175 trả về một bộ sưu tập mới, với số phần tử đã cho bị xóa khỏi phần đầu của bộ sưu tập

$collection = collect[[1, 2, 3]];

23

$collection = collect[[1, 2, 3]];

176

Phương thức

$collection = collect[[1, 2, 3]];

177 bỏ qua các mục từ bộ sưu tập cho đến khi hàm gọi lại đã cho trả về

firstWhere['colume name','value'];

256 và sau đó trả về các mục còn lại trong bộ sưu tập dưới dạng phiên bản bộ sưu tập mới

$collection = collect[[1, 2, 3]];

24

Bạn cũng có thể chuyển một giá trị đơn giản cho phương thức

$collection = collect[[1, 2, 3]];

177 để bỏ qua tất cả các mục cho đến khi tìm thấy giá trị đã cho

$collection = collect[[1, 2, 3]];

25

Cảnh báo
Nếu không tìm thấy giá trị đã cho hoặc lệnh gọi lại không bao giờ trả về

firstWhere['colume name','value'];

256, thì phương thức

$collection = collect[[1, 2, 3]];

177 sẽ trả về một tập hợp rỗng.

$collection = collect[[1, 2, 3]];

182

Phương thức

$collection = collect[[1, 2, 3]];

183 bỏ qua các mục từ bộ sưu tập trong khi hàm gọi lại đã cho trả về

firstWhere['colume name','value'];

256 và sau đó trả về các mục còn lại trong bộ sưu tập dưới dạng một bộ sưu tập mới

$collection = collect[[1, 2, 3]];

26

Cảnh báo
Nếu lệnh gọi lại không bao giờ trả về

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

92, thì phương thức

$collection = collect[[1, 2, 3]];

183 sẽ trả về một bộ sưu tập trống.

$collection = collect[[1, 2, 3]];

187

Phương thức

$collection = collect[[1, 2, 3]];

188 trả về một phần của bộ sưu tập bắt đầu từ chỉ mục đã cho

$collection = collect[[1, 2, 3]];

27

Nếu bạn muốn giới hạn kích thước của lát cắt được trả về, hãy chuyển kích thước mong muốn làm đối số thứ hai cho phương thức

$collection = collect[[1, 2, 3]];

28

Theo mặc định, lát cắt được trả về sẽ giữ nguyên các khóa. Nếu bạn không muốn giữ lại các khóa ban đầu, bạn có thể sử dụng phương thức

$collection = collect[[1, 2, 3]];

189 để lập chỉ mục lại chúng

$collection = collect[[1, 2, 3]];

190

Phương thức

$collection = collect[[1, 2, 3]];

191 trả về một tập hợp các khối mới biểu thị chế độ xem "cửa sổ trượt" của các mục trong bộ sưu tập

$collection = collect[[1, 2, 3]];

29

Điều này đặc biệt hữu ích khi kết hợp với phương pháp

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

94

$collection = collect[[1, 2, 3]];

30

Bạn có thể tùy chọn chuyển giá trị "bước" thứ hai, giá trị này xác định khoảng cách giữa mục đầu tiên của mỗi đoạn

$collection = collect[[1, 2, 3]];

31

$collection = collect[[1, 2, 3]];

193

Phương thức

$collection = collect[[1, 2, 3]];

194 trả về phần tử đầu tiên trong bộ sưu tập vượt qua bài kiểm tra giá trị thực nhất định, nhưng chỉ khi bài kiểm tra giá trị thực khớp với chính xác một phần tử

$collection = collect[[1, 2, 3]];

32

Bạn cũng có thể chuyển một cặp khóa/giá trị cho phương thức

$collection = collect[[1, 2, 3]];

194, phương thức này sẽ trả về phần tử đầu tiên trong bộ sưu tập khớp với cặp đã cho, nhưng chỉ khi nó khớp chính xác với một phần tử

$collection = collect[[1, 2, 3]];

33

Ngoài ra, bạn cũng có thể gọi phương thức

$collection = collect[[1, 2, 3]];

194 không có đối số để lấy phần tử đầu tiên trong tập hợp nếu chỉ có một phần tử

$collection = collect[[1, 2, 3]];

34

Nếu không có phần tử nào trong bộ sưu tập cần được trả về bằng phương thức

$collection = collect[[1, 2, 3]];

194, một ngoại lệ

$collection = collect[[1, 2, 3]];

198 sẽ được đưa ra. Nếu có nhiều hơn một phần tử cần được trả về, một

$collection = collect[[1, 2, 3]];

199 sẽ được ném ra

$collection = collect[[1, 2, 3]];

400

Bí danh cho phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

47

$collection = collect[[1, 2, 3]];

402

Phương thức

$collection = collect[[1, 2, 3]];

403 sắp xếp bộ sưu tập. Bộ sưu tập được sắp xếp giữ các khóa mảng ban đầu, vì vậy trong ví dụ sau, chúng tôi sẽ sử dụng phương pháp

$collection = collect[[1, 2, 3]];

189 để đặt lại các khóa thành các chỉ mục được đánh số liên tiếp

$collection = collect[[1, 2, 3]];

35

Nếu nhu cầu sắp xếp của bạn nâng cao hơn, bạn có thể chuyển một cuộc gọi lại tới

$collection = collect[[1, 2, 3]];

403 bằng thuật toán của riêng bạn. Tham khảo tài liệu PHP trên

$collection = collect[[1, 2, 3]];

406, đây là cách gọi phương thức

$collection = collect[[1, 2, 3]];

403 của bộ sưu tập sử dụng nội bộ

Lưu ý
Nếu bạn cần sắp xếp một tập hợp các mảng hoặc đối tượng lồng nhau, hãy xem các phương thức

$collection = collect[[1, 2, 3]];

408 và

$collection = collect[[1, 2, 3]];

409.

$collection = collect[[1, 2, 3]];

410

Phương thức

$collection = collect[[1, 2, 3]];

408 sắp xếp bộ sưu tập theo khóa đã cho. Bộ sưu tập được sắp xếp giữ các khóa mảng ban đầu, vì vậy trong ví dụ sau, chúng tôi sẽ sử dụng phương pháp

$collection = collect[[1, 2, 3]];

189 để đặt lại các khóa thành các chỉ mục được đánh số liên tiếp

$collection = collect[[1, 2, 3]];

36

Phương thức

$collection = collect[[1, 2, 3]];

408 chấp nhận các cờ sắp xếp làm đối số thứ hai của nó

$collection = collect[[1, 2, 3]];

37

Ngoài ra, bạn có thể chuyển bao đóng của riêng mình để xác định cách sắp xếp các giá trị của bộ sưu tập

$collection = collect[[1, 2, 3]];

38

Nếu bạn muốn sắp xếp bộ sưu tập của mình theo nhiều thuộc tính, bạn có thể chuyển một mảng các thao tác sắp xếp cho phương thức

$collection = collect[[1, 2, 3]];

408. Mỗi thao tác sắp xếp phải là một mảng bao gồm thuộc tính mà bạn muốn sắp xếp theo và hướng sắp xếp mong muốn

$collection = collect[[1, 2, 3]];

39

Khi sắp xếp một bộ sưu tập theo nhiều thuộc tính, bạn cũng có thể cung cấp các bao đóng xác định từng thao tác sắp xếp

$collection = collect[[1, 2, 3]];

40

$collection = collect[[1, 2, 3]];

415

Phương thức này có cùng chữ ký với phương thức

$collection = collect[[1, 2, 3]];

408, nhưng sẽ sắp xếp bộ sưu tập theo thứ tự ngược lại

$collection = collect[[1, 2, 3]];

417

Phương pháp này sẽ sắp xếp bộ sưu tập theo thứ tự ngược lại như phương pháp

$collection = collect[[1, 2, 3]];

403

$collection = collect[[1, 2, 3]];

41

Không giống như

$collection = collect[[1, 2, 3]];

403, bạn không thể chuyển một đóng cho

$collection = collect[[1, 2, 3]];

420. Thay vào đó, bạn nên sử dụng phương pháp

$collection = collect[[1, 2, 3]];

403 và đảo ngược phép so sánh của mình

$collection = collect[[1, 2, 3]];

422

Phương thức

$collection = collect[[1, 2, 3]];

423 sắp xếp bộ sưu tập theo các khóa của mảng kết hợp cơ bản

$collection = collect[[1, 2, 3]];

42

$collection = collect[[1, 2, 3]];

424

Phương thức này có cùng chữ ký với phương thức

$collection = collect[[1, 2, 3]];

423, nhưng sẽ sắp xếp bộ sưu tập theo thứ tự ngược lại

$collection = collect[[1, 2, 3]];

426

Phương thức

$collection = collect[[1, 2, 3]];

427 sắp xếp bộ sưu tập theo các khóa của mảng kết hợp cơ bản bằng cách sử dụng hàm gọi lại

$collection = collect[[1, 2, 3]];

43

Hàm gọi lại phải là một hàm so sánh trả về một số nguyên nhỏ hơn, bằng hoặc lớn hơn 0. Để biết thêm thông tin, hãy tham khảo tài liệu PHP trên

$collection = collect[[1, 2, 3]];

428, đây là hàm PHP mà phương thức

$collection = collect[[1, 2, 3]];

427 sử dụng nội bộ

$collection = collect[[1, 2, 3]];

430

Phương thức

$collection = collect[[1, 2, 3]];

431 xóa và trả về một lát mục bắt đầu từ chỉ mục đã chỉ định

$collection = collect[[1, 2, 3]];

44

Bạn có thể chuyển đối số thứ hai để giới hạn kích thước của bộ sưu tập kết quả

$collection = collect[[1, 2, 3]];

45

Ngoài ra, bạn có thể chuyển đối số thứ ba chứa các mục mới để thay thế các mục đã bị xóa khỏi bộ sưu tập

$collection = collect[[1, 2, 3]];

46

$collection = collect[[1, 2, 3]];

432

Phương thức

$collection = collect[[1, 2, 3]];

433 chia một bộ sưu tập thành một số nhóm nhất định

$collection = collect[[1, 2, 3]];

47

$collection = collect[[1, 2, 3]];

434

Phương thức

$collection = collect[[1, 2, 3]];

435 chia một tập hợp thành một số nhóm nhất định, lấp đầy hoàn toàn các nhóm không đầu cuối trước khi phân bổ phần còn lại cho nhóm cuối cùng

$collection = collect[[1, 2, 3]];

48

$collection = collect[[1, 2, 3]];

436

Phương thức

$collection = collect[[1, 2, 3]];

437 trả về tổng của tất cả các mục trong bộ sưu tập

$collection = collect[[1, 2, 3]];

49

Nếu bộ sưu tập chứa các mảng hoặc đối tượng lồng nhau, bạn nên chuyển một khóa sẽ được sử dụng để xác định giá trị nào cần tính tổng

$collection = collect[[1, 2, 3]];

50

Ngoài ra, bạn có thể chuyển bao đóng của riêng mình để xác định giá trị nào của bộ sưu tập sẽ tính tổng

$collection = collect[[1, 2, 3]];

51

$collection = collect[[1, 2, 3]];

438

Phương thức

$collection = collect[[1, 2, 3]];

439 trả về một bộ sưu tập mới với số lượng mục được chỉ định

$collection = collect[[1, 2, 3]];

52

Bạn cũng có thể chuyển một số nguyên âm để lấy số mục đã chỉ định từ cuối bộ sưu tập

$collection = collect[[1, 2, 3]];

53

$collection = collect[[1, 2, 3]];

440

Phương thức

$collection = collect[[1, 2, 3]];

441 trả về các mục trong bộ sưu tập cho đến khi hàm gọi lại đã cho trả về

firstWhere['colume name','value'];

256

$collection = collect[[1, 2, 3]];

54

Bạn cũng có thể chuyển một giá trị đơn giản cho phương thức

$collection = collect[[1, 2, 3]];

441 để lấy các mục cho đến khi tìm thấy giá trị đã cho

$collection = collect[[1, 2, 3]];

55

Cảnh báo
Nếu không tìm thấy giá trị đã cho hoặc lệnh gọi lại không bao giờ trả về

firstWhere['colume name','value'];

256, phương thức

$collection = collect[[1, 2, 3]];

441 sẽ trả về tất cả các mục trong bộ sưu tập.

$collection = collect[[1, 2, 3]];

446

Phương thức

$collection = collect[[1, 2, 3]];

447 trả về các mục trong bộ sưu tập cho đến khi hàm gọi lại đã cho trả về

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

92

$collection = collect[[1, 2, 3]];

56

Cảnh báo
Nếu lệnh gọi lại không bao giờ trả về

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

92, phương thức

$collection = collect[[1, 2, 3]];

447 sẽ trả về tất cả các mục trong bộ sưu tập.

$collection = collect[[1, 2, 3]];

451

Phương thức

$collection = collect[[1, 2, 3]];

452 chuyển bộ sưu tập tới lệnh gọi lại đã cho, cho phép bạn "chạm" vào bộ sưu tập tại một điểm cụ thể và thực hiện điều gì đó với các mục trong khi không ảnh hưởng đến chính bộ sưu tập đó. Bộ sưu tập sau đó được trả về bằng phương pháp

$collection = collect[[1, 2, 3]];

452

$collection = collect[[1, 2, 3]];

57

$collection = collect[[1, 2, 3]];

454

Phương thức tĩnh

$collection = collect[[1, 2, 3]];

455 tạo một bộ sưu tập mới bằng cách gọi bao đóng đã cho một số lần được chỉ định

$collection = collect[[1, 2, 3]];

58

$collection = collect[[1, 2, 3]];

456

Phương thức

$collection = collect[[1, 2, 3]];

457 chuyển đổi bộ sưu tập thành một PHP

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

44 đơn giản. Nếu các giá trị của bộ sưu tập là các mô hình Eloquent, thì các mô hình đó cũng sẽ được chuyển thành mảng

$collection = collect[[1, 2, 3]];

59

Cảnh báo

$collection = collect[[1, 2, 3]];

457 cũng chuyển đổi tất cả các đối tượng lồng nhau của bộ sưu tập là một thể hiện của

$collection = collect[[1, 2, 3]];

460 thành một mảng. Nếu bạn muốn lấy mảng thô bên dưới bộ sưu tập, hãy sử dụng phương thức

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

18 để thay thế.

$collection = collect[[1, 2, 3]];

462

Phương thức

$collection = collect[[1, 2, 3]];

463 chuyển đổi bộ sưu tập thành một chuỗi được tuần tự hóa JSON

$collection = collect[[1, 2, 3]];

60

$collection = collect[[1, 2, 3]];

464

Phương thức

firstWhere['colume name','value'];

285 lặp lại bộ sưu tập và gọi hàm gọi lại đã cho với từng mục trong bộ sưu tập. Các mục trong bộ sưu tập sẽ được thay thế bằng các giá trị được trả về bởi lệnh gọi lại

$collection = collect[[1, 2, 3]];

61

Cảnh báo
Không giống như hầu hết các phương pháp thu thập khác,

firstWhere['colume name','value'];

285 tự sửa đổi bộ sưu tập. Thay vào đó, nếu bạn muốn tạo một bộ sưu tập mới, hãy sử dụng phương pháp

firstWhere['colume name','value'];

283.

$collection = collect[[1, 2, 3]];

468

Phương thức

$collection = collect[[1, 2, 3]];

469 mở rộng tập hợp một chiều sử dụng ký hiệu "dấu chấm" thành tập hợp đa chiều

$collection = collect[[1, 2, 3]];

62

$collection = collect[[1, 2, 3]];

470

Phương thức

$collection = collect[[1, 2, 3]];

471 thêm mảng đã cho vào bộ sưu tập. Nếu mảng đã cho chứa các khóa đã có trong bộ sưu tập ban đầu, thì các giá trị của bộ sưu tập ban đầu sẽ được ưu tiên

$collection = collect[[1, 2, 3]];

63

$collection = collect[[1, 2, 3]];

472

Phương thức

$collection = collect[[1, 2, 3]];

473 trả về tất cả các mục duy nhất trong bộ sưu tập. Bộ sưu tập được trả về giữ các khóa mảng ban đầu, vì vậy trong ví dụ sau, chúng tôi sẽ sử dụng phương thức

$collection = collect[[1, 2, 3]];

189 để đặt lại các khóa thành các chỉ mục được đánh số liên tiếp

$collection = collect[[1, 2, 3]];

64

Khi xử lý các mảng hoặc đối tượng lồng nhau, bạn có thể chỉ định khóa được sử dụng để xác định tính duy nhất

$collection = collect[[1, 2, 3]];

65

Cuối cùng, bạn cũng có thể chuyển bao đóng của riêng mình cho phương thức

$collection = collect[[1, 2, 3]];

473 để chỉ định giá trị nào sẽ xác định tính duy nhất của một mục

$collection = collect[[1, 2, 3]];

66

Phương thức

$collection = collect[[1, 2, 3]];

473 sử dụng phép so sánh "lỏng lẻo" khi kiểm tra giá trị mục, nghĩa là một chuỗi có giá trị nguyên sẽ được coi là bằng với một số nguyên có cùng giá trị. Sử dụng phương pháp

$collection = collect[[1, 2, 3]];

477 để lọc bằng cách so sánh "nghiêm ngặt"

Lưu ý
Hành vi của phương thức này được sửa đổi khi sử dụng Bộ sưu tập Eloquent.

$collection = collect[[1, 2, 3]];

478

Phương thức này có cùng chữ ký với phương thức

$collection = collect[[1, 2, 3]];

473;

$collection = collect[[1, 2, 3]];

480

Phương thức

$collection = collect[[1, 2, 3]];

481 sẽ thực thi lệnh gọi lại đã cho trừ khi đối số đầu tiên được cung cấp cho phương thức ước tính là

firstWhere['colume name','value'];

256

$collection = collect[[1, 2, 3]];

67

Cuộc gọi lại thứ hai có thể được chuyển đến phương thức

$collection = collect[[1, 2, 3]];

481. Cuộc gọi lại thứ hai sẽ được thực thi khi đối số đầu tiên được cung cấp cho phương thức

$collection = collect[[1, 2, 3]];

481 đánh giá là

firstWhere['colume name','value'];

256

$collection = collect[[1, 2, 3]];

68

Đối với nghịch đảo của

$collection = collect[[1, 2, 3]];

481, xem phương pháp

$collection = collect[[1, 2, 3]];

487

$collection = collect[[1, 2, 3]];

488

Bí danh cho phương thức

$collection = collect[[1, 2, 3]];

489

$collection = collect[[1, 2, 3]];

490

Bí danh cho phương thức

$collection = collect[[1, 2, 3]];

491

$collection = collect[[1, 2, 3]];

492

Phương thức tĩnh

$collection = collect[[1, 2, 3]];

493 trả về các mục cơ bản của bộ sưu tập từ giá trị đã cho khi áp dụng

$collection = collect[[1, 2, 3]];

69

$collection = collect[[1, 2, 3]];

494

Phương thức

$collection = collect[[1, 2, 3]];

495 lấy một giá trị đã cho từ phần tử đầu tiên của tập hợp

$collection = collect[[1, 2, 3]];

70

$collection = collect[[1, 2, 3]];

496

Phương thức

$collection = collect[[1, 2, 3]];

189 trả về một bộ sưu tập mới với các khóa được đặt lại thành các số nguyên liên tiếp

$collection = collect[[1, 2, 3]];

71

$collection = collect[[1, 2, 3]];

498

Phương thức

$collection = collect[[1, 2, 3]];

487 sẽ thực hiện lệnh gọi lại đã cho khi đối số đầu tiên được cung cấp cho phương thức ước tính là

firstWhere['colume name','value'];

256. Thể hiện bộ sưu tập và đối số đầu tiên được cung cấp cho phương thức

$collection = collect[[1, 2, 3]];

487 sẽ được cung cấp cho phương thức đóng

$collection = collect[[1, 2, 3]];

72

Cuộc gọi lại thứ hai có thể được chuyển đến phương thức

$collection = collect[[1, 2, 3]];

487. Cuộc gọi lại thứ hai sẽ được thực thi khi đối số đầu tiên được cung cấp cho phương thức

$collection = collect[[1, 2, 3]];

487 đánh giá là

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro['toUpper', function [] {
    return $this->map[function [$value] {
        return Str::upper[$value];
$collection = collect[['first', 'second']];
$upper = $collection->toUpper[];

92

$collection = collect[[1, 2, 3]];

73

Đối với nghịch đảo của

$collection = collect[[1, 2, 3]];

487, xem phương pháp

$collection = collect[[1, 2, 3]];

481

$collection = collect[[1, 2, 3]];

507

Phương thức

$collection = collect[[1, 2, 3]];

491 sẽ thực hiện lệnh gọi lại đã cho khi bộ sưu tập trống

$collection = collect[[1, 2, 3]];

74

Lần đóng thứ hai có thể được chuyển đến phương thức

$collection = collect[[1, 2, 3]];

491 sẽ được thực thi khi bộ sưu tập không trống

$collection = collect[[1, 2, 3]];

75

Đối với nghịch đảo của

$collection = collect[[1, 2, 3]];

491, hãy xem phương pháp

$collection = collect[[1, 2, 3]];

489

$collection = collect[[1, 2, 3]];

512

Phương thức

$collection = collect[[1, 2, 3]];

489 sẽ thực hiện lệnh gọi lại đã cho khi bộ sưu tập không trống

$collection = collect[[1, 2, 3]];

76

Lần đóng thứ hai có thể được chuyển đến phương thức

$collection = collect[[1, 2, 3]];

489 sẽ được thực thi khi bộ sưu tập trống

$collection = collect[[1, 2, 3]];

77

Đối với nghịch đảo của

$collection = collect[[1, 2, 3]];

489, xem phương pháp

$collection = collect[[1, 2, 3]];

491

$collection = collect[[1, 2, 3]];

517

Phương thức

$collection = collect[[1, 2, 3]];

518 lọc bộ sưu tập theo một cặp khóa/giá trị nhất định

$collection = collect[[1, 2, 3]];

78

Phương thức

$collection = collect[[1, 2, 3]];

518 sử dụng so sánh "lỏng lẻo" khi kiểm tra giá trị mục, nghĩa là một chuỗi có giá trị nguyên sẽ được coi là bằng với một số nguyên có cùng giá trị. Sử dụng phương pháp

$collection = collect[[1, 2, 3]];

520 để lọc bằng cách so sánh "nghiêm ngặt"

Optionally, you may pass a comparison operator as the second parameter. Supported operators are: '===', '!==', '!=', '==', '=', '', '>', '=', and '