Startseite>PHP-Quellcode>Andere Kategorien
Herunterladen

parameter

Zusammenfassung

parameter ist eine Bibliothek rund um parameter -argument, die zusätzliche Funktionalität mit Validierungsregeln und Schema-Introspektion bietet.

Installieren

parameter ist über Packagist verfügbar und die Repository-Quelle befindet sich unter chevere/ parameter . 

composer require chevere/ parameter

Was macht es?

parameter ermöglicht das Erzeugen dynamischer parameter beliebiger Art mit zusätzlichen Regeln.

Zum Beispiel eine Ganzzahl mit dem Mindestwert 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

In Funktions- oder parameter können Sie Attribute verwenden, um Validierungsregeln für parameter und Rückgabewerte zu definieren.

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

Die Validierung kann mithilfe von validated (Beispiel oben), inline und/oder durch Delegieren an einen Caller-Wrapper ausgelöst werden. parameter bietet Hilfsmittel für den Zugriff auf Regeln sowohl für parameter als auch für Rückgabewerte, um den Verkabelungsprozess zu vereinfachen.

Durch jeden parameter definierte Regeln stellen ein für Menschen lesbares Schema bereit, das die Offenlegung der Validierungskriterien ermöglicht.

Wie zu verwenden

parameter stellt eine API bereit, mit der parameter mithilfe von Funktionen und/oder Attributen erstellt werden können. parameter können direkt in der Logik verwendet werden, während Attribute einen Leseschritt erfordern.

Inline-Nutzung

Verwenden Sie die Inline-Validierung, um von hier aus zu gelangen: 

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

Dazu:

parameterint; int(min: 1, max: 10)($var);">
 use function  Chevere  parameter  int ;

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

Attributbasierte Nutzung

Verwenden Sie Attribute, um Regeln für parameter und Rückgabewerte zu definieren.

Verwenden Sie die durch Attribute delegierte Validierung mit der Funktion validated() um Folgendes zu erreichen: 

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

Dazu:

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

Verwenden Sie reflectionTo parameter s und reflectionToReturn -Funktionen zur manuellen Validierung von Argumenten und Rückgabewerten:

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

Verwenden Sie die Attribut-Inline-Validierung für die manuelle Validierung innerhalb des Funktionskörpers:

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

Attribute in PHP unterstützen nur Ausdrücke, die Sie für Klassenkonstanten verwenden können. Es ist nicht möglich, dynamische parameter direkt mithilfe von Attributen zu definieren.

Um diese Einschränkung zu vermeiden, können Sie das CallableAttr -Attribut verwenden, das die Weiterleitung parameter an eine aufrufbare Instanz ermöglicht, die eine parameter Interface zurückgibt.

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

Typen

Ein parameter ist ein Objekt, das parameter Interface implementiert. Jeder parameter kann eine description und einen default sowie je nach Typ zusätzliche Validierungsregeln definieren.

Ein parameter kann mithilfe von Funktionen und/oder Attributen definiert werden, er benötigt für beide dieselben Argumente.

Beim Aufrufen eines parameter $param('value') wird eine Validierung anhand des übergebenen Arguments ausgelöst.

Zeichenfolge

Verwenden Sie die Funktion string um einen String parameter zu erstellen. Übergeben Sie einen regex für den String-Abgleich.

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

Verwenden Sie StringAttr Attribut, um einen String- parameter zu definieren.

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

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

String- parameter s

Die folgenden parameter basieren auf String.

Enum-String

Verwenden Sie die Funktion enum um einen String parameter zu erstellen, der einer Liste von Strings entspricht.

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

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

Verwenden Sie EnumAttr Attribut, um einen Enum-String- parameter zu definieren.

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

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

Int-String

Verwenden Sie die Funktion intString um einen String parameter zu erstellen, der einer Zeichenfolge mit Ganzzahlen entspricht.

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

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

Bool-String

Verwenden Sie die Funktion boolString um einen String parameter zu erstellen, der mit 0 und 1 -Strings übereinstimmt.

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

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

Datumszeichenfolge

Verwenden Sie die Funktion date , um einen String parameter zu erstellen, der mit den Strings YYYY-MM-DD übereinstimmt.

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

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

Zeitzeichenfolge

Verwenden Sie die Funktion time um einen String parameter zu erstellen, der mit hh:mm:ss -Strings übereinstimmt.

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

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

Datum/Uhrzeit-Zeichenfolge

Verwenden Sie die Funktion datetime , um einen String parameter zu erstellen, der mit YYYY-MM-DD hh:mm:ss -Strings übereinstimmt.

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

Verwenden Sie die Funktion int um einen Int parameter zu erstellen. Übergeben Sie min und max -Werte für den Ganzzahlbereich, accept eine Liste akzeptierter Ganzzahlen und reject .

parameterint; // Any int $int = int(); $int(1); // Integer between 0 and 100 $int = int(min: 0, max: 100); $int(50); // Integer matching 1, 2 or 3 $int = int(accept: [1, 2, 3]); $int(2); // Integer not-matching 1, 2 or 3 $int = int(reject: [1, 2, 3]); $int(4);">
 use function Chevere  parameter  int ;

// Any int
$ int = int ();
$ int ( 1 );
// Integer between 0 and 100
$ int = int (min: 0 , max: 100 );
$ int ( 50 );
// Integer matching 1, 2 or 3
$ int = int (accept: [ 1 , 2 , 3 ]);
$ int ( 2 );
// Integer not-matching 1, 2 or 3
$ int = int (reject: [ 1 , 2 , 3 ]);
$ int ( 4 );

Verwenden Sie IntAttr -Attribut, um einen ganzzahligen parameter zu definieren.

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

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

Int parameter s

Die folgenden parameter basieren auf Int.

Bool int

Verwenden Sie die Funktion boolInt um einen Int parameter zu erstellen, der den Ganzzahlen 0 und 1 entspricht.

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

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

Schweben

Verwenden Sie die Funktion float um einen Float parameter zu erstellen. Übergeben Sie min und max Werte für den Float-Bereich, accept eine Liste akzeptierter Floats und reject um eine Liste abgelehnter Floats zu erhalten.

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

Verwenden Sie FloatAttr Attribut, um einen Float- parameter zu definieren.

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

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

Bool

Verwenden Sie die Funktion bool um einen Bool parameter zu erstellen.

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

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

Verwenden Sie BoolAttr Attribut, um einen Bool parameter zu definieren.

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

#[BoolAttr]

Null

Verwenden Sie die Funktion null um einen Null parameter zu erstellen.

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

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

Verwenden Sie das NullAttr -Attribut, um einen parameter zu definieren.

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

#[NullAttr]

Objekt

Verwenden Sie das object , um einen Object parameter zu erstellen. Übergeben Sie einen Klassennamen für den Namen der Objektklasse.

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

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

Verwenden Sie das ObjectAttr Attribut, um einen parameter zu definieren.

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

#[ObjectAttr(stdClass::class)]

Gemischt

Verwenden Sie die Funktion mixed um einen Mixed parameter zu erstellen.

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

Verwenden Sie die Funktion union um einen Union parameter zu erstellen. Übergeben Sie eine Liste von parameter , die übereinstimmen sollen. Der Zielwert muss mit mindestens einem übereinstimmen.

parameterunion; // Any string or null $union = union(string(), null()); $union('abc'); $union(null); // Any digit string or any integer $union = union( intString(), integer() ); $union('100'); $union(100);">
 use function Chevere  parameter  union ;

// Any string or null
$ union = union ( string (), null());
$ union ( ' abc ' );
$ union ( null );
// Any digit string or any integer
$ union = union (
    intString (),
    integer ()
);
$ union ( ' 100 ' );
$ union ( 100 );

Array

parameter für den Typ array wird als zusammengesetzter parameter behandelt, der parameter für jedes seiner Mitglieder enthält.

Verwenden Sie die Funktion arrayp um einen Array parameter für benannte Argumente als erforderliche Array-Schlüssel zu erstellen.

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 unterstützt verschachtelte Arrays beliebiger Tiefe:

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

Verwenden Sie ArrayAttr Attribut, um einen Array- parameter zu definieren.

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

Mit erforderlich

Verwenden Sie die Methode withRequired um die erforderlichen parameter zu definieren. 

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

Mit optional

Verwenden Sie die Methode withOptional um optionale parameter zu definieren. 

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

Hinweis: Optionale parameter werden nur validiert, wenn ein passender Schlüssel bereitgestellt wird.

Mit modifizieren

Verwenden Sie die Methode withModify um parameter zu definieren. 

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

Mit make optional

Verwenden Sie die Methode withMakeOptional um erforderliche parameter optional zu machen. 

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

Mit Marke erforderlich

Verwenden Sie die Methode withMakeRequired um optionale parameter erforderlich zu machen. 

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

Ohne

Verwenden Sie die Methode without um parameter s zu entfernen. 

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

Mit optionalem Minimum

Verwenden Sie die Methode withOptionalMinimum um eine Mindestanzahl optionaler parameter zu definieren. Nützlich, wenn alle parameter bis auf 1 optional sind. 

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

Array- parameter s

Die folgenden parameter basieren auf Array.

Array-String

Verwenden Sie die Funktion arrayString um eine ArrayString parameter Interface für Zeichenfolgenwerte zu erstellen. Es werden nur String- parameter unterstützt.

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

Datei

Verwenden Sie die Funktion file “, um einen Array parameter für Datei-Uploads zu erstellen.

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

Standardmäßig bietet es eine Validierung für die Form $_FILES , Sie können jedoch Ihre eigenen Validierungsregeln definieren. Um beispielsweise Namen und Inhalt zu validieren:

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

Iterierbar

Der iterierbare Typ Traversable|array wird als zusammengesetzter parameter betrachtet, der eine generische Definition für Schlüssel und Wert enthält. parameter ermöglicht die Beschreibung dieser Sammlung von Elementen mit derselben Form.

Verwenden Sie die Funktion iterable um einen Iterable parameter zu erstellen. Übergeben Sie einen V und K parameter s für den generischen Schlüssel und Wert.

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

Es funktioniert auch mit benannten Schlüsseln:

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

Helfer

parameter s

Verwenden Sie parameter s um eine parameter s zu erstellen.

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

Argumente

Verwenden Sie arguments um eine Arguments Instanz zu erstellen.

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

behauptenNamedArgument

Verwenden Sie die Funktion assertNamedArgument , um ein benanntes Argument zu bestätigen.

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

zum parameter

Verwenden Sie die Funktion „Funktion to parameter um eine parameter Interface aus einer Typzeichenfolge zu erstellen. Im folgenden Beispiel ist der resultierende $ parameter ein Int parameter .

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

$ parameter = to parameter ( ' int ' );

arrayFrom

Verwenden Sie die Funktion arrayFrom um einen Array parameter aus einem anderen Array- parameter zu erstellen. Im folgenden Beispiel enthält das resultierende $array nur name und id -Schlüssel, wie in $source definiert.

parametersarrayFrom; use function Chevere parameter sarrayp; use function Chevere parameter sint; use function Chevere parameter sstring; $source = arrayp( id: int(), name: string(), email: string(), age: int(), ); $array = arrayFrom($source, 'name', 'id');">
 use function Chevere  parameter s  arrayFrom ;
use function Chevere  parameter s  arrayp ;
use function Chevere  parameter s  int ;
use function Chevere  parameter s  string ;

$ source = arrayp (
    id: int (),
    name: string (),
    email: string (),
    age: int (),
);
$ array = arrayFrom ( $ source , ' name ' , ' id ' );

takeKeys

Verwenden Sie die Funktion takeKeys um ein Array mit den Schlüsseln eines parameter abzurufen. Im folgenden Beispiel enthalten $keys id und size .

parametersarrayp; use function Chevere parameter sint; use function Chevere parameter stakeKeys; $array = arrayp( id: int(), size: int(), ); $keys = takeKeys($array);">
 use function Chevere  parameter s  arrayp ;
use function Chevere  parameter s  int ;
use function Chevere  parameter s  takeKeys ;

$ array = arrayp (
    id: int (),
    size: int (),
);
$ keys = takeKeys ( $ array );

takeFrom

Verwenden Sie die Funktion takeFrom um einen Iterator mit den gewünschten Schlüsseln aus einem parameter abzurufen. Im folgenden Beispiel liefert $iterator size und 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

Verwenden Sie den Funktionsparameter parameter sFrom um einen parameter s mit den gewünschten Schlüsseln aus einem parameter zu erstellen. Im folgenden Beispiel enthalten $ parameter s size und name .

parametersarrayp; use function Chevere parameter sint; use function Chevere parameter sstring; use function Chevere parameter s parameter sFrom; $array = arrayp( id: int(min: 0), size: int(min: 100), name: string(), ); $ parameter s = parameter sFrom($array, 'size', 'name');">
 use function Chevere  parameter s  arrayp ;
use function Chevere  parameter s  int ;
use function Chevere  parameter s  string ;
use function Chevere  parameter s  parameter sFrom ;

$ array = arrayp (
    id: int (min: 0 ),
    size: int (min: 100 ),
    name: string (),
);
$ parameter s = parameter sFrom ( $ array , ' size ' , ' name ' );

parameter s abrufen

Verwenden Sie die Funktion get parameter s , um eine parameter s von einem Objekt abzurufen, das entweder parameter AccessInterface oder parameter sInterface implementiert.

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

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

getType

Verwenden Sie die Funktion getType um den Typ abzurufen, der dieser Bibliothek bekannt ist.

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

$ type = getType ( 1 ); // int

parameter Attr

Verwenden Sie den Funktionsparameter parameter Attr um ein Objekt abzurufen, das parameter AttributeInterface aus einem Funktions- oder parameter implementiert.

parameter Attr; use Chevere parameter AttributesStringAttr; function myFunction( #[StringAttr('/^bin-[d]+$/')] string $foo ): void { // ... } $stringAttr = parameter Attr('foo', 'myFunction'); $stringAttr('bin-123');">
 use function Chevere  parameter s  parameter Attr ;
use Chevere  parameter  Attributes  StringAttr ;


function myFunction (
    #[StringAttr( ' /^bin-[d]+$/ ' )]
    string $ foo
): void {
    // ...
}

$ stringAttr = parameter Attr ( ' foo ' , ' myFunction ' );
$ stringAttr ( ' bin-123 ' );

ReflectionTo- parameter s

Verwenden Sie die Funktion reflectionTo parameter s um eine parameter s aus einer ReflectionFunction oder ReflectionMethod Instanz abzurufen.

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

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

ReflexionToReturn

Verwenden Sie die Funktion reflectionToReturn , um eine parameter Interface aus einer ReflectionFunction oder ReflectionMethod Instanz abzurufen.

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

$ parameter = reflectionToReturn ( $ reflection );

Reflektiertes parameter

Verwenden Sie reflected parameter Attribute der Funktion, um ein Objekt abzurufen, das parameter AttributeInterface aus einer Reflection parameter Parameterinstanz implementiert.

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

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

validiert

Verwenden Sie „function validated um eine Funktion oder Methodenargumente zu validieren.

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

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

Beispiele

Inline-Validierung

  • Validieren Sie die Zeichenfolge, die mit „a“ beginnt:
parameterstring; $value = 'ahhh'; string('/^a.+/')($value);">
 use function Chevere  parameter  string ;

$ value = ' ahhh ' ;
string ( ' /^a.+/ ' )( $ value );
  • Validieren Sie ein int mit einem Mindestwert von 100 :
parameterint; $value = 100; int(min: 100)($value);">
 use function Chevere  parameter  int ;

$ value = 100 ;
int (min: 100 )( $ value );
  • Validieren Sie eine int-Akzeptanzliste:
parameterint; $value = 1; int(accept: [1, 2, 3])($value);">
 use function Chevere  parameter  int ;

$ value = 1 ;
int (accept: [ 1 , 2 , 3 ])( $ value );
  • Validieren Sie eine Float-Ablehnungsliste:
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 );
  • Ein Array validieren:
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 );
  • Validieren Sie eine iterierbare int Liste:
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 );
  • Validieren Sie eine iterierbare int-Liste mit Regeln für den String-Schlüsseltyp:
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 );
  • Validieren Sie eine Union vom Typ ?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 );

Attributdelegierte Validierung

  • Verwenden Sie die Funktion validated() um eine Rückgabe anhand aller Regeln validieren zu lassen.
parametervalidated; $result = validated('myFunction', $var);">
 use function Chevere  parameter  validated ;

$ result = validated ( ' myFunction ' , $ var );
  • Verwenden Sie den reflectionTo parameter s() um Regeln für die Validierung von Argumenten abzurufen.
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 );
  • Verwenden Sie die FunktionreflexionToReturn reflectionToReturn() um Regeln für die Validierung des Funktions-/Methodenrückgabewerts abzurufen:
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

Attribut-Inline-Validierung

Verwenden Sie valid() für den Funktions-/Methodenkörper, um die Validierung für Argumente auszulösen.

  • Validieren Sie eine String-Enumeration für Hugo , Paco , Luis :
  • Validieren Sie einen minimalen Float-Wert von 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 );
  • Validieren Sie ein int mit einem beliebigen Wert außer 0 und 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 );
  • Validieren Sie a böse verschachteltes Array:
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 );
  • Iterierbare int-Liste validieren:
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 ();
}

Verwenden Sie die Funktion returnAttr() für den Funktions-/Methodenkörper.

  • Validieren 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 );
}
  • Array-Rückgabe validieren:
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 );
}

Konventionell wird beim Weglassen von ReturnAttr die Methode public static function return(): parameter Interface (falls vorhanden) verwendet, um die Rückgabevalidierungsregeln zu bestimmen.

Dokumentation

Die Dokumentation ist unter chevere.org verfügbar.

Lizenz

Copyright Rodolfo Berrios A.

Chevere ist unter der Apache-Lizenz, Version 2.0, lizenziert. Den vollständigen Lizenztext finden Sie unter LIZENZ.

Sofern nicht durch geltendes Recht vorgeschrieben oder schriftlich vereinbart, wird die im Rahmen der Lizenz vertriebene Software „WIE BESEHEN“ und OHNE GEWÄHRLEISTUNGEN ODER BEDINGUNGEN JEGLICHER ART, weder ausdrücklich noch stillschweigend, vertrieben. Die spezifische Sprache, die die Berechtigungen und Einschränkungen im Rahmen der Lizenz regelt, finden Sie in der Lizenz.

Expandieren
Zusätzliche Informationen
Ähnliche Anwendungen
Empfohlen für Sie
Ähnliche Nachrichten Alle