Collection on ララジャパン

混乱してはいけないLaravelの動的プロパティ - Collection編

Tue, 07 May 2024 22:49:37 +0900

動的プロパティは、EloquentだけでなくCollectionにもHigher Order Message（より上級のメッセージ？）という名前で颯爽と登場します。これも最初に見たら、こんなことできるの、という感じです。混乱してはいけません。Eloquentと同様に複雑なことをしないときのコード表現に便利なメソッドの短縮形です。

以下の前回の話も参照してください。混乱してはいけないLaravelの動的プロパティ - Eloquent編

Collectionメソッドを動的プロパティとして扱う

Laravelのマニュアルと似たような例を使います。

ここでは、スポーツ選手のプレイヤーをクラス（Player）とします。クラスにはプロパティとして、名前、人気の投票数、そしてVIPかどうかの３つの項目があります。例としてtinkerで表示されるようにプロパティは皆publicとしています。さらに、投票数が500以上ならVIPを正とする関数も定義されています。

app/Models/Player.php

namespace App\Models;

Class Player
{
    function __construct(
        public string $name,　// 名前
        public int $votes,  // 投票数
        public bool $isVip = false)　// VIP？
    {
        //
    }

    public function markAsVip(): void
    {
        if ($this->votes >= 500) { // 500数以上ならVIPに設定
            $this->isVip = true;
        }
    }
}

まず、２つインスタンスを含むCollectionを作成します。

> use App\Models\Player;

> $players = collect([
    new Player("LeBron James", 500), 
    new Player("Stephen Curry", 400)
]);

= Illuminate\Support\Collection {#5066
    all: [
      App\Models\Player {#5096
        +name: "LeBron James",
        +votes: 500,
        +isVip: false,
      },
      App\Models\Player {#5067
        +name: "Stephen Curry",
        +votes: 400,
        +isVip: false,
      },
    ],
  }

Collectionに含まれるプレイヤーのインスタンスにおいて、人気票に基づいてVIPかどうかを決めるとします。

通常なら、以下のようにCollectionのeach()のメソッドを使い、それぞれのインスタンスにおいてmarkAsVip()をコールバックします。

> $players->each(fn (Player $player) => $player->markAsVip());

= Illuminate\Support\Collection {#5101
    all: [
      App\Models\Player {#5089
        +name: "LeBron James",
        +votes: 500,
        +isVip: true,
      },
      App\Models\Player {#5102
        +name: "Stephen Curry",
        +votes: 400,
        +isVip: false,
      },
    ],
  }

しかし、なんとこれと同じことが、Collectionの動的プロパティとして以下のように短縮して実行も可能なのです。

> $players->each->markAsVip();

= Illuminate\Support\Collection {#5101
    all: [
      App\Models\Player {#5089
        +name: "LeBron James",
        +votes: 500,
        +isVip: true,
      },
      App\Models\Player {#5102
        +name: "Stephen Curry",
        +votes: 400,
        +isVip: false,
      },
    ],
  }

凄いですね。

Collectionの他のメソッドも使えます。VIPだけのプレイヤーを抽出したいとすると、filter()を動的プロパティとします。、

> $players->filter->isVip;
= Illuminate\Support\Collection {#5102
    all: [
      App\Models\Player {#5089
        +name: "LeBron James",
        +votes: 500,
        +isVip: true,
      },
    ],
  }

もう１つ例を見てみましょう。今度は、sum()を使ってプレーヤーの総投票数の計算もできてしまいます。

> $players->sum->votes;
= 900

ちなみに、このような短縮形が使えるのは、Collectionのすべてのメソッドとはいきませんが、以下のメソッドの使用が現在可能です。

average, avg, contains, each, every, filter, first, flatMap, groupBy, keyBy, map, max, min, partition, reject, skipUntil, skipWhile, some, sortBy, sortByDesc, sum, takeUntil, takeWhile, unique

参照

混乱してはいけないLaravelの動的プロパティ – Eloquent編混乱してはいけないLaravelの動的プロパティ – 裏側編混乱してはいけないLaravelの動的プロパティ – PHP8.2で廃止となった編

混乱してはいけないLaravelの動的プロパティ - Eloquent編

Fri, 19 Apr 2024 05:45:38 +0900

LaravelではModelやCollectionやRequestなどのクラスにおいて動的プロパティがコードの短縮形としてよく使われます。しかし、同じクラスでメソッドとして定義したものがいきなりプロパティとして使われるので、私は昔よく混乱したものです。今回はまずEloquent編として代表的な動的プロパティの活用を混乱しないように説明します。

Eloquentのアクセッサー

まず、動的プロパティの例として、DBには対応する項目は存在しないのに、あたかも存在する項目のように振る舞うEloquentのアクセッサーです（ミューテーターも同じですが）。

DBのテーブルにfirst_name（名前）とlast_name（苗字）が存在するとして、姓名（full_name）を返すアクセッサーメソッドを定義します。

namespace App\Models;
 
use Illuminate\Database\Eloquent\Casts\Attribute;
use Illuminate\Database\Eloquent\Model;
 
class User extends Model
{
...
    /**
     * 姓名を返すアクセッサー
     *
     * @return \Illuminate\Database\Eloquent\Casts\Attribute
     */
    protected function fullName(): Attribute
    {
        return Attribute::make(
            get: fn ($value, $attribute) => $attribute['last_name'].' '.$attribute['first_name'],
        );
    }
}

これを使用するときは、動的プロパティとして以下のように使います。

> User::find(1);
[!] Aliasing 'User' to 'App\Models\User' for this Tinker session.
= App\Models\User {#5393
    id: 1,
    created_at: "2024-04-16 03:42:31",
    updated_at: "2024-04-16 03:42:31",
    first_name: "直子",
    last_name: "山田",
  }

> User::find(1)->full_name;
= "山田 直子"

先ほどのアクセッサーのメソッドfullName()をコールして姓名full_nameを動的プロパティとして返します。

ちなみに、fullName()のメソッドはprotectedで宣言されているので直接はコールできません。

> User::find(1)->fullName();
   BadMethodCallException  Call to undefined method App\Models\User::fullName().

EloquentのRelationship

今度は、EloquentのRelationshipの動的プロパティです

典型的なブログを例として、ユーザーとブログの投稿を使います。それぞれのDBテーブルを代表してUserとPostがModelのクラスとなります。そして、Userのクラスでは、それらの１対多の関係を以下のように定義します。

namespace App\Models;
 
use Illuminate\Database\Eloquent\Model;
 
class User extends Model
{
    /**
     * ユーザー１に対して複数のブログの投稿
     */
    public function posts()
    {
        return $this->hasMany(Post::class);
    }
}

この関係を利用して、特定のユーザーのブログのレコードを取得するのは通常以下のようになります。

$user = User::find(1);
$posts = $user->posts()->get(); // Collectionを返す

しかし、動的プロパティを使うと、

$posts = $user->posts;

と短縮形で書くことができます。先の非短縮形と同じ結果となります。便利ですね。

しかし、この短縮形、非短縮形でできることがなんでもできる訳ではありません

例えば、非短縮形のメソッド方式では、

$user->posts()->orderBy('created_at')->get();

とレコードをソートできますが、短縮形の動的プロパティの使用ではエラーとなります。

$user->posts->orderBy('created_at');

BadMethodCallException  Method Illuminate\Database\Eloquent\Collection::orderBy does not exist.

これは、$user->posts()がIlluminate\Database\Eloquent\Relations\HasManyを返すのに、$user->postではIlluminate\Database\Eloquent\Collectionを返すからです。Collectionには、orderBy()というメソッドはないのです。しかし、前者にはあります。

ちなみに後者では、CollectionのメソッドsortBy()を使用すると同じ結果が得られます。

$user->posts->sortBy('created_at');

もう１つ、より混乱しそうな例を挙げてみましょう。

まずは非短縮形から、

$user->posts()->where('title', '=', 'ブログタイトル')->get();

タイトルに特定の条件で絞ったクエリーです。ちなみに、実行されたSQLは、以下となります。

select * from `post` where `user`.`id` = 1 and `user`.`id` is not null and `title` = 'ブログタイトル';

さて、これを短縮形の動的プロパティで書くと、

$user->posts->where('title', '=', 'ブログタイトル');

->get()がないだけの違いですが、これはまったく正規です。返す結果も前者と同じです。where()はCollectionのメソッドにもあるのですね。

実行されたSQLも見てみましょう。

select * from `post` where `user`.`id` = 1 and `user`.`id` is not null;

違いわかりますか？タイトルを制限するwhereの条件文がSQL文にありません。つまり、ユーザーが投稿したレコードをいったん全部取得して、Collectionのwhere()のメソッドでフィルターしているのです。

両者ともに実行結果は同じですが、どこまでがデータベースにより実行されるか、どこからがCollectionのメソッドで実行するかにおいての違いです。この違いでパフォーマンスが違ってきます。一般的には前者のようにDBにたくさん仕事をしてもらうのが効率的です。注意が必要ですね。

参照

混乱してはいけないLaravelの動的プロパティ – Collection編混乱してはいけないLaravelの動的プロパティ – 裏側編混乱してはいけないLaravelの動的プロパティ – PHP8.2で廃止となった編

バリデーション後のRequestの処理

Mon, 20 Jun 2022 06:07:34 +0900

FormRequestのバリデーションを問題なくパスしたら、コントローラで$request->validatedで配列としてフォームの入力値を取得できます。取得後の値は安全なのでそのままDBに保存することも可能です。しかし、その配列から必要のない値を抜いたり、足りない値を追加したりとかの処理はどうするかという説明です。

会員登録のFormRequest

例として会員登録の画面を使います。画面はこんな感じです。

その画面の入力をチェックするFormRequestは以下と定義します。

namespace App\Http\Requests;

use App\Rules\CaptchaRule;
use App\Rules\CustomerPasswordRule;
use Illuminate\Foundation\Http\FormRequest;

class CustomerRequest extends FormRequest
{
    public function rules()
    {
        $rules = [
            'email'                => ['required', 'email', 'unique:customer,email'],
            'password'             => ['required', new CustomerPasswordRule, 'confirmed'],
            'name'                 => ['required'],
            'g-recaptcha-response' => ['required', new CaptchaRule],
        ];

        return $rules;
    }
}

CustomerPasswordRuleやCaptchaRuleは事前に用意したカスタムのバリデーションのクラスです。

CustomerRequestのバリデーションを問題なく通過したら、以下のようにコントローラでDBに保存します。

namespace App\Http\Controllers\User;

use App\Http\Controllers\Controller;
use App\Http\Requests\CustomerRequest;
use App\Models\Customer;
use Illuminate\Foundation\Auth\RegistersUsers;

class RegisterController extends Controller
{
    use RegistersUsers;

...
    /**
     * 会員の登録
     *
     * @param  \App\Http\Requests\CustomerRequest  $request
     * @return \Illuminate\Http\RedirectResponse
     */
    public function register(CustomerRequest $request)
    {
        $validated = $request->validated();

        Customer::create($validated);
        ...
    }
}

ここでのregister()メソッドの$validatedの値の中身を見てみましょう。

$validated = [
  "email" => "test@example.com",
  "password" => "Test1234567890!",
  "name" => "テスト太郎",
  "g-recaptcha-response" => "03AGdBq26f1ycQWiqz2OeBFz....",
]

DBに保存するのに必要なのは、email, password（暗号化する）、nameの３つだけで、キャプチャのg-recaptach-responseは必要でありませんので、先の配列値から抜く必要あります。また、会員が有効かどうかを指定するactive_flagが必要なので、その値を配列に加える必要あります。

このような処理を行うには、Laravelのバージョン8.x以降では、以下のようにvalidated()を使わずに、safe(), merge(), except()を使って可能です。

...
    $input = $request->safe()
        ->merge(['active_flag' => 'Y'])
        ->except(['g-recaptcha-response']);

    Customer::create($input);
...

safeは、バリデーションをパスした値を抽出し、mergeは値を追加、exceptは値を削除です。しかし、mergeとexceptの使用の順番には注意してください。これらを逆にするとエラーとなってしまいます。なぜなら、exceptは配列を返すのでその後にメソッドの連結ができません。

処理の結果の配列は、以下のようになります。

$input = [
  "email" => "test@example.com",
  "password" => "Test1234567890!",
  "name" => "テスト太郎",
  "active_flag" => "Y",
]

よりフレキシブルな処理を望むなら、以下のようにcollect()を通してCollectionのオブジェクトにすることです。

...
    $input = $request->safe()
        ->collect()
        ->except(['g-recaptcha-response'])
        ->merge(['active_flag' => 'Y'])
        ->all();

    Customer::create($input);
...

さて、safe()の対応がないLaravel 7.xではどう対応しましょう。こちらも、配列をCollectionにしてしまえば、問題ありません。

...
    $input = collect($request->validated())
        ->except(['g-recaptcha-response'])
        ->merge(['active_flag' => 'Y']
        ->all();

    Customer::create($input);
...

私としては、Collectionを使用した方が好きです。以下のように、ケースにより配列の中身を変えることも簡単です。

       $input = collect($request->validated())
            ->when(! $request->active_flag, function ($collection) {
                return $collection->put('active_flag', 'N'); // 値がないときはNとする
            })
            ->when(! $request->paymethod_id, function ($collection) {
                $collection->forget([ // 値がないときは、以下の設定は必要ではない
                    'paymethod_id',
                    'card_number',
                    'card_exp',
                    'card_holder',
                ]);

                return $collection;
            })
            ->all();

Laravel Collection（１０）mapとtransformの違い

Mon, 04 Apr 2022 03:09:52 +0900

Collectionでのmap()とtransform()のメソッドは似ているようで大きな違いがあります。

まず、テストデータのレコードをtinkerで３つ作成します。

>>> User::factory(3)->create();

=> Illuminate\Database\Eloquent\Collection {#4463
     all: [
       App\Models\User {#4464
         id: 1,
         name: "坂本 知実",
         email: "tfujimoto@example.net",
         email_verified_at: "2022-04-03 02:36:03",
         #password: "$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi",
         #remember_token: "mBZjRiwtp2",
         created_at: "2022-04-03 02:36:03",
         updated_at: "2022-04-03 02:36:03",
       },
       App\Models\User {#4465
         id: 2,
         name: "高橋 知実",
         email: "kazuya.miyazawa@example.net",
         email_verified_at: "2022-04-03 02:36:03",
         #password: "$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi",
         #remember_token: "2ERHaySLEo",
         created_at: "2022-04-03 02:36:03",
         updated_at: "2022-04-03 02:36:03",
       },
       App\Models\User {#4466
         id: 3,
         name: "藤本 修平",
         email: "mkiriyama@example.net",
         email_verified_at: "2022-04-03 02:36:03",
         #password: "$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi",
         #remember_token: "JpPxv9yr0d",
         created_at: "2022-04-03 02:36:03",
         updated_at: "2022-04-03 02:36:03",
       },
     ],
   }

作成されたレコードを$usersの変数に入れます。

>>> $users = User::all();

map()もtransform()もCollectionの中のそれぞれのアイテムを処理してCollectionの値を返すのは同じです。

まず、mapから、

>>> $users->map(function ($user) {
        return $user->only(['id', 'name']);
    })

=> Illuminate\Support\Collection {#4473
     all: [
       [
         "id" => 1,
         "name" => "坂本 知実",
       ],
       [
         "id" => 2,
         "name" => "高橋 知実",
       ],
       [
         "id" => 3,
         "name" => "藤本 修平",
       ],
     ],
   }

この後に$usersの中身を見てみましょう。

>>> $users

=> Illuminate\Database\Eloquent\Collection {#4463
     all: [
       App\Models\User {#4464
         id: 1,
         name: "坂本 知実",
         email: "tfujimoto@example.net",
         email_verified_at: "2022-04-03 02:36:03",
         #password: "$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi",
         #remember_token: "mBZjRiwtp2",
         birth_date: "1988-03-20",
         created_at: "2022-04-03 02:36:03",
         updated_at: "2022-04-03 02:36:03",
       },
       App\Models\User {#4465
         id: 2,
         name: "高橋 知実",
         email: "kazuya.miyazawa@example.net",
         email_verified_at: "2022-04-03 02:36:03",
         #password: "$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi",
         #remember_token: "2ERHaySLEo",
         birth_date: "1975-06-25",
         created_at: "2022-04-03 02:36:03",
         updated_at: "2022-04-03 02:36:03",
       },
       App\Models\User {#4466
         id: 3,
         name: "藤本 修平",
         email: "mkiriyama@example.net",
         email_verified_at: "2022-04-03 02:36:03",
         #password: "$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi",
         #remember_token: "JpPxv9yr0d",
         birth_date: "2011-06-17",
         created_at: "2022-04-03 02:36:03",
         updated_at: "2022-04-03 02:36:03",
       },
     ],
   }

何も変わっていませんね。今度は、transformです。

>>> $users->transform(function($user) {
        return $user->only(['id', 'name']);
})

=> Illuminate\Database\Eloquent\Collection {#4463
     all: [
       [
         "id" => 1,
         "name" => "坂本 知実",
       ],
       [
         "id" => 2,
         "name" => "高橋 知実",
       ],
       [
         "id" => 3,
         "name" => "藤本 修平",
       ],
     ],
   }

ここまではmapの結果とまったく同じですね。しかし、もとの変数の中身を見ると、

>>> $users

=> Illuminate\Database\Eloquent\Collection {#4463
     all: [
       [
         "id" => 1,
         "name" => "坂本 知実",
       ],
       [
         "id" => 2,
         "name" => "高橋 知実",
       ],
       [
         "id" => 3,
         "name" => "藤本 修平",
       ],
     ],
   }

中身が返り値と同じ値で上書きとなっているのです。transformという名前はそれゆえにです。

ページネーションのデータを変える

Sat, 12 Feb 2022 12:41:41 +0900

例えば、User::paginate(5)で返されるデータは、@foreachでループできるゆえにコレクションと思いきや、そうでありません。

ページネーション

ページネーションは、以下の画面のように複数のレコードをページごと閲覧できるために使われます。

上の表示に使われるコントローラは、以下のように簡単なコードです。

namespace App\Http\Controllers;

use App\Models\User;

class UserController extends Controller
{
    public function index()
    {
        $users = User::paginate(2); //１ページ２個表示の設定
        return view('users.index', compact('users'));
    }
}

ブレードも簡単です。

@extends('layouts.app')

@section('content')
    <div class="main py-4">
        <div class="card card-body border-0 shadow table-wrapper table-responsive">
            <h2 class="mb-4 h5">会員名</h2>

            <table class="table table-hover">
                <thead>
                    <tr>
                        <th class="border-gray-200">名前</th>
                        <th class="border-gray-200">メールアドレス</th>
                    </tr>
                </thead>
                <tbody>
                    @foreach ($users as $user)
                        <tr>
                            <td><span class="fw-normal">{{ $user->name }}</span></td>
                            <td><span class="fw-normal">{{ $user->email }}</span></td>
                        </tr>
                    @endforeach
                </tbody>
            </table>
            <div
                class="card-footer px-3 border-0 d-flex flex-column flex-lg-row align-items-center justify-content-between">
                {{ $users->links() }}
            </div>
        </div>
    </div>
@endsection

表示するレコードを変える

さて、画面１で表示されるコードに会員IDを追加して、以下のように表示したいです。

ブレードを以下のようにすれば簡単に表示を変更できます。

...
<td><span class="fw-normal">{{ $user->id }} : {{ $user->name }}</span></td>
...

しかし、ブレードを変更せずに、$user->nameに会員ID + 名前の値としたいなら、どうしましょうか？先のコントローラの定義において、

...
   $users = User::paginate(2);

   $users->each(function($user) {
       $user->name = $user->id.' : '.$user->name;
   });
...

と変更すればよいです。transform()を使用してもよいです。

...
   $users = User::paginate(2);

   $users->transform(function($user) {
       $user->name = $user->id.' : '.$user->name;
       return $user;
   });
...

され、これらをみて、誰しも思うのは、以下のようにメソッドをチェーンすることです。わかりやすいし、Laravelらしい。

...
   $users = User::paginate(2)->each(function($user) {
       $user->name = $user->id.' : '.$user->name;
   });
...

しかし、そうするとエラーとなってしまいます。

そこで気が付くのは、User::paginate(2)が返すのはCollectionではない、ということです。

通常は、以下のようにCollectionを返します。

>>> get_class(User::all());
=> "Illuminate\Database\Eloquent\Collection"

しかし、ページネーションだと、

>>> get_class(User::paginate(2));
=> "Illuminate\Pagination\LengthAwarePaginator"

返すのは、Collectionではなく、LengthAwarePaginatorです。これには、ページに表示するレコードだけでなく、何番目のページとか、他のページに移動するためのリンクとか、など他にもたくさんデータが詰まっています。

>>> User::paginate(2)->toArray();
[!] Aliasing 'User' to 'App\Models\User' for this Tinker session.
=> [
     "current_page" => 1,
     "data" => [
       [
         "id" => 1,
         "name" => "村山 涼平",
         "email" => "kenichi.yoshida@example.org",
         "email_verified_at" => "2022-02-11T02:11:12.000000Z",
         "created_at" => "2022-02-11T02:11:12.000000Z",
         "updated_at" => "2022-02-11T02:11:12.000000Z",
       ],
       [
         "id" => 2,
         "name" => "笹田 裕樹",
         "email" => "shuhei99@example.com",
         "email_verified_at" => "2022-02-11T02:11:12.000000Z",
         "created_at" => "2022-02-11T02:11:12.000000Z",
         "updated_at" => "2022-02-11T02:11:12.000000Z",
       ],
     ],
     "first_page_url" => "http://localhost?page=1",
     "from" => 1,
     "last_page" => 2,
     "last_page_url" => "http://localhost?page=2",
     "links" => [
       [
         "url" => null,
         "label" => "&laquo; Previous",
         "active" => false,
       ],
       [
         "url" => "http://localhost?page=1",
         "label" => "1",
         "active" => true,
       ],
       [
         "url" => "http://localhost?page=2",
         "label" => "2",
         "active" => false,
       ],
       [
         "url" => "http://localhost?page=2",
         "label" => "Next &raquo;",
         "active" => false,
       ],
     ],
     "next_page_url" => "http://localhost?page=2",
     "path" => "http://localhost",
     "per_page" => 2,
     "prev_page_url" => null,
     "to" => 2,
     "total" => 3,
   ]

それゆえに、先ほどのようにメソッドのチェーンをしてデータの変更をすると、これらのデータが失われエラーとなってしまうのです。それでは、どのようにメソッドをチェーンできるのでしょう？

paginate()にチェーン

そのためのメソッドがあるのです。

...
    $users = User::paginate(2)->through(function($user) {
        $user->name = $user->id.' : '.$user->name;
        return $user;
    });
...

through()は、Collectionのtransform()のようなもので、ページネーションのオブジェクトのdataの部分だけの編集が可能です。

ちなみに、以下のようにtap()を使用しても同様なことができます。（参照：https://stackoverflow.com/questions/37102841/laravel-change-pagination-data）

...
  $users = tap(User::paginate(2), function($page) {
        return $page->each( function($user) {
            $user->name = $user->id.' : '.$user->name;
        });
  });
...

なるほど、tap()はこのようなときに使うのですね。paginate()が返すLengthAwarePaginatorのオブジェクトはキープして、その中身を操作することが可能なのです。

Laravel Collection（９）foreachの代わりにeach

Mon, 24 Jan 2022 03:42:16 +0900

phpでは配列のデータをループするならforeachを使います。LaravelのCollectionでもforeachを使ってループできます。しかし、Collectionならeach()を使いましょう。

foreachからeachへ

まず、tinkerでCollectionのデータを作成します。

>>> use Illuminate\Support\Collection;
>>> $c = Collection::times(5);
=> Illuminate\Support\Collection {#3500
     all: [
       1,
       2,
       3,
       4,
       5,
     ],
   }

foreachを使ってループします。

>>> foreach($c as $item) {
        echo $item." ";
    }

1 2 3 4 5

これと同じことが、Collectionのメソッドのeach()で可能です。

>>> $c->each(function($item) {
        echo $item." ";
    })

1 2 3 4 5

continue, break

foreachでは、ループの途中である条件でスキップ(continue)、あるいはループから抜け出す(break)ことができます。each()でも同様なことができますが、ちょっと違うやり方です。

continueの代わりに、return true（あるいは returnだけ）とします。

>>> foreach($c as $item) {
        if ($item > 2) continue;
        echo $item." ";
    }

1 2 

>>> $c->each(function($item) {
        if ($item > 2) return true;
        echo $item." ";
    })

1 2

breakの代わりに、return falseとします。

>>> foreach($c as $item) {
        if ($item > 2) break;
        echo $item." ";
    }

1 2

>>> $c->each(function($item) {
        if ($item > 2) return false;
        echo $item." ";
    })

1 2

変数のスコープ

foreachでは以下のようなことは簡単です。

>>> $sum = 0
>>> foreach($c as $item) {
        $sum += $item;
    }

>>> echo $sum

15

しかし、eachでは、

>>> $sum = 0
>>> $c->each(function($item) {
        $sum += $item;
    })

<warning>PHP Notice:  Undefined variable: sum in Psy Shell code on line 2</warning>
<warning>PHP Notice:  Undefined variable: sum in Psy Shell code on line 2</warning>
<warning>PHP Notice:  Undefined variable: sum in Psy Shell code on line 2</warning>
<warning>PHP Notice:  Undefined variable: sum in Psy Shell code on line 2</warning>
<warning>PHP Notice:  Undefined variable: sum in Psy Shell code on line 2</warning>

>>> echo $sum

0

foreachではOkなのに、each()のループの中では、$sumは未定義となりループの外では値が初期値のままです。警告もでていますね。

これを正しく行うには、each()のコールバックの関数に$sumの変数をポインターで渡す必要あります。この手のuse()の使用はよくあります。

>>> $c->each(function($item) use(&$sum) {
        $sum += $item;
    })

>>> echo $sum;

15

まあ、この例ではそんなことしなくても、sum()を使えば、

>>> $c->sum()

15

で済みますけれど。

しかし、each()を使えば、こんなことも可能です。

>>> $sum = $c->each(function($item) {
        echo $item." ";
    })->sum()

1 2 3 4 5

>>> echo $sum

15

これは、each()がCollectionを返すので、それをsum()にチェーンできるからです。

Laravel Collection（８） filterの代わりにwhere

Sun, 10 Oct 2021 02:43:23 +0900

「Laravel Collection（２） Collectionを返すメソッド」ではfilterメソッドを紹介しました。今度はfilterメソッドのように条件でCollectionを絞るwhereメソッドの話です。EloquentやSQL文で慣れているならwhereの方がわかりやすいかもしれません。

データの準備

用意するデータは、Laravel Collection（１）１つの値を返すメソッド　をもとに、以下のDBレコードがすでに作成されていると仮定します。

mysql> select id, name, birth_date from users;
+----+------------------+------------+
| id | name             | birth_date |
+----+------------------+------------+
|  1 | 石田 裕美子      | 1991-05-26 |
|  2 | 佐藤 香織        | 2002-01-12 |
|  3 | 杉山 明美        | 2000-03-13 |
+----+------------------+------------+
3 rows in set (0.00 sec)

今回は女の人だけになりました。

where

まず、filter()を使った例です。

>>> User::all()->filter(function ($user) {
        return $user->birth_date < '2000-01-01';
    })

=> Illuminate\Database\Eloquent\Collection {#4317
     all: [
       App\User {#4260
         id: 1,
         name: "石田 裕美子",
         email: "sasaki.naoko@example.net",
         email_verified_at: "2021-10-07 02:41:15",
         #password: "$2y$10$53mZGiOMkJEVm1VDij642eWGi.i4/bWt3fElQjQvp86dfG/9MK5mW",
         #remember_token: "fCSd0AlA84",
         birth_date: "1991-05-26",
         created_at: "2021-10-07 02:41:16",
         updated_at: "2021-10-07 02:41:16",
       },
     ],
   }

これと同じ処理をwhere()で行うと、

>>> User::all()->where('birth_date', '<', '2000-01-01')

=> Illuminate\Database\Eloquent\Collection {#3393
     all: [
       App\User {#4105
         id: 1,
         name: "石田 裕美子",
         email: "sasaki.naoko@example.net",
         email_verified_at: "2021-10-07 02:41:15",
         #password: "$2y$10$53mZGiOMkJEVm1VDij642eWGi.i4/bWt3fElQjQvp86dfG/9MK5mW",
         #remember_token: "fCSd0AlA84",
         birth_date: "1991-05-26",
         created_at: "2021-10-07 02:41:16",
         updated_at: "2021-10-07 02:41:16",
       },
     ],
   }

短くてわかりやすいです。

今度はwhere()を２つ繋げます。

>>> User::all()->where('birth_date', '>=', '1990-01-01')
   ->where('birth_date', '<=', '2000-01-01')

=> Illuminate\Database\Eloquent\Collection {#4171
     all: [
       App\User {#3376
         id: 1,
         name: "石田 裕美子",
         email: "sasaki.naoko@example.net",
         email_verified_at: "2021-10-07 02:41:15",
         #password: "$2y$10$53mZGiOMkJEVm1VDij642eWGi.i4/bWt3fElQjQvp86dfG/9MK5mW",
         #remember_token: "fCSd0AlA84",
         birth_date: "1991-05-26",
         created_at: "2021-10-07 02:41:16",
         updated_at: "2021-10-07 02:41:16",
       },
     ],
   }

これは、Laravel Collection（２） Collectionを返すメソッド　で掲載したfilter()を使用した以下とまったく同じ処理なことわかりますか？

>>> User::all()->filter(function ($user) {
        if ($user->birth_date > '2000-01-01') return false;
        if ($user->birth_date < '1990-01-01') return false;
        return true;
    })

whereBetween()というメソッドもありますよ。これを使えばもっと短くなります。

>>> User::all()->whereBetween('birth_date', ['1990-01-01', '2000-01-01'])

=> Illuminate\Database\Eloquent\Collection {#3383
     all: [
       App\User {#3412
         id: 1,
         name: "石田 裕美子",
         email: "sasaki.naoko@example.net",
         email_verified_at: "2021-10-07 02:41:15",
         #password: "$2y$10$53mZGiOMkJEVm1VDij642eWGi.i4/bWt3fElQjQvp86dfG/9MK5mW",
         #remember_token: "fCSd0AlA84",
         birth_date: "1991-05-26",
         created_at: "2021-10-07 02:41:16",
         updated_at: "2021-10-07 02:41:16",
       },
     ],
   }

対象のレコードを条件で絞るという点では、CollectionのwhereメソッドはEloquentやDBクエリのwhereメソッドと同じようなメソッドです。しかし両者のwhereメソッドはどこが違うのでしょうか。

EloquentとCollectionでのwhereメソッドの違い

この違いを理解するには、裏で実行されているSQL文を見る必要があります。注意：以下のtinkerで使用されているsql()はユーザー定義です。こちらを参照してください。

まず、Eloquentのクエリでのwhereの実行です。

>>> User::where('birth_date', '<', '2000-01-01')->get()

=> Illuminate\Database\Eloquent\Collection {#4172
     all: [
       App\User {#4104
         id: 1,
         name: "石田 裕美子",
         email: "sasaki.naoko@example.net",
         email_verified_at: "2021-10-07 02:41:15",
         #password: "$2y$10$53mZGiOMkJEVm1VDij642eWGi.i4/bWt3fElQjQvp86dfG/9MK5mW",
         #remember_token: "fCSd0AlA84",
         birth_date: "1991-05-26",
         created_at: "2021-10-07 02:41:16",
         updated_at: "2021-10-07 02:41:16",
       },
     ],
   }
>>> sql()
=> [
     [
       "query" => "select * from `users` where `birth_date` < ?",
       "bindings" => [
         "2000-01-01",
       ],
       "time" => 5.02,
     ],
   ]

SQL文にはしっかりSQLのwhere節が含まれています。つまりDBレベルで条件で絞っています。

次に、Collectionでのwhere()の実行です。

>>> User::all()->where('birth_date', '<', '2000-01-01')

=> Illuminate\Database\Eloquent\Collection {#3393
     all: [
       App\User {#4105
         id: 1,
         name: "石田 裕美子",
         email: "sasaki.naoko@example.net",
         email_verified_at: "2021-10-07 02:41:15",
         #password: "$2y$10$53mZGiOMkJEVm1VDij642eWGi.i4/bWt3fElQjQvp86dfG/9MK5mW",
         #remember_token: "fCSd0AlA84",
         birth_date: "1991-05-26",
         created_at: "2021-10-07 02:41:16",
         updated_at: "2021-10-07 02:41:16",
       },
     ],
   }
>>> sql()
=> [
     [
       "query" => "select * from `users`",
       "bindings" => [],
       "time" => 4.45,
     ],
   ]
>>>

こちらのSQL文にはwhere節は含まれておらず、DBのusersテーブルからすべてのレコードを取得しています。そしてその中から条件に適うレコードをプログラムで抽出しています。今回はDBには３つしかレコードがありませんが、これが何千ともあるならそれらすべてをメモリに保持することになるのでリソースの無駄遣いとなり、さらにはパフォーマンスの低下ともなります。

となると、いつEloquentのクエリでwhere()を使うか、いつCollectionでwhere()を使うかを十分注意すること重要になります。Eloquent、つまりDBレベルでできるだけ取得するレコードを絞って、その結果のCollectionにおいてさらにいろいろな条件で絞るとかの場合にCollectionのwhereメソッドが使われるのが適切です。

Laravel Collection（７）よく使うgroupBy

Sun, 25 Jul 2021 02:18:40 +0900

Collectionの中でとても好きなメソッドは、groupBy()です。Laravelが存在しなかった時代ではよくDBクエリから返ってくる１次元の配列をグループ化するため、汚いコードを書いて２次元の配列に変換していたものです。しかし、CollectionのgroupByがあるとコードがシンプルで綺麗に書けること書けること。

このような画面が欲しい

以下のようなデータがDBにあると仮定して、

mysql> select id, name, gender from users;
+----+---------------+-----------+
| id | name          | gender    |
+----+---------------+-----------+
|  1 | 山田 千代     | 無回答    |
|  2 | 佐藤 健一     | 男        |
|  3 | 加藤 篤司     | 無回答    |
|  4 | 山口 花子     | 女        |
+----+---------------+-----------+
4 rows in set (0.01 sec)

このデータを性別でグループ化して、以下の画面の表示となるようにしたいのです。

DBレベルでのデータのグループ化

DBレベルでは、データをグループ化して例えば性別（gender）ごとのユーザー数とかを以下のように取得できます。

>>> User::groupBy('gender')->selectRaw('gender, count(*)')->get();
=> Illuminate\Database\Eloquent\Collection {#3422
     all: [
       App\User {#4345
         gender: "女",
         count(*): 1,
       },
       App\User {#4348
         gender: "無回答",
         count(*): 2,
       },
       App\User {#4349
         gender: "男",
         count(*): 1,
       },
     ],
   }

ちなみに実行されたSQL文は、

>>> sql()
=> [
     [
       "query" => "select gender, count(*) from `users` group by `gender`",
       "bindings" => [],
       "time" => 0.56,
     ],
   ]

しかしこれでは先の欲しい画面のデータを表示するには、さらにそれぞれの性別において個々のDBレコードの情報取得が必要となります。つまり、以下のようなSQLの実行が３回必要となります。

>>> User::where('gender', '=', '男')->get();
=> Illuminate\Database\Eloquent\Collection {#4345
     all: [
       App\User {#4348
         id: 2,
         name: "佐藤 健一",
         gender: "男",
...
       },
     ],
   }

しかし、これではトータル４回のSQL文の実行となってしまい効率的でありません。

Collectionでのグループ化

今度は、DBからレコードを全部取得してからデータをグループ化します。

>>> User::all()->groupBy('gender');
=> Illuminate\Database\Eloquent\Collection {#4336
     all: [
       "無回答" => Illuminate\Database\Eloquent\Collection {#4120
         all: [
           App\User {#3392
             id: 1,
             name: "山田 千代",
...
           },
           App\User {#4361
             id: 3,
             name: "加藤 篤司",
 ...
           },
         ],
       },
       "男" => Illuminate\Database\Eloquent\Collection {#4345
         all: [
           App\User {#4188
             id: 2,
             name: "佐藤 健一",
...
           },
         ],
       },
       "女" => Illuminate\Database\Eloquent\Collection {#4276
         all: [
           App\User {#3403
             id: 4,
             name: "山口 花子",
...
           },
         ],
       },
     ],
   }

DBレベルのグループ化と違って、DBから取得した後にCollectionのgroupBy()を適用なので、データをグループ化するだけでなく個々のデータもコレクションにキープしてくれます。そして、実行されたSQL文をチェックしてみると以下のように１つのみです。

>>> sql()
=> [
     [
       "query" => "select * from `users`",
       "bindings" => [],
       "time" => 0.51,
     ],
   ]

コントローラの作成

CollectionのgroupByを使用して必要な構造データを取得できたところで、コントローラを作成です。

app/Http/Controlles/UserController.php

namespace App\Http\Controllers;

use App\User;

class UserController extends Controller
{
    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {
        return view('users')
            ->with(['genders' => User::all()->groupBy('gender')]);
    }
}

ブレードは以下のように、２つのループ（@foreach）を使い、グループのキーである性別と個々のレコードを分けて表示します。

resources/views/users.blade.php

@section('content')
<div class="container">
    <div class="row justify-content-center">
        <div class="col-md-8">
            <div class="card">
                <div class="card-header">ユーザー性別分け</div>
                <div class="card-body">
                    <table class="table">
                        <thead>
                            <tr>
                                <td class="col-1"></td>
                                <td class="col-1">ID</td>
                                <td>名前</td>
                            </tr>
                        </thead>
                        <tbody>
                        @foreach($genders as $gender => $users)
                            <tr>
                                <td colspan="3">{{ $gender }}</td>
                            </tr>
                            @foreach($users as $user)
                                <tr>
                                    <td></td>
                                    <td class="text-right">{{ $user->id }}</td>
                                    <td>{{ $user->name }}</td>
                                </tr>
                            @endforeach
                        @endforeach
                        </tbody>
                    </table>
                </div>
            </div>
        </div>
    </div>
</div>
@endsection

これでめでたし欲しかった画面の完成です。

Laravel Collection（６）複数のキーでソート

Mon, 12 Jul 2021 00:00:42 +0900

前回に続き、Collectionのsortメソッドについて解説していきます。今回は複数の項目を使ったソートについてです。

前回同様、以下のサンプルデータを使いますのでコピペして手を動かしつつ読み進めていただけると幸いです。

// 再掲
$houses = collect([
    ['id' => 1, 'price' => 3000, 'size' => 100, 'age' => 20, 'station_distance' => 0.6],
    ['id' => 10, 'price' => 3000, 'size' => 70, 'age' => 3, 'station_distance' => 1.1],
    ['id' => 23, 'price' => 1600, 'size' => 60, 'age' => 13],
    ['id' => 3, 'price' => 1600, 'size' => 50, 'age' => 11, 'station_distance' => 2.0],
]);

複数の項目によるソート

前回は物件情報を例にsort, sortBy, sortKeysを使い、広さや築年数など１つの項目をピックアップして並び替える方法について解説しました。しかし、時としてある項目で並び替えた後に値が同じであるならば、別の項目によって並び替えたいケースがあります。

例えば、物件情報を価格の安い順に並び替えた後、同じ価格の物件が複数あるならそれらを築年数が浅い順に並び替えたい、などの場合です。このような複雑な並び替えは、sort()の引数に比較ロジックをcallback関数で指定します。

sort($callback)

Laravel公式のドキュメントにはsort()にcallback関数を渡す場合について、実例が載っていませんが、

If your sorting needs are more advanced, you may pass a callback to sort with your own algorithm. Refer to the PHP documentation on uasort, which is what the collection's sort method calls under the hood.

と書かれています。ので、PHPのuasortのドキュメントを確認しましょう。そちらの例1 基本的な uasort() の例にてcallback関数の例が示されています。

<?php
// 比較用の関数
function cmp($a, $b) {
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}

なるほど、$aと$bを引数に取り大小を比較する関数ですね。$a < $b なら１、$a > $b なら−１、$a = $b なら０が返されます。

例を参考に、まずは価格（昇順）で並び替えるcallback関数を書いてみましょう。

>>> function cmpPrice($a, $b) {
        if ($a['price'] == $b['price']) {
            return 0;
        }
 
        return ($a['price'] < $b['price']) ? -1 : 1;
    }

そして、それをsort()に指定してみましょう。

>>> $houses->sort('cmpPrice');
=> Illuminate\Support\Collection {#3397
     all: [
       2 => [
         "id" => 23,
         "price" => 1600,
         "size" => 60,
         "age" => 13,
       ],
       3 => [
         "id" => 3,
         "price" => 1600,
         "size" => 50,
         "age" => 11,
         "station_distance" => 2.0,
       ],
       0 => [
         "id" => 1,
         "price" => 3000,
         "size" => 100,
         "age" => 20,
         "station_distance" => 0.6,
       ],
       1 => [
         "id" => 10,
         "price" => 3000,
         "size" => 70,
         "age" => 3,
         "station_distance" => 1.1,
       ],
     ],
   }

価格が安い順にソートされましたね。正しくソートされているか不安な場合は前回紹介したsortBy()を使って確認してみましょう。

>>> $houses->sort('cmpPrice') == $houses->sortBy('price');
=> true

因みに、cmpPriceは昇順にソートされますが、

return ($a['price'] < $b['price']) ? -1 : 1;

この部分を

return ($a['price'] < $b['price']) ? 1 : -1;

とプラスマイナスを逆にすれば、降順にする事もできます。

続いて、価格が同じだった場合に築年数で比較するロジックを追加してみましょう。価格の比較では名前付き関数を用意しましたが、次のコードではsort()内で無名関数で指定しています。laravelではこちらが一般的です。コードは以下のようになります。

>>> $houses->sort(function ($a, $b) {
        if ($a['price'] == $b['price']) {
            if ($a['age'] == $b['age']) {
                return 0;
            }
    
            return ($a['age'] < $b['age']) ? -1 : 1;
        }
    
        return ($a['price'] < $b['price']) ? -1 : 1;
    });
=> Illuminate\Support\Collection {#3397
     all: [
       3 => [
         "id" => 3,
         "price" => 1600,
         "size" => 50,
         "age" => 11,
         "station_distance" => 2.0,
       ],
       2 => [
         "id" => 23,
         "price" => 1600,
         "size" => 60,
         "age" => 13,
       ],
       1 => [
         "id" => 10,
         "price" => 3000,
         "size" => 70,
         "age" => 3,
         "station_distance" => 1.1,
       ],
       0 => [
         "id" => 1,
         "price" => 3000,
         "size" => 100,
         "age" => 20,
         "station_distance" => 0.6,
       ],
     ],
   }

価格だけで並び替えた際と見比べてください、同じ価格の場合に築浅順に並び替えられていますね。

今回は価格と築年数のみを考慮しましたが、同様に比較ロジックを追加していけば更に細かく並び順を指定できます。しかし、上記のコードではifの入れ子が増え、とても読み辛いコードになってしまいます。でも安心して下さい、次に紹介する宇宙船演算子とエルビス演算子の合せ技でとてもスッキリさせることができます！

宇宙船演算子(<=>)とエルビス演算子(?:)の合せ技

２つの演算子について軽くおさらいしておきましょう。

宇宙船演算子

宇宙演算子はPHP7から追加された比較演算子で以下のように記述します。

$a <=> $b;

$aと$bを比較し、$a > $bなら１、$a = $bなら0、 $a < $bなら-1を返します。

お気づきかと思いますが、まさに前項で作成したcallback関数と同じ結果を返してくれます。

それにしても面白い名前ですね。初めてこの演算子を見た時は、使い方よりもまず名前の由来を検索してしまいました。諸説色々あるみたいですが、中でもStar Warsのダースベーダー専用タイファイターに似ている！というのが有力なのだとか。。。気になる人はググってみて下さい！

エルビス演算子

もう１つキーとなるのがエルビス演算子です。こちらはPHP5.3からあるので馴染みのある演算子かと思います。

$a ?: $b;

$aがtrueなら$aを返し、falseなら$bを返します。

エルビス演算子の由来は、歌手のエルヴィス・プレスリーの顔文字だそうです。。。どこが？っとなりますが、確かにハテナマークがリーゼントに見えなくも無いかも・・・。私はよくNULL合体演算子と混同してしまうのですが、こちらも名前の由来を知ってから忘れなくなりました。

宇宙船演算子とエルビス演算子を組み合わせると前項のコードは以下のように書き換えられます。

>>> $houses->sort(function ($a, $b) {
        return $a['price'] <=> $b['price']
            ?: $a['age'] <=> $b['age'];
    });

とてもスッキリしましたね！価格が同じ場合は $a[‘price’] <=> $b[‘price’]の結果が0となり、booleanに変換するとfalseなのでエルビス演算子により築年数の比較に進む、というわけです。

さらに築年数が同じなら広さ、広さが同じなら駅からの距離、と並び替えたい場合は以下のように２行加えるだけです。

 
>>> $houses->sort(function ($a, $b) {
        return $a['price'] <=> $b['price']
            ?: $a['age'] <=> $b['age']
            ?: ($a['size'] <=> $b['size']) * -1
            ?: ($a['station_distance'] <=> $b['station_distance']) * -1;
    });

簡単ですね！

sizeとstation_distanceは降順に並び替えたいので-1を掛けています、ご注意を。

Laravel8のsortBy()

ここまでLaravel7を前提に複数の項目で並び替える方法を紹介してきました。しかし実はこれ、Laravel8ではsortBy()でもっと簡単に同じことができます。

公式ドキュメントを見ると、sortBy()に並べ替える属性と目的の並べ替えの方向で構成される配列が指定できる旨が書いてあります。よって、Laravel8では以下で同じことが出来ます。

$houses->sortBy([
    ['price', 'asc'],
    ['age', 'asc'],
    ['size', 'desc'],
    ['station_distance', 'desc'],
]);

こちらの方が分かりやすいですね、Laravel8にアップグレードした際はこちらを使っていきたいと思います。

Laravel Collection（５）ソート

Sun, 04 Jul 2021 11:45:47 +0900

そろそろ引っ越しをしようかと思い、毎日物件情報サイトを物色しているhikaruです。

物件選びは価格や広さ、築年数、その他様々な側面から比較していく必要があるのでなかなか骨の折れる作業ですね。物件情報がCollectionにまとめられていればサクッと私好み順に並び替えられるのに、としみじみCollectionのありがたみを実感している今日このごろです。

ということで、今回はCollectionのありがたいsort関連のメソッド３つ、sort, sortBy, sortKeysについて解説したいと思います。

サンプルデータ

以降の解説にて使う物件情報を

物件ID
価格(万円)
広さ(㎡)
築年数
駅までの距離(km)

としてコレクションにまとめました、コピペして活用してくださいね。

$houses = collect([
    ['id' => 1, 'price' => 3000, 'size' => 100, 'age' => 20, 'station_distance' => 0.6],
    ['id' => 10, 'price' => 3000, 'size' => 70, 'age' => 3, 'station_distance' => 1.1],
    ['id' => 23, 'price' => 1600, 'size' => 60, 'age' => 13],
    ['id' => 3, 'price' => 1600, 'size' => 50, 'age' => 11, 'station_distance' => 2.0],
]);

sort()

sortメソッドは一次元なコレクションデータを並び替えるのに使用します、例えば築年数を抽出して浅い順に並び替えてみましょう。

>>> $houses->pluck('age', 'id')->sort();
=> Illuminate\Support\Collection {#3330
     all: [
       10 => 3,
       3 => 11,
       23 => 13,
       1 => 20,
     ],
   }

特定の項目を抽出するのはpluckメソッドでしたね、khino氏がLaravel Collection（２） Collectionを返すメソッドで解説しているので忘れてしまった人は復習しておきましょう。

実行結果を見ると、小さい値から大きい値へ順に並び変えられているのが分かります。小から大へ並び変える事を昇順と言います。逆に大から小へ並び替える事を降順と言います。降順に並び替えるにはsortDescメソッドを使います。

>>> $houses->pluck('age', 'id')->sortDesc();
=> Illuminate\Support\Collection {#3396
     all: [
       1 => 20,
       23 => 13,
       3 => 11,
       10 => 3,
     ],
   }

また、この後説明するsortByもsortKeysも末尾にDescを付ける事で降順となります。覚えやすいですね！

sortBy()

sortByは指定した引数の項目によって並び替えるメソッドです。例えば、$housesを狭い順に並び替えてみましょう。

>>> $houses->sortBy('size')
=> Illuminate\Support\Collection {#3404
     all: [
       3 => [
         "id" => 3,
         "price" => 1600,
         "size" => 50,
         "age" => 11,
         "station_distance" => 2.0,
       ],
       2 => [
         "id" => 23,
         "price" => 1600,
         "size" => 60,
         "age" => 13,
       ],
       1 => [
         "id" => 10,
         "price" => 3000,
         "size" => 70,
         "age" => 3,
         "station_distance" => 1.1,
       ],
       0 => [
         "id" => 1,
         "price" => 3000,
         "size" => 100,
         "age" => 20,
         "station_distance" => 0.6,
       ],
     ],
   }

ところで、引数で指定した項目がセットされていない場合はどうなるのでしょう？station_distanceで並び替えてみましょう。

>>> $houses->sortBy('station_distance');
=> Illuminate\Support\Collection {#3406
     all: [
       2 => [
         "id" => 23,
         "price" => 1600,
         "size" => 60,
         "age" => 13,
       ],
       0 => [
         "id" => 1,
         "price" => 3000,
         "size" => 100,
         "age" => 20,
         "station_distance" => 0.6,
       ],
       1 => [
         "id" => 10,
         "price" => 3000,
         "size" => 70,
         "age" => 3,
         "station_distance" => 1.1,
       ],
       3 => [
         "id" => 3,
         "price" => 1600,
         "size" => 50,
         "age" => 11,
         "station_distance" => 2.0,
       ],
     ],
   }

station_distanceがセットされていない要素が先頭に来ました。セットされていない要素は0と同じ扱いなのでしょうか？いえ、そうではありません。セットされていない値はnullとして扱われているのです。そして、マイナス値を含めてソートした場合も先頭にきます。以下のように１次元コレクションで確認すると分かりやすいです。

>>> $col = collect([1, null, -1]);
=> Illuminate\Support\Collection {#3388
     all: [
       1,
       null,
       -1,
     ],
   }
>>> $col->sort()
=> Illuminate\Support\Collection {#3406
     all: [
       1 => null,
       2 => -1,
       0 => 1,
     ],
   }
>>> $col->sortDesc()
=> Illuminate\Support\Collection {#3398
     all: [
       0 => 1,
       2 => -1,
       1 => null,
     ],
   }

これは配列のsort関数と同じ仕様です。nullとは値を持たない事を表現する型の唯一の値であり、他の型（boolean, int, float, stringなど）が混在する配列においては、昇順では先頭に、降順では末尾に並び替えされるのです。

sortKeys()

最後にCollectionのキーによってソートするsortKeysについて見てみましょう。$housesをidをキーにしてソートしてみましょう。特定の項目をkeyに指定するにはkeyByメソッドを使います。

>>> $houses->keyBy('id')->sortKeys()
=> Illuminate\Support\Collection {#3414
     all: [
       1 => [
         "id" => 1,
         "price" => 3000,
         "size" => 100,
         "age" => 20,
         "station_distance" => 0.6,
       ],
       3 => [
         "id" => 3,
         "price" => 1600,
         "size" => 50,
         "age" => 11,
         "station_distance" => 2.0,
       ],
       10 => [
         "id" => 10,
         "price" => 3000,
         "size" => 70,
         "age" => 3,
         "station_distance" => 1.1,
       ],
       23 => [
         "id" => 23,
         "price" => 1600,
         "size" => 60,
         "age" => 13,
       ],
     ],
   }

まとめ

以上がCollectionの基本的なsort系メソッドの使い方になります。次回は一歩踏み込んだソートについて解説していきたいと思います。

Laravel Collection（４）合計の計算

Mon, 28 Jun 2021 22:49:23 +0900

Collectionを使っての合計の計算は簡単です。例えば、注文の総個数の計算は$collection->sum(‘quantity’)です。金額と個数の掛け算で総合計金額の計算はどうでしょう。直感的に$collection->sum(‘price*quantity’)では、と思いますがそれはうまくいきません。さて、どう計算するのでしょう？

データの準備

準備として、まず以下migrationファイルを作成して、DBテーブルを作成します。

database/migrations/2021_06_26_164123_create_order_items_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateOrderItemsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('order_items', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('order_id')->index();
            $table->string('name');
            $table->decimal('price', 8, 0);
            $table->unsignedInteger('quantity');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('order_items');
    }
}

今度は、factoryの作成です。

database/factories/OrderItemFactory.php

/** @var \Illuminate\Database\Eloquent\Factory $factory */

use App\OrderItem;
use Faker\Generator as Faker;
use Illuminate\Support\Str;

$factory->define(OrderItem::class, function (Faker $faker) {
    return [
        'order_id' => $faker->numberBetween(1, 3),
        'name' => Str::upper($faker->word()),
        'price' => $faker->numberBetween(100, 1000),
        'quantity' => $faker->numberBetween(1, 10),
    ];
});

さて、次にtinkerでサンプルデータを作成します。

>>> factory(App\OrderItem::class, 9)->create();
=> Illuminate\Database\Eloquent\Collection {#4246
     all: [
       App\OrderItem {#4247
         id: 1,
         order_id: 1,
         name: "BEATAE",
         price: "924",
         quantity: 10,
         created_at: "2021-06-26 19:58:26",
         updated_at: "2021-06-26 19:58:26",
       },
       App\OrderItem {#4248
         id: 2,
         order_id: 1,
...

作成されたデータをmysqlで閲覧するとこんな感じです。

mysql> select id, order_id, price, quantity from order_items where order_id = 1;
+----+----------+-------+----------+
| id | order_id | price | quantity |
+----+----------+-------+----------+
|  1 |        1 |   924 |       10 |
|  2 |        1 |   157 |        8 |
|  3 |        1 |   294 |        7 |
|  4 |        1 |   839 |        2 |
|  6 |        1 |   450 |        6 |
|  8 |        1 |   310 |        9 |
+----+----------+-------+----------+

ちなみに、sqlでは先の合計金額の計算は、

mysql> select sum(price * quantity) from order_items where order_id = 1;
+-----------------------+
| sum(price * quantity) |
+-----------------------+
|                 19722 |
+-----------------------+

と簡単に計算できます。

合計金額の計算

データが揃ったところでCollectionを利用して計算です。最初に、Eloquentで注文番号１のアイテムのCollectionを作成します。

>>> use App\OrdreItem;
>>> $items = OrderItem::where('order_id', '=', 1)->get();
=> Illuminate\Database\Eloquent\Collection {#3317
     all: [
       App\OrderItem {#4249
         id: 1,
         order_id: 1,
         name: "BEATAE",
         price: "924",
         quantity: 10,
         created_at: "2021-06-26 19:58:26",
         updated_at: "2021-06-26 19:58:26",
       },
       App\OrderItem {#4103
         id: 2,
         order_id: 1,
...

試しに、先の間違った合計金額の計算を実行してみましょうか。さて、どうなるか。

>>> >>> $items->sum('price*quantity');
=> 0

もちろん、sum()の引数は項目名を指定しなければならないので、‘price*quantity’ような項目名はありもしないので合計はゼロです。

正しい方法としては、map()とsum()の２つの関数を利用します。それぞれのアイテムの合計金額のCollectionを作成してその和を計算です。

>>> $items->map(function($item) { return $item->price * $item->quantity; })->sum();
=> 19722

ちょっと長くなったけれどわかりやすい計算です。

この他には、reduce()を使用した計算もあります。

>>> $items->reduce(function($carry, $item) { return $carry + $item->price * $item->quantity;}, 0);
=> 19722

reduce()で使われる$carryは第２の引数として与えらた値（この場合ゼロ）を初期値としてループの中で計算（金額ｘ個数）した値を前回の$carryに足していきます。こちらの方法も悪くはないですね。前のmapに比べては余計なCollectionを作成しない分だけ効率かもしれません。

Laravel Collection（３）カスタムメソッド

Sun, 13 Jun 2021 09:23:55 +0900

前回においてCollectionのeach()でUserのオブジェクトにageの属性を追加する処理をしましたが、今回はこれを発展させて、UserのCollectionにカスタムメソッドを追加します。

目的

例えば、いつも大人（２０歳以上）だけのユーザーを対象にした処理を行いたいとします。 DBから取得したレコードにおいては、birth_dateの属性があるので現時点での大人だけのレコードは、以下のようにfilter()を利用して、

User::all()->filter(function ($user) {
    return $user->isAdult();
})

のような処理をすれば大人だけのレコード取得が可能です。

上で使用されているisAdult()は以下のように定義します。歳の計算は、アクセッサ getAgeAttributeで行います。

app/User.php

namespace App;

use Carbon\Carbon;
use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;

class User extends Authenticatable
{
    use Notifiable;
...
    public function getAgeAttribute()
    {
        return Carbon::parse($this->birth_date)->age;
    }

    public function isAdult()
    {
        return $this->age >= 20;
    }
}

さて、これで実際に先ほどのコードをtinkerで実行すると、

>>> User::all()->filter(function ($user) {
        return $user->isAdult();
});

=> Illuminate\Database\Eloquent\Collection {#4179
     all: [
       0 => App\User {#3306
         id: 1,
         name: "坂本 充",
         email: "nishida@example.net",
         email_verified_at: "2021-05-30 21:55:14",
         #password: "$2y$10$snEjTmJvBDu3uxd1bz0QDupihJA3zjvEH5J0pm/aLHG4UvpSfJe/q",
         #remember_token: "j8hPjp8ob7",
         birth_date: "1997-03-02",
         created_at: "2021-05-30 21:55:14",
         updated_at: "2021-05-30 21:55:14",
       },
       2 => App\User {#3986
         id: 3,
         name: "近藤 知実",
         email: "atsushi.ito@example.net",
         email_verified_at: "2021-05-30 21:55:14",
         #password: "$2y$10$A7xldQvOiCfUOyNS57EEYu2/s77a70BPmGoOjzDSgTmveeRlcAD8.",
         #remember_token: "qOFWQFb5ER",
         birth_date: "1972-09-14",
         created_at: "2021-05-30 21:55:14",
         updated_at: "2021-05-30 21:55:14",
       },
     ],
   }

と大人だけのレコードを返してくれます。

さらに、コールバックの定義も必要なしに、以下のようにfilterをあたかも属性のようにしての使用も可能です。短縮されていいですね。

>>> User::all()->filter->isAdult()

=> Illuminate\Database\Eloquent\Collection {#3299
     all: [
       0 => App\User {#4238
         id: 1,
         name: "坂本 充",
         email: "nishida@example.net",
         email_verified_at: "2021-05-30 21:55:14",
         #password: "$2y$10$snEjTmJvBDu3uxd1bz0QDupihJA3zjvEH5J0pm/aLHG4UvpSfJe/q",
         #remember_token: "j8hPjp8ob7",
         birth_date: "1997-03-02",
         created_at: "2021-05-30 21:55:14",
         updated_at: "2021-05-30 21:55:14",
       },
       2 => App\User {#4240
         id: 3,
         name: "近藤 知実",
         email: "atsushi.ito@example.net",
         email_verified_at: "2021-05-30 21:55:14",
         #password: "$2y$10$A7xldQvOiCfUOyNS57EEYu2/s77a70BPmGoOjzDSgTmveeRlcAD8.",
         #remember_token: "qOFWQFb5ER",
         birth_date: "1972-09-14",
         created_at: "2021-05-30 21:55:14",
         updated_at: "2021-05-30 21:55:14",
       },
     ],
   }
>>>

しかし、凄いことに、これをさらに進めて、以下のようにCollectionのカスタムメソッドの作成してUserのCollectionに適用することも可能なのです。

User::all()->adults()

まず、Collectionを継承したクラスを作成して、adults()のカスタムメソッドを定義します。

app/Collections/UserCollection.php

namespace App\Collections;

use Illuminate\Database\Eloquent\Collection;

class UserCollection extends Collection
{
    public function adults()
    {
        return $this->filter->isAdult();
    }
}

そして、そのカスタムクラスをモデルのクラス（User）のnewCollection()のメソッドで返り値とします。

app/User.php

namespace App;

use App\Collections\UserCollection;
use Carbon\Carbon;
use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;

class User extends Authenticatable
{
    use Notifiable;
...
    public function getAgeAttribute()
    {
        return Carbon::parse($this->birth_date)->age;
    }

    public function isAdult()
    {
        return $this->age >= 20;
    }

    public function newCollection(array $models = [])
    {
        return new UserCollection($models);
    }
}

実行してみましょう。

>>> User::all()->adults();

=> App\Collections\UserCollection {#3305
     all: [
       0 => App\User {#4024
         id: 1,
         name: "坂本 充",
         email: "nishida@example.net",
         email_verified_at: "2021-05-30 21:55:14",
         #password: "$2y$10$snEjTmJvBDu3uxd1bz0QDupihJA3zjvEH5J0pm/aLHG4UvpSfJe/q",
         #remember_token: "j8hPjp8ob7",
         birth_date: "1997-03-02",
         created_at: "2021-05-30 21:55:14",
         updated_at: "2021-05-30 21:55:14",
       },
       2 => App\User {#3986
         id: 3,
         name: "近藤 知実",
         email: "atsushi.ito@example.net",
         email_verified_at: "2021-05-30 21:55:14",
         #password: "$2y$10$A7xldQvOiCfUOyNS57EEYu2/s77a70BPmGoOjzDSgTmveeRlcAD8.",
         #remember_token: "qOFWQFb5ER",
         birth_date: "1972-09-14",
         created_at: "2021-05-30 21:55:14",
         updated_at: "2021-05-30 21:55:14",
       },
     ],
   }

同じ結果となりました。コードが短くなっただけでなくわかりやすくもなりました。

最後に注意としてですが、今回の例はレコード数がとても多いときはパフォーマンスの点からすると非常に悪い例です。すべてのDBレコードを取得してコードにおいて抽出を行うわけですゆえに。パフォーマンスを考えるとDBのSQLレベルにおいて大人の条件を入れて実行すべきです。

Laravel Collection（２） Collectionを返すメソッド

Sun, 06 Jun 2021 04:47:59 +0900

前回は、１つの値を返すCollectionのメソッドを紹介しましたが、今度はCollectionを返すメソッドの紹介です。まさにこれが実践でよく使われるものです。

レコード

まずは、前回と同様に、以下の３レコードのみがusersのDBテーブルに存在するとの仮定です。

mysql> select id, name, birth_date from users;
+----+---------------+------------+
| id | name          | birth_date |
+----+---------------+------------+
|  1 | 坂本 充       | 1997-03-02 |
|  2 | 藤本 和也     | 2005-10-03 |
|  3 | 近藤 知実     | 1972-09-14 |
+----+---------------+------------+
3 rows in set (0.00 sec)

指定した項目値の抽出

pluck()

このメソッドは、引数として与えた項目名の値をCollectionとして返します。

>>> User::all()->pluck('birth_date')

=> Illuminate\Support\Collection {#3302
     all: [
       "1997-03-02",
       "2005-10-03",
       "1972-09-14",
     ],
   }

引数として２つの項目名を与えると、後者をキーとした連想配列のCollectionを返します。

>>> User::all()->pluck('name', 'id')

=> Illuminate\Support\Collection {#4258
     all: [
       1 => "坂本 充",
       2 => "藤本 和也",
       3 => "近藤 知実",
     ],
   }

複数の項目値を抽出するには、

map()

を使用します。

>>> User::all()->map(function ($user) {
        return $user->only(['id', 'name', 'birth_date']);
    })

=> Illuminate\Support\Collection {#4090
     all: [
       [
         "id" => 1,
         "name" => "坂本 充",
         "birth_date" => "1997-03-02",
       ],
       [
         "id" => 2,
         "name" => "藤本 和也",
         "birth_date" => "2005-10-03",
       ],
       [
         "id" => 3,
         "name" => "近藤 知実",
         "birth_date" => "1972-09-14",
       ],
     ],
   }

条件に合うレコードを抽出

filter()

このメソッドは、Collectionから条件に合う必要なレコードだけを抽出します。

>>> User::all()->filter(function ($user) {
        return $user->birth_date < '1990-01-01';
    })

=> Illuminate\Database\Eloquent\Collection {#4025
     all: [
       2 => App\User {#4179
         id: 3,
         name: "近藤 知実",
         email: "atsushi.ito@example.net",
         email_verified_at: "2021-05-30 21:55:14",
         #password: "$2y$10$A7xldQvOiCfUOyNS57EEYu2/s77a70BPmGoOjzDSgTmveeRlcAD8.",
         #remember_token: "qOFWQFb5ER",
         birth_date: "1972-09-14",
         created_at: "2021-05-30 21:55:14",
         updated_at: "2021-05-30 21:55:14",
       },
     ],
   }

条件を少し複雑にすると、

>>> User::all()->filter(function ($user) {
        if ($user->birth_date > '2000-01-01') return false;
        if ($user->birth_date < '1990-01-01') return false;
        return true;
    })

=> Illuminate\Database\Eloquent\Collection {#4249
     all: [
       App\User {#4246
         id: 1,
         name: "坂本 充",
         email: "nishida@example.net",
         email_verified_at: "2021-05-30 21:55:14",
         #password: "$2y$10$snEjTmJvBDu3uxd1bz0QDupihJA3zjvEH5J0pm/aLHG4UvpSfJe/q",
         #remember_token: "j8hPjp8ob7",
         birth_date: "1997-03-02",
         created_at: "2021-05-30 21:55:14",
         updated_at: "2021-05-30 21:55:14",
       },
     ],
   }

というように、1990-01-01と2000-01-01の間に生まれたユーザーだけの取得も可能です。

ちなみに、reject()はfilter()の逆で、上と同じ結果が欲しいなら、以下のようtrue, falseがすべて逆になります。

>>> User::all()->reject(function ($user) {
        if ($user->birth_date > '2000-01-01') return true;
        if ($user->birth_date < '1990-01-01') return true;
        return false;
    })

それぞれのレコード（Userのオブジェクト）で属性処理

each()

このメソッドはまさに、よく使う以下のforeach()の関数のようなもので取得したそれぞれのDBレコードにおいて、属性の処理が可能です。

foreach($rows as $row) {
...
}

例えば、以下のようにUserのオブジェクトにageの属性を追加することができます。

>>> use Carbon\Carbon;

>>> User::all()->each(function ($user) {
        $user->age = Carbon::parse($user->birth_date)->age;
    })

=> Illuminate\Database\Eloquent\Collection {#3986
     all: [
       App\User {#4234
         id: 1,
         name: "坂本 充",
         email: "nishida@example.net",
         email_verified_at: "2021-05-30 21:55:14",
         #password: "$2y$10$snEjTmJvBDu3uxd1bz0QDupihJA3zjvEH5J0pm/aLHG4UvpSfJe/q",
         #remember_token: "j8hPjp8ob7",
         birth_date: "1997-03-02",
         created_at: "2021-05-30 21:55:14",
         updated_at: "2021-05-30 21:55:14",
         age: 24,
       },
       App\User {#4238
         id: 2,
         name: "藤本 和也",
         email: "yoshida.kana@example.com",
         email_verified_at: "2021-05-30 21:55:14",
         #password: "$2y$10$QiozldxVUo3LLj347mqHxeoDh5TEcjddDwc6vN8Pv5b4kPgPUgjri",
         #remember_token: "frW94QFFZh",
         birth_date: "2005-10-03",
         created_at: "2021-05-30 21:55:14",
         updated_at: "2021-05-30 21:55:14",
         age: 15,
       },
       App\User {#4180
         id: 3,
         name: "近藤 知実",
         email: "atsushi.ito@example.net",
         email_verified_at: "2021-05-30 21:55:14",
         #password: "$2y$10$A7xldQvOiCfUOyNS57EEYu2/s77a70BPmGoOjzDSgTmveeRlcAD8.",
         #remember_token: "qOFWQFb5ER",
         birth_date: "1972-09-14",
         created_at: "2021-05-30 21:55:14",
         updated_at: "2021-05-30 21:55:14",
         age: 48,
       },
     ],
   }

Laravel Collection（１）１つの値を返すメソッド

Mon, 31 May 2021 07:54:21 +0900

Laravelをフレームワークとして使う１つの魅力は、Collectionにあります。Eloquentでデータベースから取得した後のレコード処理がとてもエレガントにわかりやく書くことができます。というものの、Laravelのマニュアルに出てくるCollectionの例は配列ベースをcollect()したものばかりで物足りません。ということで、ここでCollectionの紹介を兼ねてDBからの取得にCollectionのメソッドを適用する例を掲載します。

準備

まずは、DBレコード取得ための準備から。

ここでで作成したLaravelのプロジェクトをもとにします。

そこで使用されている、DBテーブルにある項目を追加したいので、まずはmigrationを作成します。

$ php artisan make:migration add_new_fields_to_users_table --table=users

Created Migration: 2021_05_30_213829_add_new_fields_to_users_table

以下のようにusersのDBテーブルにbirth_date、つまり誕生日の項目を追加します。

database/migrations/2021_05_24_022418_add_new_fields_to_users_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class AddNewFieldsToUsersTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->date('birth_date')->nullable()->after('remember_token');
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->dropColumn('birth_date');
        });
    }
}

そして、migrationを実行してDBに項目を追加します。

$ php artisan migrate

Migrating: 2021_05_30_213829_add_new_fields_to_users_table
Migrated:  2021_05_30_213829_add_new_fields_to_users_table (0.09 seconds)

次に、factoryで自動データ作成のために項目を追加します。

database/factories/UserFactory.php

...
$factory->define(User::class, function (Faker $faker) {
    return [
        'name' => $faker->name(),
        'email' => $faker->unique()->safeEmail(),
        'email_verified_at' => now(),
        'password' => Hash::make('password'),
        'remember_token' => Str::random(10),
        'birth_date' => $faker->date(),
    ];
});

tinkerでdate_birthを追加したusersのレコードを３つ作成します。

>>> User::truncate()

=> Illuminate\Database\Eloquent\Builder {#3302}

>>> factory(\App\User::class, 3)->create()

=> Illuminate\Database\Eloquent\Collection {#4258
     all: [
       App\User {#4254
         name: "坂本 充",
         email: "nishida@example.net",
         email_verified_at: "2021-05-30 21:55:14",
         #password: "$2y$10$snEjTmJvBDu3uxd1bz0QDupihJA3zjvEH5J0pm/aLHG4UvpSfJe/q",
         #remember_token: "j8hPjp8ob7",
         birth_date: "1997-03-02",
         updated_at: "2021-05-30 21:55:14",
         created_at: "2021-05-30 21:55:14",
         id: 1,
       },
       App\User {#4252
         name: "藤本 和也",
         email: "yoshida.kana@example.com",
         email_verified_at: "2021-05-30 21:55:14",
         #password: "$2y$10$QiozldxVUo3LLj347mqHxeoDh5TEcjddDwc6vN8Pv5b4kPgPUgjri",
         #remember_token: "frW94QFFZh",
         birth_date: "2005-10-03",
         updated_at: "2021-05-30 21:55:14",
         created_at: "2021-05-30 21:55:14",
         id: 2,
       },
       App\User {#4251
         name: "近藤 知実",
         email: "atsushi.ito@example.net",
         email_verified_at: "2021-05-30 21:55:14",
         #password: "$2y$10$A7xldQvOiCfUOyNS57EEYu2/s77a70BPmGoOjzDSgTmveeRlcAD8.",
         #remember_token: "qOFWQFb5ER",
         birth_date: "1972-09-14",
         updated_at: "2021-05-30 21:55:14",
         created_at: "2021-05-30 21:55:14",
         id: 3,
       },
     ],
   }

Collectionから１つの値を返すメソッド

DBレコードが揃ったところで、CollectionのメソッドをEloquentで取得したCollectionに適用です。今回は、１つの値だけを返す簡単なメソッドの紹介をします。

まずは、Collectionのレコード数が必要なら以下のようにcount()をチェーンして返すことできます。

>>> User::all()->count()

=> 3

>>> User::where('id', '>', 1)->get()->count()

=> 2

ここDB処理でも同じことできますけれど、それに関しては「Eloquentでカウントするときの注意」で説明しています。

次の例ではmax()、min()はそれぞれ最大値と最小値を返してくれます。この手の集計関数は他にも、avg()、median()、reduce()、sum()もあります。

>>> User::all()->max('birth_date')

=> "2005-10-03"

>>> User::all()->min('birth_date')

=> "1972-09-14"

次の例はブーリアン値を返すメソッドです。

contains()は、含んでいるならブーリアン値のtrueを返します。

>>> User::all()->contains(function($item) {
        return $item->birth_date === '2005-10-03';
    })

=> true

また、EloquentのモデルのUserのプライマリキーを引数として渡すこともできます。これは通常のCollectionには適用不可でEloquentのCollectionのみに使用できるメソッドです。

>>> User::all()->contains(3)

=> true

>>> User::all()->contains(4)

=> false

ブーリアン値を返すものには以下の空判定のメソッドもありますね。

>>> User::all()->isEmpty()

=> false

>>> User::all()->isNotEmpty()

=> true

次の例はオブジェクトを返すメソッドです。

以下のように、最初と最後のレコードのオブジェクトを返すことが可能です。

>>> User::all()->first()

=> App\User {#4254
     id: 1,
     name: "坂本 充",
     email: "nishida@example.net",
     email_verified_at: "2021-05-30 21:55:14",
     #password: "$2y$10$snEjTmJvBDu3uxd1bz0QDupihJA3zjvEH5J0pm/aLHG4UvpSfJe/q",
     #remember_token: "j8hPjp8ob7",
     birth_date: "1997-03-02",
     created_at: "2021-05-30 21:55:14",
     updated_at: "2021-05-30 21:55:14",
   }

>>> User::all()->last()

=> App\User {#4260
     id: 3,
     name: "近藤 知実",
     email: "atsushi.ito@example.net",
     email_verified_at: "2021-05-30 21:55:14",
     #password: "$2y$10$A7xldQvOiCfUOyNS57EEYu2/s77a70BPmGoOjzDSgTmveeRlcAD8.",
     #remember_token: "qOFWQFb5ER",
     birth_date: "1972-09-14",
     created_at: "2021-05-30 21:55:14",
     updated_at: "2021-05-30 21:55:14",
   }

次回は、Collectionを返すメソッドを紹介します。

正しいのは、isEmptyでした

Sat, 02 Mar 2019 03:57:47 +0900

日常、いつもの考えや習慣で仮定してしまい、「実はそうでなかった」と後で冷や汗なること多々あります。Laravelのプログラミングもそうです。その過ちを繰り返さないために、出会ったらブログに書いていくことにします。

今回はCollectionに関して、最近うっかりしたこと。

例えば、tinkerで空の結果のEloquentのCollectionを作成して、

>>> $users = User::where('email', '=', '')->get(); // 空のCollection

=> Illuminate\Database\Eloquent\Collection {#2319
     all: [],
   } 

>>> if (empty($users)) echo "空です！"

empty()で空の判断を試みるが、「実はそうでなかった」。 empty()は引数が配列ならＯＫだけれど、Collectionのオブジェクトなら空を判断できません。

正しくは、Collectionのメソッド、isEmpty()を使います。

>>> if ($users->isEmpty()) echo "空です！"

空です！

同様に、count()でレコード数を数えてもＯＫですが、否定の!が必要。

>>> if (!$users->count()) echo "空です！"

空です！

また、配列を取り出すなら、empty()も使えます。

>>> if (empty($users->all())) echo "空です！"

空です！