Mojo::Parameters - Parameters

NAME  SYNOPSIS  DESCRIPTION  ATTRIBUTES  charset  METHODS  append  clone  every_param  merge  names  new  pairs  param  parse  remove  to_hash  to_string  OPERATORS  array  bool  stringify  SEE ALSO 

---

NAME

Mojo::Parameters − Parameters

SYNOPSIS

use Mojo::Parameters;
# Parse
my $params = Mojo::Parameters−>new('foo=bar&baz=23');
say $params−>param('baz');
# Build
my $params = Mojo::Parameters−>new(foo => 'bar', baz => 23);
push @$params, i => '⥠mojolicious';
say "$params";

DESCRIPTION

Mojo::Parameters is a container for form parameters used by Mojo::URL, based on RFC 3986 <https://tools.ietf.org/html/rfc3986> and the HTML Living Standard <https://html.spec.whatwg.org>.

ATTRIBUTES

Mojo::Parameters implements the following attributes.

charset

my $charset = $params−>charset;
$params = $params−>charset('UTF−8');

Charset used for encoding and decoding parameters, defaults to "UTF−8".

# Disable encoding and decoding
$params−>charset(undef);

METHODS

Mojo::Parameters inherits all methods from Mojo::Base and implements the following new ones.

append

$params = $params−>append(foo => 'ba&r');
$params = $params−>append(foo => ['ba&r', 'baz']);
$params = $params−>append(foo => ['bar', 'baz'], bar => 23);
$params = $params−>append(Mojo::Parameters−>new);

Append parameters. Note that this method will normalize the parameters.

# "foo=bar&foo=baz"
Mojo::Parameters−>new('foo=bar')−>append(Mojo::Parameters−>new('foo=baz'));
# "foo=bar&foo=baz"
Mojo::Parameters−>new('foo=bar')−>append(foo => 'baz');
# "foo=bar&foo=baz&foo=yada"
Mojo::Parameters−>new('foo=bar')−>append(foo => ['baz', 'yada']);
# "foo=bar&foo=baz&foo=yada&bar=23"
Mojo::Parameters−>new('foo=bar')−>append(foo => ['baz', 'yada'], bar => 23);

clone

my $params2 = $params−>clone;

Return a new Mojo::Parameters object cloned from these parameters.

every_param

my $values = $params−>every_param('foo');

Similar to "param", but returns all values sharing the same name as an array reference. Note that this method will normalize the parameters.

# Get first value
say $params−>every_param('foo')−>[0];

merge

$params = $params−>merge(foo => 'ba&r');
$params = $params−>merge(foo => ['ba&r', 'baz']);
$params = $params−>merge(foo => ['bar', 'baz'], bar => 23);
$params = $params−>merge(Mojo::Parameters−>new);

Merge parameters. Note that this method will normalize the parameters.

# "foo=baz"
Mojo::Parameters−>new('foo=bar')−>merge(Mojo::Parameters−>new('foo=baz'));
# "yada=yada&foo=baz"
Mojo::Parameters−>new('foo=bar&yada=yada')−>merge(foo => 'baz');
# "yada=yada"
Mojo::Parameters−>new('foo=bar&yada=yada')−>merge(foo => undef);

names

my $names = $params−>names;

Return an array reference with all parameter names.

# Names of all parameters
say for @{$params−>names};

new

my $params = Mojo::Parameters−>new;
my $params = Mojo::Parameters−>new('foo=b%3Bar&baz=23');
my $params = Mojo::Parameters−>new(foo => 'b&ar');
my $params = Mojo::Parameters−>new(foo => ['ba&r', 'baz']);
my $params = Mojo::Parameters−>new(foo => ['bar', 'baz'], bar => 23);

Construct a new Mojo::Parameters object and "parse" parameters if necessary.

pairs

my $array = $params−>pairs;
$params = $params−>pairs([foo => 'b&ar', baz => 23]);

Parsed parameter pairs. Note that this method will normalize the parameters.

# Remove all parameters
$params−>pairs([]);

param

my $value = $params−>param('foo');
$params = $params−>param(foo => 'ba&r');
$params = $params−>param(foo => qw(ba&r baz));
$params = $params−>param(foo => ['ba;r', 'baz']);

Access parameter values. If there are multiple values sharing the same name, and you want to access more than just the last one, you can use "every_param". Note that this method will normalize the parameters.

parse

$params = $params−>parse('foo=b%3Bar&baz=23');

Parse parameters.

remove

$params = $params−>remove('foo');

Remove parameters. Note that this method will normalize the parameters.

# "bar=yada"
Mojo::Parameters−>new('foo=bar&foo=baz&bar=yada')−>remove('foo');

to_hash

my $hash = $params−>to_hash;

Turn parameters into a hash reference. Note that this method will normalize the parameters.

# "baz"
Mojo::Parameters−>new('foo=bar&foo=baz')−>to_hash−>{foo}[1];

to_string

my $str = $params−>to_string;

Turn parameters into a string.

# "foo=bar&baz=23"
Mojo::Parameters−>new−>pairs([foo => 'bar', baz => 23])−>to_string;

OPERATORS

Mojo::Parameters overloads the following operators.

array

my @pairs = @$params;

Alias for "pairs". Note that this will normalize the parameters.

say $params−>[0];
say for @$params;

bool

my $bool = !!$params;

Always true.

stringify

my $str = "$params";

Alias for "to_string".

SEE ALSO

Mojolicious, Mojolicious::Guides, <https://mojolicious.org>.

---