1 | =head1 NAME |
---|
2 | |
---|
3 | perlfaq4 - Data Manipulation ($Revision: 1.1.1.2 $, $Date: 2000-04-07 20:44:20 $) |
---|
4 | |
---|
5 | =head1 DESCRIPTION |
---|
6 | |
---|
7 | The section of the FAQ answers question related to the manipulation |
---|
8 | of data as numbers, dates, strings, arrays, hashes, and miscellaneous |
---|
9 | data issues. |
---|
10 | |
---|
11 | =head1 Data: Numbers |
---|
12 | |
---|
13 | =head2 Why am I getting long decimals (eg, 19.9499999999999) instead of the numbers I should be getting (eg, 19.95)? |
---|
14 | |
---|
15 | The infinite set that a mathematician thinks of as the real numbers can |
---|
16 | only be approximate on a computer, since the computer only has a finite |
---|
17 | number of bits to store an infinite number of, um, numbers. |
---|
18 | |
---|
19 | Internally, your computer represents floating-point numbers in binary. |
---|
20 | Floating-point numbers read in from a file or appearing as literals |
---|
21 | in your program are converted from their decimal floating-point |
---|
22 | representation (eg, 19.95) to the internal binary representation. |
---|
23 | |
---|
24 | However, 19.95 can't be precisely represented as a binary |
---|
25 | floating-point number, just like 1/3 can't be exactly represented as a |
---|
26 | decimal floating-point number. The computer's binary representation |
---|
27 | of 19.95, therefore, isn't exactly 19.95. |
---|
28 | |
---|
29 | When a floating-point number gets printed, the binary floating-point |
---|
30 | representation is converted back to decimal. These decimal numbers |
---|
31 | are displayed in either the format you specify with printf(), or the |
---|
32 | current output format for numbers (see L<perlvar/"$#"> if you use |
---|
33 | print. C<$#> has a different default value in Perl5 than it did in |
---|
34 | Perl4. Changing C<$#> yourself is deprecated.) |
---|
35 | |
---|
36 | This affects B<all> computer languages that represent decimal |
---|
37 | floating-point numbers in binary, not just Perl. Perl provides |
---|
38 | arbitrary-precision decimal numbers with the Math::BigFloat module |
---|
39 | (part of the standard Perl distribution), but mathematical operations |
---|
40 | are consequently slower. |
---|
41 | |
---|
42 | To get rid of the superfluous digits, just use a format (eg, |
---|
43 | C<printf("%.2f", 19.95)>) to get the required precision. |
---|
44 | See L<perlop/"Floating-point Arithmetic">. |
---|
45 | |
---|
46 | =head2 Why isn't my octal data interpreted correctly? |
---|
47 | |
---|
48 | Perl only understands octal and hex numbers as such when they occur |
---|
49 | as literals in your program. If they are read in from somewhere and |
---|
50 | assigned, no automatic conversion takes place. You must explicitly |
---|
51 | use oct() or hex() if you want the values converted. oct() interprets |
---|
52 | both hex ("0x350") numbers and octal ones ("0350" or even without the |
---|
53 | leading "0", like "377"), while hex() only converts hexadecimal ones, |
---|
54 | with or without a leading "0x", like "0x255", "3A", "ff", or "deadbeef". |
---|
55 | |
---|
56 | This problem shows up most often when people try using chmod(), mkdir(), |
---|
57 | umask(), or sysopen(), which all want permissions in octal. |
---|
58 | |
---|
59 | chmod(644, $file); # WRONG -- perl -w catches this |
---|
60 | chmod(0644, $file); # right |
---|
61 | |
---|
62 | =head2 Does Perl have a round() function? What about ceil() and floor()? Trig functions? |
---|
63 | |
---|
64 | Remember that int() merely truncates toward 0. For rounding to a |
---|
65 | certain number of digits, sprintf() or printf() is usually the easiest |
---|
66 | route. |
---|
67 | |
---|
68 | printf("%.3f", 3.1415926535); # prints 3.142 |
---|
69 | |
---|
70 | The POSIX module (part of the standard Perl distribution) implements |
---|
71 | ceil(), floor(), and a number of other mathematical and trigonometric |
---|
72 | functions. |
---|
73 | |
---|
74 | use POSIX; |
---|
75 | $ceil = ceil(3.5); # 4 |
---|
76 | $floor = floor(3.5); # 3 |
---|
77 | |
---|
78 | In 5.000 to 5.003 Perls, trigonometry was done in the Math::Complex |
---|
79 | module. With 5.004, the Math::Trig module (part of the standard Perl |
---|
80 | distribution) implements the trigonometric functions. Internally it |
---|
81 | uses the Math::Complex module and some functions can break out from |
---|
82 | the real axis into the complex plane, for example the inverse sine of |
---|
83 | 2. |
---|
84 | |
---|
85 | Rounding in financial applications can have serious implications, and |
---|
86 | the rounding method used should be specified precisely. In these |
---|
87 | cases, it probably pays not to trust whichever system rounding is |
---|
88 | being used by Perl, but to instead implement the rounding function you |
---|
89 | need yourself. |
---|
90 | |
---|
91 | To see why, notice how you'll still have an issue on half-way-point |
---|
92 | alternation: |
---|
93 | |
---|
94 | for ($i = 0; $i < 1.01; $i += 0.05) { printf "%.1f ",$i} |
---|
95 | |
---|
96 | 0.0 0.1 0.1 0.2 0.2 0.2 0.3 0.3 0.4 0.4 0.5 0.5 0.6 0.7 0.7 |
---|
97 | 0.8 0.8 0.9 0.9 1.0 1.0 |
---|
98 | |
---|
99 | Don't blame Perl. It's the same as in C. IEEE says we have to do this. |
---|
100 | Perl numbers whose absolute values are integers under 2**31 (on 32 bit |
---|
101 | machines) will work pretty much like mathematical integers. Other numbers |
---|
102 | are not guaranteed. |
---|
103 | |
---|
104 | =head2 How do I convert bits into ints? |
---|
105 | |
---|
106 | To turn a string of 1s and 0s like C<10110110> into a scalar containing |
---|
107 | its binary value, use the pack() and unpack() functions (documented in |
---|
108 | L<perlfunc/"pack"> and L<perlfunc/"unpack">): |
---|
109 | |
---|
110 | $decimal = unpack('c', pack('B8', '10110110')); |
---|
111 | |
---|
112 | This packs the string C<10110110> into an eight bit binary structure. |
---|
113 | This is then unpacked as a character, which returns its ordinal value. |
---|
114 | |
---|
115 | This does the same thing: |
---|
116 | |
---|
117 | $decimal = ord(pack('B8', '10110110')); |
---|
118 | |
---|
119 | Here's an example of going the other way: |
---|
120 | |
---|
121 | $binary_string = unpack('B*', "\x29"); |
---|
122 | |
---|
123 | =head2 Why doesn't & work the way I want it to? |
---|
124 | |
---|
125 | The behavior of binary arithmetic operators depends on whether they're |
---|
126 | used on numbers or strings. The operators treat a string as a series |
---|
127 | of bits and work with that (the string C<"3"> is the bit pattern |
---|
128 | C<00110011>). The operators work with the binary form of a number |
---|
129 | (the number C<3> is treated as the bit pattern C<00000011>). |
---|
130 | |
---|
131 | So, saying C<11 & 3> performs the "and" operation on numbers (yielding |
---|
132 | C<1>). Saying C<"11" & "3"> performs the "and" operation on strings |
---|
133 | (yielding C<"1">). |
---|
134 | |
---|
135 | Most problems with C<&> and C<|> arise because the programmer thinks |
---|
136 | they have a number but really it's a string. The rest arise because |
---|
137 | the programmer says: |
---|
138 | |
---|
139 | if ("\020\020" & "\101\101") { |
---|
140 | # ... |
---|
141 | } |
---|
142 | |
---|
143 | but a string consisting of two null bytes (the result of C<"\020\020" |
---|
144 | & "\101\101">) is not a false value in Perl. You need: |
---|
145 | |
---|
146 | if ( ("\020\020" & "\101\101") !~ /[^\000]/) { |
---|
147 | # ... |
---|
148 | } |
---|
149 | |
---|
150 | =head2 How do I multiply matrices? |
---|
151 | |
---|
152 | Use the Math::Matrix or Math::MatrixReal modules (available from CPAN) |
---|
153 | or the PDL extension (also available from CPAN). |
---|
154 | |
---|
155 | =head2 How do I perform an operation on a series of integers? |
---|
156 | |
---|
157 | To call a function on each element in an array, and collect the |
---|
158 | results, use: |
---|
159 | |
---|
160 | @results = map { my_func($_) } @array; |
---|
161 | |
---|
162 | For example: |
---|
163 | |
---|
164 | @triple = map { 3 * $_ } @single; |
---|
165 | |
---|
166 | To call a function on each element of an array, but ignore the |
---|
167 | results: |
---|
168 | |
---|
169 | foreach $iterator (@array) { |
---|
170 | some_func($iterator); |
---|
171 | } |
---|
172 | |
---|
173 | To call a function on each integer in a (small) range, you B<can> use: |
---|
174 | |
---|
175 | @results = map { some_func($_) } (5 .. 25); |
---|
176 | |
---|
177 | but you should be aware that the C<..> operator creates an array of |
---|
178 | all integers in the range. This can take a lot of memory for large |
---|
179 | ranges. Instead use: |
---|
180 | |
---|
181 | @results = (); |
---|
182 | for ($i=5; $i < 500_005; $i++) { |
---|
183 | push(@results, some_func($i)); |
---|
184 | } |
---|
185 | |
---|
186 | This situation has been fixed in Perl5.005. Use of C<..> in a C<for> |
---|
187 | loop will iterate over the range, without creating the entire range. |
---|
188 | |
---|
189 | for my $i (5 .. 500_005) { |
---|
190 | push(@results, some_func($i)); |
---|
191 | } |
---|
192 | |
---|
193 | will not create a list of 500,000 integers. |
---|
194 | |
---|
195 | =head2 How can I output Roman numerals? |
---|
196 | |
---|
197 | Get the http://www.perl.com/CPAN/modules/by-module/Roman module. |
---|
198 | |
---|
199 | =head2 Why aren't my random numbers random? |
---|
200 | |
---|
201 | If you're using a version of Perl before 5.004, you must call C<srand> |
---|
202 | once at the start of your program to seed the random number generator. |
---|
203 | 5.004 and later automatically call C<srand> at the beginning. Don't |
---|
204 | call C<srand> more than once--you make your numbers less random, rather |
---|
205 | than more. |
---|
206 | |
---|
207 | Computers are good at being predictable and bad at being random |
---|
208 | (despite appearances caused by bugs in your programs :-). |
---|
209 | http://www.perl.com/CPAN/doc/FMTEYEWTK/random, courtesy of Tom |
---|
210 | Phoenix, talks more about this.. John von Neumann said, ``Anyone who |
---|
211 | attempts to generate random numbers by deterministic means is, of |
---|
212 | course, living in a state of sin.'' |
---|
213 | |
---|
214 | If you want numbers that are more random than C<rand> with C<srand> |
---|
215 | provides, you should also check out the Math::TrulyRandom module from |
---|
216 | CPAN. It uses the imperfections in your system's timer to generate |
---|
217 | random numbers, but this takes quite a while. If you want a better |
---|
218 | pseudorandom generator than comes with your operating system, look at |
---|
219 | ``Numerical Recipes in C'' at http://www.nr.com/ . |
---|
220 | |
---|
221 | =head1 Data: Dates |
---|
222 | |
---|
223 | =head2 How do I find the week-of-the-year/day-of-the-year? |
---|
224 | |
---|
225 | The day of the year is in the array returned by localtime() (see |
---|
226 | L<perlfunc/"localtime">): |
---|
227 | |
---|
228 | $day_of_year = (localtime(time()))[7]; |
---|
229 | |
---|
230 | or more legibly (in 5.004 or higher): |
---|
231 | |
---|
232 | use Time::localtime; |
---|
233 | $day_of_year = localtime(time())->yday; |
---|
234 | |
---|
235 | You can find the week of the year by dividing this by 7: |
---|
236 | |
---|
237 | $week_of_year = int($day_of_year / 7); |
---|
238 | |
---|
239 | Of course, this believes that weeks start at zero. The Date::Calc |
---|
240 | module from CPAN has a lot of date calculation functions, including |
---|
241 | day of the year, week of the year, and so on. Note that not |
---|
242 | all businesses consider ``week 1'' to be the same; for example, |
---|
243 | American businesses often consider the first week with a Monday |
---|
244 | in it to be Work Week #1, despite ISO 8601, which considers |
---|
245 | WW1 to be the first week with a Thursday in it. |
---|
246 | |
---|
247 | =head2 How do I find the current century or millennium? |
---|
248 | |
---|
249 | Use the following simple functions: |
---|
250 | |
---|
251 | sub get_century { |
---|
252 | return int((((localtime(shift || time))[5] + 1999))/100); |
---|
253 | } |
---|
254 | sub get_millennium { |
---|
255 | return 1+int((((localtime(shift || time))[5] + 1899))/1000); |
---|
256 | } |
---|
257 | |
---|
258 | On some systems, you'll find that the POSIX module's strftime() function |
---|
259 | has been extended in a non-standard way to use a C<%C> format, which they |
---|
260 | sometimes claim is the "century". It isn't, because on most such systems, |
---|
261 | this is only the first two digits of the four-digit year, and thus cannot |
---|
262 | be used to reliably determine the current century or millennium. |
---|
263 | |
---|
264 | =head2 How can I compare two dates and find the difference? |
---|
265 | |
---|
266 | If you're storing your dates as epoch seconds then simply subtract one |
---|
267 | from the other. If you've got a structured date (distinct year, day, |
---|
268 | month, hour, minute, seconds values), then for reasons of accessibility, |
---|
269 | simplicity, and efficiency, merely use either timelocal or timegm (from |
---|
270 | the Time::Local module in the standard distribution) to reduce structured |
---|
271 | dates to epoch seconds. However, if you don't know the precise format of |
---|
272 | your dates, then you should probably use either of the Date::Manip and |
---|
273 | Date::Calc modules from CPAN before you go hacking up your own parsing |
---|
274 | routine to handle arbitrary date formats. |
---|
275 | |
---|
276 | =head2 How can I take a string and turn it into epoch seconds? |
---|
277 | |
---|
278 | If it's a regular enough string that it always has the same format, |
---|
279 | you can split it up and pass the parts to C<timelocal> in the standard |
---|
280 | Time::Local module. Otherwise, you should look into the Date::Calc |
---|
281 | and Date::Manip modules from CPAN. |
---|
282 | |
---|
283 | =head2 How can I find the Julian Day? |
---|
284 | |
---|
285 | Use the Time::JulianDay module (part of the Time-modules bundle |
---|
286 | available from CPAN.) |
---|
287 | |
---|
288 | Before you immerse yourself too deeply in this, be sure to verify that it |
---|
289 | is the I<Julian> Day you really want. Are they really just interested in |
---|
290 | a way of getting serial days so that they can do date arithmetic? If you |
---|
291 | are interested in performing date arithmetic, this can be done using |
---|
292 | either Date::Manip or Date::Calc, without converting to Julian Day first. |
---|
293 | |
---|
294 | There is too much confusion on this issue to cover in this FAQ, but the |
---|
295 | term is applied (correctly) to a calendar now supplanted by the Gregorian |
---|
296 | Calendar, with the Julian Calendar failing to adjust properly for leap |
---|
297 | years on centennial years (among other annoyances). The term is also used |
---|
298 | (incorrectly) to mean: [1] days in the Gregorian Calendar; and [2] days |
---|
299 | since a particular starting time or `epoch', usually 1970 in the Unix |
---|
300 | world and 1980 in the MS-DOS/Windows world. If you find that it is not |
---|
301 | the first meaning that you really want, then check out the Date::Manip |
---|
302 | and Date::Calc modules. (Thanks to David Cassell for most of this text.) |
---|
303 | |
---|
304 | =head2 How do I find yesterday's date? |
---|
305 | |
---|
306 | The C<time()> function returns the current time in seconds since the |
---|
307 | epoch. Take twenty-four hours off that: |
---|
308 | |
---|
309 | $yesterday = time() - ( 24 * 60 * 60 ); |
---|
310 | |
---|
311 | Then you can pass this to C<localtime()> and get the individual year, |
---|
312 | month, day, hour, minute, seconds values. |
---|
313 | |
---|
314 | Note very carefully that the code above assumes that your days are |
---|
315 | twenty-four hours each. For most people, there are two days a year |
---|
316 | when they aren't: the switch to and from summer time throws this off. |
---|
317 | A solution to this issue is offered by Russ Allbery. |
---|
318 | |
---|
319 | sub yesterday { |
---|
320 | my $now = defined $_[0] ? $_[0] : time; |
---|
321 | my $then = $now - 60 * 60 * 24; |
---|
322 | my $ndst = (localtime $now)[8] > 0; |
---|
323 | my $tdst = (localtime $then)[8] > 0; |
---|
324 | $then - ($tdst - $ndst) * 60 * 60; |
---|
325 | } |
---|
326 | # Should give you "this time yesterday" in seconds since epoch relative to |
---|
327 | # the first argument or the current time if no argument is given and |
---|
328 | # suitable for passing to localtime or whatever else you need to do with |
---|
329 | # it. $ndst is whether we're currently in daylight savings time; $tdst is |
---|
330 | # whether the point 24 hours ago was in daylight savings time. If $tdst |
---|
331 | # and $ndst are the same, a boundary wasn't crossed, and the correction |
---|
332 | # will subtract 0. If $tdst is 1 and $ndst is 0, subtract an hour more |
---|
333 | # from yesterday's time since we gained an extra hour while going off |
---|
334 | # daylight savings time. If $tdst is 0 and $ndst is 1, subtract a |
---|
335 | # negative hour (add an hour) to yesterday's time since we lost an hour. |
---|
336 | # |
---|
337 | # All of this is because during those days when one switches off or onto |
---|
338 | # DST, a "day" isn't 24 hours long; it's either 23 or 25. |
---|
339 | # |
---|
340 | # The explicit settings of $ndst and $tdst are necessary because localtime |
---|
341 | # only says it returns the system tm struct, and the system tm struct at |
---|
342 | # least on Solaris doesn't guarantee any particular positive value (like, |
---|
343 | # say, 1) for isdst, just a positive value. And that value can |
---|
344 | # potentially be negative, if DST information isn't available (this sub |
---|
345 | # just treats those cases like no DST). |
---|
346 | # |
---|
347 | # Note that between 2am and 3am on the day after the time zone switches |
---|
348 | # off daylight savings time, the exact hour of "yesterday" corresponding |
---|
349 | # to the current hour is not clearly defined. Note also that if used |
---|
350 | # between 2am and 3am the day after the change to daylight savings time, |
---|
351 | # the result will be between 3am and 4am of the previous day; it's |
---|
352 | # arguable whether this is correct. |
---|
353 | # |
---|
354 | # This sub does not attempt to deal with leap seconds (most things don't). |
---|
355 | # |
---|
356 | # Copyright relinquished 1999 by Russ Allbery <rra@stanford.edu> |
---|
357 | # This code is in the public domain |
---|
358 | |
---|
359 | =head2 Does Perl have a Year 2000 problem? Is Perl Y2K compliant? |
---|
360 | |
---|
361 | Short answer: No, Perl does not have a Year 2000 problem. Yes, Perl is |
---|
362 | Y2K compliant (whatever that means). The programmers you've hired to |
---|
363 | use it, however, probably are not. |
---|
364 | |
---|
365 | Long answer: The question belies a true understanding of the issue. |
---|
366 | Perl is just as Y2K compliant as your pencil--no more, and no less. |
---|
367 | Can you use your pencil to write a non-Y2K-compliant memo? Of course |
---|
368 | you can. Is that the pencil's fault? Of course it isn't. |
---|
369 | |
---|
370 | The date and time functions supplied with Perl (gmtime and localtime) |
---|
371 | supply adequate information to determine the year well beyond 2000 |
---|
372 | (2038 is when trouble strikes for 32-bit machines). The year returned |
---|
373 | by these functions when used in an array context is the year minus 1900. |
---|
374 | For years between 1910 and 1999 this I<happens> to be a 2-digit decimal |
---|
375 | number. To avoid the year 2000 problem simply do not treat the year as |
---|
376 | a 2-digit number. It isn't. |
---|
377 | |
---|
378 | When gmtime() and localtime() are used in scalar context they return |
---|
379 | a timestamp string that contains a fully-expanded year. For example, |
---|
380 | C<$timestamp = gmtime(1005613200)> sets $timestamp to "Tue Nov 13 01:00:00 |
---|
381 | 2001". There's no year 2000 problem here. |
---|
382 | |
---|
383 | That doesn't mean that Perl can't be used to create non-Y2K compliant |
---|
384 | programs. It can. But so can your pencil. It's the fault of the user, |
---|
385 | not the language. At the risk of inflaming the NRA: ``Perl doesn't |
---|
386 | break Y2K, people do.'' See http://language.perl.com/news/y2k.html for |
---|
387 | a longer exposition. |
---|
388 | |
---|
389 | =head1 Data: Strings |
---|
390 | |
---|
391 | =head2 How do I validate input? |
---|
392 | |
---|
393 | The answer to this question is usually a regular expression, perhaps |
---|
394 | with auxiliary logic. See the more specific questions (numbers, mail |
---|
395 | addresses, etc.) for details. |
---|
396 | |
---|
397 | =head2 How do I unescape a string? |
---|
398 | |
---|
399 | It depends just what you mean by ``escape''. URL escapes are dealt |
---|
400 | with in L<perlfaq9>. Shell escapes with the backslash (C<\>) |
---|
401 | character are removed with: |
---|
402 | |
---|
403 | s/\\(.)/$1/g; |
---|
404 | |
---|
405 | This won't expand C<"\n"> or C<"\t"> or any other special escapes. |
---|
406 | |
---|
407 | =head2 How do I remove consecutive pairs of characters? |
---|
408 | |
---|
409 | To turn C<"abbcccd"> into C<"abccd">: |
---|
410 | |
---|
411 | s/(.)\1/$1/g; # add /s to include newlines |
---|
412 | |
---|
413 | Here's a solution that turns "abbcccd" to "abcd": |
---|
414 | |
---|
415 | y///cs; # y == tr, but shorter :-) |
---|
416 | |
---|
417 | =head2 How do I expand function calls in a string? |
---|
418 | |
---|
419 | This is documented in L<perlref>. In general, this is fraught with |
---|
420 | quoting and readability problems, but it is possible. To interpolate |
---|
421 | a subroutine call (in list context) into a string: |
---|
422 | |
---|
423 | print "My sub returned @{[mysub(1,2,3)]} that time.\n"; |
---|
424 | |
---|
425 | If you prefer scalar context, similar chicanery is also useful for |
---|
426 | arbitrary expressions: |
---|
427 | |
---|
428 | print "That yields ${\($n + 5)} widgets\n"; |
---|
429 | |
---|
430 | Version 5.004 of Perl had a bug that gave list context to the |
---|
431 | expression in C<${...}>, but this is fixed in version 5.005. |
---|
432 | |
---|
433 | See also ``How can I expand variables in text strings?'' in this |
---|
434 | section of the FAQ. |
---|
435 | |
---|
436 | =head2 How do I find matching/nesting anything? |
---|
437 | |
---|
438 | This isn't something that can be done in one regular expression, no |
---|
439 | matter how complicated. To find something between two single |
---|
440 | characters, a pattern like C</x([^x]*)x/> will get the intervening |
---|
441 | bits in $1. For multiple ones, then something more like |
---|
442 | C</alpha(.*?)omega/> would be needed. But none of these deals with |
---|
443 | nested patterns, nor can they. For that you'll have to write a |
---|
444 | parser. |
---|
445 | |
---|
446 | If you are serious about writing a parser, there are a number of |
---|
447 | modules or oddities that will make your life a lot easier. There are |
---|
448 | the CPAN modules Parse::RecDescent, Parse::Yapp, and Text::Balanced; |
---|
449 | and the byacc program. |
---|
450 | |
---|
451 | One simple destructive, inside-out approach that you might try is to |
---|
452 | pull out the smallest nesting parts one at a time: |
---|
453 | |
---|
454 | while (s/BEGIN((?:(?!BEGIN)(?!END).)*)END//gs) { |
---|
455 | # do something with $1 |
---|
456 | } |
---|
457 | |
---|
458 | A more complicated and sneaky approach is to make Perl's regular |
---|
459 | expression engine do it for you. This is courtesy Dean Inada, and |
---|
460 | rather has the nature of an Obfuscated Perl Contest entry, but it |
---|
461 | really does work: |
---|
462 | |
---|
463 | # $_ contains the string to parse |
---|
464 | # BEGIN and END are the opening and closing markers for the |
---|
465 | # nested text. |
---|
466 | |
---|
467 | @( = ('(',''); |
---|
468 | @) = (')',''); |
---|
469 | ($re=$_)=~s/((BEGIN)|(END)|.)/$)[!$3]\Q$1\E$([!$2]/gs; |
---|
470 | @$ = (eval{/$re/},$@!~/unmatched/); |
---|
471 | print join("\n",@$[0..$#$]) if( $$[-1] ); |
---|
472 | |
---|
473 | =head2 How do I reverse a string? |
---|
474 | |
---|
475 | Use reverse() in scalar context, as documented in |
---|
476 | L<perlfunc/reverse>. |
---|
477 | |
---|
478 | $reversed = reverse $string; |
---|
479 | |
---|
480 | =head2 How do I expand tabs in a string? |
---|
481 | |
---|
482 | You can do it yourself: |
---|
483 | |
---|
484 | 1 while $string =~ s/\t+/' ' x (length($&) * 8 - length($`) % 8)/e; |
---|
485 | |
---|
486 | Or you can just use the Text::Tabs module (part of the standard Perl |
---|
487 | distribution). |
---|
488 | |
---|
489 | use Text::Tabs; |
---|
490 | @expanded_lines = expand(@lines_with_tabs); |
---|
491 | |
---|
492 | =head2 How do I reformat a paragraph? |
---|
493 | |
---|
494 | Use Text::Wrap (part of the standard Perl distribution): |
---|
495 | |
---|
496 | use Text::Wrap; |
---|
497 | print wrap("\t", ' ', @paragraphs); |
---|
498 | |
---|
499 | The paragraphs you give to Text::Wrap should not contain embedded |
---|
500 | newlines. Text::Wrap doesn't justify the lines (flush-right). |
---|
501 | |
---|
502 | =head2 How can I access/change the first N letters of a string? |
---|
503 | |
---|
504 | There are many ways. If you just want to grab a copy, use |
---|
505 | substr(): |
---|
506 | |
---|
507 | $first_byte = substr($a, 0, 1); |
---|
508 | |
---|
509 | If you want to modify part of a string, the simplest way is often to |
---|
510 | use substr() as an lvalue: |
---|
511 | |
---|
512 | substr($a, 0, 3) = "Tom"; |
---|
513 | |
---|
514 | Although those with a pattern matching kind of thought process will |
---|
515 | likely prefer: |
---|
516 | |
---|
517 | $a =~ s/^.../Tom/; |
---|
518 | |
---|
519 | =head2 How do I change the Nth occurrence of something? |
---|
520 | |
---|
521 | You have to keep track of N yourself. For example, let's say you want |
---|
522 | to change the fifth occurrence of C<"whoever"> or C<"whomever"> into |
---|
523 | C<"whosoever"> or C<"whomsoever">, case insensitively. These |
---|
524 | all assume that $_ contains the string to be altered. |
---|
525 | |
---|
526 | $count = 0; |
---|
527 | s{((whom?)ever)}{ |
---|
528 | ++$count == 5 # is it the 5th? |
---|
529 | ? "${2}soever" # yes, swap |
---|
530 | : $1 # renege and leave it there |
---|
531 | }ige; |
---|
532 | |
---|
533 | In the more general case, you can use the C</g> modifier in a C<while> |
---|
534 | loop, keeping count of matches. |
---|
535 | |
---|
536 | $WANT = 3; |
---|
537 | $count = 0; |
---|
538 | $_ = "One fish two fish red fish blue fish"; |
---|
539 | while (/(\w+)\s+fish\b/gi) { |
---|
540 | if (++$count == $WANT) { |
---|
541 | print "The third fish is a $1 one.\n"; |
---|
542 | } |
---|
543 | } |
---|
544 | |
---|
545 | That prints out: C<"The third fish is a red one."> You can also use a |
---|
546 | repetition count and repeated pattern like this: |
---|
547 | |
---|
548 | /(?:\w+\s+fish\s+){2}(\w+)\s+fish/i; |
---|
549 | |
---|
550 | =head2 How can I count the number of occurrences of a substring within a string? |
---|
551 | |
---|
552 | There are a number of ways, with varying efficiency: If you want a |
---|
553 | count of a certain single character (X) within a string, you can use the |
---|
554 | C<tr///> function like so: |
---|
555 | |
---|
556 | $string = "ThisXlineXhasXsomeXx'sXinXit"; |
---|
557 | $count = ($string =~ tr/X//); |
---|
558 | print "There are $count X characters in the string"; |
---|
559 | |
---|
560 | This is fine if you are just looking for a single character. However, |
---|
561 | if you are trying to count multiple character substrings within a |
---|
562 | larger string, C<tr///> won't work. What you can do is wrap a while() |
---|
563 | loop around a global pattern match. For example, let's count negative |
---|
564 | integers: |
---|
565 | |
---|
566 | $string = "-9 55 48 -2 23 -76 4 14 -44"; |
---|
567 | while ($string =~ /-\d+/g) { $count++ } |
---|
568 | print "There are $count negative numbers in the string"; |
---|
569 | |
---|
570 | =head2 How do I capitalize all the words on one line? |
---|
571 | |
---|
572 | To make the first letter of each word upper case: |
---|
573 | |
---|
574 | $line =~ s/\b(\w)/\U$1/g; |
---|
575 | |
---|
576 | This has the strange effect of turning "C<don't do it>" into "C<Don'T |
---|
577 | Do It>". Sometimes you might want this, instead (Suggested by brian d. |
---|
578 | foy): |
---|
579 | |
---|
580 | $string =~ s/ ( |
---|
581 | (^\w) #at the beginning of the line |
---|
582 | | # or |
---|
583 | (\s\w) #preceded by whitespace |
---|
584 | ) |
---|
585 | /\U$1/xg; |
---|
586 | $string =~ /([\w']+)/\u\L$1/g; |
---|
587 | |
---|
588 | To make the whole line upper case: |
---|
589 | |
---|
590 | $line = uc($line); |
---|
591 | |
---|
592 | To force each word to be lower case, with the first letter upper case: |
---|
593 | |
---|
594 | $line =~ s/(\w+)/\u\L$1/g; |
---|
595 | |
---|
596 | You can (and probably should) enable locale awareness of those |
---|
597 | characters by placing a C<use locale> pragma in your program. |
---|
598 | See L<perllocale> for endless details on locales. |
---|
599 | |
---|
600 | This is sometimes referred to as putting something into "title |
---|
601 | case", but that's not quite accurate. Consider the proper |
---|
602 | capitalization of the movie I<Dr. Strangelove or: How I Learned to |
---|
603 | Stop Worrying and Love the Bomb>, for example. |
---|
604 | |
---|
605 | =head2 How can I split a [character] delimited string except when inside |
---|
606 | [character]? (Comma-separated files) |
---|
607 | |
---|
608 | Take the example case of trying to split a string that is comma-separated |
---|
609 | into its different fields. (We'll pretend you said comma-separated, not |
---|
610 | comma-delimited, which is different and almost never what you mean.) You |
---|
611 | can't use C<split(/,/)> because you shouldn't split if the comma is inside |
---|
612 | quotes. For example, take a data line like this: |
---|
613 | |
---|
614 | SAR001,"","Cimetrix, Inc","Bob Smith","CAM",N,8,1,0,7,"Error, Core Dumped" |
---|
615 | |
---|
616 | Due to the restriction of the quotes, this is a fairly complex |
---|
617 | problem. Thankfully, we have Jeffrey Friedl, author of a highly |
---|
618 | recommended book on regular expressions, to handle these for us. He |
---|
619 | suggests (assuming your string is contained in $text): |
---|
620 | |
---|
621 | @new = (); |
---|
622 | push(@new, $+) while $text =~ m{ |
---|
623 | "([^\"\\]*(?:\\.[^\"\\]*)*)",? # groups the phrase inside the quotes |
---|
624 | | ([^,]+),? |
---|
625 | | , |
---|
626 | }gx; |
---|
627 | push(@new, undef) if substr($text,-1,1) eq ','; |
---|
628 | |
---|
629 | If you want to represent quotation marks inside a |
---|
630 | quotation-mark-delimited field, escape them with backslashes (eg, |
---|
631 | C<"like \"this\"">. Unescaping them is a task addressed earlier in |
---|
632 | this section. |
---|
633 | |
---|
634 | Alternatively, the Text::ParseWords module (part of the standard Perl |
---|
635 | distribution) lets you say: |
---|
636 | |
---|
637 | use Text::ParseWords; |
---|
638 | @new = quotewords(",", 0, $text); |
---|
639 | |
---|
640 | There's also a Text::CSV module on CPAN. |
---|
641 | |
---|
642 | =head2 How do I strip blank space from the beginning/end of a string? |
---|
643 | |
---|
644 | Although the simplest approach would seem to be: |
---|
645 | |
---|
646 | $string =~ s/^\s*(.*?)\s*$/$1/; |
---|
647 | |
---|
648 | Not only is this unnecessarily slow and destructive, it also fails with |
---|
649 | embedded newlines. It is much faster to do this operation in two steps: |
---|
650 | |
---|
651 | $string =~ s/^\s+//; |
---|
652 | $string =~ s/\s+$//; |
---|
653 | |
---|
654 | Or more nicely written as: |
---|
655 | |
---|
656 | for ($string) { |
---|
657 | s/^\s+//; |
---|
658 | s/\s+$//; |
---|
659 | } |
---|
660 | |
---|
661 | This idiom takes advantage of the C<foreach> loop's aliasing |
---|
662 | behavior to factor out common code. You can do this |
---|
663 | on several strings at once, or arrays, or even the |
---|
664 | values of a hash if you use a slice: |
---|
665 | |
---|
666 | # trim whitespace in the scalar, the array, |
---|
667 | # and all the values in the hash |
---|
668 | foreach ($scalar, @array, @hash{keys %hash}) { |
---|
669 | s/^\s+//; |
---|
670 | s/\s+$//; |
---|
671 | } |
---|
672 | |
---|
673 | =head2 How do I pad a string with blanks or pad a number with zeroes? |
---|
674 | |
---|
675 | (This answer contributed by Uri Guttman, with kibitzing from |
---|
676 | Bart Lateur.) |
---|
677 | |
---|
678 | In the following examples, C<$pad_len> is the length to which you wish |
---|
679 | to pad the string, C<$text> or C<$num> contains the string to be padded, |
---|
680 | and C<$pad_char> contains the padding character. You can use a single |
---|
681 | character string constant instead of the C<$pad_char> variable if you |
---|
682 | know what it is in advance. And in the same way you can use an integer in |
---|
683 | place of C<$pad_len> if you know the pad length in advance. |
---|
684 | |
---|
685 | The simplest method uses the C<sprintf> function. It can pad on the left |
---|
686 | or right with blanks and on the left with zeroes and it will not |
---|
687 | truncate the result. The C<pack> function can only pad strings on the |
---|
688 | right with blanks and it will truncate the result to a maximum length of |
---|
689 | C<$pad_len>. |
---|
690 | |
---|
691 | # Left padding a string with blanks (no truncation): |
---|
692 | $padded = sprintf("%${pad_len}s", $text); |
---|
693 | |
---|
694 | # Right padding a string with blanks (no truncation): |
---|
695 | $padded = sprintf("%-${pad_len}s", $text); |
---|
696 | |
---|
697 | # Left padding a number with 0 (no truncation): |
---|
698 | $padded = sprintf("%0${pad_len}d", $num); |
---|
699 | |
---|
700 | # Right padding a string with blanks using pack (will truncate): |
---|
701 | $padded = pack("A$pad_len",$text); |
---|
702 | |
---|
703 | If you need to pad with a character other than blank or zero you can use |
---|
704 | one of the following methods. They all generate a pad string with the |
---|
705 | C<x> operator and combine that with C<$text>. These methods do |
---|
706 | not truncate C<$text>. |
---|
707 | |
---|
708 | Left and right padding with any character, creating a new string: |
---|
709 | |
---|
710 | $padded = $pad_char x ( $pad_len - length( $text ) ) . $text; |
---|
711 | $padded = $text . $pad_char x ( $pad_len - length( $text ) ); |
---|
712 | |
---|
713 | Left and right padding with any character, modifying C<$text> directly: |
---|
714 | |
---|
715 | substr( $text, 0, 0 ) = $pad_char x ( $pad_len - length( $text ) ); |
---|
716 | $text .= $pad_char x ( $pad_len - length( $text ) ); |
---|
717 | |
---|
718 | =head2 How do I extract selected columns from a string? |
---|
719 | |
---|
720 | Use substr() or unpack(), both documented in L<perlfunc>. |
---|
721 | If you prefer thinking in terms of columns instead of widths, |
---|
722 | you can use this kind of thing: |
---|
723 | |
---|
724 | # determine the unpack format needed to split Linux ps output |
---|
725 | # arguments are cut columns |
---|
726 | my $fmt = cut2fmt(8, 14, 20, 26, 30, 34, 41, 47, 59, 63, 67, 72); |
---|
727 | |
---|
728 | sub cut2fmt { |
---|
729 | my(@positions) = @_; |
---|
730 | my $template = ''; |
---|
731 | my $lastpos = 1; |
---|
732 | for my $place (@positions) { |
---|
733 | $template .= "A" . ($place - $lastpos) . " "; |
---|
734 | $lastpos = $place; |
---|
735 | } |
---|
736 | $template .= "A*"; |
---|
737 | return $template; |
---|
738 | } |
---|
739 | |
---|
740 | =head2 How do I find the soundex value of a string? |
---|
741 | |
---|
742 | Use the standard Text::Soundex module distributed with Perl. |
---|
743 | But before you do so, you may want to determine whether `soundex' is in |
---|
744 | fact what you think it is. Knuth's soundex algorithm compresses words |
---|
745 | into a small space, and so it does not necessarily distinguish between |
---|
746 | two words which you might want to appear separately. For example, the |
---|
747 | last names `Knuth' and `Kant' are both mapped to the soundex code K530. |
---|
748 | If Text::Soundex does not do what you are looking for, you might want |
---|
749 | to consider the String::Approx module available at CPAN. |
---|
750 | |
---|
751 | =head2 How can I expand variables in text strings? |
---|
752 | |
---|
753 | Let's assume that you have a string like: |
---|
754 | |
---|
755 | $text = 'this has a $foo in it and a $bar'; |
---|
756 | |
---|
757 | If those were both global variables, then this would |
---|
758 | suffice: |
---|
759 | |
---|
760 | $text =~ s/\$(\w+)/${$1}/g; # no /e needed |
---|
761 | |
---|
762 | But since they are probably lexicals, or at least, they could |
---|
763 | be, you'd have to do this: |
---|
764 | |
---|
765 | $text =~ s/(\$\w+)/$1/eeg; |
---|
766 | die if $@; # needed /ee, not /e |
---|
767 | |
---|
768 | It's probably better in the general case to treat those |
---|
769 | variables as entries in some special hash. For example: |
---|
770 | |
---|
771 | %user_defs = ( |
---|
772 | foo => 23, |
---|
773 | bar => 19, |
---|
774 | ); |
---|
775 | $text =~ s/\$(\w+)/$user_defs{$1}/g; |
---|
776 | |
---|
777 | See also ``How do I expand function calls in a string?'' in this section |
---|
778 | of the FAQ. |
---|
779 | |
---|
780 | =head2 What's wrong with always quoting "$vars"? |
---|
781 | |
---|
782 | The problem is that those double-quotes force stringification, |
---|
783 | coercing numbers and references into strings, even when you |
---|
784 | don't want them to be. Think of it this way: double-quote |
---|
785 | expansion is used to produce new strings. If you already |
---|
786 | have a string, why do you need more? |
---|
787 | |
---|
788 | If you get used to writing odd things like these: |
---|
789 | |
---|
790 | print "$var"; # BAD |
---|
791 | $new = "$old"; # BAD |
---|
792 | somefunc("$var"); # BAD |
---|
793 | |
---|
794 | You'll be in trouble. Those should (in 99.8% of the cases) be |
---|
795 | the simpler and more direct: |
---|
796 | |
---|
797 | print $var; |
---|
798 | $new = $old; |
---|
799 | somefunc($var); |
---|
800 | |
---|
801 | Otherwise, besides slowing you down, you're going to break code when |
---|
802 | the thing in the scalar is actually neither a string nor a number, but |
---|
803 | a reference: |
---|
804 | |
---|
805 | func(\@array); |
---|
806 | sub func { |
---|
807 | my $aref = shift; |
---|
808 | my $oref = "$aref"; # WRONG |
---|
809 | } |
---|
810 | |
---|
811 | You can also get into subtle problems on those few operations in Perl |
---|
812 | that actually do care about the difference between a string and a |
---|
813 | number, such as the magical C<++> autoincrement operator or the |
---|
814 | syscall() function. |
---|
815 | |
---|
816 | Stringification also destroys arrays. |
---|
817 | |
---|
818 | @lines = `command`; |
---|
819 | print "@lines"; # WRONG - extra blanks |
---|
820 | print @lines; # right |
---|
821 | |
---|
822 | =head2 Why don't my <<HERE documents work? |
---|
823 | |
---|
824 | Check for these three things: |
---|
825 | |
---|
826 | =over 4 |
---|
827 | |
---|
828 | =item 1. There must be no space after the << part. |
---|
829 | |
---|
830 | =item 2. There (probably) should be a semicolon at the end. |
---|
831 | |
---|
832 | =item 3. You can't (easily) have any space in front of the tag. |
---|
833 | |
---|
834 | =back |
---|
835 | |
---|
836 | If you want to indent the text in the here document, you |
---|
837 | can do this: |
---|
838 | |
---|
839 | # all in one |
---|
840 | ($VAR = <<HERE_TARGET) =~ s/^\s+//gm; |
---|
841 | your text |
---|
842 | goes here |
---|
843 | HERE_TARGET |
---|
844 | |
---|
845 | But the HERE_TARGET must still be flush against the margin. |
---|
846 | If you want that indented also, you'll have to quote |
---|
847 | in the indentation. |
---|
848 | |
---|
849 | ($quote = <<' FINIS') =~ s/^\s+//gm; |
---|
850 | ...we will have peace, when you and all your works have |
---|
851 | perished--and the works of your dark master to whom you |
---|
852 | would deliver us. You are a liar, Saruman, and a corrupter |
---|
853 | of men's hearts. --Theoden in /usr/src/perl/taint.c |
---|
854 | FINIS |
---|
855 | $quote =~ s/\s*--/\n--/; |
---|
856 | |
---|
857 | A nice general-purpose fixer-upper function for indented here documents |
---|
858 | follows. It expects to be called with a here document as its argument. |
---|
859 | It looks to see whether each line begins with a common substring, and |
---|
860 | if so, strips that off. Otherwise, it takes the amount of leading |
---|
861 | white space found on the first line and removes that much off each |
---|
862 | subsequent line. |
---|
863 | |
---|
864 | sub fix { |
---|
865 | local $_ = shift; |
---|
866 | my ($white, $leader); # common white space and common leading string |
---|
867 | if (/^\s*(?:([^\w\s]+)(\s*).*\n)(?:\s*\1\2?.*\n)+$/) { |
---|
868 | ($white, $leader) = ($2, quotemeta($1)); |
---|
869 | } else { |
---|
870 | ($white, $leader) = (/^(\s+)/, ''); |
---|
871 | } |
---|
872 | s/^\s*?$leader(?:$white)?//gm; |
---|
873 | return $_; |
---|
874 | } |
---|
875 | |
---|
876 | This works with leading special strings, dynamically determined: |
---|
877 | |
---|
878 | $remember_the_main = fix<<' MAIN_INTERPRETER_LOOP'; |
---|
879 | @@@ int |
---|
880 | @@@ runops() { |
---|
881 | @@@ SAVEI32(runlevel); |
---|
882 | @@@ runlevel++; |
---|
883 | @@@ while ( op = (*op->op_ppaddr)() ); |
---|
884 | @@@ TAINT_NOT; |
---|
885 | @@@ return 0; |
---|
886 | @@@ } |
---|
887 | MAIN_INTERPRETER_LOOP |
---|
888 | |
---|
889 | Or with a fixed amount of leading white space, with remaining |
---|
890 | indentation correctly preserved: |
---|
891 | |
---|
892 | $poem = fix<<EVER_ON_AND_ON; |
---|
893 | Now far ahead the Road has gone, |
---|
894 | And I must follow, if I can, |
---|
895 | Pursuing it with eager feet, |
---|
896 | Until it joins some larger way |
---|
897 | Where many paths and errands meet. |
---|
898 | And whither then? I cannot say. |
---|
899 | --Bilbo in /usr/src/perl/pp_ctl.c |
---|
900 | EVER_ON_AND_ON |
---|
901 | |
---|
902 | =head1 Data: Arrays |
---|
903 | |
---|
904 | =head2 What is the difference between a list and an array? |
---|
905 | |
---|
906 | An array has a changeable length. A list does not. An array is something |
---|
907 | you can push or pop, while a list is a set of values. Some people make |
---|
908 | the distinction that a list is a value while an array is a variable. |
---|
909 | Subroutines are passed and return lists, you put things into list |
---|
910 | context, you initialize arrays with lists, and you foreach() across |
---|
911 | a list. C<@> variables are arrays, anonymous arrays are arrays, arrays |
---|
912 | in scalar context behave like the number of elements in them, subroutines |
---|
913 | access their arguments through the array C<@_>, push/pop/shift only work |
---|
914 | on arrays. |
---|
915 | |
---|
916 | As a side note, there's no such thing as a list in scalar context. |
---|
917 | When you say |
---|
918 | |
---|
919 | $scalar = (2, 5, 7, 9); |
---|
920 | |
---|
921 | you're using the comma operator in scalar context, so it uses the scalar |
---|
922 | comma operator. There never was a list there at all! This causes the |
---|
923 | last value to be returned: 9. |
---|
924 | |
---|
925 | =head2 What is the difference between $array[1] and @array[1]? |
---|
926 | |
---|
927 | The former is a scalar value, the latter an array slice, which makes |
---|
928 | it a list with one (scalar) value. You should use $ when you want a |
---|
929 | scalar value (most of the time) and @ when you want a list with one |
---|
930 | scalar value in it (very, very rarely; nearly never, in fact). |
---|
931 | |
---|
932 | Sometimes it doesn't make a difference, but sometimes it does. |
---|
933 | For example, compare: |
---|
934 | |
---|
935 | $good[0] = `some program that outputs several lines`; |
---|
936 | |
---|
937 | with |
---|
938 | |
---|
939 | @bad[0] = `same program that outputs several lines`; |
---|
940 | |
---|
941 | The C<use warnings> pragma and the B<-w> flag will warn you about these |
---|
942 | matters. |
---|
943 | |
---|
944 | =head2 How can I remove duplicate elements from a list or array? |
---|
945 | |
---|
946 | There are several possible ways, depending on whether the array is |
---|
947 | ordered and whether you wish to preserve the ordering. |
---|
948 | |
---|
949 | =over 4 |
---|
950 | |
---|
951 | =item a) If @in is sorted, and you want @out to be sorted: |
---|
952 | (this assumes all true values in the array) |
---|
953 | |
---|
954 | $prev = 'nonesuch'; |
---|
955 | @out = grep($_ ne $prev && ($prev = $_), @in); |
---|
956 | |
---|
957 | This is nice in that it doesn't use much extra memory, simulating |
---|
958 | uniq(1)'s behavior of removing only adjacent duplicates. It's less |
---|
959 | nice in that it won't work with false values like undef, 0, or ""; |
---|
960 | "0 but true" is OK, though. |
---|
961 | |
---|
962 | =item b) If you don't know whether @in is sorted: |
---|
963 | |
---|
964 | undef %saw; |
---|
965 | @out = grep(!$saw{$_}++, @in); |
---|
966 | |
---|
967 | =item c) Like (b), but @in contains only small integers: |
---|
968 | |
---|
969 | @out = grep(!$saw[$_]++, @in); |
---|
970 | |
---|
971 | =item d) A way to do (b) without any loops or greps: |
---|
972 | |
---|
973 | undef %saw; |
---|
974 | @saw{@in} = (); |
---|
975 | @out = sort keys %saw; # remove sort if undesired |
---|
976 | |
---|
977 | =item e) Like (d), but @in contains only small positive integers: |
---|
978 | |
---|
979 | undef @ary; |
---|
980 | @ary[@in] = @in; |
---|
981 | @out = grep {defined} @ary; |
---|
982 | |
---|
983 | =back |
---|
984 | |
---|
985 | But perhaps you should have been using a hash all along, eh? |
---|
986 | |
---|
987 | =head2 How can I tell whether a list or array contains a certain element? |
---|
988 | |
---|
989 | Hearing the word "in" is an I<in>dication that you probably should have |
---|
990 | used a hash, not a list or array, to store your data. Hashes are |
---|
991 | designed to answer this question quickly and efficiently. Arrays aren't. |
---|
992 | |
---|
993 | That being said, there are several ways to approach this. If you |
---|
994 | are going to make this query many times over arbitrary string values, |
---|
995 | the fastest way is probably to invert the original array and keep an |
---|
996 | associative array lying about whose keys are the first array's values. |
---|
997 | |
---|
998 | @blues = qw/azure cerulean teal turquoise lapis-lazuli/; |
---|
999 | undef %is_blue; |
---|
1000 | for (@blues) { $is_blue{$_} = 1 } |
---|
1001 | |
---|
1002 | Now you can check whether $is_blue{$some_color}. It might have been a |
---|
1003 | good idea to keep the blues all in a hash in the first place. |
---|
1004 | |
---|
1005 | If the values are all small integers, you could use a simple indexed |
---|
1006 | array. This kind of an array will take up less space: |
---|
1007 | |
---|
1008 | @primes = (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31); |
---|
1009 | undef @is_tiny_prime; |
---|
1010 | for (@primes) { $is_tiny_prime[$_] = 1 } |
---|
1011 | # or simply @istiny_prime[@primes] = (1) x @primes; |
---|
1012 | |
---|
1013 | Now you check whether $is_tiny_prime[$some_number]. |
---|
1014 | |
---|
1015 | If the values in question are integers instead of strings, you can save |
---|
1016 | quite a lot of space by using bit strings instead: |
---|
1017 | |
---|
1018 | @articles = ( 1..10, 150..2000, 2017 ); |
---|
1019 | undef $read; |
---|
1020 | for (@articles) { vec($read,$_,1) = 1 } |
---|
1021 | |
---|
1022 | Now check whether C<vec($read,$n,1)> is true for some C<$n>. |
---|
1023 | |
---|
1024 | Please do not use |
---|
1025 | |
---|
1026 | $is_there = grep $_ eq $whatever, @array; |
---|
1027 | |
---|
1028 | or worse yet |
---|
1029 | |
---|
1030 | $is_there = grep /$whatever/, @array; |
---|
1031 | |
---|
1032 | These are slow (checks every element even if the first matches), |
---|
1033 | inefficient (same reason), and potentially buggy (what if there are |
---|
1034 | regex characters in $whatever?). If you're only testing once, then |
---|
1035 | use: |
---|
1036 | |
---|
1037 | $is_there = 0; |
---|
1038 | foreach $elt (@array) { |
---|
1039 | if ($elt eq $elt_to_find) { |
---|
1040 | $is_there = 1; |
---|
1041 | last; |
---|
1042 | } |
---|
1043 | } |
---|
1044 | if ($is_there) { ... } |
---|
1045 | |
---|
1046 | =head2 How do I compute the difference of two arrays? How do I compute the intersection of two arrays? |
---|
1047 | |
---|
1048 | Use a hash. Here's code to do both and more. It assumes that |
---|
1049 | each element is unique in a given array: |
---|
1050 | |
---|
1051 | @union = @intersection = @difference = (); |
---|
1052 | %count = (); |
---|
1053 | foreach $element (@array1, @array2) { $count{$element}++ } |
---|
1054 | foreach $element (keys %count) { |
---|
1055 | push @union, $element; |
---|
1056 | push @{ $count{$element} > 1 ? \@intersection : \@difference }, $element; |
---|
1057 | } |
---|
1058 | |
---|
1059 | Note that this is the I<symmetric difference>, that is, all elements in |
---|
1060 | either A or in B, but not in both. Think of it as an xor operation. |
---|
1061 | |
---|
1062 | =head2 How do I test whether two arrays or hashes are equal? |
---|
1063 | |
---|
1064 | The following code works for single-level arrays. It uses a stringwise |
---|
1065 | comparison, and does not distinguish defined versus undefined empty |
---|
1066 | strings. Modify if you have other needs. |
---|
1067 | |
---|
1068 | $are_equal = compare_arrays(\@frogs, \@toads); |
---|
1069 | |
---|
1070 | sub compare_arrays { |
---|
1071 | my ($first, $second) = @_; |
---|
1072 | no warnings; # silence spurious -w undef complaints |
---|
1073 | return 0 unless @$first == @$second; |
---|
1074 | for (my $i = 0; $i < @$first; $i++) { |
---|
1075 | return 0 if $first->[$i] ne $second->[$i]; |
---|
1076 | } |
---|
1077 | return 1; |
---|
1078 | } |
---|
1079 | |
---|
1080 | For multilevel structures, you may wish to use an approach more |
---|
1081 | like this one. It uses the CPAN module FreezeThaw: |
---|
1082 | |
---|
1083 | use FreezeThaw qw(cmpStr); |
---|
1084 | @a = @b = ( "this", "that", [ "more", "stuff" ] ); |
---|
1085 | |
---|
1086 | printf "a and b contain %s arrays\n", |
---|
1087 | cmpStr(\@a, \@b) == 0 |
---|
1088 | ? "the same" |
---|
1089 | : "different"; |
---|
1090 | |
---|
1091 | This approach also works for comparing hashes. Here |
---|
1092 | we'll demonstrate two different answers: |
---|
1093 | |
---|
1094 | use FreezeThaw qw(cmpStr cmpStrHard); |
---|
1095 | |
---|
1096 | %a = %b = ( "this" => "that", "extra" => [ "more", "stuff" ] ); |
---|
1097 | $a{EXTRA} = \%b; |
---|
1098 | $b{EXTRA} = \%a; |
---|
1099 | |
---|
1100 | printf "a and b contain %s hashes\n", |
---|
1101 | cmpStr(\%a, \%b) == 0 ? "the same" : "different"; |
---|
1102 | |
---|
1103 | printf "a and b contain %s hashes\n", |
---|
1104 | cmpStrHard(\%a, \%b) == 0 ? "the same" : "different"; |
---|
1105 | |
---|
1106 | |
---|
1107 | The first reports that both those the hashes contain the same data, |
---|
1108 | while the second reports that they do not. Which you prefer is left as |
---|
1109 | an exercise to the reader. |
---|
1110 | |
---|
1111 | =head2 How do I find the first array element for which a condition is true? |
---|
1112 | |
---|
1113 | You can use this if you care about the index: |
---|
1114 | |
---|
1115 | for ($i= 0; $i < @array; $i++) { |
---|
1116 | if ($array[$i] eq "Waldo") { |
---|
1117 | $found_index = $i; |
---|
1118 | last; |
---|
1119 | } |
---|
1120 | } |
---|
1121 | |
---|
1122 | Now C<$found_index> has what you want. |
---|
1123 | |
---|
1124 | =head2 How do I handle linked lists? |
---|
1125 | |
---|
1126 | In general, you usually don't need a linked list in Perl, since with |
---|
1127 | regular arrays, you can push and pop or shift and unshift at either end, |
---|
1128 | or you can use splice to add and/or remove arbitrary number of elements at |
---|
1129 | arbitrary points. Both pop and shift are both O(1) operations on Perl's |
---|
1130 | dynamic arrays. In the absence of shifts and pops, push in general |
---|
1131 | needs to reallocate on the order every log(N) times, and unshift will |
---|
1132 | need to copy pointers each time. |
---|
1133 | |
---|
1134 | If you really, really wanted, you could use structures as described in |
---|
1135 | L<perldsc> or L<perltoot> and do just what the algorithm book tells you |
---|
1136 | to do. For example, imagine a list node like this: |
---|
1137 | |
---|
1138 | $node = { |
---|
1139 | VALUE => 42, |
---|
1140 | LINK => undef, |
---|
1141 | }; |
---|
1142 | |
---|
1143 | You could walk the list this way: |
---|
1144 | |
---|
1145 | print "List: "; |
---|
1146 | for ($node = $head; $node; $node = $node->{LINK}) { |
---|
1147 | print $node->{VALUE}, " "; |
---|
1148 | } |
---|
1149 | print "\n"; |
---|
1150 | |
---|
1151 | You could grow the list this way: |
---|
1152 | |
---|
1153 | my ($head, $tail); |
---|
1154 | $tail = append($head, 1); # grow a new head |
---|
1155 | for $value ( 2 .. 10 ) { |
---|
1156 | $tail = append($tail, $value); |
---|
1157 | } |
---|
1158 | |
---|
1159 | sub append { |
---|
1160 | my($list, $value) = @_; |
---|
1161 | my $node = { VALUE => $value }; |
---|
1162 | if ($list) { |
---|
1163 | $node->{LINK} = $list->{LINK}; |
---|
1164 | $list->{LINK} = $node; |
---|
1165 | } else { |
---|
1166 | $_[0] = $node; # replace caller's version |
---|
1167 | } |
---|
1168 | return $node; |
---|
1169 | } |
---|
1170 | |
---|
1171 | But again, Perl's built-in are virtually always good enough. |
---|
1172 | |
---|
1173 | =head2 How do I handle circular lists? |
---|
1174 | |
---|
1175 | Circular lists could be handled in the traditional fashion with linked |
---|
1176 | lists, or you could just do something like this with an array: |
---|
1177 | |
---|
1178 | unshift(@array, pop(@array)); # the last shall be first |
---|
1179 | push(@array, shift(@array)); # and vice versa |
---|
1180 | |
---|
1181 | =head2 How do I shuffle an array randomly? |
---|
1182 | |
---|
1183 | Use this: |
---|
1184 | |
---|
1185 | # fisher_yates_shuffle( \@array ) : |
---|
1186 | # generate a random permutation of @array in place |
---|
1187 | sub fisher_yates_shuffle { |
---|
1188 | my $array = shift; |
---|
1189 | my $i; |
---|
1190 | for ($i = @$array; --$i; ) { |
---|
1191 | my $j = int rand ($i+1); |
---|
1192 | next if $i == $j; |
---|
1193 | @$array[$i,$j] = @$array[$j,$i]; |
---|
1194 | } |
---|
1195 | } |
---|
1196 | |
---|
1197 | fisher_yates_shuffle( \@array ); # permutes @array in place |
---|
1198 | |
---|
1199 | You've probably seen shuffling algorithms that work using splice, |
---|
1200 | randomly picking another element to swap the current element with: |
---|
1201 | |
---|
1202 | srand; |
---|
1203 | @new = (); |
---|
1204 | @old = 1 .. 10; # just a demo |
---|
1205 | while (@old) { |
---|
1206 | push(@new, splice(@old, rand @old, 1)); |
---|
1207 | } |
---|
1208 | |
---|
1209 | This is bad because splice is already O(N), and since you do it N times, |
---|
1210 | you just invented a quadratic algorithm; that is, O(N**2). This does |
---|
1211 | not scale, although Perl is so efficient that you probably won't notice |
---|
1212 | this until you have rather largish arrays. |
---|
1213 | |
---|
1214 | =head2 How do I process/modify each element of an array? |
---|
1215 | |
---|
1216 | Use C<for>/C<foreach>: |
---|
1217 | |
---|
1218 | for (@lines) { |
---|
1219 | s/foo/bar/; # change that word |
---|
1220 | y/XZ/ZX/; # swap those letters |
---|
1221 | } |
---|
1222 | |
---|
1223 | Here's another; let's compute spherical volumes: |
---|
1224 | |
---|
1225 | for (@volumes = @radii) { # @volumes has changed parts |
---|
1226 | $_ **= 3; |
---|
1227 | $_ *= (4/3) * 3.14159; # this will be constant folded |
---|
1228 | } |
---|
1229 | |
---|
1230 | If you want to do the same thing to modify the values of the hash, |
---|
1231 | you may not use the C<values> function, oddly enough. You need a slice: |
---|
1232 | |
---|
1233 | for $orbit ( @orbits{keys %orbits} ) { |
---|
1234 | ($orbit **= 3) *= (4/3) * 3.14159; |
---|
1235 | } |
---|
1236 | |
---|
1237 | =head2 How do I select a random element from an array? |
---|
1238 | |
---|
1239 | Use the rand() function (see L<perlfunc/rand>): |
---|
1240 | |
---|
1241 | # at the top of the program: |
---|
1242 | srand; # not needed for 5.004 and later |
---|
1243 | |
---|
1244 | # then later on |
---|
1245 | $index = rand @array; |
---|
1246 | $element = $array[$index]; |
---|
1247 | |
---|
1248 | Make sure you I<only call srand once per program, if then>. |
---|
1249 | If you are calling it more than once (such as before each |
---|
1250 | call to rand), you're almost certainly doing something wrong. |
---|
1251 | |
---|
1252 | =head2 How do I permute N elements of a list? |
---|
1253 | |
---|
1254 | Here's a little program that generates all permutations |
---|
1255 | of all the words on each line of input. The algorithm embodied |
---|
1256 | in the permute() function should work on any list: |
---|
1257 | |
---|
1258 | #!/usr/bin/perl -n |
---|
1259 | # tsc-permute: permute each word of input |
---|
1260 | permute([split], []); |
---|
1261 | sub permute { |
---|
1262 | my @items = @{ $_[0] }; |
---|
1263 | my @perms = @{ $_[1] }; |
---|
1264 | unless (@items) { |
---|
1265 | print "@perms\n"; |
---|
1266 | } else { |
---|
1267 | my(@newitems,@newperms,$i); |
---|
1268 | foreach $i (0 .. $#items) { |
---|
1269 | @newitems = @items; |
---|
1270 | @newperms = @perms; |
---|
1271 | unshift(@newperms, splice(@newitems, $i, 1)); |
---|
1272 | permute([@newitems], [@newperms]); |
---|
1273 | } |
---|
1274 | } |
---|
1275 | } |
---|
1276 | |
---|
1277 | =head2 How do I sort an array by (anything)? |
---|
1278 | |
---|
1279 | Supply a comparison function to sort() (described in L<perlfunc/sort>): |
---|
1280 | |
---|
1281 | @list = sort { $a <=> $b } @list; |
---|
1282 | |
---|
1283 | The default sort function is cmp, string comparison, which would |
---|
1284 | sort C<(1, 2, 10)> into C<(1, 10, 2)>. C<< <=> >>, used above, is |
---|
1285 | the numerical comparison operator. |
---|
1286 | |
---|
1287 | If you have a complicated function needed to pull out the part you |
---|
1288 | want to sort on, then don't do it inside the sort function. Pull it |
---|
1289 | out first, because the sort BLOCK can be called many times for the |
---|
1290 | same element. Here's an example of how to pull out the first word |
---|
1291 | after the first number on each item, and then sort those words |
---|
1292 | case-insensitively. |
---|
1293 | |
---|
1294 | @idx = (); |
---|
1295 | for (@data) { |
---|
1296 | ($item) = /\d+\s*(\S+)/; |
---|
1297 | push @idx, uc($item); |
---|
1298 | } |
---|
1299 | @sorted = @data[ sort { $idx[$a] cmp $idx[$b] } 0 .. $#idx ]; |
---|
1300 | |
---|
1301 | Which could also be written this way, using a trick |
---|
1302 | that's come to be known as the Schwartzian Transform: |
---|
1303 | |
---|
1304 | @sorted = map { $_->[0] } |
---|
1305 | sort { $a->[1] cmp $b->[1] } |
---|
1306 | map { [ $_, uc( (/\d+\s*(\S+)/)[0]) ] } @data; |
---|
1307 | |
---|
1308 | If you need to sort on several fields, the following paradigm is useful. |
---|
1309 | |
---|
1310 | @sorted = sort { field1($a) <=> field1($b) || |
---|
1311 | field2($a) cmp field2($b) || |
---|
1312 | field3($a) cmp field3($b) |
---|
1313 | } @data; |
---|
1314 | |
---|
1315 | This can be conveniently combined with precalculation of keys as given |
---|
1316 | above. |
---|
1317 | |
---|
1318 | See http://www.perl.com/CPAN/doc/FMTEYEWTK/sort.html for more about |
---|
1319 | this approach. |
---|
1320 | |
---|
1321 | See also the question below on sorting hashes. |
---|
1322 | |
---|
1323 | =head2 How do I manipulate arrays of bits? |
---|
1324 | |
---|
1325 | Use pack() and unpack(), or else vec() and the bitwise operations. |
---|
1326 | |
---|
1327 | For example, this sets $vec to have bit N set if $ints[N] was set: |
---|
1328 | |
---|
1329 | $vec = ''; |
---|
1330 | foreach(@ints) { vec($vec,$_,1) = 1 } |
---|
1331 | |
---|
1332 | And here's how, given a vector in $vec, you can |
---|
1333 | get those bits into your @ints array: |
---|
1334 | |
---|
1335 | sub bitvec_to_list { |
---|
1336 | my $vec = shift; |
---|
1337 | my @ints; |
---|
1338 | # Find null-byte density then select best algorithm |
---|
1339 | if ($vec =~ tr/\0// / length $vec > 0.95) { |
---|
1340 | use integer; |
---|
1341 | my $i; |
---|
1342 | # This method is faster with mostly null-bytes |
---|
1343 | while($vec =~ /[^\0]/g ) { |
---|
1344 | $i = -9 + 8 * pos $vec; |
---|
1345 | push @ints, $i if vec($vec, ++$i, 1); |
---|
1346 | push @ints, $i if vec($vec, ++$i, 1); |
---|
1347 | push @ints, $i if vec($vec, ++$i, 1); |
---|
1348 | push @ints, $i if vec($vec, ++$i, 1); |
---|
1349 | push @ints, $i if vec($vec, ++$i, 1); |
---|
1350 | push @ints, $i if vec($vec, ++$i, 1); |
---|
1351 | push @ints, $i if vec($vec, ++$i, 1); |
---|
1352 | push @ints, $i if vec($vec, ++$i, 1); |
---|
1353 | } |
---|
1354 | } else { |
---|
1355 | # This method is a fast general algorithm |
---|
1356 | use integer; |
---|
1357 | my $bits = unpack "b*", $vec; |
---|
1358 | push @ints, 0 if $bits =~ s/^(\d)// && $1; |
---|
1359 | push @ints, pos $bits while($bits =~ /1/g); |
---|
1360 | } |
---|
1361 | return \@ints; |
---|
1362 | } |
---|
1363 | |
---|
1364 | This method gets faster the more sparse the bit vector is. |
---|
1365 | (Courtesy of Tim Bunce and Winfried Koenig.) |
---|
1366 | |
---|
1367 | Here's a demo on how to use vec(): |
---|
1368 | |
---|
1369 | # vec demo |
---|
1370 | $vector = "\xff\x0f\xef\xfe"; |
---|
1371 | print "Ilya's string \\xff\\x0f\\xef\\xfe represents the number ", |
---|
1372 | unpack("N", $vector), "\n"; |
---|
1373 | $is_set = vec($vector, 23, 1); |
---|
1374 | print "Its 23rd bit is ", $is_set ? "set" : "clear", ".\n"; |
---|
1375 | pvec($vector); |
---|
1376 | |
---|
1377 | set_vec(1,1,1); |
---|
1378 | set_vec(3,1,1); |
---|
1379 | set_vec(23,1,1); |
---|
1380 | |
---|
1381 | set_vec(3,1,3); |
---|
1382 | set_vec(3,2,3); |
---|
1383 | set_vec(3,4,3); |
---|
1384 | set_vec(3,4,7); |
---|
1385 | set_vec(3,8,3); |
---|
1386 | set_vec(3,8,7); |
---|
1387 | |
---|
1388 | set_vec(0,32,17); |
---|
1389 | set_vec(1,32,17); |
---|
1390 | |
---|
1391 | sub set_vec { |
---|
1392 | my ($offset, $width, $value) = @_; |
---|
1393 | my $vector = ''; |
---|
1394 | vec($vector, $offset, $width) = $value; |
---|
1395 | print "offset=$offset width=$width value=$value\n"; |
---|
1396 | pvec($vector); |
---|
1397 | } |
---|
1398 | |
---|
1399 | sub pvec { |
---|
1400 | my $vector = shift; |
---|
1401 | my $bits = unpack("b*", $vector); |
---|
1402 | my $i = 0; |
---|
1403 | my $BASE = 8; |
---|
1404 | |
---|
1405 | print "vector length in bytes: ", length($vector), "\n"; |
---|
1406 | @bytes = unpack("A8" x length($vector), $bits); |
---|
1407 | print "bits are: @bytes\n\n"; |
---|
1408 | } |
---|
1409 | |
---|
1410 | =head2 Why does defined() return true on empty arrays and hashes? |
---|
1411 | |
---|
1412 | The short story is that you should probably only use defined on scalars or |
---|
1413 | functions, not on aggregates (arrays and hashes). See L<perlfunc/defined> |
---|
1414 | in the 5.004 release or later of Perl for more detail. |
---|
1415 | |
---|
1416 | =head1 Data: Hashes (Associative Arrays) |
---|
1417 | |
---|
1418 | =head2 How do I process an entire hash? |
---|
1419 | |
---|
1420 | Use the each() function (see L<perlfunc/each>) if you don't care |
---|
1421 | whether it's sorted: |
---|
1422 | |
---|
1423 | while ( ($key, $value) = each %hash) { |
---|
1424 | print "$key = $value\n"; |
---|
1425 | } |
---|
1426 | |
---|
1427 | If you want it sorted, you'll have to use foreach() on the result of |
---|
1428 | sorting the keys as shown in an earlier question. |
---|
1429 | |
---|
1430 | =head2 What happens if I add or remove keys from a hash while iterating over it? |
---|
1431 | |
---|
1432 | Don't do that. :-) |
---|
1433 | |
---|
1434 | [lwall] In Perl 4, you were not allowed to modify a hash at all while |
---|
1435 | iterating over it. In Perl 5 you can delete from it, but you still |
---|
1436 | can't add to it, because that might cause a doubling of the hash table, |
---|
1437 | in which half the entries get copied up to the new top half of the |
---|
1438 | table, at which point you've totally bamboozled the iterator code. |
---|
1439 | Even if the table doesn't double, there's no telling whether your new |
---|
1440 | entry will be inserted before or after the current iterator position. |
---|
1441 | |
---|
1442 | Either treasure up your changes and make them after the iterator finishes, |
---|
1443 | or use keys to fetch all the old keys at once, and iterate over the list |
---|
1444 | of keys. |
---|
1445 | |
---|
1446 | =head2 How do I look up a hash element by value? |
---|
1447 | |
---|
1448 | Create a reverse hash: |
---|
1449 | |
---|
1450 | %by_value = reverse %by_key; |
---|
1451 | $key = $by_value{$value}; |
---|
1452 | |
---|
1453 | That's not particularly efficient. It would be more space-efficient |
---|
1454 | to use: |
---|
1455 | |
---|
1456 | while (($key, $value) = each %by_key) { |
---|
1457 | $by_value{$value} = $key; |
---|
1458 | } |
---|
1459 | |
---|
1460 | If your hash could have repeated values, the methods above will only find |
---|
1461 | one of the associated keys. This may or may not worry you. If it does |
---|
1462 | worry you, you can always reverse the hash into a hash of arrays instead: |
---|
1463 | |
---|
1464 | while (($key, $value) = each %by_key) { |
---|
1465 | push @{$key_list_by_value{$value}}, $key; |
---|
1466 | } |
---|
1467 | |
---|
1468 | =head2 How can I know how many entries are in a hash? |
---|
1469 | |
---|
1470 | If you mean how many keys, then all you have to do is |
---|
1471 | take the scalar sense of the keys() function: |
---|
1472 | |
---|
1473 | $num_keys = scalar keys %hash; |
---|
1474 | |
---|
1475 | In void context, the keys() function just resets the iterator, which is |
---|
1476 | faster for tied hashes than would be iterating through the whole |
---|
1477 | hash, one key-value pair at a time. |
---|
1478 | |
---|
1479 | =head2 How do I sort a hash (optionally by value instead of key)? |
---|
1480 | |
---|
1481 | Internally, hashes are stored in a way that prevents you from imposing |
---|
1482 | an order on key-value pairs. Instead, you have to sort a list of the |
---|
1483 | keys or values: |
---|
1484 | |
---|
1485 | @keys = sort keys %hash; # sorted by key |
---|
1486 | @keys = sort { |
---|
1487 | $hash{$a} cmp $hash{$b} |
---|
1488 | } keys %hash; # and by value |
---|
1489 | |
---|
1490 | Here we'll do a reverse numeric sort by value, and if two keys are |
---|
1491 | identical, sort by length of key, and if that fails, by straight ASCII |
---|
1492 | comparison of the keys (well, possibly modified by your locale -- see |
---|
1493 | L<perllocale>). |
---|
1494 | |
---|
1495 | @keys = sort { |
---|
1496 | $hash{$b} <=> $hash{$a} |
---|
1497 | || |
---|
1498 | length($b) <=> length($a) |
---|
1499 | || |
---|
1500 | $a cmp $b |
---|
1501 | } keys %hash; |
---|
1502 | |
---|
1503 | =head2 How can I always keep my hash sorted? |
---|
1504 | |
---|
1505 | You can look into using the DB_File module and tie() using the |
---|
1506 | $DB_BTREE hash bindings as documented in L<DB_File/"In Memory Databases">. |
---|
1507 | The Tie::IxHash module from CPAN might also be instructive. |
---|
1508 | |
---|
1509 | =head2 What's the difference between "delete" and "undef" with hashes? |
---|
1510 | |
---|
1511 | Hashes are pairs of scalars: the first is the key, the second is the |
---|
1512 | value. The key will be coerced to a string, although the value can be |
---|
1513 | any kind of scalar: string, number, or reference. If a key C<$key> is |
---|
1514 | present in the array, C<exists($key)> will return true. The value for |
---|
1515 | a given key can be C<undef>, in which case C<$array{$key}> will be |
---|
1516 | C<undef> while C<$exists{$key}> will return true. This corresponds to |
---|
1517 | (C<$key>, C<undef>) being in the hash. |
---|
1518 | |
---|
1519 | Pictures help... here's the C<%ary> table: |
---|
1520 | |
---|
1521 | keys values |
---|
1522 | +------+------+ |
---|
1523 | | a | 3 | |
---|
1524 | | x | 7 | |
---|
1525 | | d | 0 | |
---|
1526 | | e | 2 | |
---|
1527 | +------+------+ |
---|
1528 | |
---|
1529 | And these conditions hold |
---|
1530 | |
---|
1531 | $ary{'a'} is true |
---|
1532 | $ary{'d'} is false |
---|
1533 | defined $ary{'d'} is true |
---|
1534 | defined $ary{'a'} is true |
---|
1535 | exists $ary{'a'} is true (Perl5 only) |
---|
1536 | grep ($_ eq 'a', keys %ary) is true |
---|
1537 | |
---|
1538 | If you now say |
---|
1539 | |
---|
1540 | undef $ary{'a'} |
---|
1541 | |
---|
1542 | your table now reads: |
---|
1543 | |
---|
1544 | |
---|
1545 | keys values |
---|
1546 | +------+------+ |
---|
1547 | | a | undef| |
---|
1548 | | x | 7 | |
---|
1549 | | d | 0 | |
---|
1550 | | e | 2 | |
---|
1551 | +------+------+ |
---|
1552 | |
---|
1553 | and these conditions now hold; changes in caps: |
---|
1554 | |
---|
1555 | $ary{'a'} is FALSE |
---|
1556 | $ary{'d'} is false |
---|
1557 | defined $ary{'d'} is true |
---|
1558 | defined $ary{'a'} is FALSE |
---|
1559 | exists $ary{'a'} is true (Perl5 only) |
---|
1560 | grep ($_ eq 'a', keys %ary) is true |
---|
1561 | |
---|
1562 | Notice the last two: you have an undef value, but a defined key! |
---|
1563 | |
---|
1564 | Now, consider this: |
---|
1565 | |
---|
1566 | delete $ary{'a'} |
---|
1567 | |
---|
1568 | your table now reads: |
---|
1569 | |
---|
1570 | keys values |
---|
1571 | +------+------+ |
---|
1572 | | x | 7 | |
---|
1573 | | d | 0 | |
---|
1574 | | e | 2 | |
---|
1575 | +------+------+ |
---|
1576 | |
---|
1577 | and these conditions now hold; changes in caps: |
---|
1578 | |
---|
1579 | $ary{'a'} is false |
---|
1580 | $ary{'d'} is false |
---|
1581 | defined $ary{'d'} is true |
---|
1582 | defined $ary{'a'} is false |
---|
1583 | exists $ary{'a'} is FALSE (Perl5 only) |
---|
1584 | grep ($_ eq 'a', keys %ary) is FALSE |
---|
1585 | |
---|
1586 | See, the whole entry is gone! |
---|
1587 | |
---|
1588 | =head2 Why don't my tied hashes make the defined/exists distinction? |
---|
1589 | |
---|
1590 | They may or may not implement the EXISTS() and DEFINED() methods |
---|
1591 | differently. For example, there isn't the concept of undef with hashes |
---|
1592 | that are tied to DBM* files. This means the true/false tables above |
---|
1593 | will give different results when used on such a hash. It also means |
---|
1594 | that exists and defined do the same thing with a DBM* file, and what |
---|
1595 | they end up doing is not what they do with ordinary hashes. |
---|
1596 | |
---|
1597 | =head2 How do I reset an each() operation part-way through? |
---|
1598 | |
---|
1599 | Using C<keys %hash> in scalar context returns the number of keys in |
---|
1600 | the hash I<and> resets the iterator associated with the hash. You may |
---|
1601 | need to do this if you use C<last> to exit a loop early so that when you |
---|
1602 | re-enter it, the hash iterator has been reset. |
---|
1603 | |
---|
1604 | =head2 How can I get the unique keys from two hashes? |
---|
1605 | |
---|
1606 | First you extract the keys from the hashes into lists, then solve |
---|
1607 | the "removing duplicates" problem described above. For example: |
---|
1608 | |
---|
1609 | %seen = (); |
---|
1610 | for $element (keys(%foo), keys(%bar)) { |
---|
1611 | $seen{$element}++; |
---|
1612 | } |
---|
1613 | @uniq = keys %seen; |
---|
1614 | |
---|
1615 | Or more succinctly: |
---|
1616 | |
---|
1617 | @uniq = keys %{{%foo,%bar}}; |
---|
1618 | |
---|
1619 | Or if you really want to save space: |
---|
1620 | |
---|
1621 | %seen = (); |
---|
1622 | while (defined ($key = each %foo)) { |
---|
1623 | $seen{$key}++; |
---|
1624 | } |
---|
1625 | while (defined ($key = each %bar)) { |
---|
1626 | $seen{$key}++; |
---|
1627 | } |
---|
1628 | @uniq = keys %seen; |
---|
1629 | |
---|
1630 | =head2 How can I store a multidimensional array in a DBM file? |
---|
1631 | |
---|
1632 | Either stringify the structure yourself (no fun), or else |
---|
1633 | get the MLDBM (which uses Data::Dumper) module from CPAN and layer |
---|
1634 | it on top of either DB_File or GDBM_File. |
---|
1635 | |
---|
1636 | =head2 How can I make my hash remember the order I put elements into it? |
---|
1637 | |
---|
1638 | Use the Tie::IxHash from CPAN. |
---|
1639 | |
---|
1640 | use Tie::IxHash; |
---|
1641 | tie(%myhash, Tie::IxHash); |
---|
1642 | for ($i=0; $i<20; $i++) { |
---|
1643 | $myhash{$i} = 2*$i; |
---|
1644 | } |
---|
1645 | @keys = keys %myhash; |
---|
1646 | # @keys = (0,1,2,3,...) |
---|
1647 | |
---|
1648 | =head2 Why does passing a subroutine an undefined element in a hash create it? |
---|
1649 | |
---|
1650 | If you say something like: |
---|
1651 | |
---|
1652 | somefunc($hash{"nonesuch key here"}); |
---|
1653 | |
---|
1654 | Then that element "autovivifies"; that is, it springs into existence |
---|
1655 | whether you store something there or not. That's because functions |
---|
1656 | get scalars passed in by reference. If somefunc() modifies C<$_[0]>, |
---|
1657 | it has to be ready to write it back into the caller's version. |
---|
1658 | |
---|
1659 | This has been fixed as of Perl5.004. |
---|
1660 | |
---|
1661 | Normally, merely accessing a key's value for a nonexistent key does |
---|
1662 | I<not> cause that key to be forever there. This is different than |
---|
1663 | awk's behavior. |
---|
1664 | |
---|
1665 | =head2 How can I make the Perl equivalent of a C structure/C++ class/hash or array of hashes or arrays? |
---|
1666 | |
---|
1667 | Usually a hash ref, perhaps like this: |
---|
1668 | |
---|
1669 | $record = { |
---|
1670 | NAME => "Jason", |
---|
1671 | EMPNO => 132, |
---|
1672 | TITLE => "deputy peon", |
---|
1673 | AGE => 23, |
---|
1674 | SALARY => 37_000, |
---|
1675 | PALS => [ "Norbert", "Rhys", "Phineas"], |
---|
1676 | }; |
---|
1677 | |
---|
1678 | References are documented in L<perlref> and the upcoming L<perlreftut>. |
---|
1679 | Examples of complex data structures are given in L<perldsc> and |
---|
1680 | L<perllol>. Examples of structures and object-oriented classes are |
---|
1681 | in L<perltoot>. |
---|
1682 | |
---|
1683 | =head2 How can I use a reference as a hash key? |
---|
1684 | |
---|
1685 | You can't do this directly, but you could use the standard Tie::Refhash |
---|
1686 | module distributed with Perl. |
---|
1687 | |
---|
1688 | =head1 Data: Misc |
---|
1689 | |
---|
1690 | =head2 How do I handle binary data correctly? |
---|
1691 | |
---|
1692 | Perl is binary clean, so this shouldn't be a problem. For example, |
---|
1693 | this works fine (assuming the files are found): |
---|
1694 | |
---|
1695 | if (`cat /vmunix` =~ /gzip/) { |
---|
1696 | print "Your kernel is GNU-zip enabled!\n"; |
---|
1697 | } |
---|
1698 | |
---|
1699 | On less elegant (read: Byzantine) systems, however, you have |
---|
1700 | to play tedious games with "text" versus "binary" files. See |
---|
1701 | L<perlfunc/"binmode"> or L<perlopentut>. Most of these ancient-thinking |
---|
1702 | systems are curses out of Microsoft, who seem to be committed to putting |
---|
1703 | the backward into backward compatibility. |
---|
1704 | |
---|
1705 | If you're concerned about 8-bit ASCII data, then see L<perllocale>. |
---|
1706 | |
---|
1707 | If you want to deal with multibyte characters, however, there are |
---|
1708 | some gotchas. See the section on Regular Expressions. |
---|
1709 | |
---|
1710 | =head2 How do I determine whether a scalar is a number/whole/integer/float? |
---|
1711 | |
---|
1712 | Assuming that you don't care about IEEE notations like "NaN" or |
---|
1713 | "Infinity", you probably just want to use a regular expression. |
---|
1714 | |
---|
1715 | if (/\D/) { print "has nondigits\n" } |
---|
1716 | if (/^\d+$/) { print "is a whole number\n" } |
---|
1717 | if (/^-?\d+$/) { print "is an integer\n" } |
---|
1718 | if (/^[+-]?\d+$/) { print "is a +/- integer\n" } |
---|
1719 | if (/^-?\d+\.?\d*$/) { print "is a real number\n" } |
---|
1720 | if (/^-?(?:\d+(?:\.\d*)?|\.\d+)$/) { print "is a decimal number" } |
---|
1721 | if (/^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/) |
---|
1722 | { print "a C float" } |
---|
1723 | |
---|
1724 | If you're on a POSIX system, Perl's supports the C<POSIX::strtod> |
---|
1725 | function. Its semantics are somewhat cumbersome, so here's a C<getnum> |
---|
1726 | wrapper function for more convenient access. This function takes |
---|
1727 | a string and returns the number it found, or C<undef> for input that |
---|
1728 | isn't a C float. The C<is_numeric> function is a front end to C<getnum> |
---|
1729 | if you just want to say, ``Is this a float?'' |
---|
1730 | |
---|
1731 | sub getnum { |
---|
1732 | use POSIX qw(strtod); |
---|
1733 | my $str = shift; |
---|
1734 | $str =~ s/^\s+//; |
---|
1735 | $str =~ s/\s+$//; |
---|
1736 | $! = 0; |
---|
1737 | my($num, $unparsed) = strtod($str); |
---|
1738 | if (($str eq '') || ($unparsed != 0) || $!) { |
---|
1739 | return undef; |
---|
1740 | } else { |
---|
1741 | return $num; |
---|
1742 | } |
---|
1743 | } |
---|
1744 | |
---|
1745 | sub is_numeric { defined getnum($_[0]) } |
---|
1746 | |
---|
1747 | Or you could check out the String::Scanf module on CPAN instead. The |
---|
1748 | POSIX module (part of the standard Perl distribution) provides the |
---|
1749 | C<strtol> and C<strtod> for converting strings to double and longs, |
---|
1750 | respectively. |
---|
1751 | |
---|
1752 | =head2 How do I keep persistent data across program calls? |
---|
1753 | |
---|
1754 | For some specific applications, you can use one of the DBM modules. |
---|
1755 | See L<AnyDBM_File>. More generically, you should consult the FreezeThaw, |
---|
1756 | Storable, or Class::Eroot modules from CPAN. Here's one example using |
---|
1757 | Storable's C<store> and C<retrieve> functions: |
---|
1758 | |
---|
1759 | use Storable; |
---|
1760 | store(\%hash, "filename"); |
---|
1761 | |
---|
1762 | # later on... |
---|
1763 | $href = retrieve("filename"); # by ref |
---|
1764 | %hash = %{ retrieve("filename") }; # direct to hash |
---|
1765 | |
---|
1766 | =head2 How do I print out or copy a recursive data structure? |
---|
1767 | |
---|
1768 | The Data::Dumper module on CPAN (or the 5.005 release of Perl) is great |
---|
1769 | for printing out data structures. The Storable module, found on CPAN, |
---|
1770 | provides a function called C<dclone> that recursively copies its argument. |
---|
1771 | |
---|
1772 | use Storable qw(dclone); |
---|
1773 | $r2 = dclone($r1); |
---|
1774 | |
---|
1775 | Where $r1 can be a reference to any kind of data structure you'd like. |
---|
1776 | It will be deeply copied. Because C<dclone> takes and returns references, |
---|
1777 | you'd have to add extra punctuation if you had a hash of arrays that |
---|
1778 | you wanted to copy. |
---|
1779 | |
---|
1780 | %newhash = %{ dclone(\%oldhash) }; |
---|
1781 | |
---|
1782 | =head2 How do I define methods for every class/object? |
---|
1783 | |
---|
1784 | Use the UNIVERSAL class (see L<UNIVERSAL>). |
---|
1785 | |
---|
1786 | =head2 How do I verify a credit card checksum? |
---|
1787 | |
---|
1788 | Get the Business::CreditCard module from CPAN. |
---|
1789 | |
---|
1790 | =head2 How do I pack arrays of doubles or floats for XS code? |
---|
1791 | |
---|
1792 | The kgbpack.c code in the PGPLOT module on CPAN does just this. |
---|
1793 | If you're doing a lot of float or double processing, consider using |
---|
1794 | the PDL module from CPAN instead--it makes number-crunching easy. |
---|
1795 | |
---|
1796 | =head1 AUTHOR AND COPYRIGHT |
---|
1797 | |
---|
1798 | Copyright (c) 1997-1999 Tom Christiansen and Nathan Torkington. |
---|
1799 | All rights reserved. |
---|
1800 | |
---|
1801 | When included as part of the Standard Version of Perl, or as part of |
---|
1802 | its complete documentation whether printed or otherwise, this work |
---|
1803 | may be distributed only under the terms of Perl's Artistic License. |
---|
1804 | Any distribution of this file or derivatives thereof I<outside> |
---|
1805 | of that package require that special arrangements be made with |
---|
1806 | copyright holder. |
---|
1807 | |
---|
1808 | Irrespective of its distribution, all code examples in this file |
---|
1809 | are hereby placed into the public domain. You are permitted and |
---|
1810 | encouraged to use this code in your own programs for fun |
---|
1811 | or for profit as you see fit. A simple comment in the code giving |
---|
1812 | credit would be courteous but is not required. |
---|