téléchargement parameter - téléchargement du code source parameter

parameter

Résumé

parameter est une bibliothèque autour parameter -argument qui fournit des fonctionnalités supplémentaires avec des règles de validation et une introspection de schéma.

Installation

parameter est disponible via Packagist et la source du référentiel se trouve dans chevere/ parameter .

composer require chevere/ parameter

Qu'est-ce que ça fait ?

parameter permet de générer parameter dynamiques de tout type avec des règles supplémentaires.

Par exemple, un entier de valeur minimale 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

Dans parameter de fonction ou de méthode, vous pouvez utiliser des attributs pour définir des règles de validation pour parameter et la valeur de retour.

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 validation peut être déclenchée à l'aide de validated (exemple ci-dessus), en ligne et/ou déléguée à un wrapper d'appelant. parameter fournit des aides pour accéder aux règles pour parameter et la valeur de retour afin de faciliter le processus de câblage.

Les règles définies par chaque parameter fournissent un schéma lisible par l'homme qui permet d'exposer les critères de validation.

Comment utiliser

parameter fournit une API qui peut être utilisée pour créer parameter à l’aide de fonctions et/ou d’attributs. les objets parameter peuvent être utilisés directement dans la logique tandis que les attributs nécessitent une étape de lecture.

Utilisation en ligne

Utilisez la validation en ligne pour partir de ceci :

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

À ceci :

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

 use function  Chevere  parameter  int ;

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

Utilisation basée sur les attributs

Utilisez des attributs pour définir des règles pour parameter et la valeur de retour.

Utilisez la validation déléguée d'attribut avec la fonction validated() pour partir de ceci :

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

À ceci :

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

Utilisez reflectionTo parameter s et les fonctions reflectionToReturn pour la validation manuelle des arguments et de la valeur de retour :

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

Utilisez la validation en ligne d'attribut pour la validation manuelle dans le corps de la fonction :

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

Les attributs en PHP ne prennent en charge que les expressions que vous pouvez utiliser sur les constantes de classe. Il n'est pas possible de définir directement parameter dynamiques à l'aide d'attributs.

Pour éviter cette limitation, vous pouvez utiliser l'attribut CallableAttr qui permet de transmettre la résolution parameter à un appelable renvoyant une instance 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 ' )]

Espèces

Un parameter est un objet implémentant parameter Interface . Chaque parameter peut définir une description et une valeur default , ainsi que des règles de validation supplémentaires selon le type.

Un parameter peut être défini à l'aide de fonctions et/ou d'attributs, il prend les mêmes arguments pour les deux.

Lors de l'invocation d'un parameter $param('value') cela déclenchera la validation par rapport à l'argument passé.

Chaîne

Utilisez la fonction string pour créer un String parameter . Passez une regex pour la correspondance de chaînes.

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

Utilisez l'attribut StringAttr pour définir un parameter de chaîne.

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

 use Chevere  parameter  Attributes  StringAttr ;

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

Pseudo- parameter de chaîne

Les parameter suivants sont basés sur String.

Chaîne d'énumération

Utilisez la fonction enum pour créer un String parameter correspondant à une liste de chaînes.

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

 use function Chevere  parameter  enum ;

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

Utilisez l'attribut EnumAttr pour définir un parameter de chaîne d'énumération.

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

 use Chevere  parameter  Attributes  EnumAttr ;

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

Chaîne entière

Utilisez la fonction intString pour créer un String parameter correspondant à une chaîne d'entiers.

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

 use function Chevere  parameter  intString ;

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

Chaîne booléenne

Utilisez la fonction boolString pour créer un String parameter correspondant aux chaînes 0 et 1 .

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

 use function Chevere  parameter  boolString ;

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

Chaîne de dates

Utilisez la fonction date pour créer un String parameter correspondant aux chaînes YYYY-MM-DD .

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

 use function Chevere  parameter  date ;

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

Chaîne de temps

Utilisez la fonction time pour créer un String parameter correspondant aux chaînes hh:mm:ss .

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

 use function Chevere  parameter  time ;

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

Chaîne date/heure

Utilisez la fonction datetime pour créer un String parameter correspondant 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

Utilisez la fonction int pour créer un Int parameter . Transmettez les valeurs min et max pour la plage d’entiers, accept pour une liste d’entiers acceptés et reject pour une liste d’entiers rejetés.

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

Utilisez l'attribut IntAttr pour définir un parameter entier.

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

 use Chevere  parameter  Attributes  IntAttr ;

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

Int pseudo- parameter

Les parameter suivants sont basés sur Int.

Bool entier

Utilisez la fonction boolInt pour créer un Int parameter correspondant aux entiers 0 et 1 .

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

 use function Chevere  parameter  boolInt ;

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

Flotter

Utilisez la fonction float pour créer un Float parameter . Transmettez les valeurs min et max pour la plage des flottants, accept pour une liste de flottants acceptés et reject pour une liste de flottants rejetés.

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

Utilisez l'attribut FloatAttr pour définir un parameter float.

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

 use Chevere  parameter  Attributes  FloatAttr ;

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

Booléen

Utilisez la fonction bool pour créer un Bool parameter .

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

 use function Chevere  parameter  bool ;

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

Utilisez l'attribut BoolAttr pour définir un parameter booléen.

parameterAttributesBoolAttr; #[BoolAttr]">

 use Chevere  parameter  Attributes  BoolAttr ;

#[BoolAttr]

Nul

Utilisez la fonction null pour créer un Null parameter .

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

 use function Chevere  parameter  null ;

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

Utilisez l'attribut NullAttr pour définir un parameter nul.

parameterAttributesNullAttr; #[NullAttr]">

 use Chevere  parameter  Attributes  NullAttr ;

#[NullAttr]

Objet

Utilisez object fonction pour créer un Object parameter . Transmettez un className pour le nom de la classe d'objet.

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

 use function Chevere  parameter  object ;

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

Utilisez l'attribut ObjectAttr pour définir un parameter d'objet.

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

 use Chevere  parameter  Attributes  ObjectAttr ;

#[ObjectAttr(stdClass::class)]

Mixte

Utilisez la fonction mixed pour créer 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 );

Union

Utilisez la fonction union pour créer un Union parameter . Transmettez une liste de parameter à faire correspondre, la valeur cible doit correspondre à au moins un.

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

Tableau

parameter pour array de types est géré comme un parameter composite contenant la définition parameter pour chacun de ses membres.

Utilisez la fonction arrayp pour créer un Array parameter pour les arguments nommés en tant que clés de tableau requises.

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 prend en charge les tableaux imbriqués de n’importe quelle profondeur :

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

Utilisez l'attribut ArrayAttr pour définir un parameter de tableau.

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

Avec requis

utilisez la méthode withRequired pour définir parameter requis.

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

Avec en option

utilisez la méthode withOptional pour définir parameter facultatifs.

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

Remarque : parameter facultatifs ne seront validés que si une clé correspondante est fournie.

Avec modifier

utilisez la méthode withModify pour définir parameter de modification.

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

Avec make facultatif

utilisez la méthode withMakeOptional pour rendre parameter requis facultatifs.

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

Avec marque requise

utilisez la méthode withMakeRequired pour rendre parameter facultatifs obligatoires.

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

Sans

utilisez la méthode without supprimer parameter s.

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

Avec minimum optionnel

utilisez la méthode withOptionalMinimum pour définir un nombre minimum de parameter facultatifs. Utile si tous parameter sont facultatifs sauf 1.

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

Pseudo- parameter du tableau

Les parameter suivants sont basés sur Array.

Chaîne de tableau

Utilisez la fonction arrayString pour créer une ArrayString parameter Interface pour les valeurs de chaîne. Il ne prend en charge que parameter de chaîne.

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

Déposer

Utilisez file de fonction pour créer un Array parameter pour les téléchargements de fichiers.

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

Par défaut, il fournit une validation pour la forme $_FILES , mais vous pouvez définir vos propres règles de validation. Par exemple, pour valider le nom et le contenu :

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

Itérable

Le type itérable Traversable|array est considéré comme un parameter composite contenant une définition générique de la clé et de la valeur. parameter permet de décrire cet ensemble d’éléments partageant la même forme.

Utilisez la fonction iterable pour créer un Iterable parameter . Passez un parameter V et K s pour la clé et la valeur génériques.

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

Cela fonctionne également avec des clés nommées :

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

Aides

parameter s

Utilisez parameter s de fonction pour créer l'instance 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

Utilisez arguments de fonction pour créer une instance 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

Utilisez la fonction assertNamedArgument pour affirmer un argument nommé.

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

Utilisez la fonction to parameter pour créer une instance parameter Interface à partir d'une chaîne de type. Dans l'exemple ci-dessous, le $ parameter résultant sera un Int parameter .

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

 use function Chevere  parameter s  to parameter ;

$ parameter = to parameter ( ' int ' );

tableauDe

Utilisez la fonction arrayFrom pour créer un parameter Array à partir d'un autre parameter de tableau. Dans l'exemple ci-dessous, le $array résultant contiendra uniquement les clés name et id telles que définies dans $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 ' );

prendre les clés

Utilisez la fonction takeKeys pour récupérer un tableau avec les clés d'un parameter . Dans l'exemple ci-dessous, $keys contiendra id et 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 );

prendreDe

Utilisez la fonction takeFrom pour récupérer un itérateur avec les clés souhaitées à partir d'un parameter . Dans l'exemple ci-dessous, $iterator produira des clés size et 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

Utilisez parameter sFrom pour créer un parameter s avec les clés souhaitées à partir d'un parameter . Dans l'exemple ci-dessous, $ parameter s contiendra les clés size et 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 ' );

obtenir parameter s

Utilisez la fonction get parameter s pour récupérer l'instance parameter s à partir d'un objet implémentant 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 );

obtenirType

Utilisez la fonction getType pour récupérer le type connu par cette bibliothèque.

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

 use function Chevere  parameter s  getType ;

$ type = getType ( 1 ); // int

parameter Attr

Utilisez parameter Attr pour récupérer un parameter AttributeInterface à partir d'un parameter de fonction ou de méthode 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 réflexionTo s

Utilisez la fonction reflectionTo parameter s pour récupérer l’instance parameter s à partir d’une instance ReflectionFunction ou ReflectionMethod .

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

 use function Chevere  parameter  reflectionTo parameter s ;

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

réflexionVersRetour

Utilisez la fonction reflectionToReturn pour récupérer une instance parameter Interface à partir d’une instance ReflectionFunction ou ReflectionMethod .

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

 use function Chevere  parameter  reflectionToReturn ;

$ parameter = reflectionToReturn ( $ reflection );

parameter reflété Attribut

Utilisez reflected parameter Attribute pour récupérer un objet implémentant parameter AttributeInterface à partir d’une instance 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 );

validé

Utilisez function validated pour valider les arguments d’une fonction ou d’une méthode.

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

 use function Chevere  parameter  validated ;

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

Exemples

Validation en ligne

Validez la chaîne commençant par "a" :

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

 use function Chevere  parameter  string ;

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

Validez un int de valeur min 100 :

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

 use function Chevere  parameter  int ;

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

Validez une liste d'acceptation int :

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

 use function Chevere  parameter  int ;

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

Validez une liste de rejet flottante :

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

Validez un tableau :

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

Validez une liste int itérable :

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

Validez une liste int itérable avec des règles de type de clé de chaîne :

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

Validez une union de type ?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 );

Validation déléguée d'attribut

Utilisez la fonction validated() pour obtenir un retour validé par rapport à toutes les règles.

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

 use function Chevere  parameter  validated ;

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

Utilisez reflectionTo parameter s() pour obtenir les règles de validation des arguments.

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

Utilisez la fonction reflectionToReturn() pour obtenir les règles de validation de la valeur de retour de la fonction/méthode :

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

Validation en ligne des attributs

Utilisez valid() sur le corps de la fonction/méthode pour déclencher la validation des arguments.

Validez une énumération de chaîne pour Hugo , Paco , Luis :
Validez une valeur flottante minimale 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 );

Validez un int de n'importe quelle valeur sauf 0 et 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 );

Valider un ~~méchant~~ tableau imbriqué :

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

Validez la liste int itérable :

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

Utilisez la fonction returnAttr() sur le corps de la fonction/méthode.

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

Validez le retour du tableau :

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

Par convention, en omettant ReturnAttr , la méthode public static function return(): parameter Interface (le cas échéant) sera utilisé pour déterminer les règles de validation de retour.

Documentation

La documentation est disponible sur chevere.org.

Licence

Chevere est sous licence Apache, version 2.0. Voir LICENCE pour le texte complet de la licence.

Sauf disposition contraire de la loi applicable ou accord écrit, le logiciel distribué sous la licence est distribué « EN L'ÉTAT », SANS GARANTIE OU CONDITION D'AUCUNE SORTE, expresse ou implicite. Consultez la licence pour connaître la langue spécifique régissant les autorisations et les limitations en vertu de la licence.

Développer