Descarga parameter - Descarga de código fuente parameter

parameter

Resumen

parameter es una biblioteca alrededor de parameter -argumento que proporciona funcionalidad adicional con reglas de validación e introspección de esquema.

Instalación

parameter está disponible a través de Packagist y la fuente del repositorio está en chevere/ parameter .

composer require chevere/ parameter

¿Qué hace?

parameter permite generar parameter dinámicos de cualquier tipo con reglas adicionales.

Por ejemplo, un número entero 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

En parameter de función o método, puede utilizar atributos para definir reglas de validación para parameter y el 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 );

La validación se puede activar mediante validated (ejemplo anterior), en línea y/o delegado a un contenedor de llamada. parameter proporciona ayuda para acceder a las reglas tanto para parameter como para el valor de retorno para facilitar el proceso de cableado.

Las reglas definidas por cada parameter proporcionan un esquema legible por humanos que permite exponer los criterios de validación.

como usar

parameter proporciona una API que se puede utilizar para crear parameter utilizando funciones y/o atributos. Los objetos parameter se pueden usar directamente en la lógica, mientras que los atributos requieren un paso de lectura.

Uso en línea

Utilice la validación en línea para pasar de esto:

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

A esto:

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

 use function  Chevere  parameter  int ;

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

Uso basado en atributos

Utilice atributos para definir reglas para parameter y el valor de retorno.

Utilice la validación delegada de atributos con la función validated() para pasar de esto:

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

A esto:

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

Utilice reflectionTo parameter s y las funciones reflectionToReturn para la validación manual de argumentos y 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

Utilice la validación en línea de atributos para la validación manual dentro del cuerpo de la función:

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

Los atributos en PHP solo admiten expresiones que puedes usar en constantes de clase. No es posible definir directamente los parameter dinámicos utilizando atributos.

Para evitar esta limitación, puede utilizar el atributo CallableAttr que permite reenviar la resolución parameter a una instancia invocable que devuelve una instancia 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

Un parameter es un objeto que implementa parameter Interface . Cada parameter puede definir una description y un valor default , además de reglas de validación adicionales según el tipo.

Un parameter se puede definir usando funciones y/o atributos, se necesitan los mismos argumentos para ambos.

Al invocar un parameter $param('value') activará la validación del argumento pasado.

Cadena

Utilice string de función para crear un String parameter . Pase una regex para la coincidencia de cadenas.

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

Utilice el atributo StringAttr para definir un parameter de cadena.

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

 use Chevere  parameter  Attributes  StringAttr ;

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

parameter de cadena s

Los siguientes parameter se basan en String.

cadena de enumeración

Utilice la función enum para crear un String parameter que coincida con una lista de cadenas.

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

 use function Chevere  parameter  enum ;

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

Utilice el atributo EnumAttr para definir un parameter de cadena de enumeración.

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

 use Chevere  parameter  Attributes  EnumAttr ;

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

cadena interna

Utilice la función intString para crear un String parameter que coincida con números enteros de cadena.

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

 use function Chevere  parameter  intString ;

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

cadena bool

Utilice la función boolString para crear un String parameter que coincida con las cadenas 0 y 1 .

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

 use function Chevere  parameter  boolString ;

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

Cadena de fecha

Utilice la función date para crear un String parameter que coincida con las cadenas YYYY-MM-DD .

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

 use function Chevere  parameter  date ;

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

Cadena de tiempo

Utilice la función time para crear un String parameter que coincida con las cadenas hh:mm:ss .

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

 use function Chevere  parameter  time ;

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

Cadena de fecha y hora

Utilice la función datetime para crear un String parameter que coincida con las cadenas 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 ' );

internacional

Utilice la función int para crear un Int parameter . Pase los valores min y max para el rango de enteros, accept para obtener una lista de enteros aceptados y reject para obtener una lista de enteros rechazados.

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

Utilice el atributo IntAttr para definir un parameter de número entero.

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

 use Chevere  parameter  Attributes  IntAttr ;

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

Int parameter s

Los siguientes parameter se basan en Int.

entero booleano

Utilice la función boolInt para crear un Int parameter que coincida con números enteros 0 y 1 .

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

 use function Chevere  parameter  boolInt ;

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

Flotar

Utilice la función float para crear un Float parameter . Pase los valores min y max para el rango de flotadores, accept para obtener una lista de flotadores aceptados y reject para obtener una lista de flotadores rechazados.

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

Utilice el atributo FloatAttr para definir un parameter flotante.

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

 use Chevere  parameter  Attributes  FloatAttr ;

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

booleano

Utilice la función bool para crear un Bool parameter .

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

 use function Chevere  parameter  bool ;

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

Utilice el atributo BoolAttr para definir un parameter bool.

parameterAttributesBoolAttr; #[BoolAttr]">

 use Chevere  parameter  Attributes  BoolAttr ;

#[BoolAttr]

Nulo

Utilice la función null para crear un Null parameter .

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

 use function Chevere  parameter  null ;

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

Utilice el atributo NullAttr para definir un parameter nulo.

parameterAttributesNullAttr; #[NullAttr]">

 use Chevere  parameter  Attributes  NullAttr ;

#[NullAttr]

Objeto

Utilice object de función para crear un Object parameter . Pase un nombre de clase para el nombre de la clase del objeto.

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

 use function Chevere  parameter  object ;

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

Utilice el atributo ObjectAttr para definir un parameter de objeto.

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

 use Chevere  parameter  Attributes  ObjectAttr ;

#[ObjectAttr(stdClass::class)]

Mezclado

Utilice la función mixed para crear un 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ón

Utilice la función union para crear un Union parameter . Pase una lista de parameter para que coincidan; el valor objetivo debe coincidir con al menos uno.

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

Formación

parameter para array de tipo se maneja como un parameter compuesto que contiene la definición parameter para cada uno de sus miembros.

Utilice la función arrayp para crear un Array parameter para argumentos con nombre como claves de matriz requeridas.

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 admite matrices anidadas de cualquier profundidad:

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

Utilice el atributo ArrayAttr para definir un parameter de matriz.

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

Con requerido

utilice el método withRequired para definir parameter requeridos.

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

Con opcional

utilice el método withOptional para definir parameter opcionales.

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

Nota: parameter opcionales se validarán solo si se proporciona una clave coincidente.

con modificar

utilice el método withModify para definir parameter de modificación.

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

Con hacer opcional

use el método withMakeOptional para hacer que parameter requeridos sean opcionales.

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

Con marca requerida

use el método withMakeRequired para hacer que parameter opcionales sean necesarios.

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

Sin

use el método without eliminar parameter .

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

Con mínimo opcional

utilice el método withOptionalMinimum para definir un número mínimo de parameter opcionales. Útil si todos parameter son opcionales excepto 1.

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

parameter de matriz

Los siguientes parameter se basan en Array.

Cadena de matriz

Utilice la función arrayString para crear una ArrayString parameter Interface para valores de cadena. Solo admite parameter de cadena.

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

Archivo

Utilice file de función para crear un Array parameter para cargar archivos.

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

De forma predeterminada, proporciona validación para la forma $_FILES , pero puedes definir tus propias reglas de validación. Por ejemplo, para validar el nombre y el contenido:

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

iterable

El tipo iterable Traversable|array se considera un parameter compuesto que contiene una definición genérica de clave y valor. parameter permite describir esta colección de elementos que comparten la misma forma.

Utilice la función iterable para crear un Iterable parameter . Pase un parameter V y K para clave y 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 ]);

También funciona con claves con nombre:

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

Ayudantes

parameter m

Utilice parameter s de función para crear una instancia 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

Utilice arguments de función para crear una instancia 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 ' ]);

afirmar argumento con nombre

Utilice la función assertNamedArgument para afirmar un argumento con nombre.

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

al parameter

Utilice la función to parameter para crear una instancia parameter Interface a partir de una cadena de tipo. En el siguiente ejemplo, el $ parameter resultante será un Int parameter .

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

 use function Chevere  parameter s  to parameter ;

$ parameter = to parameter ( ' int ' );

matrizDesde

Utilice la función arrayFrom para crear un parameter de matriz a partir de otro parameter de matriz. En el siguiente ejemplo, la $array resultante contendrá solo las claves name e id tal como se definen en $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 ' );

tomar llaves

Utilice la función takeKeys para recuperar una matriz con las claves de un parameter . En el siguiente ejemplo, $keys contendrá id y 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 );

tomar de

Utilice la función takeFrom para recuperar un iterador con las claves deseadas de un parameter . En el siguiente ejemplo, $iterator generará claves size y 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 sDesde

Utilice parameter sFrom para crear un parameter s con las teclas deseadas de un parameter . En el siguiente ejemplo, $ parameter s contendrán claves size y 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 ' );

obtener parameter s

Utilice la función get parameter s para recuperar una instancia parameter s de un objeto que implemente parameter AccessInterface o parameter sInterface .

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

 use function Chevere  parameter s  get parameter s ;

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

obtener tipo

Utilice la función getType para recuperar el tipo tal como lo conoce esta biblioteca.

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

 use function Chevere  parameter s  getType ;

$ type = getType ( 1 ); // int

atributo parameter

Utilice parameter Attr para recuperar un objeto que implementa parameter AttributeInterface de un parameter de método de función o clase.

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

reflexión al parameter s

Utilice reflectionTo parameter s para recuperar una instancia parameter s de una instancia de ReflectionFunction o ReflectionMethod .

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

 use function Chevere  parameter  reflectionTo parameter s ;

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

reflexiónParaRegresar

Utilice la función reflectionToReturn para recuperar una instancia parameter Interface de una instancia de ReflectionFunction o ReflectionMethod .

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

 use function Chevere  parameter  reflectionToReturn ;

$ parameter = reflectionToReturn ( $ reflection );

Atributo parameter reflejado

Utilice la función reflected parameter Attribute para recuperar un objeto que implementa parameter AttributeInterface de una instancia 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

Utilice la función validated para validar los argumentos de una función o método.

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

 use function Chevere  parameter  validated ;

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

Ejemplos

Validación en línea

Validar cadena que comienza con "a":

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

 use function Chevere  parameter  string ;

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

Valide un int de valor mínimo 100 :

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

 use function Chevere  parameter  int ;

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

Validar una lista de aceptación int:

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

 use function Chevere  parameter  int ;

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

Validar una lista flotante de rechazos:

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

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

Validar una lista int iterable:

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 una lista int iterable con reglas de tipo de clave de cadena:

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

Validar una unión de 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 );

Validación delegada de atributos

Utilice la función validated() para obtener una devolución validada según todas las reglas.

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

 use function Chevere  parameter  validated ;

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

Utilice reflectionTo parameter s() para obtener reglas 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 );

Utilice la función reflectionToReturn() para obtener reglas para validar el valor de retorno de la función/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

Validación en línea de atributos

Utilice valid() en el cuerpo de la función/método para activar la validación de los argumentos.

Validar una enumeración de cadena para Hugo , Paco , Luis :
Valide un valor flotante 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 un int de cualquier valor excepto 0 y 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 un ~~asqueroso~~ matriz anidada:

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

Validar lista int iterable:

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

Utilice la función returnAttr() en el cuerpo de la función/método.

Validar int min: 0, max: 5 return:

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

Validar retorno de matriz:

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 convención, al omitir ReturnAttr , el método public static function return(): parameter Interface (si corresponde) se utilizará para determinar las reglas de validación de devolución.

Documentación

La documentación está disponible en chevere.org.

Licencia

Chevere tiene la licencia Apache, versión 2.0. Consulte LICENCIA para obtener el texto completo de la licencia.

A menos que lo exija la ley aplicable o se acuerde por escrito, el software distribuido bajo la Licencia se distribuye "TAL CUAL", SIN GARANTÍAS NI CONDICIONES DE NINGÚN TIPO, ya sean expresas o implícitas. Consulte la Licencia para conocer el idioma específico que rige los permisos y limitaciones de la Licencia.

Expandir