parameter Download - parameter Download do código-fonte

parameter

Resumo

parameter é uma biblioteca em torno de parameter -argumento que fornece funcionalidade adicional com regras de validação e introspecção de esquema.

Instalando

parameter está disponível através do Packagist e a fonte do repositório está em chevere/ parameter .

composer require chevere/ parameter

O que isso faz?

parameter permite gerar parameter dinâmicos de qualquer tipo com regras extras.

Por exemplo, um número inteiro de valor mínimo 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

Em parameter de função ou método, você pode usar atributos para definir regras de validação para parameter e valor de retorno.

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

A validação pode ser acionada usando validated (exemplo acima), embutido e/ou delegado a um wrapper de chamada. parameter fornece auxiliares para acessar regras para parameter e valor de retorno para facilitar o processo de fiação.

As regras definidas por cada parameter fornecem um esquema legível que permite expor os critérios de validação.

Como usar

parameter fornece uma API que pode ser usada para criar parameter usando funções e/ou atributos. objetos parameter podem ser usados diretamente na lógica, enquanto atributos requerem uma etapa de leitura.

Uso embutido

Use a validação in-line para partir disto:

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

Para isso:

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

 use function  Chevere  parameter  int ;

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

Uso baseado em atributos

Use atributos para definir regras para parameter e valores de retorno.

Use a validação delegada de atributos com a função validated() para partir disto:

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

Para isso:

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

Use reflectionTo parameter s e funções reflectionToReturn para validação manual de argumentos e valor de retorno:

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

Use a validação in-line de atributos para validação manual no corpo da função:

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

 use Chevere  parameter  Attributes  IntAttr ;
use Chevere  parameter  Attributes  ReturnAttr ;
use Chevere  parameter  Attributes  StringAttr ;
use function Chevere  parameter  valid ;
use function Chevere  parameter  returnAttr ;

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

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

CallableAttr

Os atributos em PHP suportam apenas expressões que você pode usar em constantes de classe. Não é possível definir parameter dinâmicos diretamente usando atributos.

Para evitar essa limitação, você pode usar o atributo CallableAttr que permite encaminhar a resolução parameter para um callable retornando uma instância 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 ' )]

Tipos

Um parameter é um objeto que implementa parameter Interface . Cada parameter pode definir uma description e um valor default , além de regras de validação adicionais dependendo do tipo.

Um parameter pode ser definido usando funções e/ou atributos, requer os mesmos argumentos para ambos.

Ao invocar um parameter $param('value') ele acionará a validação do argumento passado.

Corda

Use string de função para criar um String parameter . Passe um regex para correspondência de strings.

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

Use o atributo StringAttr para definir um parameter de string.

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

 use Chevere  parameter  Attributes  StringAttr ;

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

parameter de string s

Os parameter a seguir são baseados em String.

Sequência de enumeração

Use a função enum para criar um String parameter que corresponda a uma lista de strings.

parameterenum; $enum = enum('on', 'off'); $enum('on'); $enum('off');">

 use function Chevere  parameter  enum ;

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

Use o atributo EnumAttr para definir um parameter de string enum.

parameterAttributesEnumAttr; #[EnumAttr('on', 'off')]">

 use Chevere  parameter  Attributes  EnumAttr ;

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

String interna

Use a função intString para criar um String parameter correspondente a números inteiros de string.

parameterintString; $int = intString(); $int('100');">

 use function Chevere  parameter  intString ;

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

String booleana

Use a função boolString para criar um String parameter que corresponda às strings 0 e 1 .

parameterboolString; $bool = boolString(); $bool('0'); $bool('1');">

 use function Chevere  parameter  boolString ;

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

Sequência de data

Use a função date para criar um String parameter que corresponda às strings YYYY-MM-DD .

parameterdate; $date = date(); $date('2021-01-01');">

 use function Chevere  parameter  date ;

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

Sequência de tempo

Use a função time para criar um String parameter que corresponda às strings hh:mm:ss .

parametertime; $time = time(); $time('12:00:00');">

 use function Chevere  parameter  time ;

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

String de data e hora

Use a função datetime para criar um String parameter que corresponda às strings 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 ' );

Interno

Use a função int para criar um Int parameter . Passe os valores min e max para o intervalo de inteiros, accept para uma lista de inteiros aceitos e reject para uma lista de inteiros rejeitados.

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

Use o atributo IntAttr para definir um parameter inteiro.

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

 use Chevere  parameter  Attributes  IntAttr ;

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

parameter int

Os seguintes parameter são baseados em Int.

Bool int

Use a função boolInt para criar um Int parameter que corresponda a números inteiros 0 e 1 .

parameterboolInt; $bool = boolInt(); $bool(0); $bool(1);">

 use function Chevere  parameter  boolInt ;

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

Flutuador

Use a função float para criar um Float parameter . Passe os valores min e max para o intervalo de flutuações, accept para uma lista de flutuações aceitas e reject para uma lista de flutuações rejeitadas.

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

Use o atributo FloatAttr para definir um parameter float.

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

 use Chevere  parameter  Attributes  FloatAttr ;

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

Bool

Use a função bool para criar um Bool parameter .

parameterbool; $bool = bool(); $bool(true); $bool(false);">

 use function Chevere  parameter  bool ;

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

Use o atributo BoolAttr para definir um parameter bool.

parameterAttributesBoolAttr; #[BoolAttr]">

 use Chevere  parameter  Attributes  BoolAttr ;

#[BoolAttr]

Nulo

Use a função null para criar um Null parameter .

parameternull; $null = null(); $null(null);">

 use function Chevere  parameter  null ;

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

Use o atributo NullAttr para definir um parameter nulo.

parameterAttributesNullAttr; #[NullAttr]">

 use Chevere  parameter  Attributes  NullAttr ;

#[NullAttr]

Objeto

Use object de função para criar um Object parameter . Passe um className para o nome da classe do objeto.

parameterobject; $object = object(stdClass::class); $object(new stdClass());">

 use function Chevere  parameter  object ;

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

Use o atributo ObjectAttr para definir um parameter de objeto.

parameterAttributesObjectAttr; #[ObjectAttr(stdClass::class)]">

 use Chevere  parameter  Attributes  ObjectAttr ;

#[ObjectAttr(stdClass::class)]

Misturado

Use a função mixed para criar um 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 );

União

Use a função union para criar um Union parameter . Passe uma lista de parameter para corresponder, o valor alvo deve corresponder a pelo menos um.

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

Variedade

parameter para o tipo array é tratado como um parameter composto que contém a definição de parameter para cada um de seus membros.

Use a função arrayp para criar um Array parameter para argumentos nomeados como chaves de array necessárias.

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 suporta matrizes aninhadas de qualquer profundidade:

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

Use o atributo ArrayAttr para definir um parameter de array.

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

 use Chevere  parameter  Attributes  ArrayAttr ;
use Chevere  parameter  Attributes  FloatAttr ;
use Chevere  parameter  Attributes  IntAttr ;

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

Com obrigatório

use o método withRequired para definir parameter necessários.

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

Com opcional

use o método withOptional para definir parameter opcionais.

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

Nota: Os parameter opcionais serão validados somente se uma chave correspondente for fornecida.

Com modificação

use o método withModify para definir parameter de modificação.

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

Com tornar opcional

use o método withMakeOptional para tornar parameter obrigatórios opcionais.

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

Com make obrigatório

use o método withMakeRequired para tornar obrigatórios parameter opcionais.

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

Sem

use o método without remover parameter .

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

Com mínimo opcional

use o método withOptionalMinimum para definir um número mínimo de parameter opcionais. Útil se todos parameter forem opcionais, exceto 1.

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

parameter de array s

Os parameter a seguir são baseados em Array.

Sequência de Matriz

Use a função arrayString para criar uma ArrayString parameter Interface para valores de string. Ele suporta apenas parameter de string.

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

Arquivo

Use file de função para criar um Array parameter para uploads de arquivos.

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

Por padrão, ele fornece validação para o formato $_FILES , mas você pode definir suas próprias regras de validação. Por exemplo, para validar nome e conteúdo:

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

Iterável

O tipo iterável Traversable|array é considerado um parameter composto que contém uma definição genérica para chave e valor. parameter permite descrever esta coleção de itens que compartilham a mesma forma.

Use a função iterable para criar um Iterable parameter . Passe parameter V e K para chave e valor genéricos.

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

Também funciona com chaves nomeadas:

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

Ajudantes

parameter S

Use parameter s de função para criar uma instância 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 ());

argumentos

Use arguments de função para criar uma instância 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 ' ]);

assertNamedArgumento

Use a função assertNamedArgument para afirmar um argumento nomeado.

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

para parameter

Use função to parameter para criar uma instância parameter Interface a partir de uma string de tipo. No exemplo abaixo o $ parameter resultante será um Int parameter .

parameter ; $ parameter = to parameter ('int');">

 use function Chevere  parameter s  to parameter ;

$ parameter = to parameter ( ' int ' );

arrayFrom

Use a função arrayFrom para criar um parameter Array a partir de outro parameter array. No exemplo abaixo, o $array resultante conterá apenas as chaves name e id conforme definido em $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 ' );

pegue as chaves

Use a função takeKeys para recuperar um array com as chaves de um parameter . No exemplo abaixo, $keys conterá id e 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 );

pegarDe

Use a função takeFrom para recuperar um iterador com as chaves desejadas de um parameter . No exemplo abaixo, $iterator produzirá chaves size e 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 sDe

Use parameter sFrom para criar um parameter s com as chaves desejadas de um parameter . No exemplo abaixo, $ parameter s conterá chaves size e 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 ' );

obter parameter s

Use a função get parameter s para recuperar a instância de um parameter s de um objeto que implementa parameter AccessInterface ou 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

Use a função getType para recuperar o tipo conhecido por esta biblioteca.

parametersgetType; $type = getType(1); // int">

 use function Chevere  parameter s  getType ;

$ type = getType ( 1 ); // int

parameter Atributo

Use parameter Attr para recuperar um parameter AttributeInterface de uma função ou parameter de método de classe.

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 reflexãoTo s

Use reflectionTo parameter s para recuperar a instância parameter s de uma instância ReflectionFunction ou ReflectionMethod .

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

 use function Chevere  parameter  reflectionTo parameter s ;

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

reflexãoToReturn

Use a função reflectionToReturn para recuperar uma instância parameter Interface de uma instância ReflectionFunction ou ReflectionMethod .

parameterreflectionToReturn; $ parameter = reflectionToReturn($reflection);">

 use function Chevere  parameter  reflectionToReturn ;

$ parameter = reflectionToReturn ( $ reflection );

Atributo parameter refletido

Use reflected parameter Attribute para recuperar um objeto que implementa parameter AttributeInterface de uma instância 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 );

validado

Use função validated para validar argumentos de função ou método.

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

 use function Chevere  parameter  validated ;

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

Exemplos

Validação embutida

Valide a string começando com "a":

parameterstring; $value = 'ahhh'; string('/^a.+/')($value);">

 use function Chevere  parameter  string ;

$ value = ' ahhh ' ;
string ( ' /^a.+/ ' )( $ value );

Valide um int de valor mínimo 100 :

parameterint; $value = 100; int(min: 100)($value);">

 use function Chevere  parameter  int ;

$ value = 100 ;
int (min: 100 )( $ value );

Valide uma lista de aceitação interna:

parameterint; $value = 1; int(accept: [1, 2, 3])($value);">

 use function Chevere  parameter  int ;

$ value = 1 ;
int (accept: [ 1 , 2 , 3 ])( $ value );

Valide uma lista flutuante de rejeição:

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

Valide uma matriz:

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

Valide uma lista int iterável:

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

Valide uma lista int iterável com regras de tipo de chave de string:

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

 use function Chevere  parameter  int ;
use function Chevere  parameter  iterable ;

$ value = [
    ' unila ' => 1 ,
    ' dorila ' => 2 ,
    ' tirifila ' => 3 ,
];
iterable (
    K: string ( ' /ila$/ ' ),
    V: int (min: 1 )
)( $ value );

Valide uma união do tipo ?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 );

Validação delegada de atributos

Use a função validated() para obter um retorno validado em relação a todas as regras.

parametervalidated; $result = validated('myFunction', $var);">

 use function Chevere  parameter  validated ;

$ result = validated ( ' myFunction ' , $ var );

Use a função reflectionTo parameter s() para obter regras para validar argumentos.

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

Use a função reflectionToReturn() para obter regras para validar o valor de retorno da função/método:

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

Validação in-line de atributos

Use valid() no corpo da função/método para acionar a validação dos argumentos.

Valide uma string enum para Hugo , Paco , Luis :
Valide um valor flutuante mínimo de 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 );

Valide um int de qualquer valor, exceto 0 e 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 );

Validar um ~~nojento~~ matriz aninhada:

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

Valide a lista int iterável:

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

Use a função returnAttr() no corpo da função/método.

Validar int min: 0, max: 5 retorno:

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

Valide o retorno do array:

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

 use Chevere  parameter  Attributes  ArrayAttr ;
use Chevere  parameter  Attributes  IntAttr ;
use Chevere  parameter  Attributes  StringAttr ;
use Chevere  parameter  Attributes  ReturnAttr ;
use function Chevere  parameter  returnAttr ;

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

    return returnAttr ()( $ result );
}

Por convenção, ao omitir ReturnAttr o método public static function return(): parameter Interface (se houver) será usado para determinar regras de validação de retorno.

Documentação

A documentação está disponível em chevere.org.

Licença

Chevere está licenciado sob a Licença Apache, Versão 2.0. Consulte LICENÇA para obter o texto completo da licença.

A menos que exigido pela lei aplicável ou acordado por escrito, o software distribuído sob a Licença é distribuído "COMO ESTÁ", SEM GARANTIAS OU CONDIÇÕES DE QUALQUER TIPO, expressas ou implícitas. Consulte a Licença para saber o idioma específico que rege as permissões e limitações da Licença.

Expandir