Data::Types(3) User Contributed Perl Documentation Data::Types(3)NAMEData::Types - Validate and convert data types.
SYNOPSIS
use Data::Types qw(:all);
my $whole = 4.5;
$whole = to_whole($whole) unless is_whole($whole);
my $int = 1.2;
$int = to_int($int) unless is_int($int);
my $decimal = '1.2foo';
$decimal = to_decimal($decimal) unless is_decimal($decimal);
my $real = '1.2foo';
$real = to_real($real) unless is_real($real);
my $float = '1.2foo';
$float = to_float($float) unless is_float($float);
my $string = [];
$string = to_string($string) unless is_string($string);
DESCRIPTION
This module exports a number of functions that are useful for
validating and converting data types. It is intended for use in
applications where data types are more important than they typically
are in Perl -- e.g., database applications.
EXPORT
No functions are exported by default, though each function may be
exported explicitly (see "Functions", below, for a list of functions
available for export). The following export tags are supported:
:whole
Exports is_whole() and to_whole().
:count
Exports is_count() and to_count().
:int
Exports is_int() and to_int().
:decimal
Exports is_decimal() and to_decimal().
:real
Exports is_real() and to_real().
:float
Exports is_float() and to_float().
:string
Exports is_string() and to_string().
:is Exports all validation functions: is_whole(), is_int(), is_real(),
is_decimal(), is_float(), and is_string().
:to Exports all conversion functions: to_whole(), to_int(), to_real(),
to_decimal(), to_float(), and to_string().
:all
Exports all functions.
FUNCTIONS
is_whole
my $bool = is_whole($val);
Returns true if $val is a whole number (including 0), and false if it
is not. The regular expression used to test the wholeness of $val is
"/^\d+$/".
my $bool = is_whole(1); # Returns true.
$bool = is_whole(-1); # Returns false.
$bool = is_whole(0); # Returns true.
to_whole
my $whole = to_whole($val);
Converts $val to a whole number and returns it. Numbers will be rounded
to the nearest whole. If $val is a mixture of numbers and letters,
to_whole() will extract the first decimal number it finds and convert
that number to a whole number.
my $whole = to_whole(10); # Returns 10.
$whole = to_whole(0); # Returns 0.
$whole = to_whole(.22); # Returns 0.
$whole = to_whole(-2); # Returns undef.
$whole = to_whole('foo3.56'); # Returns 4.
$whole = to_whole('foo'); # Returns undef.
is_count
my $bool = is_count($val);
Returns true if $val is a counting number (1, 2, 3, ...), and false if
it is not. The regular expression used to test whether $val is a
counting number is "/^\d+$/".
my $bool = is_count(1); # Returns true.
$bool = is_count(-1); # Returns false.
$bool = is_count(0); # Returns false.
to_count
my $count = to_count($val);
Converts $val to a counting number and returns it. Numbers will be
rounded to the nearest counting number. Note that since 0 (zero) is not
considered a counting number by this module, it will not be returned.
If $val is a mixture of numbers and letters, to_count() will extract
the first decimal number it finds and convert that number to a counting
number.
my $count = to_count(10); # Returns 10.
$count = to_count(0); # Returns undef.
$count = to_count(.22); # Returns undef (rounded down to 0).
$count = to_count(-2); # Returns undef.
$count = to_count('foo3.56'); # Returns 4.
$count = to_count('foo'); # Returns undef.
is_int
my $bool = is_int($val);
Returns true if $val is an integer, and false if it is not. Numbers may
be preceded by a plus or minus sign. The regular expression used to
test for an integer in $val is "/^[+-]?\d+$/".
my $bool = is_int(0); # Returns true.
$bool = is_int(22); # Returns true.
$bool = is_int(-22); # Returns false.
$bool = is_int(3.2); # Returns false.
to_int
my $int = to_int($val);
Converts $val to an integer. If $val is a decimal number, it will be
rounded to the nearest integer. If $val is a mixture of numbers and
letters, to_int() will extract the first decimal number it finds and
convert that number to an integer.
my $int = to_int(10.5); # Returns 10.
$int = to_int(10.51); # Returns 11.
$int = to_int(-0.22); # Returns 0.
$int = to_int(-6.51); # Returns 7.
$int = to_int('foo'); # Returns undef.
is_decimal
my $bool = is_decimal($val);
Returns true if $val is a decimal number, and false if it is not.
Numbers may be preceded by a plus or minus sign. The regular expression
used to test $val is "/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/".
my $bool = is_decimal(10) # Returns true.
$bool = is_decimal(10.8) # Returns true.
$bool = is_decimal(-33.48) # Returns true.
$bool = is_decimal((1.23e99) # Returns false.
to_decimal
my $dec = to_decimal($val);
$dec = to_decimal($val, $precision);
Converts $val to a decimal number. The optional second argument sets
the precision of the number. The default precision is 5. If $val is a
mixture of numbers and letters, to_decimal() will extract the first
decimal number it finds.
my $dec = to_decimal(0); # Returns 0.00000.
$dec = to_decimal(10.5); # Returns 10.5.
$dec = to_decimal(10.500009); # Returns 10.50001.
$dec = to_decimal(10.500009, 7); # Returns 10.5000090.
$dec = to_decimal('foo10.3') # Returns 10.30000.
$dec = to_decimal('foo-4.9') # Returns -4.90000.
$dec = to_decimal('foo') # Returns undef.
is_real
my $bool = is_real($val);
Returns true if $val is a real number, and false if it is not.
Note: This function is currently equivalent to is_decimal(), since this
module cannot identify non-decimal real numbers (e.g., irrational
numbers). This implementation may change in the future.
to_real
my $real = to_real($val);
$real = to_real($val, $precision);
Converts $val to a real number.
Note: Currently, this function is the equivalent of to_decimal(), since
this module cannot identify non-decimal real numbers (e.g., irrational
numbers). This implementation may change in the future.
is_float
my $bool = is_real($val);
Returns true if $val is a float, and false if it is not. The regular
expression used to test $val is
"/^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/".
my $bool = is_real(30); # Returns true.
$bool = is_real(1.23e99); # Returns true.
$bool = is_real('foo'); # Returns false.
to_float
my $dec = to_float($val);
$dec = to_float($val, $precision);
Converts $val to a float. The optional second argument sets the
precision of the number. The default precision is 5. If $val is a
mixture of numbers and letters, to_float() will extract the first float
it finds.
my $float = to_float(1.23); # Returns 1.23000.
$float = to_float(1.23e99); # Returns 1.23000e+99.
$float = to_float(1.23e99, 1); # Returns 1.2e+99.
$float = to_float('foo-1.23'); # Returns -1.23000.
$float = to_float('ick_1.23e99foo'); # Returns 1.23000e+99.
is_string
my $bool = is_string($val);
Returns true if $val is a string, and false if it is not. All defined
non-references are considered strings.
my $bool = is_string('foo'); # Returns true.
$bool = is_string(20001); # Returns true.
$bool = is_string([]); # Returns false.
$bool = is_string(undef); # Returns false.
to_string
my $string = to_string($val);
$string = to_string($val, $length);
Converts $val into a string. If $val is a reference, the string value
of the reference will be returned. Such a value may be a memory
address, or some other value, if the stringification operator has been
overridden for the object stored in $val. If the optional second
argument $length is passed, to_string() will truncate the string to
that length. If $length is 0 (zero), it will not limit the length of
the return string. If $val is undefined, to_string() will return undef.
my $string = to_string('foo'); # Returns 'foo'.
$string = to_string([]); # Returns 'ARRAY(0x101bec14)'.
$string = to_string(undef); # Returns undef.
$string = to_string('hello', 4); # Returns 'hell'.
SUPPORT
This module is stored in an open repository at the following address:
https://svn.kineticode.com/Data-Types/trunk/
<https://svn.kineticode.com/Data-Types/trunk/>
Patches against Data::Types are welcome. Please send bug reports to
<bug-data-types@rt.cpan.org>.
AUTHOR
David Wheeler <david@kineticode.com>
SEE ALSO
perlfaq4 lists the most of the regular expressions used to identify the
different numeric types used in this module.
String::Checker also does some data type validation.
String::Scanf reimplements the C "sscanf()" function in perl, and also
does data type validation and conversion.
Regexp::Common contains many useful common regular expressions
(surprise!), including some that can be used to identify data types.
Arthur Bergman's types pragma, offers compile-time data types for Perl
5.8.0. The data types include int, float, and string. I highly
recommend using this prgrma for fast, static data types.
COPYRIGHT AND LICENSE
Copyright (c) 2002-2008, David Wheeler. Some Rights Reserved.
This module is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.
perl v5.14.1 2011-06-20 Data::Types(3)
