Diğer Doğrulayıcılar

Composer'da doğrudan kullanılabilecek birçok doğrulayıcı mevcuttur:

webman/validation (Önerilen)

top-think/think-validate

respect/validation

Doğrulayıcı webman/validation

illuminate/validation tabanlıdır; manuel doğrulama, annotation doğrulama, parametre düzeyinde doğrulama ve yeniden kullanılabilir kural setleri sağlar.

Kurulum

composer require webman/validation

Temel Kavramlar

• Kural Seti Yeniden Kullanımı: support\validation\Validator sınıfını genişleterek yeniden kullanılabilir rules, messages, attributes ve scenes tanımlayın; hem manuel hem de annotation doğrulamada kullanılabilir.
• Metot Düzeyinde Annotation (Attribute) Doğrulama: PHP 8 attribute #[Validate] ile doğrulamayı controller metotlarına bağlayın.
• Parametre Düzeyinde Annotation (Attribute) Doğrulama: PHP 8 attribute #[Param] ile doğrulamayı controller metot parametrelerine bağlayın.
• İstisna İşleme: Doğrulama başarısız olduğunda support\validation\ValidationException fırlatır; istisna sınıfı yapılandırılabilir.
• Veritabanı Doğrulaması: Veritabanı doğrulaması söz konusuysa composer require webman/database kurmanız gerekir.

Manuel Doğrulama

Temel Kullanım

use support\validation\Validator;

$data = ['email' => 'user@example.com'];

Validator::make($data, [
    'email' => 'required|email',
])->validate();

Not
validate() doğrulama başarısız olduğunda support\validation\ValidationException fırlatır. İstisna fırlatmak istemiyorsanız, hata mesajlarını almak için aşağıdaki fails() yaklaşımını kullanın.

Özel mesajlar ve nitelikler

use support\validation\Validator;

$data = ['contact' => 'user@example.com'];

Validator::make(
    $data,
    ['contact' => 'required|email'],
    ['contact.email' => 'Invalid email format'],
    ['contact' => 'Email']
)->validate();

İstisna Olmadan Doğrulama (Hata Mesajlarını Alma)

İstisna fırlatmak istemiyorsanız, fails() ile kontrol edin ve errors() (MessageBag döndürür) üzerinden hata mesajlarını alın:

use support\validation\Validator;

$data = ['email' => 'bad-email'];

$validator = Validator::make($data, [
    'email' => 'required|email',
]);

if ($validator->fails()) {
    $firstError = $validator->errors()->first();      // string
    $allErrors = $validator->errors()->all();         // array
    $errorsByField = $validator->errors()->toArray(); // array
    // handle errors...
}

Kural Seti Yeniden Kullanımı (Özel Doğrulayıcı)

namespace app\validation;

use support\validation\Validator;

class UserValidator extends Validator
{
    protected array $rules = [
        'id' => 'required|integer|min:1',
        'name' => 'required|string|min:2|max:20',
        'email' => 'required|email',
    ];

    protected array $messages = [
        'name.required' => 'Name is required',
        'email.required' => 'Email is required',
        'email.email' => 'Invalid email format',
    ];

    protected array $attributes = [
        'name' => 'Name',
        'email' => 'Email',
    ];
}

Manuel Doğrulama Yeniden Kullanımı

use app\validation\UserValidator;

UserValidator::make($data)->validate();

Sahne kullanımı (İsteğe Bağlı)

scenes isteğe bağlı bir özelliktir; withScene(...) çağırdığınızda yalnızca alanların bir alt kümesini doğrular.

namespace app\validation;

use support\validation\Validator;

class UserValidator extends Validator
{
    protected array $rules = [
        'id' => 'required|integer|min:1',
        'name' => 'required|string|min:2|max:20',
        'email' => 'required|email',
    ];

    protected array $scenes = [
        'create' => ['name', 'email'],
        'update' => ['id', 'name', 'email'],
    ];
}

use app\validation\UserValidator;

// Sahne belirtilmedi -> tüm kuralları doğrula
UserValidator::make($data)->validate();

// Sahne belirtildi -> yalnızca o sahnedeki alanları doğrula
UserValidator::make($data)->withScene('create')->validate();

Annotation Doğrulama (Metot Düzeyinde)

Doğrudan Kurallar

use support\Request;
use support\validation\annotation\Validate;

class AuthController
{
    #[Validate(
        rules: [
            'email' => 'required|email',
            'password' => 'required|string|min:6',
        ],
        messages: [
            'email.required' => 'Email is required',
            'password.required' => 'Password is required',
        ],
        attributes: [
            'email' => 'Email',
            'password' => 'Password',
        ]
    )]
    public function login(Request $request)
    {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Kural Setlerini Yeniden Kullanma

use app\validation\UserValidator;
use support\Request;
use support\validation\annotation\Validate;

class UserController
{
    #[Validate(validator: UserValidator::class, scene: 'create')]
    public function create(Request $request)
    {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Çoklu Doğrulama Katmanları

use support\validation\annotation\Validate;

class UserController
{
    #[Validate(rules: ['email' => 'required|email'])]
    #[Validate(rules: ['token' => 'required|string'])]
    public function send()
    {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Doğrulama Veri Kaynağı

use support\validation\annotation\Validate;

class UserController
{
    #[Validate(
        rules: ['email' => 'required|email'],
        in: ['query', 'body', 'path']
    )]
    public function send()
    {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

in parametresi ile veri kaynağını belirtin:

• query HTTP istek sorgu parametreleri, $request->get() üzerinden
• body HTTP istek gövdesi, $request->post() üzerinden
• path HTTP istek yol parametreleri, $request->route->param() üzerinden

in bir string veya dizi olabilir; dizi olduğunda değerler sırayla birleştirilir ve sonraki değerler öncekilerin üzerine yazar. in geçirilmediğinde varsayılan olarak ['query', 'body', 'path'] kullanılır.

Parametre Düzeyinde Doğrulama (Param)

Temel Kullanım

use support\validation\annotation\Param;

class MailController
{
    public function send(
        #[Param(rules: 'required|email')] string $from,
        #[Param(rules: 'required|email')] string $to,
        #[Param(rules: 'required|string|min:1|max:500')] string $content
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Doğrulama Veri Kaynağı

Benzer şekilde, parametre düzeyinde doğrulama da kaynağı belirtmek için in parametresini destekler:

use support\validation\annotation\Param;

class MailController
{
    public function send(
        #[Param(rules: 'required|email', in: ['body'])] string $from
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

rules string veya array destekler

use support\validation\annotation\Param;

class MailController
{
    public function send(
        #[Param(rules: ['required', 'email'])] string $from
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Özel mesajlar / nitelik

use support\validation\annotation\Param;

class UserController
{
    public function updateEmail(
        #[Param(
            rules: 'required|email',
            messages: ['email.email' => 'Invalid email format'],
            attribute: 'Email'
        )]
        string $email
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Kural Sabiti Yeniden Kullanımı

final class ParamRules
{
    public const EMAIL = ['required', 'email'];
}

class UserController
{
    public function send(
        #[Param(rules: ParamRules::EMAIL)] string $email
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Metot Düzeyinde + Parametre Düzeyinde Birleşik

use support\Request;
use support\validation\annotation\Param;
use support\validation\annotation\Validate;

class UserController
{
    #[Validate(rules: ['token' => 'required|string'])]
    public function send(
        Request $request,
        #[Param(rules: 'required|email')] string $from,
        #[Param(rules: 'required|integer')] int $id
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Otomatik Kural Çıkarımı (Parametre İmzasına Dayalı)

Bir metotta #[Validate] kullanıldığında veya o metodun herhangi bir parametresi #[Param] kullandığında, bu bileşen metot parametre imzasından temel doğrulama kurallarını otomatik olarak çıkarır ve tamamlar, ardından doğrulamadan önce mevcut kurallarla birleştirir.

Örnek: #[Validate] eşdeğer genişletme

1) Yalnızca #[Validate] etkinleştirilmiş, kurallar manuel yazılmamış:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate]
    public function create(string $content, int $uid)
    {
    }
}

Şuna eşdeğer:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate(rules: [
        'content' => 'required|string',
        'uid' => 'required|integer',
    ])]
    public function create(string $content, int $uid)
    {
    }
}

2) Yalnızca kısmi kurallar yazılmış, geri kalanı parametre imzasıyla tamamlanıyor:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate(rules: [
        'content' => 'min:2',
    ])]
    public function create(string $content, int $uid)
    {
    }
}

Şuna eşdeğer:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate(rules: [
        'content' => 'required|string|min:2',
        'uid' => 'required|integer',
    ])]
    public function create(string $content, int $uid)
    {
    }
}

3) Varsayılan değer / nullable tip:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate]
    public function create(string $content = 'default', ?int $uid = null)
    {
    }
}

Şuna eşdeğer:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate(rules: [
        'content' => 'string',
        'uid' => 'integer|nullable',
    ])]
    public function create(string $content = 'default', ?int $uid = null)
    {
    }
}

İstisna İşleme

Varsayılan İstisna

Doğrulama başarısızlığı varsayılan olarak support\validation\ValidationException fırlatır; bu sınıf Webman\Exception\BusinessException sınıfını genişletir ve hata günlüğe kaydedilmez.

Varsayılan yanıt davranışı BusinessException::render() tarafından işlenir:

• Normal istekler: string mesaj döndürür, örn. token is required.
• JSON istekleri: JSON yanıt döndürür, örn. {"code": 422, "msg": "token is required.", "data":....}

Özel istisna ile özelleştirme

• Global yapılandırma: config/plugin/webman/validation/app.php içindeki exception

Çoklu Dil Desteği

Bileşen yerleşik Çince ve İngilizce dil paketleri içerir ve proje geçersiz kılmalarını destekler. Yükleme sırası:

1. Proje dil paketi resource/translations/{locale}/validation.php
2. Bileşen yerleşik vendor/webman/validation/resources/lang/{locale}/validation.php
3. Illuminate yerleşik İngilizce (yedek)

Not
Webman varsayılan dili config/translation.php içinde yapılandırılır veya locale('en'); ile değiştirilebilir.

Yerel Geçersiz Kılma Örneği

resource/translations/zh_CN/validation.php

return [
    'email' => ':attribute is not a valid email format.',
];

Middleware Otomatik Yükleme

Kurulumdan sonra bileşen, config/plugin/webman/validation/middleware.php üzerinden doğrulama middleware'ini otomatik yükler; manuel kayıt gerekmez.

Komut Satırı Oluşturma

Doğrulayıcı sınıfları oluşturmak için make:validator komutunu kullanın (varsayılan çıktı app/validation dizinine).

Not
composer require webman/console gerekir

Temel Kullanım

• Boş şablon oluştur

php webman make:validator UserValidator

• Mevcut dosyanın üzerine yaz

php webman make:validator UserValidator --force
php webman make:validator UserValidator -f

Tablo yapısından kurallar oluşturma

• Temel kurallar oluşturmak için tablo adı belirtin (alan tipi/nullable/uzunluk vb.den $rules çıkarır; varsayılan olarak ORM ile ilgili alanları hariç tutar: laravel created_at/updated_at/deleted_at, thinkorm create_time/update_time/delete_time kullanır)

php webman make:validator UserValidator --table=wa_users
php webman make:validator UserValidator -t wa_users

• Veritabanı bağlantısı belirtin (çoklu bağlantı senaryoları)

php webman make:validator UserValidator --table=wa_users --database=mysql
php webman make:validator UserValidator -t wa_users -d mysql

Sahne

• CRUD sahneleri oluştur: create/update/delete/detail

php webman make:validator UserValidator --table=wa_users --scenes=crud
php webman make:validator UserValidator -t wa_users -s crud

update sahnesi birincil anahtar alanını (kayıt bulmak için) artı diğer alanları içerir; delete/detail varsayılan olarak yalnızca birincil anahtarı içerir.

ORM seçimi (laravel (illuminate/database) vs think-orm)

• Otomatik seçim (varsayılan): Kurulu/yapılandırılan kullanılır; her ikisi de mevcutsa varsayılan olarak illuminate kullanılır
• Zorla belirt

php webman make:validator UserValidator --table=wa_users --orm=laravel
php webman make:validator UserValidator --table=wa_users --orm=thinkorm
php webman make:validator UserValidator -t wa_users -o thinkorm

Tam örnek

php webman make:validator UserValidator -t wa_users -d mysql -s crud -o laravel -f

Birim Testleri

webman/validation kök dizininden çalıştırın:

composer install
vendor\bin\phpunit -c phpunit.xml

Doğrulama Kuralları Referansı

Mevcut Doğrulama Kuralları

[!IMPORTANT]

• Webman Validation illuminate/validation tabanlıdır; kural adları Laravel ile eşleşir ve Webman'e özgü kurallar yoktur.
• Middleware varsayılan olarak $request->all() (GET+POST) ile rota parametrelerinin birleşiminden gelen veriyi doğrular, yüklenen dosyalar hariç; dosya kuralları için $request->file() veriyi kendiniz birleştirin veya Validator::make'i manuel çağırın.
• current_password auth guard'a bağlıdır; exists/unique veritabanı bağlantısına ve sorgu oluşturucuya bağlıdır; bu kurallar ilgili bileşenler entegre edilmediğinde kullanılamaz.

Aşağıda tüm mevcut doğrulama kuralları ve amaçları listelenmiştir:

Boolean

String

Numeric

Array

Date

File

Database

Utility

accepted

Alan "yes", "on", 1, "1", true veya "true" olmalıdır. Genellikle kullanıcının hizmet şartlarını kabul ettiğini doğrulama gibi senaryolarda kullanılır.

accepted_if:anotherfield,value,...

Başka bir alan belirtilen değere eşit olduğunda, alan "yes", "on", 1, "1", true veya "true" olmalıdır. Genellikle koşullu kabul senaryolarında kullanılır.

active_url

Alan geçerli bir A veya AAAA kaydına sahip olmalıdır. Bu kural önce URL host adını çıkarmak için parse_url kullanır, ardından dns_get_record ile doğrular.

after:date

Alan verilen tarihten sonra bir değer olmalıdır. Tarih geçerli bir DateTime'a dönüştürmek için strtotime'a geçirilir:

use support\validation\Validator;

Validator::make($data, [
    'start_date' => 'required|date|after:tomorrow',
])->validate();

Karşılaştırma için başka bir alan adı da geçirebilirsiniz:

Validator::make($data, [
    'finish_date' => 'required|date|after:start_date',
])->validate();

Akıcı date kural oluşturucusunu kullanabilirsiniz:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->after(\Carbon\Carbon::today()->addDays(7)),
    ],
])->validate();

afterToday ve todayOrAfter "bugünden sonra olmalı" veya "bugün veya sonrası olmalı" ifadelerini kolayca belirtir:

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->afterToday(),
    ],
])->validate();

after_or_equal:date

Alan verilen tarihte veya sonrasında olmalıdır. Daha fazla ayrıntı için after bölümüne bakın.

Akıcı date kural oluşturucusunu kullanabilirsiniz:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->afterOrEqual(\Carbon\Carbon::today()->addDays(7)),
    ],
])->validate();

anyOf

Rule::anyOf "herhangi bir kural setini karşıla" belirtmeye izin verir. Örneğin aşağıdaki kural username'in ya bir e-posta adresi ya da en az 6 karakterlik alfanumerik/alt çizgi/tire dizisi olması gerektiği anlamına gelir:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'username' => [
        'required',
        Rule::anyOf([
            ['string', 'email'],
            ['string', 'alpha_dash', 'min:6'],
        ]),
    ],
])->validate();

alpha

Alan Unicode harflerden oluşmalıdır (\p{L} ve \p{M}).

Yalnızca ASCII (a-z, A-Z) izin vermek için ascii seçeneğini ekleyin:

Validator::make($data, [
    'username' => 'alpha:ascii',
])->validate();

alpha_dash

Alan yalnızca Unicode harfler ve sayılar (\p{L}, \p{M}, \p{N}) artı ASCII tire (-) ve alt çizgi (_) içerebilir.

Yalnızca ASCII (a-z, A-Z, 0-9) izin vermek için ascii seçeneğini ekleyin:

Validator::make($data, [
    'username' => 'alpha_dash:ascii',
])->validate();

alpha_num

Alan yalnızca Unicode harfler ve sayılar (\p{L}, \p{M}, \p{N}) içerebilir.

Yalnızca ASCII (a-z, A-Z, 0-9) izin vermek için ascii seçeneğini ekleyin:

Validator::make($data, [
    'username' => 'alpha_num:ascii',
])->validate();

array

Alan bir PHP array olmalıdır.

array kuralı ek parametrelere sahip olduğunda, giriş dizi anahtarları parametre listesinde olmalıdır. Örnekte admin anahtarı izin verilen listede değil, bu yüzden geçersizdir:

use support\validation\Validator;

$input = [
    'user' => [
        'name' => 'Taylor Otwell',
        'username' => 'taylorotwell',
        'admin' => true,
    ],
];

Validator::make($input, [
    'user' => 'array:name,username',
])->validate();

Gerçek projelerde izin verilen dizi anahtarlarını açıkça tanımlamanız önerilir.

ascii

Alan yalnızca 7-bit ASCII karakterler içerebilir.

bail

İlk kural başarısız olduğunda alan için diğer kuralların doğrulanmasını durdurun.

Bu kural yalnızca mevcut alanı etkiler. "Genel olarak ilk başarısızlıkta dur" için Illuminate doğrulayıcısını doğrudan kullanın ve stopOnFirstFailure() çağırın.

before:date

Alan verilen tarihten önce olmalıdır. Tarih geçerli bir DateTime'a dönüştürmek için strtotime'a geçirilir. after gibi karşılaştırma için başka bir alan adı geçirebilirsiniz.

Akıcı date kural oluşturucusunu kullanabilirsiniz:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->before(\Carbon\Carbon::today()->subDays(7)),
    ],
])->validate();

beforeToday ve todayOrBefore "bugünden önce olmalı" veya "bugün veya öncesi olmalı" ifadelerini kolayca belirtir:

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->beforeToday(),
    ],
])->validate();

before_or_equal:date

Alan verilen tarihte veya öncesinde olmalıdır. Tarih geçerli bir DateTime'a dönüştürmek için strtotime'a geçirilir. after gibi karşılaştırma için başka bir alan adı geçirebilirsiniz.

Akıcı date kural oluşturucusunu kullanabilirsiniz:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->beforeOrEqual(\Carbon\Carbon::today()->subDays(7)),
    ],
])->validate();

between:min,max

Alan boyutu min ve max (dahil) arasında olmalıdır. String, sayı, dizi ve dosyalar için değerlendirme size ile aynıdır.

boolean

Alan boolean'a dönüştürülebilir olmalıdır. Kabul edilebilir girişler: true, false, 1, 0, "1", "0".

Yalnızca true veya false izin vermek için strict parametresini kullanın:

Validator::make($data, [
    'foo' => 'boolean:strict',
])->validate();

confirmed

Alan eşleşen bir {field}_confirmation alanına sahip olmalıdır. Örneğin alan password olduğunda password_confirmation gerekir.

Özel onay alan adı da belirtebilirsiniz, örn. confirmed:repeat_username mevcut alanla eşleşmesi için repeat_username gerektirir.

contains:foo,bar,...

Alan bir dizi olmalı ve verilen parametre değerlerinin tümünü içermelidir. Bu kural genellikle dizi doğrulaması için kullanılır; oluşturmak için Rule::contains kullanabilirsiniz:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'roles' => [
        'required',
        'array',
        Rule::contains(['admin', 'editor']),
    ],
])->validate();

doesnt_contain:foo,bar,...

Alan bir dizi olmalı ve verilen parametre değerlerinden hiçbirini içermemelidir. Oluşturmak için Rule::doesntContain kullanabilirsiniz:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'roles' => [
        'required',
        'array',
        Rule::doesntContain(['admin', 'editor']),
    ],
])->validate();

current_password

Alan mevcut kimliği doğrulanmış kullanıcının şifresiyle eşleşmelidir. Auth guard'ı ilk parametre olarak belirtebilirsiniz:

Validator::make($data, [
    'password' => 'current_password:api',
])->validate();

[!WARNING]
Bu kural auth bileşenine ve guard yapılandırmasına bağlıdır; auth entegre edilmediğinde kullanmayın.

date

Alan strtotime tarafından tanınan geçerli (göreli olmayan) bir tarih olmalıdır.

date_equals:date

Alan verilen tarihe eşit olmalıdır. Tarih geçerli bir DateTime'a dönüştürmek için strtotime'a geçirilir.

date_format:format,...

Alan verilen formatlardan birine uymalıdır. date veya date_format kullanın. Bu kural tüm PHP DateTime formatlarını destekler.

Akıcı date kural oluşturucusunu kullanabilirsiniz:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->format('Y-m-d'),
    ],
])->validate();

decimal:min,max

Alan gerekli ondalık basamaklara sahip sayısal olmalıdır:

Validator::make($data, [
    'price' => 'decimal:2',
])->validate();

Validator::make($data, [
    'price' => 'decimal:2,4',
])->validate();

declined

Alan "no", "off", 0, "0", false veya "false" olmalıdır.

declined_if:anotherfield,value,...

Başka bir alan belirtilen değere eşit olduğunda, alan "no", "off", 0, "0", false veya "false" olmalıdır.

different:field

Alan field ile farklı olmalıdır.

digits:value

Alan value uzunluğunda bir tam sayı olmalıdır.

digits_between:min,max

Alan min ve max arasında uzunlukta bir tam sayı olmalıdır.

dimensions

Alan bir resim olmalı ve boyut kısıtlamalarını karşılamalıdır:

Validator::make($data, [
    'avatar' => 'dimensions:min_width=100,min_height=200',
])->validate();

Mevcut kısıtlamalar: min_width, max_width, min_height, max_height, width, height, ratio.

ratio en-boy oranıdır; kesir veya float olarak ifade edilebilir:

Validator::make($data, [
    'avatar' => 'dimensions:ratio=3/2',
])->validate();

Bu kuralın birçok parametresi vardır; oluşturmak için Rule::dimensions kullanmanız önerilir:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'avatar' => [
        'required',
        Rule::dimensions()
            ->maxWidth(1000)
            ->maxHeight(500)
            ->ratio(3 / 2),
    ],
])->validate();

distinct

Diziler doğrulanırken alan değerleri tekrarlanmamalıdır:

Validator::make($data, [
    'foo.*.id' => 'distinct',
])->validate();

Varsayılan olarak gevşek karşılaştırma kullanır. Kesin karşılaştırma için strict ekleyin:

Validator::make($data, [
    'foo.*.id' => 'distinct:strict',
])->validate();

Büyük/küçük harf farklarını yok saymak için ignore_case ekleyin:

Validator::make($data, [
    'foo.*.id' => 'distinct:ignore_case',
])->validate();

doesnt_start_with:foo,bar,...

Alan belirtilen değerlerden hiçbiriyle başlamamalıdır.

doesnt_end_with:foo,bar,...

Alan belirtilen değerlerden hiçbiriyle bitmemelidir.

email

Alan geçerli bir e-posta adresi olmalıdır. Bu kural egulias/email-validator'a bağlıdır, varsayılan olarak RFCValidation kullanır ve diğer doğrulama yöntemlerini kullanabilir:

Validator::make($data, [
    'email' => 'email:rfc,dns',
])->validate();

Mevcut doğrulama yöntemleri:

Akıcı kural oluşturucusunu kullanabilirsiniz:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        'required',
        Rule::email()
            ->rfcCompliant(strict: false)
            ->validateMxRecord()
            ->preventSpoofing(),
    ],
])->validate();

[!WARNING]
dns ve spoof PHP intl uzantısını gerektirir.

encoding:encoding_type

Alan belirtilen karakter kodlamasıyla eşleşmelidir. Bu kural dosya veya string kodlamasını tespit etmek için mb_check_encoding kullanır. Dosya kural oluşturucusu ile kullanılabilir:

use Illuminate\Validation\Rules\File;
use support\validation\Validator;

Validator::make($data, [
    'attachment' => [
        'required',
        File::types(['csv'])->encoding('utf-8'),
    ],
])->validate();

ends_with:foo,bar,...

Alan belirtilen değerlerden biriyle bitmelidir.

enum

Enum, alan değerinin geçerli bir enum değeri olduğunu doğrulayan sınıf tabanlı bir kuraldır. Oluştururken enum sınıf adını geçirin. İlkel değerler için Backed Enum kullanın:

use app\enums\ServerStatus;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'status' => [Rule::enum(ServerStatus::class)],
])->validate();

Enum değerlerini kısıtlamak için only/except kullanın:

use app\enums\ServerStatus;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'status' => [
        Rule::enum(ServerStatus::class)
            ->only([ServerStatus::Pending, ServerStatus::Active]),
    ],
])->validate();

Validator::make($data, [
    'status' => [
        Rule::enum(ServerStatus::class)
            ->except([ServerStatus::Pending, ServerStatus::Active]),
    ],
])->validate();

Koşullu kısıtlamalar için when kullanın:

use app\Enums\ServerStatus;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'status' => [
        Rule::enum(ServerStatus::class)->when(
            $isAdmin,
            fn ($rule) => $rule->only(ServerStatus::Active),
            fn ($rule) => $rule->only(ServerStatus::Pending),
        ),
    ],
])->validate();

exclude

Alan validate/validated tarafından döndürülen veriden hariç tutulacaktır.

exclude_if:anotherfield,value

anotherfield value ile eşit olduğunda, alan validate/validated tarafından döndürülen veriden hariç tutulacaktır.

Karmaşık koşullar için Rule::excludeIf kullanın:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'role_id' => Rule::excludeIf($isAdmin),
])->validate();

Validator::make($data, [
    'role_id' => Rule::excludeIf(fn () => $isAdmin),
])->validate();

exclude_unless:anotherfield,value

anotherfield value ile eşit olmadıkça, alan validate/validated tarafından döndürülen veriden hariç tutulacaktır. value null ise (örn. exclude_unless:name,null), alan yalnızca karşılaştırma alanı null veya yok olduğunda tutulur.

exclude_with:anotherfield

anotherfield mevcut olduğunda, alan validate/validated tarafından döndürülen veriden hariç tutulacaktır.

exclude_without:anotherfield

anotherfield mevcut olmadığında, alan validate/validated tarafından döndürülen veriden hariç tutulacaktır.

exists:table,column

Alan belirtilen veritabanı tablosunda mevcut olmalıdır.

Exists kuralının temel kullanımı

Validator::make($data, [
    'state' => 'exists:states',
])->validate();

column belirtilmediğinde varsayılan olarak alan adı kullanılır. Bu örnek state sütununun states tablosunda mevcut olup olmadığını doğrular.

Özel sütun adı belirtme

Tablo adından sonra sütun adını ekleyin:

Validator::make($data, [
    'state' => 'exists:states,abbreviation',
])->validate();

Veritabanı bağlantısı belirtmek için tablo adından önce bağlantı adını ekleyin:

Validator::make($data, [
    'email' => 'exists:connection.staff,email',
])->validate();

Model sınıf adı da geçirebilirsiniz; framework tablo adını çözer:

Validator::make($data, [
    'user_id' => 'exists:app\model\User,id',
])->validate();

Özel sorgu koşulları için Rule oluşturucusunu kullanın:

use Illuminate\Database\Query\Builder;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        'required',
        Rule::exists('staff')->where(function (Builder $query) {
            $query->where('account_id', 1);
        }),
    ],
])->validate();

Rule::exists içinde sütun adını doğrudan da belirtebilirsiniz:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'state' => [Rule::exists('states', 'abbreviation')],
])->validate();

Bir değer setinin mevcut olduğunu doğrulamak için array kuralı ile birleştirin:

Validator::make($data, [
    'states' => ['array', Rule::exists('states', 'abbreviation')],
])->validate();

Hem array hem exists mevcut olduğunda, tek bir sorgu tüm değerleri doğrular.

extensions:foo,bar,...

Yüklenen dosya uzantısının izin verilen listede olduğunu doğrular:

Validator::make($data, [
    'photo' => ['required', 'extensions:jpg,png'],
])->validate();

[!WARNING]
Dosya tipi doğrulaması için yalnızca uzantıya güvenmeyin; mimes veya mimetypes ile birlikte kullanın.

file

Alan başarıyla yüklenmiş bir dosya olmalıdır.

filled

Alan mevcut olduğunda değeri boş olmamalıdır.

gt:field

Alan verilen field veya value değerinden büyük olmalıdır. Her iki alan da aynı tipte olmalıdır. String, sayı, dizi ve dosyalar için değerlendirme size ile aynıdır.

gte:field

Alan verilen field veya value değerinden büyük veya eşit olmalıdır. Her iki alan da aynı tipte olmalıdır. String, sayı, dizi ve dosyalar için değerlendirme size ile aynıdır.

hex_color

Alan geçerli bir hex renk değeri olmalıdır.

image

Alan bir resim olmalıdır (jpg, jpeg, png, bmp, gif veya webp).

[!WARNING]
XSS riski nedeniyle SVG varsayılan olarak izin verilmez. İzin vermek için allow_svg ekleyin: image:allow_svg.

in:foo,bar,...

Alan verilen değer listesinde olmalıdır. Oluşturmak için Rule::in kullanabilirsiniz:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'zones' => [
        'required',
        Rule::in(['first-zone', 'second-zone']),
    ],
])->validate();

array kuralı ile birleştirildiğinde, giriş dizisindeki her değer in listesinde olmalıdır:

use support\validation\Rule;
use support\validation\Validator;

$input = [
    'airports' => ['NYC', 'LAS'],
];

Validator::make($input, [
    'airports' => [
        'required',
        'array',
    ],
    'airports.*' => Rule::in(['NYC', 'LIT']),
])->validate();

in_array:anotherfield.*

Alan anotherfield değer listesinde mevcut olmalıdır.

in_array_keys:value.*

Alan bir dizi olmalı ve verilen değerlerden en az birini anahtar olarak içermelidir:

Validator::make($data, [
    'config' => 'array|in_array_keys:timezone',
])->validate();

integer

Alan bir tam sayı olmalıdır.

Alan tipinin tam sayı olmasını gerektirmek için strict parametresini kullanın; string tam sayılar geçersiz olacaktır:

Validator::make($data, [
    'age' => 'integer:strict',
])->validate();

[!WARNING]
Bu kural yalnızca PHP'nin FILTER_VALIDATE_INT'inden geçip geçmediğini doğrular; kesin sayısal tipler için numeric ile birlikte kullanın.

ip

Alan geçerli bir IP adresi olmalıdır.

ipv4

Alan geçerli bir IPv4 adresi olmalıdır.

ipv6

Alan geçerli bir IPv6 adresi olmalıdır.

json

Alan geçerli bir JSON string olmalıdır.

lt:field

Alan verilen field değerinden küçük olmalıdır. Her iki alan da aynı tipte olmalıdır. String, sayı, dizi ve dosyalar için değerlendirme size ile aynıdır.

lte:field

Alan verilen field değerinden küçük veya eşit olmalıdır. Her iki alan da aynı tipte olmalıdır. String, sayı, dizi ve dosyalar için değerlendirme size ile aynıdır.

lowercase

Alan küçük harf olmalıdır.

list

Alan bir liste dizisi olmalıdır. Liste dizi anahtarları 0'dan count($array) - 1'e kadar ardışık sayılar olmalıdır.

mac_address

Alan geçerli bir MAC adresi olmalıdır.

max:value

Alan value değerinden küçük veya eşit olmalıdır. String, sayı, dizi ve dosyalar için değerlendirme size ile aynıdır.

max_digits:value

Alan value değerini aşmayan uzunlukta bir tam sayı olmalıdır.

mimetypes:text/plain,...

Dosyanın MIME tipinin listede olduğunu doğrular:

Validator::make($data, [
    'video' => 'mimetypes:video/avi,video/mpeg,video/quicktime',
])->validate();

MIME tipi dosya içeriği okunarak tahmin edilir ve istemci tarafından sağlanan MIME'dan farklı olabilir.

mimes:foo,bar,...

Dosyanın MIME tipinin verilen uzantıya karşılık geldiğini doğrular:

Validator::make($data, [
    'photo' => 'mimes:jpg,bmp,png',
])->validate();

Parametreler uzantı olsa da bu kural MIME'ı belirlemek için dosya içeriğini okur. Uzantı-MIME eşlemesi:

https://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types

MIME tipleri ve uzantılar

Bu kural "dosya uzantısı"nın "gerçek MIME" ile eşleştiğini doğrulamaz. Örneğin mimes:png PNG içeriğine sahip photo.txt dosyasını geçerli sayar. Uzantıyı doğrulamak için extensions kullanın.

min:value

Alan value değerinden büyük veya eşit olmalıdır. String, sayı, dizi ve dosyalar için değerlendirme size ile aynıdır.

min_digits:value

Alan value değerinden az olmayan uzunlukta bir tam sayı olmalıdır.

multiple_of:value

Alan value değerinin katı olmalıdır.

missing

Alan giriş verisinde mevcut olmamalıdır.

missing_if:anotherfield,value,...

anotherfield herhangi bir value değerine eşit olduğunda, alan mevcut olmamalıdır.

missing_unless:anotherfield,value

anotherfield herhangi bir value değerine eşit olmadıkça, alan mevcut olmamalıdır.

missing_with:foo,bar,...

Belirtilen alanlardan herhangi biri mevcut olduğunda, alan mevcut olmamalıdır.

missing_with_all:foo,bar,...

Belirtilen alanların tümü mevcut olduğunda, alan mevcut olmamalıdır.

not_in:foo,bar,...

Alan verilen değer listesinde olmamalıdır. Oluşturmak için Rule::notIn kullanabilirsiniz:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'toppings' => [
        'required',
        Rule::notIn(['sprinkles', 'cherries']),
    ],
])->validate();

not_regex:pattern

Alan verilen düzenli ifadeyle eşleşmemelidir.

Bu kural PHP preg_match kullanır. Regex sınırlayıcılara sahip olmalıdır, örn. 'email' => 'not_regex:/^.+$/i'.

[!WARNING]
regex/not_regex kullanırken, regex | içeriyorsa | ayırıcısıyla çakışmayı önlemek için dizi formu kullanın.

nullable

Alan null olabilir.

numeric

Alan sayısal olmalıdır.

Yalnızca tam sayı veya float tiplerine izin vermek için strict parametresini kullanın; sayısal stringler geçersiz olacaktır:

Validator::make($data, [
    'amount' => 'numeric:strict',
])->validate();

present

Alan giriş verisinde mevcut olmalıdır.

present_if:anotherfield,value,...

anotherfield herhangi bir value değerine eşit olduğunda, alan mevcut olmalıdır.

present_unless:anotherfield,value

anotherfield herhangi bir value değerine eşit olmadıkça, alan mevcut olmalıdır.

present_with:foo,bar,...

Belirtilen alanlardan herhangi biri mevcut olduğunda, alan mevcut olmalıdır.

present_with_all:foo,bar,...

Belirtilen alanların tümü mevcut olduğunda, alan mevcut olmalıdır.

prohibited

Alan eksik veya boş olmalıdır. "Boş" şu anlama gelir:

prohibited_if:anotherfield,value,...

anotherfield herhangi bir value değerine eşit olduğunda, alan eksik veya boş olmalıdır. "Boş" şu anlama gelir:

Karmaşık koşullar için Rule::prohibitedIf kullanın:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'role_id' => Rule::prohibitedIf($isAdmin),
])->validate();

Validator::make($data, [
    'role_id' => Rule::prohibitedIf(fn () => $isAdmin),
])->validate();

prohibited_if_accepted:anotherfield,...

anotherfield "yes", "on", 1, "1", true veya "true" olduğunda, alan eksik veya boş olmalıdır.

prohibited_if_declined:anotherfield,...

anotherfield "no", "off", 0, "0", false veya "false" olduğunda, alan eksik veya boş olmalıdır.

prohibited_unless:anotherfield,value,...

anotherfield herhangi bir value değerine eşit olmadıkça, alan eksik veya boş olmalıdır. "Boş" şu anlama gelir:

prohibits:anotherfield,...

Alan mevcut ve boş değilse, anotherfield içindeki tüm alanlar eksik veya boş olmalıdır. "Boş" şu anlama gelir:

regex:pattern

Alan verilen düzenli ifadeyle eşleşmelidir.

Bu kural PHP preg_match kullanır. Regex sınırlayıcılara sahip olmalıdır, örn. 'email' => 'regex:/^.+@.+$/i'.

[!WARNING]
regex/not_regex kullanırken, regex | içeriyorsa | ayırıcısıyla çakışmayı önlemek için dizi formu kullanın.

required

Alan mevcut olmalı ve boş olmamalıdır. "Boş" şu anlama gelir:

required_if:anotherfield,value,...

anotherfield herhangi bir value değerine eşit olduğunda, alan mevcut olmalı ve boş olmamalıdır.

Karmaşık koşullar için Rule::requiredIf kullanın:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'role_id' => Rule::requiredIf($isAdmin),
])->validate();

Validator::make($data, [
    'role_id' => Rule::requiredIf(fn () => $isAdmin),
])->validate();

required_if_accepted:anotherfield,...

anotherfield "yes", "on", 1, "1", true veya "true" olduğunda, alan mevcut olmalı ve boş olmamalıdır.

required_if_declined:anotherfield,...

anotherfield "no", "off", 0, "0", false veya "false" olduğunda, alan mevcut olmalı ve boş olmamalıdır.

required_unless:anotherfield,value,...

anotherfield herhangi bir value değerine eşit olmadıkça, alan mevcut olmalı ve boş olmamalıdır. value null ise (örn. required_unless:name,null), alan yalnızca karşılaştırma alanı null veya yok olduğunda boş olabilir.

required_with:foo,bar,...

Belirtilen alanlardan herhangi biri mevcut ve boş değilse, alan mevcut olmalı ve boş olmamalıdır.

required_with_all:foo,bar,...

Belirtilen alanların tümü mevcut ve boş değilse, alan mevcut olmalı ve boş olmamalıdır.

required_without:foo,bar,...

Belirtilen alanlardan herhangi biri boş veya yoksa, alan mevcut olmalı ve boş olmamalıdır.

required_without_all:foo,bar,...

Belirtilen alanların tümü boş veya yoksa, alan mevcut olmalı ve boş olmamalıdır.

required_array_keys:foo,bar,...

Alan bir dizi olmalı ve en az belirtilen anahtarları içermelidir.

sometimes

Yalnızca alan mevcut olduğunda sonraki doğrulama kurallarını uygulayın. Genellikle "isteğe bağlı ama mevcut olduğunda geçerli olmalı" alanları için kullanılır:

Validator::make($data, [
    'nickname' => 'sometimes|string|max:20',
])->validate();

same:field

Alan field ile aynı olmalıdır.

size:value

Alan boyutu verilen value değerine eşit olmalıdır. Stringler için: karakter sayısı; sayılar için: belirtilen tam sayı (numeric veya integer ile kullanın); diziler için: öğe sayısı; dosyalar için: KB cinsinden boyut. Örnek:

Validator::make($data, [
    'title' => 'size:12',
    'seats' => 'integer|size:10',
    'tags' => 'array|size:5',
    'image' => 'file|size:512',
])->validate();

starts_with:foo,bar,...

Alan belirtilen değerlerden biriyle başlamalıdır.

string

Alan bir string olmalıdır. null izin vermek için nullable ile birlikte kullanın.

timezone

Alan geçerli bir saat dilimi tanımlayıcısı olmalıdır (DateTimeZone::listIdentifiers'dan). Bu metodu destekleyen parametreleri geçirebilirsiniz:

Validator::make($data, [
    'timezone' => 'required|timezone:all',
])->validate();

Validator::make($data, [
    'timezone' => 'required|timezone:Africa',
])->validate();

Validator::make($data, [
    'timezone' => 'required|timezone:per_country,US',
])->validate();

unique:table,column

Alan belirtilen tabloda benzersiz olmalıdır.

Özel tablo/sütun adı belirtin:

Model sınıf adını doğrudan belirtebilirsiniz:

Validator::make($data, [
    'email' => 'unique:app\model\User,email_address',
])->validate();

Sütun adını belirtebilirsiniz (belirtilmediğinde varsayılan olarak alan adı kullanılır):

Validator::make($data, [
    'email' => 'unique:users,email_address',
])->validate();

Veritabanı bağlantısı belirtin:

Validator::make($data, [
    'email' => 'unique:connection.users,email_address',
])->validate();

Belirtilen ID'yi yoksay:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        'required',
        Rule::unique('users')->ignore($user->id),
    ],
])->validate();

[!WARNING]
ignore kullanıcı girişi almamalıdır; yalnızca sistem tarafından oluşturulan benzersiz ID'ler (otomatik artan ID veya model UUID) kullanın, aksi halde SQL enjeksiyon riski olabilir.

Model örneği de geçirebilirsiniz:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        Rule::unique('users')->ignore($user),
    ],
])->validate();

Birincil anahtar id değilse, birincil anahtar adını belirtin:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        Rule::unique('users')->ignore($user->id, 'user_id'),
    ],
])->validate();

Varsayılan olarak benzersiz sütun olarak alan adını kullanır; sütun adını da belirtebilirsiniz:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        Rule::unique('users', 'email_address')->ignore($user->id),
    ],
])->validate();

Ek koşullar ekleyin:

use Illuminate\Database\Query\Builder;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        Rule::unique('users')->where(
            fn (Builder $query) => $query->where('account_id', 1)
        ),
    ],
])->validate();

Yumuşak silinen kayıtları yoksay:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [Rule::unique('users')->withoutTrashed()],
])->validate();

Yumuşak silme sütunu deleted_at değilse:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [Rule::unique('users')->withoutTrashed('was_deleted_at')],
])->validate();

uppercase

Alan büyük harf olmalıdır.

url

Alan geçerli bir URL olmalıdır.

İzin verilen protokolleri belirtebilirsiniz:

Validator::make($data, [
    'url' => 'url:http,https',
    'game' => 'url:minecraft,steam',
])->validate();

ulid

Alan geçerli bir ULID olmalıdır.

uuid

Alan geçerli bir RFC 9562 UUID (sürüm 1, 3, 4, 5, 6, 7 veya 8) olmalıdır.

Sürümü belirtebilirsiniz:

Validator::make($data, [
    'uuid' => 'uuid:4',
])->validate();

Doğrulayıcı top-think/think-validate

Açıklama

Resmi ThinkPHP doğrulayıcısı

Proje URL'si

https://github.com/top-think/think-validate

Kurulum

composer require topthink/think-validate

Hızlı Başlangıç

app/index/validate/User.php oluşturun

<?php
namespace app\index\validate;

use think\Validate;

class User extends Validate
{
    protected $rule =   [
        'name'  => 'require|max:25',
        'age'   => 'number|between:1,120',
        'email' => 'email',    
    ];

    protected $message  =   [
        'name.require' => 'Name is required',
        'name.max'     => 'Name cannot exceed 25 characters',
        'age.number'   => 'Age must be a number',
        'age.between'  => 'Age must be between 1 and 120',
        'email'        => 'Invalid email format',    
    ];

}

Kullanım

$data = [
    'name'  => 'thinkphp',
    'email' => 'thinkphp@qq.com',
];

$validate = new \app\index\validate\User;

if (!$validate->check($data)) {
    var_dump($validate->getError());
}

Not
webman, think-validate'in Validate::rule() metodunu desteklemez

Doğrulayıcı workerman/validation

Açıklama

Bu proje https://github.com/Respect/Validation adresinin yerelleştirilmiş sürümüdür

Proje URL'si

https://github.com/walkor/validation

Kurulum

composer require workerman/validation

Hızlı Başlangıç

<?php
namespace app\controller;

use support\Request;
use Respect\Validation\Validator as v;
use support\Db;

class IndexController
{
    public function index(Request $request)
    {
        $data = v::input($request->post(), [
            'nickname' => v::length(1, 64)->setName('Nickname'),
            'username' => v::alnum()->length(5, 64)->setName('Username'),
            'password' => v::length(5, 64)->setName('Password')
        ]);
        Db::table('user')->insert($data);
        return json(['code' => 0, 'msg' => 'ok']);
    }
}  

jQuery ile erişim

  $.ajax({
      url : 'http://127.0.0.1:8787',
      type : "post",
      dataType:'json',
      data : {nickname:'Tom', username:'tom cat', password: '123456'}
  });

Sonuç:

{"code":500,"msg":"Username may only contain letters (a-z) and numbers (0-9)"}

Açıklama:

v::input(array $input, array $rules) veriyi doğrular ve toplar. Doğrulama başarısız olursa Respect\Validation\Exceptions\ValidationException fırlatır; başarılı olursa doğrulanmış veriyi (dizi) döndürür.

İş mantığı doğrulama istisnasını yakalamazsa, webman framework yakalar ve HTTP başlıklarına göre JSON (örn. {"code":500, "msg":"xxx"}) veya normal istisna sayfası döndürür. Yanıt formatı ihtiyaçlarınızı karşılamıyorsa, aşağıdaki örnekteki gibi ValidationException'ı yakalayıp özel veri döndürebilirsiniz:

<?php
namespace app\controller;

use support\Request;
use Respect\Validation\Validator as v;
use Respect\Validation\Exceptions\ValidationException;

class IndexController
{
    public function index(Request $request)
    {
        try {
            $data = v::input($request->post(), [
                'username' => v::alnum()->length(5, 64)->setName('Username'),
                'password' => v::length(5, 64)->setName('Password')
            ]);
        } catch (ValidationException $e) {
            return json(['code' => 500, 'msg' => $e->getMessage()]);
        }
        return json(['code' => 0, 'msg' => 'ok', 'data' => $data]);
    }
}

Doğrulayıcı Kılavuzu

use Respect\Validation\Validator as v;

// Tek kural doğrulama
$number = 123;
v::numericVal()->validate($number); // true

// Zincirleme doğrulama
$usernameValidator = v::alnum()->noWhitespace()->length(1, 15);
$usernameValidator->validate('alganet'); // true

// İlk doğrulama başarısızlık nedenini al
try {
    $usernameValidator->setName('Username')->check('alg  anet');
} catch (ValidationException $exception) {
    echo $exception->getMessage(); // Username may only contain letters (a-z) and numbers (0-9)
}

// Tüm doğrulama başarısızlık nedenlerini al
try {
    $usernameValidator->setName('Username')->assert('alg  anet');
} catch (ValidationException $exception) {
    echo $exception->getFullMessage();
    // Yazdıracak
    // -  Username must satisfy the following rules
    //     - Username may only contain letters (a-z) and numbers (0-9)
    //     - Username must not contain whitespace

    var_export($exception->getMessages());
    // Yazdıracak
    // array (
    //   'alnum' => 'Username may only contain letters (a-z) and numbers (0-9)',
    //   'noWhitespace' => 'Username must not contain whitespace',
    // )
}

// Özel hata mesajları
try {
    $usernameValidator->setName('Username')->assert('alg  anet');
} catch (ValidationException $exception) {
    var_export($exception->getMessages([
        'alnum' => 'Username may only contain letters and numbers',
        'noWhitespace' => 'Username must not contain spaces',
        'length' => 'length satisfies the rule, so this will not be shown'
    ]));
    // Yazdıracak 
    // array(
    //    'alnum' => 'Username may only contain letters and numbers',
    //    'noWhitespace' => 'Username must not contain spaces'
    // )
}

// Nesne doğrulama
$user = new stdClass;
$user->name = 'Alexandre';
$user->birthdate = '1987-07-01';
$userValidator = v::attribute('name', v::stringType()->length(1, 32))
                ->attribute('birthdate', v::date()->minAge(18));
$userValidator->validate($user); // true

// Dizi doğrulama
$data = [
    'parentKey' => [
        'field1' => 'value1',
        'field2' => 'value2'
        'field3' => true,
    ]
];
v::key(
    'parentKey',
    v::key('field1', v::stringType())
        ->key('field2', v::stringType())
        ->key('field3', v::boolType())
    )
    ->assert($data); // check() veya validate() da kullanılabilir

// İsteğe bağlı doğrulama
v::alpha()->validate(''); // false 
v::alpha()->validate(null); // false 
v::optional(v::alpha())->validate(''); // true
v::optional(v::alpha())->validate(null); // true

// Olumsuzlama kuralı
v::not(v::intVal())->validate(10); // false

Doğrulayıcı metodları validate() check() assert() arasındaki fark

validate() boolean döndürür, istisna fırlatmaz

check() doğrulama başarısız olduğunda istisna fırlatır; ilk başarısızlık nedenini $exception->getMessage() ile alın

assert() doğrulama başarısız olduğunda istisna fırlatır; tüm başarısızlık nedenlerini $exception->getFullMessage() ile alın

Yaygın Doğrulama Kuralları

Alnum() Yalnızca harfler ve sayılar

Alpha() Yalnızca harfler

ArrayType() Dizi tipi

Between(mixed $minimum, mixed $maximum) Girişin iki değer arasında olduğunu doğrular.

BoolType() Boolean tipi doğrular

Contains(mixed $expectedValue) Girişin belirli değeri içerdiğini doğrular

ContainsAny(array $needles) Girişin en az bir tanımlı değer içerdiğini doğrular

Digit() Girişin yalnızca rakam içerdiğini doğrular

Domain() Geçerli etki alanı adı doğrular

Email() Geçerli e-posta adresi doğrular

Extension(string $extension) Dosya uzantısı doğrular

FloatType() Float tipi doğrular

IntType() Tam sayı tipi doğrular

Ip() IP adresi doğrular

Json() JSON verisi doğrular

Length(int $min, int $max) Uzunluğun aralıkta olduğunu doğrular

LessThan(mixed $compareTo) Uzunluğun verilen değerden küçük olduğunu doğrular

Lowercase() Küçük harf doğrular

MacAddress() MAC adresi doğrular

NotEmpty() Boş olmadığını doğrular

NullType() Null doğrular

Number() Sayı doğrular

ObjectType() Nesne tipi doğrular

StringType() String tipi doğrular

Url() URL doğrular

Daha fazla doğrulama kuralı için https://respect-validation.readthedocs.io/en/2.0/list-of-rules/ adresine bakın.

Daha Fazla

https://respect-validation.readthedocs.io/en/2.0/ adresini ziyaret edin.