/ 
String-Random-0.196
River stage two • 53 direct dependents • 66 total dependents
/ String::Random

NAME

String::Random - Perl module to generate random strings based on a pattern

SYNOPSIS

use String::Random;
$foo = new String::Random;
print $foo->randregex('\d\d\d'); # Prints 3 random digits
print $foo->randpattern("...");  # Prints 3 random printable characters

or

use String::Random qw(random_string);
print random_string("..."); # Also prints 3 random characters

DESCRIPTION

This module makes it trivial to generate random strings.

As an example, let's say you are writing a script that needs to generate a random password for a user. The relevant code might look something like this:

use String::Random;
$pass = new String::Random;
print "Your password is ", $pass->randpattern("CCcc!ccn"), "\n";

This would output something like this:

Your password is UDwp$tj5

Patterns

The pre-defined patterns are as follows:

c	Any lowercase character [A-Z]
C	Any uppercase character [a-z]
n	Any digit [0-9]
!	A punctuation character [~`!@$%^&*()-_+={}[]|\:;"'.<>?/#,]
.	Any of the above
s	A "salt" character [A-Za-z0-9./]

These can be modified, but if you need a different pattern it is better to create another pattern, possibly using one of the pre-defined as a base. For example, if you wanted a pattern A that contained all upper and lower case letters ([A-Za-z]), the following would work:

$foo = new String::Random;
$foo->{'A'} = [ 'A'..'Z', 'a'..'z' ];

or

$foo = new String::Random;
$foo->{'A'} = [ @{$foo->{'C'}}, @{$foo->{'c'}} ];

The random_string function, described below, has an alternative interface for adding patterns.

Methods

randpattern LIST

The randpattern method returns a random string based on the concatenation of all the pattern strings in the list.

Please note that in a future revision, it will return a list of random strings corresponding to the pattern strings when used in list context.

randregex LIST

The randregex method returns a random string that will match the regular expression passed in the list argument.

Please note that the arguments to randregex are not real regular expressions. Only a small subset of regular expression syntax is actually supported. So far, the following regular expression elements are supported:

[]	Character classes
{}    Repetition
\w    Alphanumeric + "_".
\d    Digits.
\W    Printable characters other than those in \w.
\D    Printable characters other than those in \d.

Regular expression support is still very experimental. Currently special characters inside [] are not supported (with the exception of "-" to denote ranges of characters). The parser doesn't care for spaces in the "regular expression" either.

Functions

random_string PATTERN,LIST
random_string PATTERN

When called with a single scalar argument, random_string returns a random string using that scalar as a pattern. Optionally, references to lists containing other patterns can be passed to the function. Those lists will be used for 0 through 9 in the pattern (meaning the maximum number of lists that can be passed is 10). For example, the following code:

print random_string("0101",
                    ["a", "b", "c"],
                    ["d", "e", "f"]), "\n";

would print something like this:

cebd

BUGS

As noted above, randpattern doesn't do the right thing when called in a list context. Whether it does the right thing in a scalar context when passed a list is up for debate.

I don't even want to think about what kind of bugs might be in randregex at this point.

AUTHOR

Steven Pritchard <steve@silug.org>

SEE ALSO

perl(1).