NAME¶
Data::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 GitHub repository
<
http://github.com/theory/data-types/>. Feel free to fork and
contribute!
Please file bug reports via GitHub Issues
<
http://github.com/theory/data-types/issues/> or by sending mail to
bug-Data-Types.cpan.org <mailto:bug-Data-Types.cpan.org>.
Patches against Class::Meta are welcome. Please send bug reports to
<bug-data-types@rt.cpan.org>.
AUTHOR¶
David E. Wheeler <david@justatheory.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-2011, David E. Wheeler. Some Rights Reserved.
This module is free software; you can redistribute it and/or modify it under the
same terms as Perl itself.