Beranda>Kode sumber PHP>Kategori lainnya
Unduh

parameter

Ringkasan

parameter adalah perpustakaan di sekitar parameter -argumen yang menyediakan fungsionalitas tambahan dengan aturan validasi dan introspeksi skema.

Menginstal

parameter tersedia melalui Packagist dan sumber repositori ada di chevere/ parameter . 

composer require chevere/ parameter

Apa fungsinya?

parameter memungkinkan untuk memunculkan parameter dinamis jenis apa pun dengan aturan tambahan.

Misalnya, bilangan bulat dengan nilai minimum 10.

parameterint; $int = int(min: 10); $int($var); // exception if $var < 10">
 use function Chevere  parameter  int ;

$ int = int (min: 10 );
$ int ( $ var ); // exception if $var < 10

Dalam parameter fungsi atau metode, Anda dapat menggunakan atribut untuk menentukan aturan validasi untuk parameter dan nilai kembalian.

parameterAttributesFloatAttr; use Chevere parameter AttributesIntAttr; use Chevere parameter AttributesReturnAttr; use function Chevere parameter returnAttr; use function Chevere parameter validated; #[ReturnAttr( new FloatAttr(min: 0, max: 2400) )] function wageWeekWA( #[IntAttr(min: 1628)] int $cents, #[FloatAttr(min: 0, max: 40)] float $hours ) { return $cents*$hours/100; } validated('wageWeekWA', $cents, $hours);">
 use Chevere  parameter  Attributes  FloatAttr ;
use Chevere  parameter  Attributes  IntAttr ;
use Chevere  parameter  Attributes  ReturnAttr ;
use function Chevere  parameter  returnAttr ;
use function Chevere  parameter  validated ;

#[ReturnAttr(
    new FloatAttr (min: 0 , max: 2400 )
)]
function wageWeekWA (
    #[IntAttr(min: 1628 )]
    int $ cents ,
    #[FloatAttr(min: 0 , max: 40 )]
    float $ hours
) {
    return $ cents * $ hours / 100 ;
}
validated ( ' wageWeekWA ' , $ cents , $ hours );

Validasi dapat dipicu menggunakan validated (contoh di atas), inline dan/atau didelegasikan ke pembungkus pemanggil. parameter menyediakan pembantu untuk mengakses aturan untuk parameter dan nilai kembalian untuk memudahkan proses pengkabelan.

Aturan yang ditentukan oleh setiap parameter menyediakan skema yang dapat dibaca manusia yang memungkinkan untuk mengekspos kriteria validasi.

Cara menggunakan

parameter menyediakan API yang dapat digunakan untuk membuat parameter menggunakan fungsi dan/atau atribut. objek parameter dapat digunakan secara langsung dalam logika sementara atribut memerlukan langkah baca.

Penggunaan sebaris

Gunakan validasi sebaris untuk memulai dari ini: 

 if ( $ var > 10 || $ var < 1 ) {
    throw new InvalidArgumentException ();
}

Untuk ini:

parameterint; int(min: 1, max: 10)($var);">
 use function  Chevere  parameter  int ;

int (min: 1 , max: 10 )( $ var );

Penggunaan berbasis atribut

Gunakan atribut untuk menentukan aturan untuk parameter dan nilai kembalian.

Gunakan validasi atribut yang didelegasikan dengan fungsi validated() untuk memulai dari ini: 

 function myFunction ( int $ var ): string
{
    if ( $ var > 10 || $ var < 1 ) {
        throw new InvalidArgumentException ();
    }
    $ return = ' done ok ' ;
    return preg_match ( ' /ok$/ ' , $ return )
        ? $ return
        : throw new InvalidArgumentException ();
}
$ result = myFunction ( $ var );

Untuk ini:

parameterAttributesIntAttr; use Chevere parameter AttributesReturnAttr; use Chevere parameter AttributesStringAttr; use function Chevere parameter validated; #[ReturnAttr( new StringAttr('/ok$/') )] function myFunction( #[IntAttr(min: 1, max: 10)] int $var ): string { return 'done ok'; } $result = validated('myFunction', $var);">
 use Chevere  parameter  Attributes  IntAttr ;
use Chevere  parameter  Attributes  ReturnAttr ;
use Chevere  parameter  Attributes  StringAttr ;
use function Chevere  parameter  validated ;

#[ReturnAttr(
    new StringAttr ( ' /ok$/ ' )
)]
function myFunction (
    #[IntAttr(min: 1 , max: 10 )]
    int $ var
): string
{
    return ' done ok ' ;
}
$ result = validated ( ' myFunction ' , $ var );

Gunakan reflectionTo parameter s dan fungsi reflectionToReturn untuk validasi manual untuk argumen dan nilai kembalian:

parameter s; use function Chevere parameter reflectionToReturn; $reflection = new ReflectionFunction('myFunction'); $ parameter s = reflectionTo parameter s($reflection); $return = reflectionToReturn($reflection); $ parameter s(...$args); // valid $args $result = myFunction(...$args); // myFunction call $return($result); // valid $result">
 use ReflectionFunction ;
use function Chevere  parameter  reflectionTo parameter s ;
use function Chevere  parameter  reflectionToReturn ;

$ reflection = new ReflectionFunction ( ' myFunction ' );
$ parameter s = reflectionTo parameter s ( $ reflection );
$ return = reflectionToReturn ( $ reflection );
$ parameter s (... $ args ); // valid $args
$ result = myFunction (... $ args ); // myFunction call
$ return ( $ result ); // valid $result

Gunakan validasi inline atribut untuk validasi manual dalam badan fungsi:

parameterAttributesIntAttr; use Chevere parameter AttributesReturnAttr; use Chevere parameter AttributesStringAttr; use function Chevere parameter valid; use function Chevere parameter returnAttr; #[ReturnAttr( new StringAttr('/ok$/') )] function myFunction( #[IntAttr(min: 1, max: 10)] int $var ): string { valid(); // valid $var $return = 'ok'; return returnAttr()($return); // valid $return }">
 use Chevere  parameter  Attributes  IntAttr ;
use Chevere  parameter  Attributes  ReturnAttr ;
use Chevere  parameter  Attributes  StringAttr ;
use function Chevere  parameter  valid ;
use function Chevere  parameter  returnAttr ;

#[ReturnAttr(
    new StringAttr ( ' /ok$/ ' )
)]
function myFunction (
    #[IntAttr(min: 1 , max: 10 )]
    int $ var
): string
{
    valid (); // valid $var
    $ return = ' ok ' ;

    return returnAttr ()( $ return ); // valid $return
}

CallableAttr

Atribut di PHP hanya mendukung ekspresi yang dapat Anda gunakan pada konstanta kelas. Tidak mungkin mendefinisikan parameter dinamis secara langsung menggunakan atribut.

Untuk menghindari batasan ini, Anda dapat menggunakan atribut CallableAttr yang memungkinkan meneruskan resolusi parameter ke callable yang mengembalikan instance parameter Interface .

parameter Interface; use Chevere parameter AttributesCallableAttr; function myCallable(): parameter Interface { return arrayp( email: string(), )->withOptional( name: string(), ); } #[CallableAttr('myCallable')]">
 use Chevere  parameter  Interfaces  parameter Interface ;
use Chevere  parameter  Attributes  CallableAttr ;

function myCallable (): parameter Interface
{
    return arrayp (
        email: string (),
    )-> withOptional (
        name: string (),
    );
}

#[CallableAttr( ' myCallable ' )]

Jenis

parameter adalah objek yang mengimplementasikan parameter Interface . Setiap parameter dapat menentukan description dan nilai default , ditambah aturan validasi tambahan bergantung pada jenisnya.

Sebuah parameter dapat didefinisikan menggunakan fungsi dan/atau atribut, dibutuhkan argumen yang sama untuk keduanya.

Saat memanggil parameter $param('value') itu akan memicu validasi terhadap argumen yang diteruskan.

Rangkaian

Gunakan fungsi string untuk membuat String parameter . Berikan regex untuk pencocokan string.

parameterstring; // Any string $string = string(); // String matching bin-<digits> $string = string('/^bin-[d]+$/'); $string('bin-123');">
 use function Chevere  parameter  string ;

// Any string
$ string = string ();
// String matching bin-<digits>
$ string = string ( ' /^bin-[d]+$/ ' );
$ string ( ' bin-123 ' );

Gunakan atribut StringAttr untuk mendefinisikan parameter string.

parameterAttributesStringAttr; #[StringAttr('/^bin-[d]+$/')]">
 use Chevere  parameter  Attributes  StringAttr ;

#[StringAttr( ' /^bin-[d]+$/ ' )]

String semu- parameter s

parameter berikut didasarkan pada String.

string enum

Gunakan fungsi enum untuk membuat String parameter yang cocok dengan daftar string.

parameterenum; $enum = enum('on', 'off'); $enum('on'); $enum('off');">
 use function Chevere  parameter  enum ;

$ enum = enum ( ' on ' , ' off ' );
$ enum ( ' on ' );
$ enum ( ' off ' );

Gunakan atribut EnumAttr untuk mendefinisikan parameter string enum.

parameterAttributesEnumAttr; #[EnumAttr('on', 'off')]">
 use Chevere  parameter  Attributes  EnumAttr ;

#[EnumAttr( ' on ' , ' off ' )]

string ke dalam

Gunakan fungsi intString untuk membuat String parameter yang cocok dengan bilangan bulat string.

parameterintString; $int = intString(); $int('100');">
 use function Chevere  parameter  intString ;

$ int = intString ();
$ int ( ' 100 ' );

tali bodoh

Gunakan fungsi boolString untuk membuat String parameter yang cocok dengan string 0 dan 1 .

parameterboolString; $bool = boolString(); $bool('0'); $bool('1');">
 use function Chevere  parameter  boolString ;

$ bool = boolString ();
$ bool ( ' 0 ' );
$ bool ( ' 1 ' );

Rangkaian tanggal

Gunakan fungsi date untuk membuat String parameter yang cocok dengan string YYYY-MM-DD .

parameterdate; $date = date(); $date('2021-01-01');">
 use function Chevere  parameter  date ;

$ date = date ();
$ date ( ' 2021-01-01 ' );

Rangkaian waktu

Gunakan fungsi time untuk membuat String parameter yang cocok dengan string hh:mm:ss .

parametertime; $time = time(); $time('12:00:00');">
 use function Chevere  parameter  time ;

$ time = time ();
$ time ( ' 12:00:00 ' );

String tanggal dan waktu

Gunakan fungsi datetime untuk membuat String parameter yang cocok dengan string YYYY-MM-DD hh:mm:ss .

parameterdatetime; $datetime = datetime(); $datetime('2024-01-09 10:53:00');">
 use function Chevere  parameter  datetime ;

$ datetime = datetime ();
$ datetime ( ' 2024-01-09 10:53:00 ' );

Int

Gunakan fungsi int untuk membuat Int parameter . Berikan nilai min dan max untuk rentang bilangan bulat, accept untuk daftar bilangan bulat yang diterima, dan reject untuk daftar bilangan bulat yang ditolak.

parameterint; // Any int $int = int(); $int(1); // Integer between 0 and 100 $int = int(min: 0, max: 100); $int(50); // Integer matching 1, 2 or 3 $int = int(accept: [1, 2, 3]); $int(2); // Integer not-matching 1, 2 or 3 $int = int(reject: [1, 2, 3]); $int(4);">
 use function Chevere  parameter  int ;

// Any int
$ int = int ();
$ int ( 1 );
// Integer between 0 and 100
$ int = int (min: 0 , max: 100 );
$ int ( 50 );
// Integer matching 1, 2 or 3
$ int = int (accept: [ 1 , 2 , 3 ]);
$ int ( 2 );
// Integer not-matching 1, 2 or 3
$ int = int (reject: [ 1 , 2 , 3 ]);
$ int ( 4 );

Gunakan atribut IntAttr untuk mendefinisikan parameter integer.

parameterAttributesIntAttr; #[IntAttr(min: 0, max: 100)]">
 use Chevere  parameter  Attributes  IntAttr ;

#[IntAttr(min: 0 , max: 100 )]

Int pseudo- parameter s

parameter berikut didasarkan pada Int.

Bool ke dalam

Gunakan fungsi boolInt untuk membuat Int parameter yang cocok dengan bilangan bulat 0 dan 1 .

parameterboolInt; $bool = boolInt(); $bool(0); $bool(1);">
 use function Chevere  parameter  boolInt ;

$ bool = boolInt ();
$ bool ( 0 );
$ bool ( 1 );

Mengambang

Gunakan fungsi float untuk membuat Float parameter . Berikan nilai min dan max untuk rentang float, accept untuk daftar float yang diterima, dan reject untuk daftar float yang ditolak.

parameterfloat; // Any float $float = float(); $float(1.5); // Float between 0 and 100 $float = float(min: 0, max: 100); $float(50.5); // Float matching 1.5, 2.5 or 3.5 $float = float(accept: [1.5, 2.5, 3.5]); $float(2.5); // Float not-matching 1.5, 2.5 or 3.5 $float = float(reject: [1.5, 2.5, 3.5]); $float(4.5);">
 use function Chevere  parameter  float ;

// Any float
$ float = float ();
$ float ( 1.5 );
// Float between 0 and 100
$ float = float (min: 0 , max: 100 );
$ float ( 50.5 );
// Float matching 1.5, 2.5 or 3.5
$ float = float (accept: [ 1.5 , 2.5 , 3.5 ]);
$ float ( 2.5 );
// Float not-matching 1.5, 2.5 or 3.5
$ float = float (reject: [ 1.5 , 2.5 , 3.5 ]);
$ float ( 4.5 );

Gunakan atribut FloatAttr untuk mendefinisikan parameter float.

parameterAttributesFloatAttr; #[FloatAttr(min: 0, max: 100)]">
 use Chevere  parameter  Attributes  FloatAttr ;

#[FloatAttr(min: 0 , max: 100 )]

Bodoh

Gunakan fungsi bool untuk membuat Bool parameter .

parameterbool; $bool = bool(); $bool(true); $bool(false);">
 use function Chevere  parameter  bool ;

$ bool = bool ();
$ bool ( true );
$ bool ( false );

Gunakan atribut BoolAttr untuk menentukan parameter bool.

parameterAttributesBoolAttr; #[BoolAttr]">
 use Chevere  parameter  Attributes  BoolAttr ;

#[BoolAttr]

Batal

Gunakan fungsi null untuk membuat Null parameter .

parameternull; $null = null(); $null(null);">
 use function Chevere  parameter  null ;

$ null = null ();
$ null ( null );

Gunakan atribut NullAttr untuk mendefinisikan parameter null.

parameterAttributesNullAttr; #[NullAttr]">
 use Chevere  parameter  Attributes  NullAttr ;

#[NullAttr]

Obyek

Gunakan object fungsi untuk membuat Object parameter . Berikan className untuk nama kelas objek.

parameterobject; $object = object(stdClass::class); $object(new stdClass());">
 use function Chevere  parameter  object ;

$ object = object (stdClass::class);
$ object ( new stdClass ());

Gunakan atribut ObjectAttr untuk mendefinisikan parameter objek.

parameterAttributesObjectAttr; #[ObjectAttr(stdClass::class)]">
 use Chevere  parameter  Attributes  ObjectAttr ;

#[ObjectAttr(stdClass::class)]

Campur aduk

Gunakan fungsi mixed untuk membuat Mixed parameter .

parametermixed; $mixed = mixed(); $mixed(1); $mixed('1'); $mixed(true); $mixed(null);">
 use function Chevere  parameter  mixed ;

$ mixed = mixed ();
$ mixed ( 1 );
$ mixed ( ' 1 ' );
$ mixed ( true );
$ mixed ( null );

Serikat

Gunakan fungsi union untuk membuat Union parameter . Berikan daftar parameter yang akan dicocokkan, nilai target harus cocok dengan setidaknya satu.

parameterunion; // Any string or null $union = union(string(), null()); $union('abc'); $union(null); // Any digit string or any integer $union = union( intString(), integer() ); $union('100'); $union(100);">
 use function Chevere  parameter  union ;

// Any string or null
$ union = union ( string (), null());
$ union ( ' abc ' );
$ union ( null );
// Any digit string or any integer
$ union = union (
    intString (),
    integer ()
);
$ union ( ' 100 ' );
$ union ( 100 );

Himpunan

parameter untuk tipe array ditangani sebagai parameter gabungan yang menyimpan definisi parameter untuk masing-masing anggotanya.

Gunakan fungsi arrayp untuk membuat Array parameter untuk argumen bernama sebagai kunci array yang diperlukan.

parameterarrayp; // Empty array $array = arrayp(); $array([]); // Required 'a' => <string> $array = arrayp(a: string()); $array(['a' => 'Hello world']);">
 use function Chevere  parameter  arrayp ;

// Empty array
$ array = arrayp ();
$ array ([]);
// Required 'a' => <string>
$ array = arrayp (a: string ());
$ array ([ ' a ' => ' Hello world ' ]);

parameter mendukung array bersarang dengan kedalaman berapa pun:

parameterarrayp; use function Chevere parameter float; use function Chevere parameter int; $array = arrayp( id: int(min: 0), items: arrayp( id: int(min: 0), price: float(min: 0), ), ); $array([ 'id' => 1, 'items' => [ 'id' => 25, 'price' => 16.5, ] ]);">
 use function Chevere  parameter  arrayp ;
use function Chevere  parameter  float ;
use function Chevere  parameter  int ;

$ array = arrayp (
    id: int (min: 0 ),
    items: arrayp (
        id: int (min: 0 ),
        price: float (min: 0 ),
    ),
);
$ array ([
    ' id ' => 1 ,
    ' items ' => [
        ' id ' => 25 ,
        ' price ' => 16.5 ,
    ]
]);

Gunakan atribut ArrayAttr untuk mendefinisikan parameter array.

parameterAttributesArrayAttr; use Chevere parameter AttributesFloatAttr; use Chevere parameter AttributesIntAttr; #[ArrayAttr( id: new IntAttr(), items: new ArrayAttr( id: new IntAttr(), price: new FloatAttr(), ), )]">
 use Chevere  parameter  Attributes  ArrayAttr ;
use Chevere  parameter  Attributes  FloatAttr ;
use Chevere  parameter  Attributes  IntAttr ;

#[ArrayAttr(
    id: new IntAttr (),
    items: new ArrayAttr (
        id: new IntAttr (),
        price: new FloatAttr (),
    ),
)]

Dengan diperlukan

gunakan metode withRequired untuk menentukan parameter yang diperlukan. 

 $ array = $ array
    -> withRequired (
        username: string (),
        email: string ()
    );

Dengan opsional

gunakan metode withOptional untuk menentukan parameter opsional. 

 $ array = $ array
    -> withOptional (address: string ());

Catatan: parameter opsional akan divalidasi hanya jika kunci yang cocok disediakan.

Dengan memodifikasi

gunakan metode withModify untuk mendefinisikan parameter modifikasi. 

 $ array = $ array
    -> withModify (
        username: string ( ' /w+/ ' ),
    );

Dengan menjadikan opsional

gunakan metode withMakeOptional untuk menjadikan parameter yang diperlukan opsional. 

 $ array = $ array
    -> withMakeOptional ( ' username ' );

Dengan kebutuhan

gunakan metode withMakeRequired untuk membuat parameter opsional diperlukan. 

 $ array = $ array
    -> withMakeRequired ( ' email ' );

Tanpa

gunakan metode without menghapus parameter s. 

 $ array = $ array
    -> without ( ' a ' );

Dengan minimum opsional

gunakan metode withOptionalMinimum untuk menentukan jumlah minimum parameter opsional. Berguna jika semua parameter bersifat opsional kecuali 1. 

 $ array = $ array
    -> withOptionalMinimum ( 1 );

Array semu- parameter s

parameter berikut didasarkan pada Array.

Rangkaian Rangkaian

Gunakan fungsi arrayString untuk membuat ArrayString parameter Interface untuk nilai string. Ini hanya mendukung parameter string s.

parameterarrayString; use function Chevere parameter string; $array = arrayString( test: string(), ); $array(['test' => 'foo']);">
 use function Chevere  parameter  arrayString ;
use function Chevere  parameter  string ;

$ array = arrayString (
    test: string (),
);
$ array ([ ' test ' => ' foo ' ]);

Mengajukan

Gunakan file fungsi untuk membuat Array parameter untuk unggahan file.

parameterfile; $array = file(); $file = [ 'name' => 'foo.txt', 'type' => 'text/plain', 'tmp_name' => '/tmp/phpYzdqkD', 'error' => 0, 'size' => 123, ]; $array($file);">
 use function Chevere  parameter  file ;

$ array = file ();
$ file = [
    ' name ' => ' foo.txt ' ,
    ' type ' => ' text/plain ' ,
    ' tmp_name ' => ' /tmp/phpYzdqkD ' ,
    ' error ' => 0 ,
    ' size ' => 123 ,
];
$ array ( $ file );

Secara default, ini menyediakan validasi untuk bentuk $_FILES , tetapi Anda dapat menentukan aturan validasi Anda sendiri. Misalnya, untuk memvalidasi nama dan konten:

parameterfile; $array = file( name: string('/^.txt$/'), contents: string('/wage-/'), ); $array( 'name' => 'wage-2024.txt', 'type' => 'text/plain', 'tmp_name' => '/tmp/phpYzdqkD', 'error' => 0, 'size' => 27, 'contents' => 'yada yada wage-2024 bla bla', );">
 use function Chevere  parameter  file ;

$ array = file (
    name: string ( ' /^.txt$/ ' ),
    contents: string ( ' /wage-/ ' ),
);
$ array (
    ' name ' => ' wage-2024.txt ' ,
    ' type ' => ' text/plain ' ,
    ' tmp_name ' => ' /tmp/phpYzdqkD ' ,
    ' error ' => 0 ,
    ' size ' => 27 ,
    ' contents ' => ' yada yada wage-2024 bla bla ' ,
);

Dapat diubah

Tipe iterable Traversable|array dianggap sebagai parameter gabungan yang memiliki definisi umum untuk kunci dan nilai. parameter memungkinkan untuk mendeskripsikan kumpulan item yang memiliki bentuk yang sama.

Gunakan fungsi iterable untuk membuat Iterable parameter . Berikan parameter V dan K untuk kunci dan nilai generik.

parameterint; use function Chevere parameter iterable; $iterable = iterable(int(min: 0)); $iterable([0, 1, 2, 3]);">
 use function Chevere  parameter  int ;
use function Chevere  parameter  iterable ;

$ iterable = iterable ( int (min: 0 ));
$ iterable ([ 0 , 1 , 2 , 3 ]);

Ini juga berfungsi dengan kunci bernama:

parameterint; use function Chevere parameter iterable; use function Chevere parameter string; $iterable = iterable( V: arrayp( id: int(min: 0), name: string('^[w]{1,255}'), ) K: string(), ); $iterable([ 'based' => [ 'id' => 1, 'name' => 'OscarGangas' ], 'fome' => [ 'id' => 2, 'name' => 'BomboFica' ], ]);">
 use function Chevere  parameter  int ;
use function Chevere  parameter  iterable ;
use function Chevere  parameter  string ;

$ iterable = iterable (
    V: arrayp (
        id: int (min: 0 ),
        name: string ( ' ^[w]{1,255} ' ),
    )
    K: string (),
);
$ iterable ([
    ' based ' => [
        ' id ' => 1 ,
        ' name ' => ' OscarGangas '
    ],
    ' fome ' => [
        ' id ' => 2 ,
        ' name ' => ' BomboFica '
    ],
]);

Pembantu

parameter s

Gunakan parameter s fungsi untuk membuat instance parameter s .

parameter s; use function Chevere parameter sstring; $ parameter s = parameter s(foo: string());">
 use function Chevere  parameter s  parameter s ;
use function Chevere  parameter s  string ;

$ parameter s = parameter s (foo: string ());

argumen

Gunakan arguments fungsi untuk membuat instance Arguments .

parametersarguments; use function Chevere parameter sstring; $arguments = arguments($ parameter s, ['foo' => 'bar']);">
 use function Chevere  parameter s  arguments ;
use function Chevere  parameter s  string ;

$ arguments = arguments ( $ parameter s , [ ' foo ' => ' bar ' ]);

menegaskanNamaArgumen

Gunakan fungsi assertNamedArgument untuk menegaskan argumen bernama.

parametersassertNamedArgument; use function Chevere parameter sint; use function Chevere parameter s parameter s; $ parameter = int(min: 10); assertNamedArgument( name: 'foo', parameter : $ parameter , argument: 20 );">
 use function Chevere  parameter s  assertNamedArgument ;
use function Chevere  parameter s  int ;
use function Chevere  parameter s  parameter s ;

$ parameter = int (min: 10 );
assertNamedArgument (
    name: ' foo ' ,
    parameter : $ parameter ,
    argument: 20
);

ke parameter

Gunakan fungsi to parameter untuk membuat instance parameter Interface dari string tipe. Pada contoh di bawah, $ parameter yang dihasilkan akan menjadi Int parameter .

parameter ; $ parameter = to parameter ('int');">
 use function Chevere  parameter s  to parameter ;

$ parameter = to parameter ( ' int ' );

arrayDari

Gunakan fungsi arrayFrom untuk membuat parameter Array dari parameter array lain. Pada contoh di bawah, $array yang dihasilkan hanya akan berisi kunci name dan id seperti yang didefinisikan dalam $source .

parametersarrayFrom; use function Chevere parameter sarrayp; use function Chevere parameter sint; use function Chevere parameter sstring; $source = arrayp( id: int(), name: string(), email: string(), age: int(), ); $array = arrayFrom($source, 'name', 'id');">
 use function Chevere  parameter s  arrayFrom ;
use function Chevere  parameter s  arrayp ;
use function Chevere  parameter s  int ;
use function Chevere  parameter s  string ;

$ source = arrayp (
    id: int (),
    name: string (),
    email: string (),
    age: int (),
);
$ array = arrayFrom ( $ source , ' name ' , ' id ' );

ambilKeys

Gunakan fungsi takeKeys untuk mengambil array dengan kunci dari parameter . Pada contoh di bawah $keys akan berisi id dan size .

parametersarrayp; use function Chevere parameter sint; use function Chevere parameter stakeKeys; $array = arrayp( id: int(), size: int(), ); $keys = takeKeys($array);">
 use function Chevere  parameter s  arrayp ;
use function Chevere  parameter s  int ;
use function Chevere  parameter s  takeKeys ;

$ array = arrayp (
    id: int (),
    size: int (),
);
$ keys = takeKeys ( $ array );

ambilDari

Gunakan fungsi takeFrom untuk mengambil iterator dengan kunci yang diinginkan dari suatu parameter . Pada contoh di bawah $iterator akan menghasilkan kunci size dan name .

parametersarrayp; use function Chevere parameter sint; use function Chevere parameter sstring; use function Chevere parameter stakeFrom; $array = arrayp( id: int(min: 0), size: int(min: 100), name: string(), ); $iterator = takeFrom($array, 'size', 'name');">
 use function Chevere  parameter s  arrayp ;
use function Chevere  parameter s  int ;
use function Chevere  parameter s  string ;
use function Chevere  parameter s  takeFrom ;

$ array = arrayp (
    id: int (min: 0 ),
    size: int (min: 100 ),
    name: string (),
);
$ iterator = takeFrom ( $ array , ' size ' , ' name ' );

parameter sDari

Gunakan parameter sFrom untuk membuat parameter s dengan kunci yang diinginkan dari suatu parameter . Pada contoh di bawah $ parameter s akan berisi kunci size dan name .

parametersarrayp; use function Chevere parameter sint; use function Chevere parameter sstring; use function Chevere parameter s parameter sFrom; $array = arrayp( id: int(min: 0), size: int(min: 100), name: string(), ); $ parameter s = parameter sFrom($array, 'size', 'name');">
 use function Chevere  parameter s  arrayp ;
use function Chevere  parameter s  int ;
use function Chevere  parameter s  string ;
use function Chevere  parameter s  parameter sFrom ;

$ array = arrayp (
    id: int (min: 0 ),
    size: int (min: 100 ),
    name: string (),
);
$ parameter s = parameter sFrom ( $ array , ' size ' , ' name ' );

dapatkan parameter s

Gunakan fungsi get parameter s untuk mengambil instance parameter s dari objek yang mengimplementasikan parameter AccessInterface atau parameter sInterface .

parameter s; $ parameter s = get parameter s($object);">
 use function Chevere  parameter s  get parameter s ;

$ parameter s = get parameter s ( $ object );

dapatkan Tipe

Gunakan fungsi getType untuk mengambil tipe seperti yang diketahui oleh perpustakaan ini.

parametersgetType; $type = getType(1); // int">
 use function Chevere  parameter s  getType ;

$ type = getType ( 1 ); // int

parameter Attr

Gunakan parameter Attr untuk mengambil objek yang mengimplementasikan parameter AttributeInterface dari parameter fungsi atau metode kelas.

parameter Attr; use Chevere parameter AttributesStringAttr; function myFunction( #[StringAttr('/^bin-[d]+$/')] string $foo ): void { // ... } $stringAttr = parameter Attr('foo', 'myFunction'); $stringAttr('bin-123');">
 use function Chevere  parameter s  parameter Attr ;
use Chevere  parameter  Attributes  StringAttr ;


function myFunction (
    #[StringAttr( ' /^bin-[d]+$/ ' )]
    string $ foo
): void {
    // ...
}

$ stringAttr = parameter Attr ( ' foo ' , ' myFunction ' );
$ stringAttr ( ' bin-123 ' );

refleksiKe parameter s

Gunakan fungsi reflectionTo parameter s untuk mengambil instance parameter s dari instance ReflectionFunction atau ReflectionMethod .

parameter s; $ parameter s = reflectionTo parameter s($reflection);">
 use function Chevere  parameter  reflectionTo parameter s ;

$ parameter s = reflectionTo parameter s ( $ reflection );

refleksiToReturn

Gunakan fungsi reflectionToReturn untuk mengambil contoh parameter Interface dari contoh ReflectionFunction atau ReflectionMethod .

parameterreflectionToReturn; $ parameter = reflectionToReturn($reflection);">
 use function Chevere  parameter  reflectionToReturn ;

$ parameter = reflectionToReturn ( $ reflection );

parameter yang dipantulkan Atribut

Gunakan fungsi reflected parameter Attribute untuk mengambil objek yang mengimplementasikan parameter AttributeInterface dari contoh Reflection parameter .

parameter Attribute; $ parameter Attribute = reflected parameter Attribute($reflection parameter );">
 use function Chevere  parameter  reflected parameter Attribute ;

$ parameter Attribute = reflected parameter Attribute ( $ reflection parameter );

divalidasi

Gunakan fungsi validated untuk memvalidasi argumen fungsi atau metode.

parametervalidated; $result = validated('myFunction', $arg1, $arg2,);">
 use function Chevere  parameter  validated ;

$ result = validated ( ' myFunction ' , $ arg1 , $ arg2 ,);

Contoh

Validasi sebaris

  • Validasi string yang dimulai dengan "a":
parameterstring; $value = 'ahhh'; string('/^a.+/')($value);">
 use function Chevere  parameter  string ;

$ value = ' ahhh ' ;
string ( ' /^a.+/ ' )( $ value );
  • Validasi int nilai min 100 :
parameterint; $value = 100; int(min: 100)($value);">
 use function Chevere  parameter  int ;

$ value = 100 ;
int (min: 100 )( $ value );
  • Validasi daftar penerimaan int:
parameterint; $value = 1; int(accept: [1, 2, 3])($value);">
 use function Chevere  parameter  int ;

$ value = 1 ;
int (accept: [ 1 , 2 , 3 ])( $ value );
  • Validasi daftar penolakan mengambang:
parameterfloat; $value = 3.1; float(reject: [1.1, 2.1])($value);">
 use function Chevere  parameter  float ;

$ value = 3.1 ;
float (reject: [ 1.1 , 2.1 ])( $ value );
  • Validasi array:
parameterarrayp; use function Chevere parameter int; use function Chevere parameter string; $value = [ 'id' => 1, 'name' => 'Pepe' ]; arrayp( id: int(min: 1), name: string('/^[A-Z]{1}w+$/') )($value);">
 use function Chevere  parameter  arrayp ;
use function Chevere  parameter  int ;
use function Chevere  parameter  string ;

$ value = [
    ' id ' => 1 ,
    ' name ' => ' Pepe '
];
arrayp (
    id: int (min: 1 ),
    name: string ( ' /^[A-Z]{1}w+$/ ' )
)( $ value );
  • Validasi daftar int yang dapat diubah:
parameterint; use function Chevere parameter iterable; $value = [1, 2, 3]; iterable(int())($value);">
 use function Chevere  parameter  int ;
use function Chevere  parameter  iterable ;

$ value = [ 1 , 2 , 3 ];
iterable ( int ())( $ value );
  • Validasi daftar int yang dapat diubah dengan aturan tipe kunci string:
parameterint; use function Chevere parameter iterable; $value = [ 'unila' => 1, 'dorila' => 2, 'tirifila' => 3, ]; iterable( K: string('/ila$/'), V: int(min: 1) )($value);">
 use function Chevere  parameter  int ;
use function Chevere  parameter  iterable ;

$ value = [
    ' unila ' => 1 ,
    ' dorila ' => 2 ,
    ' tirifila ' => 3 ,
];
iterable (
    K: string ( ' /ila$/ ' ),
    V: int (min: 1 )
)( $ value );
  • Validasi gabungan tipe ?int:
parameterint; use function Chevere parameter null; $value = 1; union(int(), null())($value);">
 use function Chevere  parameter  int ;
use function Chevere  parameter  null ;

$ value = 1 ;
union ( int (), null())( $ value );

Validasi atribut yang didelegasikan

  • Gunakan fungsi validated() untuk mendapatkan pengembalian yang divalidasi terhadap semua aturan.
parametervalidated; $result = validated('myFunction', $var);">
 use function Chevere  parameter  validated ;

$ result = validated ( ' myFunction ' , $ var );
  • Gunakan fungsi reflectionTo parameter s() untuk mendapatkan aturan untuk memvalidasi argumen.
parameterAttributesIntAttr; use function Chevere parameter arguments; use function Chevere parameter reflectionTo parameter s; $class = new class() { public function wea( #[IntAttr(accept: [1, 10, 100])] int $base ): void { } }; $object = new $class(); $reflection = new ReflectionMethod($object, 'wea'); $ parameter s = reflectionTo parameter s($reflection); $args = ['base' => 10]; $ parameter s(...$args); // valid $args $result = $object->wea(...$args);">
 use ReflectionMethod ;
use Chevere  parameter  Attributes  IntAttr ;
use function Chevere  parameter  arguments ;
use function Chevere  parameter  reflectionTo parameter s ;

$ class = new class () {
    public function wea (
        #[IntAttr(accept: [ 1 , 10 , 100 ])]
        int $ base
    ): void {
    }
};
$ object = new $ class ();
$ reflection = new ReflectionMethod ( $ object , ' wea ' );
$ parameter s = reflectionTo parameter s ( $ reflection );
$ args = [ ' base ' => 10 ];
$ parameter s (... $ args ); // valid $args
$ result = $ object -> wea (... $ args );
  • Gunakan fungsi reflectionToReturn() untuk mendapatkan aturan untuk memvalidasi nilai pengembalian fungsi/metode:
parameterAttributesIntAttr; use Chevere parameter AttributesReturnAttr; use function Chevere parameter reflectionToReturn; $function = #[ReturnAttr( new IntAttr(min: 1000) )] function (int $base): int { return 10 * $base; }; $reflection = new ReflectionFunction($function); $return = reflectionToReturn($reflection); $base = 10; $result = $function($base); $result = $return($result); // Validates result">
 use ReflectionFunction ;
use Chevere  parameter  Attributes  IntAttr ;
use Chevere  parameter  Attributes  ReturnAttr ;
use function Chevere  parameter  reflectionToReturn ;

$ function =
    #[ReturnAttr(
        new IntAttr (min: 1000 )
    )]
    function ( int $ base ): int {
        return 10 * $ base ;
    };
$ reflection = new ReflectionFunction ( $ function );
$ return = reflectionToReturn ( $ reflection );
$ base = 10 ;
$ result = $ function ( $ base );
$ result = $ return ( $ result ); // Validates result

Validasi inline atribut

Gunakan valid() pada isi fungsi/metode untuk memicu validasi argumen.

  • Validasi enum string untuk Hugo , Paco , Luis :
  • Validasi nilai minimum float 1000 :
parameterAttributesEnumAttr; use function Chevere parameter validate; function myEnum( #[EnumAttr('Hugo', 'Paco', 'Luis')] string $name, #[FloatAttr(min: 1000)] float $money ): void { valid(); // Or single... valid('name'); valid('money'); } $arg1 = 'Paco'; $arg2 = 1000.50; myEnum($arg1, $arg2);">
 use Chevere  parameter  Attributes  EnumAttr ;
use function Chevere  parameter  validate ;

function myEnum (
    #[EnumAttr( ' Hugo ' , ' Paco ' , ' Luis ' )]
    string $ name ,
    #[FloatAttr(min: 1000 )]
    float $ money
): void
{
    valid ();
    // Or single...
    valid ( ' name ' );
    valid ( ' money ' );
}
$ arg1 = ' Paco ' ;
$ arg2 = 1000.50 ;
myEnum ( $ arg1 , $ arg2 );
  • Validasi int nilai apa pun kecuali 0 dan 100 :
parameterAttributesIntAttr; use function Chevere parameter validate; function myInt( #[IntAttr(reject: [0, 100])] int $id ): void { valid(); } $value = 50; myInt($value);">
 use Chevere  parameter  Attributes  IntAttr ;
use function Chevere  parameter  validate ;

function myInt (
    #[IntAttr(reject: [ 0 , 100 ])]
    int $ id
): void
{
    valid ();
}
$ value = 50 ;
myInt ( $ value );
  • Validasi a tidak menyenangkan array bersarang:
parameterAttributesArrayAttr; use Chevere parameter AttributesIntAttr; use Chevere parameter AttributesStringAttr; use Chevere parameter AttributesIterableAttr; use function Chevere parameter validate; function myArray( #[ArrayAttr( id: new IntAttr(min: 1), role: new ArrayAttr( mask: new IntAttr(accept: [64, 128, 256]), name: new StringAttr('/[a-z]+/'), tenants: new IterableAttr( new IntAttr(min: 1) ) ), )] array $spooky ): void { valid(); } $value = [ 'id' => 10, 'role' => [ 'mask' => 128, 'name' => 'admin', 'tenants' => [1, 2, 3, 4, 5] ], ]; myArray($value);">
 use Chevere  parameter  Attributes  ArrayAttr ;
use Chevere  parameter  Attributes  IntAttr ;
use Chevere  parameter  Attributes  StringAttr ;
use Chevere  parameter  Attributes  IterableAttr ;
use function Chevere  parameter  validate ;

function myArray (
    #[ArrayAttr(
        id: new IntAttr (min: 1 ),
        role: new ArrayAttr (
            mask: new IntAttr (accept: [ 64 , 128 , 256 ]),
            name: new StringAttr ( ' /[a-z]+/ ' ),
            tenants: new IterableAttr (
                new IntAttr (min: 1 )
            )
        ),
    )]
    array $ spooky
): void
{
    valid ();
}
$ value = [
    ' id ' => 10 ,
    ' role ' => [
        ' mask ' => 128 ,
        ' name ' => ' admin ' ,
        ' tenants ' => [ 1 , 2 , 3 , 4 , 5 ]
    ],
];
myArray ( $ value );
  • Validasi daftar int yang dapat diubah:
parameterAttributesIntAttr; use Chevere parameter AttributesIterableAttr; use function Chevere parameter validate; function myIterable( #[IterableAttr( new IntAttr(), )] array $list = [0,1,2] ): void { valid(); }">
 use Chevere  parameter  Attributes  IntAttr ;
use Chevere  parameter  Attributes  IterableAttr ;
use function Chevere  parameter  validate ;

function myIterable (
    #[IterableAttr(
        new IntAttr (),
    )]
    array $ list = [ 0 , 1 , 2 ]
): void
{
    valid ();
}

Gunakan fungsi returnAttr() pada isi fungsi/metode.

  • Validasi int min: 0, max: 5 pengembalian:
parameterAttributesIntAttr; use Chevere parameter AttributesReturnAttr; use function Chevere parameter returnAttr; #[ReturnAttr( new IntAttr(min: 0, max: 5) )] public function myReturnInt(): int { $result = 1; return returnAttr()($result); }">
 use Chevere  parameter  Attributes  IntAttr ;
use Chevere  parameter  Attributes  ReturnAttr ;
use function Chevere  parameter  returnAttr ;

#[ReturnAttr(
    new IntAttr (min: 0 , max: 5 )
)]
public function myReturnInt (): int
{
    $ result = 1 ;

    return returnAttr ()( $ result );
}
  • Validasi pengembalian array:
parameterAttributesArrayAttr; use Chevere parameter AttributesIntAttr; use Chevere parameter AttributesStringAttr; use Chevere parameter AttributesReturnAttr; use function Chevere parameter returnAttr; #[ReturnAttr( new ArrayAttr( id: new IntAttr(min: 0), name: new StringAttr() ) )] public function myReturnArray(): array { $result = [ 'id' => 1, 'name' => 'Peoples Hernandez' ]; return returnAttr()($result); }">
 use Chevere  parameter  Attributes  ArrayAttr ;
use Chevere  parameter  Attributes  IntAttr ;
use Chevere  parameter  Attributes  StringAttr ;
use Chevere  parameter  Attributes  ReturnAttr ;
use function Chevere  parameter  returnAttr ;

#[ReturnAttr(
    new ArrayAttr (
        id: new IntAttr (min: 0 ),
        name: new StringAttr ()
    )
)]
public function myReturnArray (): array
{
    $ result = [
        ' id ' => 1 ,
        ' name ' => ' Peoples Hernandez '
    ];

    return returnAttr ()( $ result );
}

Berdasarkan konvensi saat menghilangkan ReturnAttr metode public static function return(): parameter Interface (jika ada) akan digunakan untuk menentukan aturan validasi pengembalian.

Dokumentasi

Dokumentasi tersedia di chevere.org.

Lisensi

Hak Cipta Rodolfo Berrios A.

Chevere dilisensikan di bawah Lisensi Apache, Versi 2.0. Lihat LISENSI untuk teks lisensi lengkap.

Kecuali diwajibkan oleh undang-undang yang berlaku atau disetujui secara tertulis, perangkat lunak yang didistribusikan berdasarkan Lisensi didistribusikan berdasarkan DASAR "APA ADANYA", TANPA JAMINAN ATAU KETENTUAN DALAM BENTUK APAPUN, baik tersurat maupun tersirat. Lihat Lisensi untuk bahasa tertentu yang mengatur izin dan batasan berdasarkan Lisensi.

Memperluas
Informasi Tambahan
Aplikasi Terkait
Direkomendasikan untuk Anda
Informasi Terkait Semua