Params::Check;
use Params::Check qw[check]; sub fill_personal_info { my %hash = @_; my $x; my $tmpl = { firstname => { required => 1, }, lastname => { required => 1, store => \$x }, gender => { required => 1, allow => [qr/M/i, qr/F/i], }, married => { allow => [0,1] }, age => { default => 21, allow => qr/^\d+$/, }, id_list => { default => [], strict_type => 1 }, phone => { allow => sub { my %args = @_; return 1 if &valid($args{phone}); } }, employer => { default => 'NSA', no_override => 1 }, } }; my $parsed_args = check( $tmpl, \%hash, $VERBOSE ) or die [Could not parse arguments!];
Params::Check is a generic input parsing/checking mechanism.
It allows you to validate input via a template. The only requirement is that the arguments must be named.
Params::Check will do the following things for you:
Convert all keys to lowercase
Check if all required arguments have been provided
Set arguments that have not been provided to the default
Weed out arguments that are not supported and warn about them to the user
Validate the arguments given by the user based on strings, regexes, lists or even subroutines
Enforce type integrity if required
Most of Params::Check's power comes from it's template, which we'll discuss below:
As you can see in the synopsis, based on your template, the arguments provided will be validated.
The template can take a different set of rules per key that is used.
The following rules are available:
This is the default value if none was provided by the user. This is also the type strict_type will look at when checking type integrity (see below).
strict_type
A boolean flag that indicates if this argument was a required argument. If marked as required and not provided, check() will fail.
This does a ref() check on the argument provided. The ref of the argument must be the same as the ref of the default value for this check to pass.
ref()
ref
This is very usefull if you insist on taking an array reference as argument for example.
This allows you to specify constants in your template. ie, they keys that are not allowed to be altered by the user. It pretty much allows you to keep all your configurable data in one place; the Params::Check template.
constants
configurable
Params::Check
This allows you to pass a reference to a scalar, in which the data will be stored: my $x; my $args = check($foo => { default => 1, store => \$x }, $input);
This is basically shorthand for saying: my $args = check( { foo => { default => 1 }, $input ); my $x = $args->{foo};
You can alter the global variable $Params::Check::NO_DUPLICATES to control whether the store'd key will still be present in your result yet. See the "Global Variables" section below.
store
A set of criteria used to validate a perticular piece of data if it has to adhere to particular rules. You can use the following types of values for allow:
The provided argument MUST be equal to the string for the validation to pass.
The provided argument MUST equal (or match in case of a regular expression) one of the elements of the array ref for the validation to pass.
The provided argument MUST match the regular expression for the validation to pass.
The provided subroutine MUST return true in order for the validation to pass and the argument accepted.
(This is particularly usefull for more complicated data).
Params::Check only has one function, which is called check.
check
This function is not exported by default, so you'll have to ask for it via:
use Params::Check qw[check];
or use it's fully qualified name instead.
check takes a list of arguments, as follows:
This is a hashreference which contains a template as explained in the synopsis.
This is a reference to a hash of named arguments which need checking.
A boolean to indicate whether check should be verbose and warn about whant went wrong in a check or not.
check will return undef when it fails, or a hashref with lowercase keys of parsed arguments when it succeeds.
So a typical call to check would look like this:
my $parsed = check( \%template, \%arguments, $VERBOSE ) or warn q[Arguments could not be parsed!];
The behaviour of Params::Check can be altered by changing the following global variables:
This controls whether CPANPLUS::Check::Module will issue warnings and explenations as to why certain things may have failed. If you set it to 0, Params::Check will not output any warnings. The default is 1;
This works like the strict_type option you can pass to check, which will turn on strict_type globally for all calls to check. The default is 0;
If you set this flag, unknown options will still be present in the return value, rather than filtered out. This is usefull if your subroutine is only interested in a few arguments, and wants to pass the rest on blindly to perhaps another subroutine. The default is 0;
If you set this flag, all keys passed in the following manner:
function( -key => 'val' );
will have their leading dashes stripped.
If set to true, all keys in the template that are marked as to be stored in a scalar, will also be removed from the result set.
Default is false, meaning that when you use store as a template key, check will put it both in the scalar you supplied, as well as in the hashref it returns.
This module by Jos Boumans <kane@cpan.org>.
Thanks to Ann Barcomb for her suggestions and Thomas Wouters for his patches to support positional arguments.
This module is copyright (c) 2002 Jos Boumans <kane@cpan.org>. All rights reserved.
This library is free software; you may redistribute and/or modify it under the same terms as Perl itself.
To install Params::Check, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Params::Check
CPAN shell
perl -MCPAN -e shell install Params::Check
For more information on module installation, please visit the detailed CPAN module installation guide.