출처 : http://www.perlmeme.org/howtos/perlfunc/
The chomp() function will remove (usually) any newline character from the end of a string. The reason we say usually is that it actually removes any character that matches the current value of $/ (the input record separator), and $/ defaults to a newline.
For more information on the $/ variable, try perldoc perlvar and see the entry for $/.
Most often you will use chomp() when reading data from a file or from a user. When reading user input from the standard input stream (STDIN) for instance, you get a newline character with each line of data. chomp() is really useful in this case because you do not need to write a regular expression and you do not need to worry about it removing needed characters.
When running the example below, using the enter key on a line by itself will exit the program.
#!/usr/bin/perl
use strict;
use warnings;
while (my $text = <STDIN>) {
chomp($text);
print "You entered '$text'\n";
last if ($text eq '');
}
Example usage and output of this program is:
a word
You entered 'a word'
some text
You entered 'some text'
You entered ''
If you chomp an array, it will remove a newline from the end of every element in the array:
#!/usr/bin/perl
use strict;
use warnings;
my @array = ("bob\n", "jill", "fred\n");
print "Before chomp:\n";
print "@array\n";
chomp(@array);
print "After chomp:\n";
print "@array\n";
This program produces the following output:
Before chomp:
bob
jill fred
After chomp:
bob jill fred
As you can see, the newlines have been removed from "bob" and "fred", but no characters have been removed from "jill".
If you pass a hash into chomp(), it will remove newlines from every value (not key) of the hash:
#!/usr/bin/perl
use strict;
use warnings;
my %hash = (
'first' => "one\n",
'second' => "two\n",
'third' => "three\n",
);
chomp(%hash);
foreach my $k (keys %hash) {
print "$k: $hash{$k} ";
}
print "\n";
exit 0;
This program outputs:
first: one second: two third: three
Sometimes you will find you want to unconditionally remove the last character from a string. While you can easily do this with regular expressions, chop is more efficient.
The chop() function will remove the last character of a string (or group of strings) regardless of what that character is. Note, if you want to easily remove newlines or line separators see the chomp() howto.
The chop() function removes and returns the last character from the given string:
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'frog';
my $chr = chop($string);
print "String: $string\n";
print "Char: $chr\n";
This program gives you:
String: fro
Char: g
If the string is empty, chop() will return an empty string. If the string is undefined, chop() will return undefined.
If you pass the chop() function an array, it will remove the last character from every element in the array.
Note that this will only work for a one-dimensional array. In other words, it is not valid to pass in an array reference, or an array that contains an array (or hash).
#!/usr/bin/perl
use strict;
use warnings;
my @array = ('fred', 'bob', 'jill', 'joan');
my $chr = chop(@array);
foreach my $str (@array) {
print "$str\n";
}
print "Char: $chr\n";
This produces the output:
fre
bo
jil
joa
Char: n
If you pass a hash into chop(), it will remove the last character from the values (not the keys) in the hash. For example:
#!/usr/bin/perl
use strict;
use warnings;
my %hash = (
first => 'one',
second => 'two',
third => 'three',
);
my $chr = chop(%hash);
foreach my $k (keys %hash) {
print "$k: $hash{$k}\n";
}
print "Char: $chr\n";
This program outputs:
first: on
second: tw
third: thre
Char: e
Note that as with arrays, chop is not designed to process hash reference or hashes containing other hashes (or arrays).
The index() function is used to determine the position of a letter or a substring in a string. For example, in the word "frog" the letter "f" is in position 0, the "r" in position 1, the "o" in 2 and the "g" in 3. The substring "ro" is in position 1. Depending on what you are trying to achieve, the index() function may be faster or more easy to understand than using a regular expression or the split() function.
Let's say you are trying to determine if a word has a particular letter in it. Let's look for the letter "l" in the string "perlmeme.org".
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'perlmeme.org';
my $char = 'l';
my $result = index($string, $char);
print "Result: $result\n";
This program gives you:
Result: 3
If the string doesn't contain the letter, index() will return a -1. For example, we can look for the letter "L" in the string "perlmeme.org":
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'perlmeme.org';
my $char = 'L';
my $result = index($string, $char);
print "Result: $result\n";
The program outputs:
Result: -1
If the letter we're searching for appears more than once in the string, index() return the index of the first occurrence of the letter.
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'perlmeme.org';
my $char = 'e';
my $result = index($string, $char);
print "Result: $result\n";
This program gives you:
Result: 1
Looking for a substring (rather than a single character) works in exactly the same way as looking for a single character:
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'perlmeme.org';
my $substr = 'me';
my $result = index($string, $substr);
print "Result: $result\n";
This program gives you:
Result: 4
The index() function let's you specify an offset. This tells index() where to start looking in the string. In our example, we found the first occurrence of the letter 'e' at position 1. Let's try to find the second:
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'perlmeme.org';
my $char = 'e';
# The first 'e' was at position 1, so let's start
# looking again at position 2
my $offset = 2;
my $result = index($string, $char, $offset);
print "Result: $result\n";
The program outputs:
Result: 5
To find (and do something with) every occurrence of a character in a string, you could use index() in a loop, incrementing the offset each time:
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'perlmeme.org';
my $char = 'e';
my $offset = 0;
my $result = index($string, $char, $offset);
while ($result != -1) {
print "Found $char at $result\n";
$offset = $result + 1;
$result = index($string, $char, $offset);
}
When we run this program, we get the following output:
Found e at 1
Found e at 5
Found e at 7
Instead of looping through every occurrence of a letter in a string to find the last one, you can use the rindex() function. This works exactly the same as index() but it starts at the end of the string. The index value returned is string from the start of the string though.
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'perlmeme.org';
my $char = 'e';
my $result = rindex($string, $char);
print "Result: $result\n";
This would produce:
Result: 7
For more information on rindex() see our rindex() howto.
You can use the push function to add new elements to the end of an array.
You can use push to push an element onto the end of an array:
#!/usr/bin/perl
use strict;
use warnings;
my @planets = qw(mercury venus earth mars);
print "@planets\n";
push (@planets, 'jupiter');
print "@planets\n";
exit 0;
This program produces the following output:
mercury venus earth mars
mercury venus earth mars jupiter
You can see that 'jupiter' is now on the end of our @planets array.
The push function returns the number of elements in the array after the new value(s) have been appended. If we wanted to see how many planets were in the modified @planets array, we could change our code as follows:
#!/usr/bin/perl
use strict;
use warnings;
my @planets = qw(mercury venus earth mars);
print "@planets\n";
my $number_of_planets = push (@planets, 'jupiter');
print "@planets\n";
print "The number of planets is: $number_of_planets\n";
exit 0;
The output is now:
mercury venus earth mars
mercury venus earth mars jupiter
The number of planets is: 5
You can also use push to append an array onto the end of another array:
#!/usr/bin/perl
use strict;
use warnings;
my @planets = qw(mercury venus earth mars);
my @outer_planets = qw(jupiter saturn uranus neptune pluto);
print "@planets\n";
push (@planets, @outer_planets);
print "@planets\n";
exit 0;
As the following output demonstrates, the @outer_planets array has been added to the end of the @planets array:
mercury venus earth mars
mercury venus earth mars jupiter saturn uranus neptune pluto
You can use push to append elements onto the end of a reference to an array, but you must dereference it first:
#!/usr/bin/perl
use strict;
use warnings;
my @planets = qw(mercury venus earth mars);
my $planets_ref = \@planets;
push ( @{ $planets_ref }, qw(jupiter saturn uranus neptune pluto));
# Could also be written as:
# push ( @$planets_ref, qw(jupiter saturn uranus neptune pluto));
print "@{ $planets_ref }\n";
# Could also be written as:
# print "@$planets_ref\n";
exit 0;
This produces the following output:
mercury venus earth mars jupiter saturn uranus neptune pluto
The 'quote word' function qw() is used to generate a list of words. If takes a string such as:
tempfile tempdir
and returns a quoted list:
'tempfile', 'tempdir'
saving you from the tedium of having to quote and comma-separate each element of the list by hand. Here's a full example:
#!/usr/bin/perl
use strict;
use warnings;
use File::Temp qw(tempfile tempdir);
This code fragment has the effect of importing the tempfile and tempdir functions from the File::Temp module. It does this by providing the list 'tempfile', 'tempdir' to the use function.
qw() extracts words out of your string using embedded whitsepace as the delimiter and returns the words as a list. Note that this happens at compile time, which means that the call to qw() is replaced with the list before your code starts executing.
The qw() function is one of the many ways in which Perl helps to make it easier to write code. Wherever you need to construct a list like this:
my @names = ('Kernighan', 'Ritchie', 'Pike');
you can use qw to do the same thing more simply:
my @names = qw(Kernighan Ritchie Pike);
You can use any non-alphanumeric, non-whitespace delimeter to surround the qw() string argument. You'll often see qw//, for example.
If you use any of the bracketing characters (, <, [ or { as your delimeter, you'll have to close with a matching bracket.
So the following are equivalent:
@names = qw(Kernighan Ritchie Pike);
@names = qw/Kernighan Ritchie Pike/;
@names = qw'Kernighan Ritchie Pike';
@names = qw{Kernighan Ritchie Pike};
Additionlly, no interpolation is possible in the string you pass to qw().
This code fragment:
#!/usr/bin/perl
use strict;
use warnings;
my $developer = 'Thompson';
my @names = qw(Kernighan Ritchie Pike $developer);
foreach my $name (@names) {
print "name: $name\n";
}
Will output:
name: Kernighan
name: Ritchie
name: Pike
name: $developer
In Perl, quotes are considered operators. We have dealt with qw() here as if it was a function, (and indeed it is listed as such in the standard perlfunc documentation), but this is not the whole story. In order to get a better picture of the subtlety of Perl's quoting, see the following section in the perlop documentation:
Quote and Quote-like Operators
Regexp Quote-Like Operators
The rand() function is used to generate random numbers. By default it generates a number between 0 and 1, however you can pass it a maximum and it will generate numbers between 0 and that number.
To generate a random decimal number between 0 and 1, use rand() without any parameters.
#!/usr/bin/perl
use strict;
use warnings;
my $random_number = rand();
print $random_number . "\n";
This will give you a random number, like:
0.521563085335405
Quite often you don't want a number between 0 and 1, but you want a bigger range of numbers. If you pass rand() a maximum, it will return a decimal number between 0 and that number. Our example below generates a random number between 0 and 100.
#!/usr/bin/perl
use strict;
use warnings;
my $range = 100;
my $random_number = rand($range);
print $random_number . "\n";
The program will produce something like:
34.0500569277541
To generate a random integer, convert the output from rand to an integer, as follows:
#!/usr/bin/perl
use strict;
use warnings;
my $range = 100;
my $random_number = int(rand($range));
print $random_number . "\n";
This program gives you an integer from 0 to 99 inclusive:
68
To generate a random number between, for example, 100 and 150, simply work out the range and add the minimum value to your random number.
#!/usr/bin/perl
use strict;
use warnings;
my $range = 50;
my $minimum = 100;
my $random_number = int(rand($range)) + $minimum;
print $random_number . "\n";
This program gives you:
129
The rindex() function is used to determine the position of a character in a string starting at the end of the string. We recommend that you first read our index() howto.
rindex() works exactly the same as index() except that it returns the index of the last occurrence of a letter or substring in the string.
We want to find the last occurrence of the letter "m" in the string "perlmeme.org".
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'perlmeme.org';
my $char = 'm';
my $result = rindex($string, $char);
print "Result: $result\n";
This program gives you:
Result: 6
Just like for index() if the string doesn't contain the letter, rindex() will return a -1. For example, we can look for the letter "L" in the string "perlmeme.org":
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'perlmeme.org';
my $char = 'L';
my $result = rindex($string, $char);
print "Result: $result\n";
The program outputs:
Result: -1
If the letter we're searching for appears more than once in the string, rindex() return the index of the first occurrence of the letter.
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'perlmeme.org';
my $char = 'e';
my $result = rindex($string, $char);
print "Result: $result\n";
This program gives you:
Result: 7
The offset parameter for rindex() works slightly differently to the offset parameter for index().
In index() the character of substring will be searched for starting at the offset position. For example, the first occurrence of the letter 'e' in the string "perlmeme.org" is at position 1. If we want to find the second occurrence, we set the offset to 2.
With rindex() we start at the offset position and look backwards. The last occurrence of the letter 'e' is at position 7. So to find the second last occurrence we set the offset to 6.
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'perlmeme.org';
my $char = 'e';
# The first 'e' was at position 1, so let's start
# looking again at position 2
my $offset = 6;
my $result = rindex($string, $char, $offset);
print "Result: $result\n";
The program outputs:
Result: 5
To find (and do something with) every occurrence of a character in a string using rindex(), you could use index() in a loop, decrementing the offset each time. Note that when using an offset, we need to tell rindex() to start at the back of the string (otherwise it starts at 0 which returns no results).
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'perlmeme.org';
my $char = 'e';
# Start at the end of the string
my $offset = length($string);
my $result = rindex($string, $char, $offset);
while ($result != -1) {
print "Found $char at $result\n";
$offset = $result - 1;
$result = rindex($string, $char, $offset);
}
When we run this program, we get the following output:
Found e at 7
Found e at 5
Found e at 1
The sort function sorts a list (an array). The default is to sort alphabetically. However, you can define your own sorts to get around numbers and complex data structures.
#!/usr/bin/perl
use strict;
use warnings;
my @strings = ("Becky", "Simon", "Bianca", "Steven", "Greg", "Andrew");
my @sorted_strings = sort @strings;
print "@sorted_strings\n";
This gives you the following output:
Andrew Becky Bianca Greg Simon Steven
The Perl sort function sorts by strings instead of by numbers. If you were to use:
#!/usr/bin/perl
use strict;
use warnings;
my @numbers = (23, 1, 22, 7, 109, 9, 65, 3);
my @sorted_numbers = sort @numbers;
print "@sorted_numbers\n";
The output you would see would be:
1 109 22 23 3 65 7 9
To sort numerically, declare your own sort block and use the flying saucer operator <=>:
#!/usr/bin/perl
use strict;
use warnings;
my @numbers = (23, 1, 22, 7, 109, 9, 65, 3);
my @sorted_numbers = sort {$a <=> $b} @numbers;
print "@sorted_numbers\n";
The output would now be:
1 3 7 9 22 23 65 109
Note that $a and $b do not need to be declared, even with use strict on, because they are special sorting variables.
To find out more, see the tutorial Sorting in perl, or run the command:
perldoc -f sort
The split() function is used to split a string into smaller sections. You can split a string on a single character, a group of characers or a regular expression (a pattern).
You can also specify how many pieces to split the string into. This is better explained in the examples below.
A common use of split() is when parsing data from a file or from another program. In this example, we will split the string on the comma ','. Note that you typically should not use split() to parse CSV (comma separated value) files in case there are commas in your data: use Text::CSV instead.
#!/usr/bin/perl
use strict;
use warnings;
my $data = 'Becky Alcorn,25,female,Melbourne';
my @values = split(',', $data);
foreach my $val (@values) {
print "$val\n";
}
exit 0;
This program produces the following output:
Becky Alcorn
25
female
Melbourne
In the same way you use a character to split, you can use a string. In this example, the data is separated by three tildas '~~~'.
#!/usr/bin/perl
use strict;
use warnings;
my $data = 'Bob the Builder~~~10:30am~~~1,6~~~ABC';
my @values = split('~~~', $data);
foreach my $val (@values) {
print "$val\n";
}
exit 0;
This outputs:
Bob the Builder
10:30am
1,6
ABC
In some cases, you may want to split the string on a pattern (regular expression) or a type of character. We'll assume here that you know a little about regular expressions. In this example we will split on any integer:
#!/usr/bin/perl
use strict;
use warnings;
my $data = 'Home1Work2Cafe3Work4Home';
# \d+ matches one or more integer numbers
my @values = split(/\d+/, $data);
foreach my $val (@values) {
print "$val\n";
}
exit 0;
The output of this program is:
Home
Work
Cafe
Work
Home
If you split on an undefined value, the string will be split on every character:
#!/usr/bin/perl
use strict;
use warnings;
my $data = 'Becky Alcorn';
my @values = split(undef,$data);
foreach my $val (@values) {
print "$val\n";
}
exit 0;
The results of this program are:
B
e
c
k
y
A
l
c
o
r
n
If you use a space ' ' to split on, it will actually split on any kind of space including newlines and tabs (regular expression /\s+/) rather than just a space. In this example we print 'aa' either side of the values so we can see where the split took place:
#!/usr/bin/perl
use strict;
use warnings;
my $data = "Becky\n\nAlcorn";
my @values = split(' ',$data);
# Print 'aa' either side of the value, so we can see where it split
foreach my $val (@values) {
print "aa${val}aa\n";
}
exit 0;
This produces:
aaBeckyaa
aaAlcornaa
As you can see, it has split on the newlines that were in our data. If you really want to split on a space, use regular expressions:
my @values = split(/ /,$data);
If the delimiter is at the start of the string then the first element in the array of results will be empty. We'll print fixed text with each line so that you can see the blank one:
#!/usr/bin/perl
use strict;
use warnings;
my $data = ',test,data';
my @values = split(',',$data);
# We print "Val: " with each line so that you can see the blank one
foreach my $val (@values) {
print "Val: $val\n";
}
exit 0;
The output of this program is:
Val:
Val: test
Val: data
If you do not pass in a string to split, then split() will use $_. If you do not pass an expression or string to split on, then split() will use ' ':
#!/usr/bin/perl
use strict;
use warnings;
foreach ('Bob the Builder', 'Thomas the TankEngine', 'B1 and B2') {
my @values = split;
print "Split $_:\n";
foreach my $val (@values) {
print " $val\n";
}
}
exit 0;
This produces:
Split Bob the Builder:
Bob
the
Builder
Split Thomas the TankEngine:
Thomas
the
TankEngine
Split B1 and B2:
B1
and
B2
You can limit the number of sections the string will be split into. You can do this by passing in a positive integer as the third argument. In this example, we're splitting our data into 3 fields - even though there are 4 occurrances of the delimiter:
#!/usr/bin/perl
use strict;
use warnings;
my $data = 'Becky Alcorn,25,female,Melbourne';
my @values = split(',', $data, 3);
foreach my $val (@values) {
print "$val\n";
}
exit 0;
This program produces:
Becky Alcorn
25
female,Melbourne
Sometimes, when splitting on a pattern, you want the delimiter in the result of the split. You can do this by capturing the characters you want to keep inside parenthesis. Let's do our regular expression example again, but this time we'll keep the numbers in the result:
#!/usr/bin/perl
use strict;
use warnings;
my $data = 'Home1Work2Cafe3Work4Home';
# \d+ matches one or more integer numbers
# The parenthesis () mean we keep the digits we match
my @values = split(/(\d+)/, $data);
foreach my $val (@values) {
print "$val\n";
}
exit 0;
The output is:
Home
1
Work
2
Cafe
3
Work
4
Home
If you know a bit about your data, you could split it directly into a hash instead of an array:
#!/usr/bin/perl
use strict;
use warnings;
my $data = 'FIRSTFIELD=1;SECONDFIELD=2;THIRDFIELD=3';
my %values = split(/[=;]/, $data);
foreach my $k (keys %values) {
print "$k: $values{$k}\n";
}
exit 0;
The output of this program is:
FIRSTFIELD: 1
THIRDFIELD: 3
SECONDFIELD: 2
The problem is that if the data does not contain exactly what you think, for example FIRSTFIELD=1;SECONDFIELD=2;THIRDFIELD= then you will get an 'Odd number of elements in hash assignment' warning. Here is the output of the same program but with this new data:
The substr() function is used to return a substring from the expression supplied as it's first argument. The function is a good illustration of some of the ways in which Perl is different from other languages you may have used. substr() has a variable number of arguments, it can be told to start at an offset from either end of the expression, you can supply a replacement string so that it replaces part of the expression as well as returning it, and it can be assigned to!
In our first example, we'll use $string as the first argument, or expression, and supply the offset argument to indicate how far from the left side of the expression our substring should start. Since substr() returns the substring that it matches, we assign this value to $fragment
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'Now is the time for all good people to come to the aid of their party';
my $fragment = substr $string, 4;
print " string: <$string>\n";
print "fragment: <$fragment>\n";
This script produces the following output:
string: <Now is the time for all good people to come to the aid of their party>
fragment: <is the time for all good people to come to the aid of their party>
In $string, the 'i' in the word 'is' is at offset four, because the function starts counting at zero. Therefore the letter 'N' is at offset 0, 'o' is at offset 1, 'w' is at offset 2, and so on.
If we increase the offset to 7, the substring return by substr() starts at the word 'the'.
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'Now is the time for all good people to come to the aid of their party';
my $fragment = substr $string, 7;
print " string: <$string>\n";
print "fragment: <$fragment>\n";
string: <Now is the time for all good people to come to the aid of their party>
fragment: <the time for all good people to come to the aid of their party>
In this example, instead of an explicit offset argument, we'll use the index() function to determine the position of the word 'people'.
#!/usr/bin/perl
use strict;
use warnings;
# Find the location of the substring 'people'
my $string = 'Now is the time for all good people to come to the aid of their party';
my $fragment = substr $string, index($string, 'people');
print " string: <$string>\n";
print "fragment: <$fragment>\n";
string: <Now is the time for all good people to come to the aid of their party>
fragment: <people to come to the aid of their party>
We can supply a third argument to substr(), to limit the size of the substring that is returned. This is the length argument.
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'Now is the time for all good people to come to the aid of their party';
my $length = 8;
my $fragment = substr $string, 7, $length;
print " string: <$string>\n";
print "fragment: <$fragment>\n";
Now we're starting at offset 7 and only returning $length bytes.
string: <Now is the time for all good people to come to the aid of their party>
fragment: <the time>
If we supply a negative offset value, then substr() starts that many characters from the end of the string. Here our offset is -16. which means that our substring will start at the word 'aid', and since our length argument is 10, the function returns the string 'd of their'.
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'Now is the time for all good people to come to the aid of their party';
my $length = 10;
my $fragment = substr $string, -16, $length;
print " string: <$string>\n";
print "fragment: <$fragment>\n";
string: <Now is the time for all good people to come to the aid of their party>
fragment: <d of their>
If we supply a negative length argument, then that many characters are truncated off the end of the string.
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'Now is the time for all good people to come to the aid of their party';
my $length = -20;
my $fragment = substr $string, 7, $length;
print " string: <$string>\n";
print "fragment: <$fragment>\n";
string: <Now is the time for all good people to come to the aid of their party>
fragment: <the time for all good people to come to th>
Supplying negative arguments might seem weird, but that's OK, because Perl is weird. These negative arguments save you the bother of having to work out where the end of the string is. (And that can be very useful).
It's time to confess something. The string we've been using in our examples is an old typing exercise. The original typist's example assumed that only good men could come to the aid of their party! So let's supply the word 'men' as the fourth argument, and see that substr() then modifies $string, returning it to it's old-fashioned form.
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'Now is the time for all good people to come to the aid of their party';
my $fragment = substr $string, index($string, 'people'), 6, 'men';
print " string: <$string>\n";
print "fragment: <$fragment>\n";
string: <Now is the time for all good men to come to the aid of their party>
fragment: <people>
As you can see, our call to substr() has replaced the word 'people' with the word 'men'. By supplying a fourth argument, we have modified the expression $string. At the same time, substr() still returns the substring 'people'.
It is perhaps more common to see the modification demonstrated in the previous example achieved by direct assignment. In technical terms, this means that the substr() function can be used as an lvalue, something that can be assigned a value.
#!/usr/bin/perl
use strict;
use warnings;
my $string = 'Now is the time for all good people to come to the aid of their party';
substr($string, index($string, 'people'), 6) = 'women';
print " string: <$string>\n";
string: <Now is the time for all good women to come to the aid of their party>
