在线时间:8:00-16:00
迪恩网络APP
随时随地掌握行业动态
扫描二维码
关注迪恩网络微信公众号
开源软件名称:nette/schema开源软件地址:https://github.com/nette/schema开源编程语言:PHP 100.0%开源软件介绍:Nette Schema IntroductionA practical library for validation and normalization of data structures against a given schema with a smart & easy-to-understand API. Documentation can be found on the website. Installation: composer require nette/schema It requires PHP version 8.0 and supports PHP up to 8.1. Support MeDo you like Nette Schema? Are you looking forward to the new features? Thank you! Basic UsageIn variable The task is handled by the Nette\Schema\Processor class, which processes the input and either returns normalized data or throws an Nette\Schema\ValidationException exception on error. $processor = new Nette\Schema\Processor;
try {
$normalized = $processor->process($schema, $data);
} catch (Nette\Schema\ValidationException $e) {
echo 'Data is invalid: ' . $e->getMessage();
} Method Defining SchemaAnd now let's create a schema. The class Nette\Schema\Expect is used to define it, we actually define expectations of what the data should look like. Let's say that the input data must be a structure (e.g. an array) containing elements use Nette\Schema\Expect;
$schema = Expect::structure([
'processRefund' => Expect::bool(),
'refundAmount' => Expect::int(),
]); We believe that the schema definition looks clear, even if you see it for the very first time. Lets send the following data for validation: $data = [
'processRefund' => true,
'refundAmount' => 17,
];
$normalized = $processor->process($schema, $data); // OK, it passes The output, i.e. the value All elements of the structure are optional and have a default value $data = [
'refundAmount' => 17,
];
$normalized = $processor->process($schema, $data); // OK, it passes
// $normalized = {'processRefund' => null, 'refundAmount' => 17} The fact that the default value is An item can be made mandatory using And what if we wanted to accept $schema = Expect::structure([
'processRefund' => Expect::anyOf(true, false, 1, 0)->castTo('bool'),
'refundAmount' => Expect::int(),
]);
$normalized = $processor->process($schema, $data);
is_bool($normalized->processRefund); // true Now you know the basics of how the schema is defined and how the individual elements of the structure behave. We will now show what all the other elements can be used in defining a schema. Data Types: type()All standard PHP data types can be listed in the schema: Expect::string($default = null)
Expect::int($default = null)
Expect::float($default = null)
Expect::bool($default = null)
Expect::null()
Expect::array($default = []) And then all types supported by the Validators via You can also use union notation: Expect::type('bool|string|array') The default value is always Array of Values: arrayOf() listOf()The array is too general structure, it is more useful to specify exactly what elements it can contain. For example, an array whose elements can only be strings: $schema = Expect::arrayOf('string');
$processor->process($schema, ['hello', 'world']); // OK
$processor->process($schema, ['a' => 'hello', 'b' => 'world']); // OK
$processor->process($schema, ['key' => 123]); // ERROR: 123 is not a string The list is an indexed array: $schema = Expect::listOf('string');
$processor->process($schema, ['a', 'b']); // OK
$processor->process($schema, ['a', 123]); // ERROR: 123 is not a string
$processor->process($schema, ['key' => 'a']); // ERROR: is not a list
$processor->process($schema, [1 => 'a', 0 => 'b']); // ERROR: is not a list The parameter can also be a schema, so we can write: Expect::arrayOf(Expect::bool()) The default value is an empty array. If you specify default value and call Enumeration: anyOf()
$schema = Expect::listOf(
Expect::anyOf('a', true, null)
);
$processor->process($schema, ['a', true, null, 'a']); // OK
$processor->process($schema, ['a', false]); // ERROR: false does not belong there The enumeration elements can also be schemas: $schema = Expect::listOf(
Expect::anyOf(Expect::string(), true, null)
);
$processor->process($schema, ['foo', true, null, 'bar']); // OK
$processor->process($schema, [123]); // ERROR The default value is StructuresStructures are objects with defined keys. Each of these key => value pairs is referred to as a "property": Structures accept arrays and objects and return objects By default, all properties are optional and have a default value of $schema = Expect::structure([
'required' => Expect::string()->required(),
'optional' => Expect::string(), // the default value is null
]);
$processor->process($schema, ['optional' => '']);
// ERROR: item 'required' is missing
$processor->process($schema, ['required' => 'foo']);
// OK, returns {'required' => 'foo', 'optional' => null} Although $schema = Expect::structure([
'optional' => Expect::string(),
'nullable' => Expect::string()->nullable(),
]);
$processor->process($schema, ['optional' => null]);
// ERROR: 'optional' expects to be string, null given.
$processor->process($schema, ['nullable' => null]);
// OK, returns {'optional' => null, 'nullable' => null} By default, there can be no extra items in the input data: $schema = Expect::structure([
'key' => Expect::string(),
]);
$processor->process($schema, ['additional' => 1]);
// ERROR: Unexpected item 'additional' Which we can change with $schema = Expect::structure([
'key' => Expect::string(),
])->otherItems(Expect::int());
$processor->process($schema, ['additional' => 1]); // OK
$processor->process($schema, ['additional' => true]); // ERROR DeprecationsYou can deprecate property using the $schema = Expect::structure([
'old' => Expect::int()->deprecated('The item %path% is deprecated'),
]);
$processor->process($schema, ['old' => 1]); // OK
$processor->getWarnings(); // ["The item 'old' is deprecated"] Ranges: min() max()Use // array, at least 10 items, maximum 20 items
Expect::array()->min(10)->max(20); For strings, limit their length: // string, at least 10 characters long, maximum 20 characters
Expect::string()->min(10)->max(20); For numbers, limit their value: // integer, between 10 and 20 inclusive
Expect::int()->min(10)->max(20); Of course, it is possible to mention only // string, maximum 20 characters
Expect::string()->max(20); Regular Expressions: pattern()Using // just 9 digits
Expect::string()->pattern('\d{9}'); Custom Assertions: assert()You can add any other restrictions using $countIsEven = function ($v) { return count($v) % 2 === 0; };
$schema = Expect::arrayOf('string')
->assert($countIsEven); // the count must be even
$processor->process($schema, ['a', 'b']); // OK
$processor->process($schema, ['a', 'b', 'c']); // ERROR: 3 is not even Or Expect::string()->assert('is_file'); // the file must exist You can add your own description for each assertions. It will be part of the error message. $schema = Expect::arrayOf('string')
->assert($countIsEven, 'Even items in array');
$processor->process($schema, ['a', 'b', 'c']);
// Failed assertion "Even items in array" for item with value array. The method can be called repeatedly to add more assertions. Mapping to Objects: from()You can generate structure schema from the class. Example: class Config
{
/** @var string */
public $name;
/** @var string|null */
public $password;
/** @var bool */
public $admin = false;
}
$schema = Expect::from(new Config);
$data = [
'name' => 'jeff',
];
$normalized = $processor->process($schema, $data);
// $normalized instanceof Config
// $normalized = {'name' => 'jeff', 'password' => null, 'admin' => false} If you are using PHP 7.4 or higher, you can use native types: class Config
{
public string $name;
public ?string $password;
public bool $admin = false;
}
$schema = Expect::from(new Config); Anonymous classes are also supported: $schema = Expect::from(new class {
public string $name;
public ?string $password;
public bool $admin = false;
}); Because the information obtained from the class definition may not be sufficient, you can add a custom schema for the elements with the second parameter: $schema = Expect::from(new Config, [
'name' => Expect::string()->pattern('\w:.*'),
]); Casting: castTo()Successfully validated data can be cast: Expect::scalar()->castTo('string'); In addition to native PHP types, you can also cast to classes: Expect::scalar()->castTo('AddressEntity'); Normalization: before()Prior to the validation itself, the data can be normalized using the method $explode = function ($v) { return explode(' ', $v); };
$schema = Expect::arrayOf('string')
->before($explode);
$normalized = $processor->process($schema, 'a b c');
// OK, returns ['a', 'b', 'c'] |
2023-10-27
2022-08-15
2022-08-17
2022-09-23
2022-08-13
请发表评论