parameter
1.0.2
parameter เป็นไลบรารีที่อยู่รอบๆ parameter - อาร์กิวเมนต์ ซึ่งมีฟังก์ชันเพิ่มเติมพร้อมกฎการตรวจสอบและการวิปัสสนาสคีมา
parameter พร้อมใช้งานผ่าน Packagist และแหล่งเก็บข้อมูลอยู่ที่ chevere/ parameter
composer require chevere/ parameter parameter ช่วยให้สามารถวางไข่ parameter ไดนามิกประเภทใดก็ได้พร้อมกฎเพิ่มเติม
เช่น จำนวนเต็มที่มีค่าต่ำสุด 10
use function Chevere parameter int ;
$ int = int (min: 10 );
$ int ( $ var ); // exception if $var < 10ในฟังก์ชันหรือ parameter เมธอด คุณสามารถใช้แอตทริบิวต์เพื่อกำหนดกฎการตรวจสอบสำหรับ parameter และค่าที่ส่งคืนได้
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 ); การตรวจสอบความถูกต้องสามารถทริกเกอร์ได้โดยใช้การตรวจ validated (ตัวอย่างด้านบน) แบบอินไลน์ และ/หรือมอบหมายให้กับ Wrapper ผู้โทร parameter จัดเตรียมตัวช่วยในการเข้าถึงกฎสำหรับทั้ง parameter และค่าที่ส่งคืน เพื่อทำให้กระบวนการเดินสายง่ายขึ้น
กฎที่กำหนดโดยแต่ละ parameter จะมีสคีมาที่มนุษย์สามารถอ่านได้ ซึ่งช่วยให้เปิดเผยเกณฑ์การตรวจสอบได้
parameter จัดเตรียม API ซึ่งสามารถใช้เพื่อสร้าง parameter โดยใช้ฟังก์ชันและ/หรือแอตทริบิวต์ อ็อบเจ็กต์ parameter สามารถใช้ได้โดยตรงในตรรกะ ในขณะที่แอ็ตทริบิวต์ต้องมีขั้นตอนการอ่าน
ใช้การตรวจสอบแบบอินไลน์เพื่อไปจากนี้:
if ( $ var > 10 || $ var < 1 ) {
throw new InvalidArgumentException ();
}เพื่อสิ่งนี้:
use function Chevere parameter int ;
int (min: 1 , max: 10 )( $ var );ใช้แอตทริบิวต์เพื่อกำหนดกฎสำหรับ parameter และค่าที่ส่งคืน
ใช้การตรวจสอบคุณสมบัติที่ได้รับมอบหมายด้วยฟังก์ชัน validated() เพื่อไปจากนี้:
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 );เพื่อสิ่งนี้:
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 ); ใช้ reflectionTo parameter s และฟังก์ชัน reflectionToReturn สำหรับการตรวจสอบอาร์กิวเมนต์และค่าส่งคืนด้วยตนเอง:
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ใช้การตรวจสอบแบบอินไลน์แอตทริบิวต์สำหรับการตรวจสอบด้วยตนเองภายในเนื้อหาของฟังก์ชัน:
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
}คุณลักษณะใน PHP รองรับเฉพาะนิพจน์ที่คุณสามารถใช้กับค่าคงที่ของคลาสได้ ไม่สามารถกำหนด parameter ไดนามิกโดยตรงโดยใช้แอตทริบิวต์ได้
เพื่อหลีกเลี่ยงข้อจำกัดนี้ คุณสามารถใช้แอตทริบิวต์ CallableAttr ซึ่งเปิดใช้งานเพื่อส่งต่อความละเอียด parameter ไปยัง callable ที่ส่งคืนอินสแตนซ์ parameter Interface
use Chevere parameter Interfaces parameter Interface ;
use Chevere parameter Attributes CallableAttr ;
function myCallable (): parameter Interface
{
return arrayp (
email: string (),
)-> withOptional (
name: string (),
);
}
#[CallableAttr( ' myCallable ' )] parameter คือวัตถุที่ใช้ parameter Interface ทุก parameter สามารถกำหนด description และค่า default รวมถึงกฎการตรวจสอบเพิ่มเติมโดยขึ้นอยู่กับประเภท
parameter สามารถกำหนดได้โดยใช้ฟังก์ชันและ/หรือแอตทริบิวต์ โดยจะใช้อาร์กิวเมนต์เดียวกันสำหรับทั้งคู่
เมื่อเรียกใช้ parameter $param('value') มันจะทริกเกอร์การตรวจสอบความถูกต้องกับอาร์กิวเมนต์ที่ส่งผ่าน
ใช้ string ฟังก์ชันเพื่อสร้าง String parameter ส่ง regex สำหรับการจับคู่สตริง
use function Chevere parameter string ;
// Any string
$ string = string ();
// String matching bin-<digits>
$ string = string ( ' /^bin-[d]+$/ ' );
$ string ( ' bin-123 ' ); ใช้แอตทริบิวต์ StringAttr เพื่อกำหนด parameter สตริง
use Chevere parameter Attributes StringAttr ;
#[StringAttr( ' /^bin-[d]+$/ ' )]parameter ต่อไปนี้จะขึ้นอยู่กับสตริง
ใช้ฟังก์ชัน enum เพื่อสร้าง String parameter ที่ตรงกับรายการสตริง
use function Chevere parameter enum ;
$ enum = enum ( ' on ' , ' off ' );
$ enum ( ' on ' );
$ enum ( ' off ' ); ใช้แอตทริบิวต์ EnumAttr เพื่อกำหนด parameter สตริง enum
use Chevere parameter Attributes EnumAttr ;
#[EnumAttr( ' on ' , ' off ' )] ใช้ฟังก์ชัน intString เพื่อสร้าง String parameter ที่ตรงกับจำนวนเต็มสตริง
use function Chevere parameter intString ;
$ int = intString ();
$ int ( ' 100 ' ); ใช้ฟังก์ชัน boolString เพื่อสร้าง String parameter ที่ตรงกับสตริง 0 และ 1
use function Chevere parameter boolString ;
$ bool = boolString ();
$ bool ( ' 0 ' );
$ bool ( ' 1 ' ); ใช้ date ของฟังก์ชันเพื่อสร้าง String parameter ที่ตรงกับสตริง YYYY-MM-DD
use function Chevere parameter date ;
$ date = date ();
$ date ( ' 2021-01-01 ' ); ใช้ time ฟังก์ชันเพื่อสร้าง String parameter ที่ตรงกับสตริง hh:mm:ss
use function Chevere parameter time ;
$ time = time ();
$ time ( ' 12:00:00 ' ); ใช้ฟังก์ชัน datetime เพื่อสร้าง String parameter ที่ตรงกับสตริง YYYY-MM-DD hh:mm:ss
use function Chevere parameter datetime ;
$ datetime = datetime ();
$ datetime ( ' 2024-01-09 10:53:00 ' ); ใช้ฟังก์ชัน int เพื่อสร้าง Int parameter ส่งค่า min และ max สำหรับช่วงจำนวนเต็ม accept รายการจำนวนเต็มที่ยอมรับ และ reject สำหรับรายการจำนวนเต็มที่ถูกปฏิเสธ
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 ); ใช้แอตทริบิวต์ IntAttr เพื่อกำหนด parameter จำนวนเต็ม
use Chevere parameter Attributes IntAttr ;
#[IntAttr(min: 0 , max: 100 )]parameter ต่อไปนี้จะขึ้นอยู่กับ Int
ใช้ฟังก์ชัน boolInt เพื่อสร้าง Int parameter ที่ตรงกับจำนวนเต็ม 0 และ 1
use function Chevere parameter boolInt ;
$ bool = boolInt ();
$ bool ( 0 );
$ bool ( 1 ); ใช้ฟังก์ชัน float เพื่อสร้าง Float parameter ส่งผ่านค่า min และ max สำหรับช่วงโฟลต accept รายการโฟลตที่ยอมรับ และ reject สำหรับรายการโฟลตที่ถูกปฏิเสธ
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 ); ใช้แอตทริบิวต์ FloatAttr เพื่อกำหนด parameter float
use Chevere parameter Attributes FloatAttr ;
#[FloatAttr(min: 0 , max: 100 )] ใช้ฟังก์ชัน bool เพื่อสร้าง Bool parameter
use function Chevere parameter bool ;
$ bool = bool ();
$ bool ( true );
$ bool ( false ); ใช้แอตทริบิวต์ BoolAttr เพื่อกำหนด parameter bool
use Chevere parameter Attributes BoolAttr ;
#[BoolAttr] ใช้ฟังก์ชัน null เพื่อสร้าง Null parameter
use function Chevere parameter null ;
$ null = null ();
$ null ( null ); ใช้แอตทริบิวต์ NullAttr เพื่อกำหนด parameter null
use Chevere parameter Attributes NullAttr ;
#[NullAttr] ใช้ object ฟังก์ชันเพื่อสร้าง Object parameter ผ่าน className สำหรับชื่อคลาสวัตถุ
use function Chevere parameter object ;
$ object = object (stdClass::class);
$ object ( new stdClass ()); ใช้แอตทริบิวต์ ObjectAttr เพื่อกำหนด parameter วัตถุ
use Chevere parameter Attributes ObjectAttr ;
#[ObjectAttr(stdClass::class)] ใช้ฟังก์ชัน mixed เพื่อสร้าง Mixed parameter
use function Chevere parameter mixed ;
$ mixed = mixed ();
$ mixed ( 1 );
$ mixed ( ' 1 ' );
$ mixed ( true );
$ mixed ( null ); ใช้ฟังก์ชัน union เพื่อสร้าง Union parameter ส่งรายการ parameter ที่จะจับคู่ ค่าเป้าหมายต้องตรงกันอย่างน้อยหนึ่งรายการ
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 ); parameter สำหรับ array ประเภทได้รับการจัดการเป็น parameter คอมโพสิตที่เก็บคำจำกัดความ parameter สำหรับสมาชิก แต่ละคน
ใช้ฟังก์ชัน arrayp เพื่อสร้าง Array parameter สำหรับอาร์กิวเมนต์ที่มีชื่อเป็นคีย์อาร์เรย์ที่จำเป็น
use function Chevere parameter arrayp ;
// Empty array
$ array = arrayp ();
$ array ([]);
// Required 'a' => <string>
$ array = arrayp (a: string ());
$ array ([ ' a ' => ' Hello world ' ]);parameter รองรับอาร์เรย์ที่ซ้อนกันของความลึกใด ๆ :
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 ,
]
]); ใช้แอตทริบิวต์ ArrayAttr เพื่อกำหนด parameter อาร์เรย์
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 (),
),
)] ใช้วิธีการ withRequired เพื่อกำหนด parameter ที่ต้องการ
$ array = $ array
-> withRequired (
username: string (),
email: string ()
); ใช้วิธีการ withOptional เพื่อกำหนด parameter ทางเลือก s
$ array = $ array
-> withOptional (address: string ());หมายเหตุ: parameter ทางเลือก s จะได้รับการตรวจสอบเฉพาะเมื่อมีการระบุคีย์ที่ตรงกันเท่านั้น
ใช้วิธีการ withModify เพื่อกำหนด parameter การแก้ไข s
$ array = $ array
-> withModify (
username: string ( ' /w+/ ' ),
); ใช้วิธีการ withMakeOptional เพื่อทำให้ parameter ที่จำเป็นเป็นทางเลือก
$ array = $ array
-> withMakeOptional ( ' username ' ); ใช้วิธีการ withMakeRequired เพื่อทำให้จำเป็นต้องมี parameter ทางเลือก
$ array = $ array
-> withMakeRequired ( ' email ' ); ใช้วิธีการ without ต้องลบ parameter s
$ array = $ array
-> without ( ' a ' ); ใช้วิธีการ withOptionalMinimum เพื่อกำหนดจำนวน parameter ทางเลือกขั้นต่ำ s มีประโยชน์หาก parameter ทั้งหมดเป็นทางเลือก แต่เป็น 1
$ array = $ array
-> withOptionalMinimum ( 1 );parameter ต่อไปนี้จะขึ้นอยู่กับอาร์เรย์
ใช้ฟังก์ชัน arrayString เพื่อสร้าง ArrayString parameter Interface สำหรับค่าสตริง รองรับเฉพาะ parameter สตริง s
use function Chevere parameter arrayString ;
use function Chevere parameter string ;
$ array = arrayString (
test: string (),
);
$ array ([ ' test ' => ' foo ' ]); ใช้ file ฟังก์ชันเพื่อสร้าง Array parameter สำหรับการอัปโหลดไฟล์
use function Chevere parameter file ;
$ array = file ();
$ file = [
' name ' => ' foo.txt ' ,
' type ' => ' text/plain ' ,
' tmp_name ' => ' /tmp/phpYzdqkD ' ,
' error ' => 0 ,
' size ' => 123 ,
];
$ array ( $ file ); ตามค่าเริ่มต้น จะมีการตรวจสอบความถูกต้องสำหรับรูปร่าง $_FILES แต่คุณสามารถกำหนดกฎการตรวจสอบของคุณเองได้ ตัวอย่างเช่น ในการตรวจสอบชื่อและเนื้อหา:
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 ' ,
); ประเภทที่ทำซ้ำได้ Traversable|array ถือเป็น parameter ผสมที่มีคำจำกัดความทั่วไปสำหรับคีย์และค่า parameter ทำให้สามารถอธิบายคอลเลกชั่นของไอเท็มที่มีรูปร่างเหมือนกันได้
ใช้ฟังก์ชัน iterable เพื่อสร้าง Iterable parameter ส่ง parameter V และ K สำหรับคีย์และค่าทั่วไป
use function Chevere parameter int ;
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 ;
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 '
],
]); ใช้ parameter s เพื่อสร้างอินสแตนซ์ parameter s
use function Chevere parameter s parameter s ;
use function Chevere parameter s string ;
$ parameter s = parameter s (foo: string ()); ใช้ arguments ของฟังก์ชันเพื่อสร้างอินสแตนซ์ Arguments
use function Chevere parameter s arguments ;
use function Chevere parameter s string ;
$ arguments = arguments ( $ parameter s , [ ' foo ' => ' bar ' ]); ใช้ฟังก์ชัน assertNamedArgument เพื่อยืนยันอาร์กิวเมนต์ที่มีชื่อ
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
); ใช้ฟังก์ชัน to parameter เพื่อสร้าง parameter Interface จากสตริงประเภท ในตัวอย่างด้านล่าง ผลลัพธ์ของ $ parameter จะเป็น Int parameter
use function Chevere parameter s to parameter ;
$ parameter = to parameter ( ' int ' ); ใช้ฟังก์ชัน arrayFrom เพื่อสร้าง parameter Array จาก parameter อาร์เรย์อื่น ในตัวอย่างด้านล่าง ผลลัพธ์ $array จะมีเฉพาะ name และคีย์ id ตามที่กำหนดไว้ใน $source
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 ' ); ใช้ฟังก์ชัน takeKeys เพื่อดึงข้อมูลอาร์เรย์ด้วยคีย์จาก parameter ในตัวอย่างด้านล่าง $keys จะมี id และ size
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 ); ใช้ฟังก์ชัน takeFrom เพื่อดึงข้อมูลตัววนซ้ำด้วยคีย์ที่ต้องการจาก parameter ในตัวอย่างด้านล่าง $iterator จะให้ 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 sFrom เพื่อสร้าง parameter s ด้วยคีย์ที่ต้องการจาก parameter ในตัวอย่างด้านล่าง $ parameter s จะมีคีย์ 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 ' ); ใช้ฟังก์ชัน get parameter s เพื่อดึง parameter s อินสแตนซ์จากออบเจ็กต์ที่ใช้ parameter AccessInterface หรือ parameter sInterface
use function Chevere parameter s get parameter s ;
$ parameter s = get parameter s ( $ object ); ใช้ฟังก์ชัน getType เพื่อดึงข้อมูลประเภทตามที่ไลบรารีนี้รู้จัก
use function Chevere parameter s getType ;
$ type = getType ( 1 ); // int ใช้ parameter Attr เพื่อดึงวัตถุที่ใช้ parameter AttributeInterface จากฟังก์ชันหรือ parameter เมธอดคลาส
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 ' ); ใช้ฟังก์ชัน พารามิเตอร์ reflectionTo parameter s parameter s จากอินสแตนซ์ ReflectionFunction หรือ ReflectionMethod
use function Chevere parameter reflectionTo parameter s ;
$ parameter s = reflectionTo parameter s ( $ reflection ); ใช้ฟังก์ชัน reflectionToReturn เพื่อดึงอินสแตนซ์ parameter Interface จากอินสแตนซ์ ReflectionFunction หรือ ReflectionMethod
use function Chevere parameter reflectionToReturn ;
$ parameter = reflectionToReturn ( $ reflection ); ใช้คุณลักษณะ reflected parameter Attribute ฟังก์ชันเพื่อดึงวัตถุที่ใช้ parameter AttributeInterface จากอินสแตนซ์ Reflection parameter
use function Chevere parameter reflected parameter Attribute ;
$ parameter Attribute = reflected parameter Attribute ( $ reflection parameter ); ใช้ฟังก์ชัน validated เพื่อตรวจสอบฟังก์ชันหรืออาร์กิวเมนต์ของเมธอด
use function Chevere parameter validated ;
$ result = validated ( ' myFunction ' , $ arg1 , $ arg2 ,); use function Chevere parameter string ;
$ value = ' ahhh ' ;
string ( ' /^a.+/ ' )( $ value );100 : use function Chevere parameter int ;
$ value = 100 ;
int (min: 100 )( $ value ); use function Chevere parameter int ;
$ value = 1 ;
int (accept: [ 1 , 2 , 3 ])( $ value ); use function Chevere parameter float ;
$ value = 3.1 ;
float (reject: [ 1.1 , 2.1 ])( $ 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 );int ที่สามารถทำซ้ำได้: use function Chevere parameter int ;
use function Chevere parameter iterable ;
$ value = [ 1 , 2 , 3 ];
iterable ( int ())( $ 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 ); use function Chevere parameter int ;
use function Chevere parameter null ;
$ value = 1 ;
union ( int (), null())( $ value );validated() เพื่อรับการตรวจสอบการคืนสินค้าตามกฎทั้งหมด use function Chevere parameter validated ;
$ result = validated ( ' myFunction ' , $ var );reflectionTo parameter s() เพื่อรับกฎสำหรับการตรวจสอบอาร์กิวเมนต์ 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 );reflectionToReturn() เพื่อรับกฎสำหรับตรวจสอบฟังก์ชัน/วิธีการส่งคืนค่า: 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 ใช้ valid() บนเนื้อหาของฟังก์ชัน/เมธอดเพื่อทริกเกอร์การตรวจสอบอาร์กิวเมนต์
Hugo , Paco , Luis :1000 : 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 );0 และ 100 : use Chevere parameter Attributes IntAttr ;
use function Chevere parameter validate ;
function myInt (
#[IntAttr(reject: [ 0 , 100 ])]
int $ id
): void
{
valid ();
}
$ value = 50 ;
myInt ( $ 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 ); 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 ();
} ใช้ฟังก์ชัน returnAttr() บนเนื้อหาของฟังก์ชัน/เมธอด
min: 0, max: 5 ส่งคืน: 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 );
} 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 );
} ตามแบบแผนเมื่อละเว้น ReturnAttr วิธี public static function return(): parameter Interface (ถ้ามี) จะถูกนำมาใช้เพื่อกำหนดกฎการตรวจสอบการส่งคืน
เอกสารสามารถดูได้ที่ chevere.org
ลิขสิทธิ์ Rodolfo Berrios A.
Chevere ได้รับอนุญาตภายใต้ Apache License เวอร์ชัน 2.0 ดูใบอนุญาตสำหรับข้อความใบอนุญาตฉบับเต็ม
เว้นแต่กฎหมายที่ใช้บังคับกำหนดหรือตกลงเป็นลายลักษณ์อักษร ซอฟต์แวร์ที่เผยแพร่ภายใต้ใบอนุญาตนี้จะถูกแจกจ่าย "ตามที่เป็น" โดยไม่มีการรับประกันหรือเงื่อนไขใดๆ ทั้งโดยชัดแจ้งหรือโดยนัย ดูใบอนุญาตสำหรับภาษาเฉพาะที่ควบคุมการอนุญาตและข้อจำกัดภายใต้ใบอนุญาต
