Главная страница>Исходный код PHP>Другие категории
Скачать

parameter

Краткое содержание

parameter — это библиотека parameter -argument, которая предоставляет дополнительную функциональность с правилами проверки и самоанализом схемы.

Установка

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 , чтобы создать String parameter , соответствующий строкам 0 и 1 .

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

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

Строка даты

Используйте функцию date , чтобы создать String parameter , соответствующий строкам YYYY-MM-DD .

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

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

Строка времени

Используйте функцию time для создания String parameter , соответствующего строкам hh:mm:ss .

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

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

Строка даты и времени

Используйте функцию datetime для создания String parameter , соответствующего строкам 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

Используйте функцию 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 , чтобы создать Int parameter соответствующий целым числам 0 и 1 .

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 для определения parameter bool.

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

Множество

parameter для array типов обрабатывается как составной 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 s. 

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

С дополнительным

используйте метод withOptional для определения необязательных parameter s. 

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

Примечание. Необязательные parameter будут проверены только в том случае, если указан соответствующий ключ.

С изменением

используйте метод 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 . Полезно, если все parameter необязательны, кроме 1. 

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

parameter массива s

Следующие parameter основаны на Array.

Массив Строка

Используйте функцию arrayString для создания ArrayString parameter Interface для строковых значений. Он поддерживает только строковые parameter 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 ' ]);

Файл

Используйте 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 . Передайте parameter V и K для общего ключа и значения.

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

Используйте функцию 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 будет содержать только ключи name и id , как определено в $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 ' );

TakeKeys

Используйте функцию 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 s с нужными ключами из parameter . В приведенном ниже примере $ 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 s из объекта, реализующего либо parameter AccessInterface , либо parameter sInterface .

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

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

getType

Используйте функцию getType для получения типа, известного в этой библиотеке.

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

$ type = getType ( 1 ); // int

parameter Атр.

Используйте parameter Attr , чтобы получить parameter AttributeInterface , реализующий объект, из parameter метода функции или класса.

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

parameter ReflectionTo s

Используйте reflectionTo parameter s , чтобы получить экземпляр parameter s из экземпляра ReflectionFunction или ReflectionMethod .

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

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

отражениеToReturn

Используйте функцию reflectionToReturn , чтобы получить экземпляр parameter Interface из экземпляра ReflectionFunction или ReflectionMethod .

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

$ parameter = reflectionToReturn ( $ reflection );

отраженный parameter Атрибут

Используйте reflected parameter Attribute чтобы получить parameter AttributeInterface , реализующий объект, из экземпляра 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 );

проверенный

Используйте функцию, validated для проверки аргументов функции или метода.

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

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

Примеры

Встроенная проверка

  • Проверьте строку, начинающуюся с «а»:
parameterstring; $value = 'ahhh'; string('/^a.+/')($value);">
 use function Chevere  parameter  string ;

$ value = ' ahhh ' ;
string ( ' /^a.+/ ' )( $ value );
  • Подтвердите int минимального значения 100 :
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 );
  • Подтвердите int любого значения, кроме 0 и 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 );
  • Подтвердите противный вложенный массив:
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.

Лицензия

Авторские права Родольфо Берриос А.

Chevere распространяется по лицензии Apache версии 2.0. Полный текст лицензии см. в разделе ЛИЦЕНЗИЯ.

Если это не требуется применимым законодательством или не согласовано в письменной форме, программное обеспечение, распространяемое по Лицензии, распространяется на условиях «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ ИЛИ УСЛОВИЙ, явных или подразумеваемых. См. Лицензию для определения конкретного языка, регулирующего разрешения и ограничения в рамках Лицензии.

Расширять
Дополнительная информация
Связанные приложения
Рекомендуем вам
Связанные новости Все