验证

php artisan make:request StorePostRequest

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class StorePostRequest extends FormRequest
{
    /**
     * 判断用户是否有权发起此请求。
     */
    public function authorize(): bool
    {
        return true;
    }

    /**
     * 获取应用到请求的验证规则。
     *
     * @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
     */
    public function rules(): array
    {
        return [
            'title' => ['required', 'unique:posts', 'max:255'],
            'body' => ['required'],
        ];
    }
}

<?php

namespace App\Http\Controllers;

use App\Http\Requests\StorePostRequest;
use Illuminate\Http\JsonResponse;

class PostController extends Controller
{
    /**
     * 存储新博客文章。
     */
    public function store(StorePostRequest $request): JsonResponse
    {
        // 来访请求已验证通过...

        // 获取验证后的输入数据...
        $validated = $request->validated();

        // 存储博客文章...

        return response()->json(['message' => 'Post created successfully.'], 201);
    }
}

public function rules(): array
{
    return [
        'title' => ['bail', 'required', 'unique:posts', 'max:255'],
        'body' => ['required'],
    ];
}

public function rules(): array
{
    return [
        'title' => ['required', 'unique:posts', 'max:255'],
        'author.name' => ['required'],
        'author.description' => ['required'],
    ];
}

public function rules(): array
{
    return [
        'title' => ['required', 'unique:posts', 'max:255'],
        'v1\.0' => ['required'],
    ];
}

{
    "message": "The team name must be a string. (and 4 more errors)",
    "errors": {
        "team_name": [
            "The team name must be a string.",
            "The team name must be at least 1 characters."
        ],
        "authorization.role": [
            "The selected authorization.role is invalid."
        ],
        "users.0.email": [
            "The users.0.email field is required."
        ],
        "users.2.email": [
            "The users.2.email must be a valid email address."
        ]
    }
}

public function rules(): array
{
    return [
        'title' => ['required', 'unique:posts', 'max:255'],
        'body' => ['required'],
        'publish_at' => ['nullable', 'date'],
    ];
}

use App\Models\Comment;

/**
 * 判断用户是否有权发起此请求。
 */
public function authorize(): bool
{
    $comment = Comment::find($this->route('comment'));

    return $comment && $this->user()->can('update', $comment);
}

Route::post('/comment/{comment}');

return $this->user()->can('update', $this->comment);

/**
 * 判断用户是否有权发起此请求。
 */
public function authorize(): bool
{
    return true;
}

/**
 * 获取定义的验证规则的错误消息。
 *
 * @return array<string, string>
 */
public function messages(): array
{
    return [
        'title.required' => 'A title is required',
        'body.required' => 'A message is required',
    ];
}

public function messages(): array
{
    return [
        'email.required' => 'We need to know your email address!',
    ];
}

public function messages(): array
{
    return [
        'required' => 'The :attribute field is required.',
        'same' => 'The :attribute and :other must match.',
        'size' => 'The :attribute must be exactly :size.',
        'between' => 'The :attribute value :input is not between :min - :max.',
        'in' => 'The :attribute must be one of the following types: :values',
    ];
}

/**
 * 获取验证器错误的自定义属性名。
 *
 * @return array<string, string>
 */
public function attributes(): array
{
    return [
        'email' => 'email address',
    ];
}

use Illuminate\Validation\Validator;

/**
 * 获取请求的 "after" 验证可调用对象。
 */
public function after(): array
{
    return [
        function (Validator $validator) {
            if ($this->somethingElseIsInvalid()) {
                $validator->errors()->add(
                    'field',
                    'Something is wrong with this field!'
                );
            }
        }
    ];
}

use App\Validation\ValidateShippingTime;
use App\Validation\ValidateUserStatus;
use Illuminate\Validation\Validator;

/**
 * 获取请求的 "after" 验证可调用对象。
 */
public function after(): array
{
    return [
        new ValidateUserStatus,
        new ValidateShippingTime,
        function (Validator $validator) {
            //
        }
    ];
}

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\Attributes\StopOnFirstFailure;
use Illuminate\Foundation\Http\FormRequest;

#[StopOnFirstFailure]
class StorePostRequest extends FormRequest
{
    // ...
}

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\Attributes\FailOnUnknownFields;
use Illuminate\Foundation\Http\FormRequest;

#[FailOnUnknownFields]
class StorePostRequest extends FormRequest
{
    public function rules(): array
    {
        return [
            'title' => ['required', 'string'],
            'body' => ['required', 'string'],
        ];
    }
}

use Illuminate\Foundation\Http\FormRequest;

/**
 * 启动应用服务。
 */
public function boot(): void
{
    FormRequest::failOnUnknownFields();
}

#[FailOnUnknownFields(false)]
class PublicWebhookRequest extends FormRequest
{
    // ...
}

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\Attributes\ErrorBag;
use Illuminate\Foundation\Http\FormRequest;

#[ErrorBag('login')]
class LoginRequest extends FormRequest
{
    // ...
}

use Illuminate\Support\Str;

/**
 * 为验证准备数据。
 */
protected function prepareForValidation(): void
{
    $this->merge([
        'slug' => Str::slug($this->slug),
    ]);
}

/**
 * 处理验证通过后的操作。
 */
protected function passedValidation(): void
{
    $this->replace(['name' => 'Taylor']);
}

$validated = $request->validated();

$validated = $request->safe()->only(['name', 'email']);

$validated = $request->safe()->except(['name', 'email']);

$validated = $request->safe()->all();

// 验证后的数据可以遍历...
foreach ($request->safe() as $key => $value) {
    // ...
}

// 验证后的数据可以作为数组访问...
$validated = $request->safe();

$email = $validated['email'];

$validated = $request->safe()->merge(['name' => 'Taylor Otwell']);

$collection = $request->safe()->collect();

$errors = $validator->errors();

echo $errors->first('email');

foreach ($errors->get('email') as $message) {
    // ...
}

foreach ($errors->get('attachments.*') as $message) {
    // ...
}

foreach ($errors->all() as $message) {
    // ...
}

if ($errors->has('email')) {
    // ...
}

'custom' => [
    'email' => [
        'required' => 'We need to know your email address!',
        'max' => 'Your email address is too long!'
    ],
],

'attributes' => [
    'email' => 'email address',
],

public function rules(): array
{
    return [
        'credit_card_number' => ['required_if:payment_type,cc']
    ];
}

The credit card number field is required when payment type is cc.

'values' => [
    'payment_type' => [
        'cc' => 'credit card'
    ],
],

The credit card number field is required when payment type is credit card.

public function rules(): array
{
    return [
        'start_date' => ['required', 'date', 'after:tomorrow'],
    ];
}

public function rules(): array
{
    return [
        'finish_date' => ['required', 'date', 'after:start_date'],
    ];
}

use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'start_date' => [
            'required',
            Rule::date()->after(today()->addDays(7)),
        ],
    ];
}

'start_date' => [
    'required',
    Rule::date()->afterToday(),
],

use Illuminate\Validation\Rule;

'start_date' => [
    'required',
    Rule::date()->afterOrEqual(today()->addDays(7)),
],

use Illuminate\Validation\Rule;

'username' => [
    'required',
    Rule::anyOf([
        ['string', 'email'],
        ['string', 'alpha_dash', 'min:6'],
    ]),
],

'username' => ['alpha:ascii'],

'username' => ['alpha_dash:ascii'],

'username' => ['alpha_num:ascii'],

public function rules(): array
{
    return [
        'user' => ['array:name,username'],
    ];
}

use Illuminate\Validation\Rule;

'start_date' => [
    'required',
    Rule::date()->before(today()->subDays(7)),
],

'start_date' => [
    'required',
    Rule::date()->beforeToday(),
],

use Illuminate\Validation\Rule;

'start_date' => [
    'required',
    Rule::date()->beforeOrEqual(today()->subDays(7)),
],

'foo' => ['boolean:strict']

use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'roles' => [
            'required',
            'array',
            Rule::contains(['admin', 'editor']),
        ],
    ];
}

use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'roles' => [
            'required',
            'array',
            Rule::doesntContain(['admin', 'editor']),
        ],
    ];
}

'password' => ['current_password:api']

use Illuminate\Validation\Rule;

'start_date' => [
    'required',
    Rule::date()->format('Y-m-d'),
],

// 必须恰好两位小数 (9.99)...
'price' => ['decimal:2']

// 必须有 2 到 4 位小数...
'price' => ['decimal:2,4']

'avatar' => ['dimensions:min_width=100,min_height=200']

'avatar' => ['dimensions:ratio=3/2']

'avatar' => ['dimensions:min_ratio=1/2,max_ratio=3/2']

use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'avatar' => [
            'required',
            Rule::dimensions()
                ->maxWidth(1000)
                ->maxHeight(500)
                ->ratio(3 / 2),
        ],
    ];
}

Rule::dimensions()->ratioBetween(min: 1 / 2, max: 3 / 2)

'foo.*.id' => ['distinct']

'foo.*.id' => ['distinct:strict']

'foo.*.id' => ['distinct:ignore_case']

'email' => ['email:rfc,dns']

use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'email' => [
            'required',
            Rule::email()
                ->rfcCompliant(strict: false)
                ->validateMxRecord()
                ->preventSpoofing()
        ],
    ];
}

use Illuminate\Validation\Rules\File;

public function rules(): array
{
    return [
        'attachment' => [
            'required',
            File::types(['csv'])
                ->encoding('utf-8'),
        ],
    ];
}

use App\Enums\ServerStatus;
use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'status' => [Rule::enum(ServerStatus::class)],
    ];
}

Rule::enum(ServerStatus::class)
    ->only([ServerStatus::Pending, ServerStatus::Active]);

Rule::enum(ServerStatus::class)
    ->except([ServerStatus::Pending, ServerStatus::Active]);

use Illuminate\Support\Facades\Auth;
use Illuminate\Validation\Rule;

Rule::enum(ServerStatus::class)
    ->when(
        Auth::user()->isAdmin(),
        fn ($rule) => $rule->only(...),
        fn ($rule) => $rule->only(...),
    );

use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'role_id' => [Rule::excludeIf($this->user()->is_admin)],
    ];
}

// 或使用闭包
public function rules(): array
{
    return [
        'role_id' => [Rule::excludeIf(fn () => $this->user()->is_admin)],
    ];
}

use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'role_id' => [Rule::excludeUnless($this->user()->is_admin)],
    ];
}

// 或使用闭包
public function rules(): array
{
    return [
        'role_id' => [Rule::excludeUnless(fn () => $this->user()->is_admin)],
    ];
}

'state' => ['exists:states']

'state' => ['exists:states,abbreviation']

'email' => ['exists:connection.staff,email']

'user_id' => ['exists:App\Models\User,id']

use Illuminate\Database\Query\Builder;
use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'email' => [
            'required',
            Rule::exists('staff')->where(function (Builder $query) {
                $query->where('account_id', 1);
            }),
        ],
    ];
}

'state' => [Rule::exists('states', 'abbreviation')],

'states' => ['array', Rule::exists('states', 'abbreviation')],

'photo' => ['required', 'extensions:jpg,png'],

use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'zones' => [
            'required',
            Rule::in(['first-zone', 'second-zone']),
        ],
    ];
}

use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'airports' => [
            'required',
            'array',
        ],
        'airports.*' => Rule::in(['NYC', 'LIT']),
    ];
}

'config' => ['array', 'in_array_keys:timezone']

'age' => ['integer:strict']

'video' => ['mimetypes:video/avi,video/mpeg,video/quicktime'],

'media' => ['mimetypes:image/*,video/*'],

'photo' => ['mimes:jpg,bmp,png']

use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'toppings' => [
            'required',
            Rule::notIn(['sprinkles', 'cherries']),
        ],
    ];
}

'amount' => ['numeric:strict']

use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'role_id' => [Rule::prohibitedIf($this->user()->is_admin)],
    ];
}

// 或使用闭包
public function rules(): array
{
    return [
        'role_id' => [Rule::prohibitedIf(fn () => $this->user()->is_admin)],
    ];
}

use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'role_id' => [Rule::prohibitedUnless($this->user()->is_admin)],
    ];
}

// 或使用闭包
public function rules(): array
{
    return [
        'role_id' => [Rule::prohibitedUnless(fn () => $this->user()->is_admin)],
    ];
}

use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'role_id' => [Rule::requiredIf($this->user()->is_admin)],
    ];
}

// 或使用闭包
public function rules(): array
{
    return [
        'role_id' => [Rule::requiredIf(fn () => $this->user()->is_admin)],
    ];
}

use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'role_id' => [Rule::requiredUnless($this->user()->is_admin)],
    ];
}

// 或使用闭包
public function rules(): array
{
    return [
        'role_id' => [Rule::requiredUnless(fn () => $this->user()->is_admin)],
    ];
}

// 验证字符串恰好 12 个字符长...
'title' => ['size:12'];

// 验证提供的整数等于 10...
'seats' => ['integer', 'size:10'];

// 验证数组恰好有 5 个元素...
'tags' => ['array', 'size:5'];

// 验证上传文件恰好 512 千字节...
'image' => ['file', 'size:512'];

use Illuminate\Validation\Rule;

'title' => [
    'required',
    Rule::string()
        ->min(3)
        ->max(255)
        ->alphaDash(ascii: true),
],

'timezone' => ['required', 'timezone:all'];

'timezone' => ['required', 'timezone:Africa'];

'timezone' => ['required', 'timezone:per_country,US'];

'email' => ['unique:App\Models\User,email_address']

'email' => ['unique:users,email_address']

'email' => ['unique:connection.users,email_address']

use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'email' => [
            'required',
            Rule::unique('users')->ignore($user->id),
        ],
    ];
}

Rule::unique('users')->ignore($user)

Rule::unique('users')->ignore($user->id, 'user_id')

Rule::unique('users', 'email_address')->ignore($user->id)

'email' => Rule::unique('users')->where(fn (Builder $query) => $query->where('account_id', 1))

Rule::unique('users')->withoutTrashed();

Rule::unique('users')->withoutTrashed('was_deleted_at');

'url' => ['url:http,https'],

'game' => ['url:minecraft,steam'],

'uuid' => ['uuid:4']

public function rules(): array
{
    return [
        'has_appointment' => ['required', 'boolean'],
        'appointment_date' => ['exclude_if:has_appointment,false', 'required', 'date'],
        'doctor_name' => ['exclude_if:has_appointment,false', 'required', 'string'],
    ];
}

public function rules(): array
{
    return [
        'has_appointment' => ['required', 'boolean'],
        'appointment_date' => ['exclude_unless:has_appointment,true', 'required', 'date'],
        'doctor_name' => ['exclude_unless:has_appointment,true', 'required', 'string'],
    ];
}

public function rules(): array
{
    return [
        'email' => ['sometimes', 'required', 'email'],
    ];
}

use Illuminate\Support\Fluent;
use Illuminate\Validation\Validator;

/**
 * 配置验证器实例。
 */
public function withValidator(Validator $validator): void
{
    $validator->sometimes('reason', ['required', 'max:500'], function (Fluent $input) {
        return $input->games >= 100;
    });
}

public function withValidator(Validator $validator): void
{
    $validator->sometimes(['reason', 'cost'], 'required', function (Fluent $input) {
        return $input->games >= 100;
    });
}

public function withValidator(Validator $validator): void
{
    $validator->sometimes('channels.*.address', 'email', function (Fluent $input, Fluent $item) {
        return $item->type === 'email';
    });

    $validator->sometimes('channels.*.address', 'url', function (Fluent $input, Fluent $item) {
        return $item->type !== 'email';
    });
}

public function rules(): array
{
    return [
        'user' => ['array:name,username'],
    ];
}

public function rules(): array
{
    return [
        'photos.profile' => ['required', 'image'],
    ];
}

public function rules(): array
{
    return [
        'users.*.email' => ['email', 'unique:users'],
        'users.*.first_name' => ['required_with:users.*.last_name'],
    ];
}

'custom' => [
    'users.*.email' => [
        'unique' => 'Each user must have a unique email address',
    ]
],

use App\Rules\HasPermission;
use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'companies.*.id' => Rule::forEach(function (string|null $value, string $attribute) {
            return [
                Rule::exists(Company::class, 'id'),
                new HasPermission('manage-company', $value),
            ];
        }),
    ];
}

public function messages(): array
{
    return [
        'photos.*.description.required' => 'Please describe photo #:position.',
    ];
}

'photos.*.attributes.*.string' => 'Invalid attribute for photo #:second-position.',

use Illuminate\Validation\Rules\File;

public function rules(): array
{
    return [
        'attachment' => [
            'required',
            File::types(['mp3', 'wav'])
                ->min(1024)
                ->max(12 * 1024),
        ],
    ];
}

File::types(['mp3', 'wav'])
    ->min('1kb')
    ->max('10mb');

use Illuminate\Validation\Rule;
use Illuminate\Validation\Rules\File;

public function rules(): array
{
    return [
        'photo' => [
            'required',
            File::image()
                ->min(1024)
                ->max(12 * 1024)
                ->dimensions(Rule::dimensions()->maxWidth(1000)->maxHeight(500)),
        ],
    ];
}

use Illuminate\Validation\Rule;
use Illuminate\Validation\Rules\File;

File::image()->dimensions(
    Rule::dimensions()
        ->maxWidth(1000)
        ->maxHeight(500)
)

use Illuminate\Validation\Rules\Password;

public function rules(): array
{
    return [
        'password' => ['required', 'confirmed', Password::min(8)],
    ];
}

// 要求至少 8 个字符...
Password::min(8)

// 要求至少一个字母...
Password::min(8)->letters()

// 要求至少一个大写和一个小写字母...
Password::min(8)->mixedCase()

// 要求至少一个数字...
Password::min(8)->numbers()

// 要求至少一个符号...
Password::min(8)->symbols()

Password::min(8)->uncompromised()

// 确保密码在同一数据泄露中出现少于 3 次...
Password::min(8)->uncompromised(3);

Password::min(8)
    ->letters()
    ->mixedCase()
    ->numbers()
    ->symbols()
    ->uncompromised()

use Illuminate\Validation\Rules\Password;

/**
 * 启动应用服务。
 */
public function boot(): void
{
    Password::defaults(function () {
        $rule = Password::min(8);

        return $this->app->isProduction()
            ? $rule->mixedCase()->uncompromised()
            : $rule;
    });
}

public function rules(): array
{
    return [
        'password' => ['required', Password::defaults()],
    ];
}

use App\Rules\ZxcvbnRule;

Password::defaults(function () {
    $rule = Password::min(8)->rules([new ZxcvbnRule]);

    // ...
});

php artisan make:rule Uppercase

<?php

namespace App\Rules;

use Closure;
use Illuminate\Contracts\Validation\ValidationRule;

class Uppercase implements ValidationRule
{
    /**
     * 运行验证规则。
     */
    public function validate(string $attribute, mixed $value, Closure $fail): void
    {
        if (strtoupper($value) !== $value) {
            $fail('The :attribute must be uppercase.');
        }
    }
}

use App\Rules\Uppercase;

public function rules(): array
{
    return [
        'name' => ['required', 'string', new Uppercase],
    ];
}

if (strtoupper($value) !== $value) {
    $fail('validation.uppercase')->translate();
}

$fail('validation.location')->translate([
    'value' => $this->value,
], 'fr');

<?php

namespace App\Rules;

use Illuminate\Contracts\Validation\DataAwareRule;
use Illuminate\Contracts\Validation\ValidationRule;

class Uppercase implements DataAwareRule, ValidationRule
{
    /**
     * All of the data under validation.
     *
     * @var array<string, mixed>
     */
    protected $data = [];

    // ...

    /**
     * Set the data under validation.
     *
     * @param  array<string, mixed>  $data
     */
    public function setData(array $data): static
    {
        $this->data = $data;

        return $this;
    }
}

<?php

namespace App\Rules;

use Illuminate\Contracts\Validation\ValidationRule;
use Illuminate\Contracts\Validation\ValidatorAwareRule;
use Illuminate\Validation\Validator;

class Uppercase implements ValidationRule, ValidatorAwareRule
{
    /**
     * The validator instance.
     *
     * @var \Illuminate\Validation\Validator
     */
    protected $validator;

    // ...

    /**
     * Set the current validator.
     */
    public function setValidator(Validator $validator): static
    {
        $this->validator = $validator;

        return $this;
    }
}

use Closure;

public function rules(): array
{
    return [
        'title' => [
            'required',
            'max:255',
            function (string $attribute, mixed $value, Closure $fail) {
                if ($value === 'foo') {
                    $fail("The {$attribute} is invalid.");
                }
            },
        ],
    ];
}

public function rules(): array
{
    return [
        'name' => ['unique:users,name'],
    ];
}

// 如果 name 为 ''，验证将通过

php artisan make:rule Uppercase --implicit