首页>PHP源码>其他类别
下载

parameter

概括

parameter是一个围绕parameter的库，它提供了带有验证规则和模式自省的附加功能。

安装中

parameter可通过 Packagist 获得，存储库源位于 chevere/ parameter 。 

composer require chevere/ parameter

它有什么作用？

parameter可以使用额外的规则生成任何类型的动态parameter 。

例如，最小值为 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

在函数或方法parameter中，您可以使用属性来定义parameter和返回值的验证规则。

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 );

可以使用validated （上面的示例）、内联和/或委托给调用者包装器来触发验证。 parameter提供了访问parameter和返回值规则的帮助程序，以简化接线过程。

每个parameter定义的规则提供了一个人类可读的模式，允许公开验证标准。

如何使用

parameter提供了一个API，可用于使用函数和/或属性创建parameter 。 parameter对象可以直接在逻辑中使用，而属性则需要读取步骤。

内联使用

使用内联验证从这里开始： 

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

对此：

parameterint; int(min: 1, max: 10)($var);">
 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 );

对此：

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 );

使用reflectionTo parameter s和reflectionToReturn函数手动验证参数和返回值：

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

使用属性内联验证在函数体内进行手动验证：

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
}

可调用属性

PHP 中的属性仅支持可在类常量上使用的表达式。无法使用属性直接定义动态parameter 。

为了避免此限制，您可以使用CallableAttr属性，该属性可以将parameter解析转发到返回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 ' )]

类型

parameter是实现parameter Interface对象。每个parameter都可以定义description和default值，以及取决于类型的附加验证规则。

可以使用函数和/或属性来定义parameter ，两者采用相同的参数。

当调用parameter $param('value')时，它将触发对传递的参数的验证。

细绳

使用函数string创建一个String parameter 。传递一个regex进行字符串匹配。

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 ' );

使用StringAttr属性定义字符串parameter 。

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

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

字符串伪parameter s

下面的parameter都是基于String的。

枚举字符串

使用函数enum创建与字符串列表匹配的String parameter 。

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

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

使用EnumAttr属性定义枚举字符串parameter 。

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

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

整型字符串

使用函数intString创建与字符串整数匹配的String parameter 。

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

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

布尔字符串

使用函数boolString创建匹配0和1字符串的String parameter 。

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

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

日期字符串

使用函数date创建与YYYY-MM-DD字符串匹配的String parameter 。

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

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

时间字符串

使用函数time创建一个与hh:mm:ss字符串匹配的String parameter 。

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

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

日期时间字符串

使用函数datetime创建与YYYY-MM-DD hh:mm:ss字符串匹配的String parameter 。

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

使用函数int创建一个Int parameter 。传递整数范围的min和max ， accept接受的整数列表， reject拒绝的整数列表。

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 );

使用IntAttr属性定义整数parameter 。

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

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

Int 伪parameter s

下面的parameter都是基于Int的。

布尔整数

使用函数boolInt创建匹配0和1整数的Int parameter 。

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

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

漂浮

使用函数float创建一个Float parameter 。传递浮点数范围的min和max ， accept接受浮点数的列表， reject拒绝浮点数的列表。

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 );

使用FloatAttr属性定义浮点parameter 。

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

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

布尔

使用函数bool创建Bool parameter 。

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

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

使用BoolAttr属性定义 bool parameter 。

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

#[BoolAttr]

无效的

使用函数null创建一个Null parameter 。

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

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

使用NullAttr属性定义空parameter 。

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

#[NullAttr]

目的

使用函数object创建Object parameter 。传递对象类名称的 className。

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

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

使用ObjectAttr属性定义对象parameter 。

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

#[ObjectAttr(stdClass::class)]

混合

使用函数mixed创建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 );

联盟

使用函数union创建Union parameter 。传递一系列要匹配的parameter ，目标值必须至少匹配一个。

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 );

大批

类型array的parameter被处理为复合parameter保存其每个成员的parameter定义。

使用函数arrayp为命名参数创建Array parameter作为所需的数组键。

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支持任意深度的嵌套数组：

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 ,
    ]
]);

使用ArrayAttr属性定义数组parameter 。

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 (),
    ),
)]

与所需的

使用withRequired方法来定义所需的parameter 。 

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

有可选的

使用withOptional方法来定义可选parameter 。 

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

注意：仅当提供匹配的密钥时，可选parameter才会被验证。

带修改

使用withModify方法来定义修改parameter 。 

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

带有 make 可选

使用withMakeOptional方法使所需parameter可选。 

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

需要制作

使用withMakeRequired方法将可选parameter设为必需。 

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

没有

使用方法without删除parameter s。 

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

具有可选的最小值

使用withOptionalMinimum方法定义可选parameter的最小数量。如果除 1 之外所有parameter都是可选的，则很有用。 

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

数组伪parameter s

下面的parameter都是基于Array的。

数组字符串

使用函数arrayString为字符串值创建ArrayString parameter Interface 。它只支持字符串parameter 。

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 ' ]);

文件

使用函数file创建一个用于文件上传的Array parameter 。

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 );

默认情况下，它提供$_FILES形状的验证，但您可以定义自己的验证规则。例如，要验证名称和内容：

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 ' ,
);

可迭代

可迭代类型Traversable|array被视为持有键和值的通用定义的复合parameter 。 parameter能够描述共享相同形状的项目的集合。

使用函数iterable创建一个Iterable parameter 。传递通用键和值的V和K parameter 。

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 ]);

它也适用于命名键：

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 '
    ],
]);

帮手

parameter

使用函数parameter s创建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 ());

论点

使用函数arguments创建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 ' ]);

断言命名参数

使用函数assertNamedArgument断言命名参数。

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
);

至parameter

使用函数to parameter从类型字符串创建parameter Interface实例。在下面的示例中，生成的$ parameter将是Int parameter 。

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

$ parameter = to parameter ( ' int ' );

数组来源

使用函数arrayFrom从另一个数组parameter创建一个数组parameter 。在下面的示例中，生成的$array将仅包含$source中定义的name和id键。

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 ' );

拿钥匙

使用函数takeKeys从parameter中检索包含键的数组。在下面的示例中， $keys将包含id和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 );

取自

使用函数takeFrom从parameter中检索具有所需键的迭代器。在下面的示例中， $iterator将生成size和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 sFrom

使用函数parameter sFrom从parameter中创建具有所需键的parameter s 。在下面的示例中， $ parameter s将包含size和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 ' );

获取parameter s

使用函数get parameter s从实现parameter AccessInterface或parameter sInterface对象中检索parameter s实例。

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

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

获取类型

使用函数getType检索该库已知的类型。

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

$ type = getType ( 1 ); // int

parameter属性

使用函数parameter Attr从函数或类方法parameter中检索实现parameter AttributeInterface的对象。

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 ' );

ReflectionTo parameter

使用函数reflectionTo parameter s从ReflectionFunction或ReflectionMethod实例检索parameter s实例。

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

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

反射返回

使用函数reflectionToReturn从ReflectionFunction或ReflectionMethod实例检索parameter Interface实例。

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

$ parameter = reflectionToReturn ( $ reflection );

反射parameter属性

使用函数reflected parameter Attribute从Reflection parameter实例中检索实现parameter AttributeInterface的对象。

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

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

已验证

使用函数validated来验证函数或方法参数。

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

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

示例

内联验证

  • 验证以“a”开头的字符串：
parameterstring; $value = 'ahhh'; string('/^a.+/')($value);">
 use function Chevere  parameter  string ;

$ value = ' ahhh ' ;
string ( ' /^a.+/ ' )( $ value );
  • 验证最小值100的 int ：
parameterint; $value = 100; int(min: 100)($value);">
 use function Chevere  parameter  int ;

$ value = 100 ;
int (min: 100 )( $ value );
  • 验证 int 接受列表：
parameterint; $value = 1; int(accept: [1, 2, 3])($value);">
 use function Chevere  parameter  int ;

$ value = 1 ;
int (accept: [ 1 , 2 , 3 ])( $ value );
  • 验证浮动拒绝列表：
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 );
  • 验证数组：
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 );
  • 验证可迭代int列表：
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 );
  • 使用字符串键类型规则验证可迭代 int 列表：
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 );
  • 验证 ?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 );

属性委托验证

  • 使用函数validated()来获取针对所有规则进行验证的返回值。
parametervalidated; $result = validated('myFunction', $var);">
 use function Chevere  parameter  validated ;

$ result = validated ( ' myFunction ' , $ var );
  • 使用函数reflectionTo parameter s()获取验证参数的规则。
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 );
  • 使用函数reflectionToReturn()获取验证函数/方法返回值的规则：
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

属性内联验证

在函数/方法主体上使用valid()来触发参数验证。

  • 验证Hugo 、 Paco 、 Luis的字符串枚举：
  • 验证最小浮点值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 );
  • 验证除0和100之外的任何值的 int ：
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 );
  • 验证一个可恶的嵌套数组：
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 );
  • 验证可迭代 int 列表：
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 ();
}

在函数/方法主体上使用函数returnAttr() 。

  • 验证 int min: 0, max: 5返回：
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 );
}
  • 验证数组返回：
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 );
}

按照约定，当省略ReturnAttr时，方法public static function return(): parameter Interface （如果有）将用于确定返回验证规则。

文档

文档可在 chevere.org 上获取。

执照

版权所有鲁道夫·贝里奥斯 A.

Chevere 根据 Apache 许可证 2.0 版获得许可。请参阅许可证以获取完整的许可证文本。

除非适用法律要求或书面同意，否则根据许可证分发的软件均按“原样”分发，不带任何明示或暗示的保证或条件。请参阅许可证，了解许可证下管理权限和限制的特定语言。

展开
附加信息
相关应用
为您推荐
相关资讯 全部