Commit | Line | Data |
68dc0745 |
1 | =head1 NAME |
2 | |
5e3006a4 |
3 | perlfaq4 - Data Manipulation ($Revision: 1.26 $, $Date: 1998/08/05 12:04:00 $) |
68dc0745 |
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 | |
46fc3d4c |
13 | =head2 Why am I getting long decimals (eg, 19.9499999999999) instead of the numbers I should be getting (eg, 19.95)? |
14 | |
5a964f20 |
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 | |
46fc3d4c |
19 | Internally, your computer represents floating-point numbers in binary. |
92c2ed05 |
20 | Floating-point numbers read in from a file or appearing as literals |
21 | in your program are converted from their decimal floating-point |
46fc3d4c |
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. |
5a964f20 |
44 | See L<perlop/"Floating-point Arithmetic">. |
46fc3d4c |
45 | |
68dc0745 |
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 | |
5a964f20 |
62 | =head2 Does perl have a round function? What about ceil() and floor()? Trig functions? |
68dc0745 |
63 | |
92c2ed05 |
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 |
68dc0745 |
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 | |
92c2ed05 |
74 | use POSIX; |
75 | $ceil = ceil(3.5); # 4 |
76 | $floor = floor(3.5); # 3 |
77 | |
46fc3d4c |
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. |
68dc0745 |
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 | =head2 How do I convert bits into ints? |
92 | |
92c2ed05 |
93 | To turn a string of 1s and 0s like C<10110110> into a scalar containing |
68dc0745 |
94 | its binary value, use the pack() function (documented in |
95 | L<perlfunc/"pack">): |
96 | |
97 | $decimal = pack('B8', '10110110'); |
98 | |
99 | Here's an example of going the other way: |
100 | |
101 | $binary_string = join('', unpack('B*', "\x29")); |
102 | |
103 | =head2 How do I multiply matrices? |
104 | |
105 | Use the Math::Matrix or Math::MatrixReal modules (available from CPAN) |
106 | or the PDL extension (also available from CPAN). |
107 | |
108 | =head2 How do I perform an operation on a series of integers? |
109 | |
110 | To call a function on each element in an array, and collect the |
111 | results, use: |
112 | |
113 | @results = map { my_func($_) } @array; |
114 | |
115 | For example: |
116 | |
117 | @triple = map { 3 * $_ } @single; |
118 | |
119 | To call a function on each element of an array, but ignore the |
120 | results: |
121 | |
122 | foreach $iterator (@array) { |
123 | &my_func($iterator); |
124 | } |
125 | |
126 | To call a function on each integer in a (small) range, you B<can> use: |
127 | |
128 | @results = map { &my_func($_) } (5 .. 25); |
129 | |
130 | but you should be aware that the C<..> operator creates an array of |
131 | all integers in the range. This can take a lot of memory for large |
132 | ranges. Instead use: |
133 | |
134 | @results = (); |
135 | for ($i=5; $i < 500_005; $i++) { |
136 | push(@results, &my_func($i)); |
137 | } |
138 | |
139 | =head2 How can I output Roman numerals? |
140 | |
141 | Get the http://www.perl.com/CPAN/modules/by-module/Roman module. |
142 | |
143 | =head2 Why aren't my random numbers random? |
144 | |
145 | The short explanation is that you're getting pseudorandom numbers, not |
92c2ed05 |
146 | random ones, because computers are good at being predictable and bad |
147 | at being random (despite appearances caused by bugs in your programs |
148 | :-). A longer explanation is available on |
149 | http://www.perl.com/CPAN/doc/FMTEYEWTK/random, courtesy of Tom |
150 | Phoenix. John von Neumann said, ``Anyone who attempts to generate |
151 | random numbers by deterministic means is, of course, living in a state |
152 | of sin.'' |
153 | |
154 | You should also check out the Math::TrulyRandom module from CPAN. It |
155 | uses the imperfections in your system's timer to generate random |
156 | numbers, but this takes quite a while. If you want a better |
157 | pseudorandom generator than comes with your operating system, look at |
158 | ``Numerical Recipes in C'' at http://nr.harvard.edu/nr/bookc.html . |
68dc0745 |
159 | |
160 | =head1 Data: Dates |
161 | |
162 | =head2 How do I find the week-of-the-year/day-of-the-year? |
163 | |
164 | The day of the year is in the array returned by localtime() (see |
165 | L<perlfunc/"localtime">): |
166 | |
167 | $day_of_year = (localtime(time()))[7]; |
168 | |
169 | or more legibly (in 5.004 or higher): |
170 | |
171 | use Time::localtime; |
172 | $day_of_year = localtime(time())->yday; |
173 | |
174 | You can find the week of the year by dividing this by 7: |
175 | |
176 | $week_of_year = int($day_of_year / 7); |
177 | |
92c2ed05 |
178 | Of course, this believes that weeks start at zero. The Date::Calc |
179 | module from CPAN has a lot of date calculation functions, including |
5e3006a4 |
180 | day of the year, week of the year, and so on. Note that not |
181 | all business consider ``week 1'' to be the same; for example, |
182 | American business often consider the first week with a Monday |
183 | in it to be Work Week #1, despite ISO 8601, which consider |
184 | WW1 to be the frist week with a Thursday in it. |
68dc0745 |
185 | |
92c2ed05 |
186 | =head2 How can I compare two dates and find the difference? |
68dc0745 |
187 | |
92c2ed05 |
188 | If you're storing your dates as epoch seconds then simply subtract one |
189 | from the other. If you've got a structured date (distinct year, day, |
190 | month, hour, minute, seconds values) then use one of the Date::Manip |
191 | and Date::Calc modules from CPAN. |
68dc0745 |
192 | |
193 | =head2 How can I take a string and turn it into epoch seconds? |
194 | |
195 | If it's a regular enough string that it always has the same format, |
92c2ed05 |
196 | you can split it up and pass the parts to C<timelocal> in the standard |
197 | Time::Local module. Otherwise, you should look into the Date::Calc |
198 | and Date::Manip modules from CPAN. |
68dc0745 |
199 | |
200 | =head2 How can I find the Julian Day? |
201 | |
92c2ed05 |
202 | Neither Date::Manip nor Date::Calc deal with Julian days. Instead, |
203 | there is an example of Julian date calculation that should help you in |
204 | http://www.perl.com/CPAN/authors/David_Muir_Sharnoff/modules/Time/JulianDay.pm.gz |
205 | . |
68dc0745 |
206 | |
5a964f20 |
207 | =head2 Does Perl have a year 2000 problem? Is Perl Y2K compliant? |
68dc0745 |
208 | |
5e3006a4 |
209 | Short answer: No, Perl does not have a Year 2000 problem. Yes, |
368c9434 |
210 | Perl is Y2K compliant. The programmers you've hired to use it, |
5e3006a4 |
211 | however, probably are not. |
92c2ed05 |
212 | |
213 | Long answer: Perl is just as Y2K compliant as your pencil--no more, |
214 | and no less. The date and time functions supplied with perl (gmtime |
215 | and localtime) supply adequate information to determine the year well |
216 | beyond 2000 (2038 is when trouble strikes for 32-bit machines). The |
217 | year returned by these functions when used in an array context is the |
218 | year minus 1900. For years between 1910 and 1999 this I<happens> to |
219 | be a 2-digit decimal number. To avoid the year 2000 problem simply do |
220 | not treat the year as a 2-digit number. It isn't. |
68dc0745 |
221 | |
5a964f20 |
222 | When gmtime() and localtime() are used in scalar context they return |
68dc0745 |
223 | a timestamp string that contains a fully-expanded year. For example, |
224 | C<$timestamp = gmtime(1005613200)> sets $timestamp to "Tue Nov 13 01:00:00 |
225 | 2001". There's no year 2000 problem here. |
226 | |
5a964f20 |
227 | That doesn't mean that Perl can't be used to create non-Y2K compliant |
228 | programs. It can. But so can your pencil. It's the fault of the user, |
229 | not the language. At the risk of inflaming the NRA: ``Perl doesn't |
230 | break Y2K, people do.'' See http://language.perl.com/news/y2k.html for |
231 | a longer exposition. |
232 | |
68dc0745 |
233 | =head1 Data: Strings |
234 | |
235 | =head2 How do I validate input? |
236 | |
237 | The answer to this question is usually a regular expression, perhaps |
5a964f20 |
238 | with auxiliary logic. See the more specific questions (numbers, mail |
68dc0745 |
239 | addresses, etc.) for details. |
240 | |
241 | =head2 How do I unescape a string? |
242 | |
92c2ed05 |
243 | It depends just what you mean by ``escape''. URL escapes are dealt |
244 | with in L<perlfaq9>. Shell escapes with the backslash (C<\>) |
68dc0745 |
245 | character are removed with: |
246 | |
247 | s/\\(.)/$1/g; |
248 | |
92c2ed05 |
249 | This won't expand C<"\n"> or C<"\t"> or any other special escapes. |
68dc0745 |
250 | |
251 | =head2 How do I remove consecutive pairs of characters? |
252 | |
92c2ed05 |
253 | To turn C<"abbcccd"> into C<"abccd">: |
68dc0745 |
254 | |
255 | s/(.)\1/$1/g; |
256 | |
257 | =head2 How do I expand function calls in a string? |
258 | |
259 | This is documented in L<perlref>. In general, this is fraught with |
260 | quoting and readability problems, but it is possible. To interpolate |
5a964f20 |
261 | a subroutine call (in list context) into a string: |
68dc0745 |
262 | |
263 | print "My sub returned @{[mysub(1,2,3)]} that time.\n"; |
264 | |
265 | If you prefer scalar context, similar chicanery is also useful for |
266 | arbitrary expressions: |
267 | |
268 | print "That yields ${\($n + 5)} widgets\n"; |
269 | |
92c2ed05 |
270 | Version 5.004 of Perl had a bug that gave list context to the |
271 | expression in C<${...}>, but this is fixed in version 5.005. |
272 | |
273 | See also ``How can I expand variables in text strings?'' in this |
274 | section of the FAQ. |
46fc3d4c |
275 | |
68dc0745 |
276 | =head2 How do I find matching/nesting anything? |
277 | |
92c2ed05 |
278 | This isn't something that can be done in one regular expression, no |
279 | matter how complicated. To find something between two single |
280 | characters, a pattern like C</x([^x]*)x/> will get the intervening |
281 | bits in $1. For multiple ones, then something more like |
282 | C</alpha(.*?)omega/> would be needed. But none of these deals with |
283 | nested patterns, nor can they. For that you'll have to write a |
284 | parser. |
285 | |
286 | If you are serious about writing a parser, there are a number of |
287 | modules or oddities that will make your life a lot easier. There is |
288 | the CPAN module Parse::RecDescent, the standard module Text::Balanced, |
289 | the byacc program, and Mark-Jason Dominus's excellent I<py> tool at |
290 | http://www.plover.com/~mjd/perl/py/ . |
68dc0745 |
291 | |
92c2ed05 |
292 | One simple destructive, inside-out approach that you might try is to |
293 | pull out the smallest nesting parts one at a time: |
5a964f20 |
294 | |
c8db1d39 |
295 | while (s//BEGIN((?:(?!BEGIN)(?!END).)*)END/gs) { |
5a964f20 |
296 | # do something with $1 |
297 | } |
298 | |
68dc0745 |
299 | =head2 How do I reverse a string? |
300 | |
5a964f20 |
301 | Use reverse() in scalar context, as documented in |
68dc0745 |
302 | L<perlfunc/reverse>. |
303 | |
304 | $reversed = reverse $string; |
305 | |
306 | =head2 How do I expand tabs in a string? |
307 | |
5a964f20 |
308 | You can do it yourself: |
68dc0745 |
309 | |
310 | 1 while $string =~ s/\t+/' ' x (length($&) * 8 - length($`) % 8)/e; |
311 | |
312 | Or you can just use the Text::Tabs module (part of the standard perl |
313 | distribution). |
314 | |
315 | use Text::Tabs; |
316 | @expanded_lines = expand(@lines_with_tabs); |
317 | |
318 | =head2 How do I reformat a paragraph? |
319 | |
320 | Use Text::Wrap (part of the standard perl distribution): |
321 | |
322 | use Text::Wrap; |
323 | print wrap("\t", ' ', @paragraphs); |
324 | |
92c2ed05 |
325 | The paragraphs you give to Text::Wrap should not contain embedded |
46fc3d4c |
326 | newlines. Text::Wrap doesn't justify the lines (flush-right). |
327 | |
68dc0745 |
328 | =head2 How can I access/change the first N letters of a string? |
329 | |
330 | There are many ways. If you just want to grab a copy, use |
92c2ed05 |
331 | substr(): |
68dc0745 |
332 | |
333 | $first_byte = substr($a, 0, 1); |
334 | |
335 | If you want to modify part of a string, the simplest way is often to |
336 | use substr() as an lvalue: |
337 | |
338 | substr($a, 0, 3) = "Tom"; |
339 | |
92c2ed05 |
340 | Although those with a pattern matching kind of thought process will |
341 | likely prefer: |
68dc0745 |
342 | |
343 | $a =~ s/^.../Tom/; |
344 | |
345 | =head2 How do I change the Nth occurrence of something? |
346 | |
92c2ed05 |
347 | You have to keep track of N yourself. For example, let's say you want |
348 | to change the fifth occurrence of C<"whoever"> or C<"whomever"> into |
349 | C<"whosoever"> or C<"whomsoever">, case insensitively. |
68dc0745 |
350 | |
351 | $count = 0; |
352 | s{((whom?)ever)}{ |
353 | ++$count == 5 # is it the 5th? |
354 | ? "${2}soever" # yes, swap |
355 | : $1 # renege and leave it there |
356 | }igex; |
357 | |
5a964f20 |
358 | In the more general case, you can use the C</g> modifier in a C<while> |
359 | loop, keeping count of matches. |
360 | |
361 | $WANT = 3; |
362 | $count = 0; |
363 | while (/(\w+)\s+fish\b/gi) { |
364 | if (++$count == $WANT) { |
365 | print "The third fish is a $1 one.\n"; |
366 | # Warning: don't `last' out of this loop |
367 | } |
368 | } |
369 | |
92c2ed05 |
370 | That prints out: C<"The third fish is a red one."> You can also use a |
5a964f20 |
371 | repetition count and repeated pattern like this: |
372 | |
373 | /(?:\w+\s+fish\s+){2}(\w+)\s+fish/i; |
374 | |
68dc0745 |
375 | =head2 How can I count the number of occurrences of a substring within a string? |
376 | |
377 | There are a number of ways, with varying efficiency: If you want a |
378 | count of a certain single character (X) within a string, you can use the |
379 | C<tr///> function like so: |
380 | |
368c9434 |
381 | $string = "ThisXlineXhasXsomeXx'sXinXit"; |
68dc0745 |
382 | $count = ($string =~ tr/X//); |
46fc3d4c |
383 | print "There are $count X charcters in the string"; |
68dc0745 |
384 | |
385 | This is fine if you are just looking for a single character. However, |
386 | if you are trying to count multiple character substrings within a |
387 | larger string, C<tr///> won't work. What you can do is wrap a while() |
388 | loop around a global pattern match. For example, let's count negative |
389 | integers: |
390 | |
391 | $string = "-9 55 48 -2 23 -76 4 14 -44"; |
392 | while ($string =~ /-\d+/g) { $count++ } |
393 | print "There are $count negative numbers in the string"; |
394 | |
395 | =head2 How do I capitalize all the words on one line? |
396 | |
397 | To make the first letter of each word upper case: |
3fe9a6f1 |
398 | |
68dc0745 |
399 | $line =~ s/\b(\w)/\U$1/g; |
400 | |
46fc3d4c |
401 | This has the strange effect of turning "C<don't do it>" into "C<Don'T |
402 | Do It>". Sometimes you might want this, instead (Suggested by Brian |
92c2ed05 |
403 | Foy): |
46fc3d4c |
404 | |
405 | $string =~ s/ ( |
406 | (^\w) #at the beginning of the line |
407 | | # or |
408 | (\s\w) #preceded by whitespace |
409 | ) |
410 | /\U$1/xg; |
411 | $string =~ /([\w']+)/\u\L$1/g; |
412 | |
68dc0745 |
413 | To make the whole line upper case: |
3fe9a6f1 |
414 | |
68dc0745 |
415 | $line = uc($line); |
416 | |
417 | To force each word to be lower case, with the first letter upper case: |
3fe9a6f1 |
418 | |
68dc0745 |
419 | $line =~ s/(\w+)/\u\L$1/g; |
420 | |
5a964f20 |
421 | You can (and probably should) enable locale awareness of those |
422 | characters by placing a C<use locale> pragma in your program. |
92c2ed05 |
423 | See L<perllocale> for endless details on locales. |
5a964f20 |
424 | |
68dc0745 |
425 | =head2 How can I split a [character] delimited string except when inside |
426 | [character]? (Comma-separated files) |
427 | |
428 | Take the example case of trying to split a string that is comma-separated |
429 | into its different fields. (We'll pretend you said comma-separated, not |
430 | comma-delimited, which is different and almost never what you mean.) You |
431 | can't use C<split(/,/)> because you shouldn't split if the comma is inside |
432 | quotes. For example, take a data line like this: |
433 | |
434 | SAR001,"","Cimetrix, Inc","Bob Smith","CAM",N,8,1,0,7,"Error, Core Dumped" |
435 | |
436 | Due to the restriction of the quotes, this is a fairly complex |
437 | problem. Thankfully, we have Jeffrey Friedl, author of a highly |
438 | recommended book on regular expressions, to handle these for us. He |
439 | suggests (assuming your string is contained in $text): |
440 | |
441 | @new = (); |
442 | push(@new, $+) while $text =~ m{ |
443 | "([^\"\\]*(?:\\.[^\"\\]*)*)",? # groups the phrase inside the quotes |
444 | | ([^,]+),? |
445 | | , |
446 | }gx; |
447 | push(@new, undef) if substr($text,-1,1) eq ','; |
448 | |
46fc3d4c |
449 | If you want to represent quotation marks inside a |
450 | quotation-mark-delimited field, escape them with backslashes (eg, |
2ceaccd7 |
451 | C<"like \"this\"">. Unescaping them is a task addressed earlier in |
46fc3d4c |
452 | this section. |
453 | |
68dc0745 |
454 | Alternatively, the Text::ParseWords module (part of the standard perl |
455 | distribution) lets you say: |
456 | |
457 | use Text::ParseWords; |
458 | @new = quotewords(",", 0, $text); |
459 | |
460 | =head2 How do I strip blank space from the beginning/end of a string? |
461 | |
5a964f20 |
462 | Although the simplest approach would seem to be: |
68dc0745 |
463 | |
464 | $string =~ s/^\s*(.*?)\s*$/$1/; |
465 | |
5a964f20 |
466 | This is unneccesarily slow, destructive, and fails with embedded newlines. |
467 | It is much better faster to do this in two steps: |
68dc0745 |
468 | |
469 | $string =~ s/^\s+//; |
470 | $string =~ s/\s+$//; |
471 | |
472 | Or more nicely written as: |
473 | |
474 | for ($string) { |
475 | s/^\s+//; |
476 | s/\s+$//; |
477 | } |
478 | |
5e3006a4 |
479 | This idiom takes advantage of the C<foreach> loop's aliasing |
5a964f20 |
480 | behavior to factor out common code. You can do this |
481 | on several strings at once, or arrays, or even the |
482 | values of a hash if you use a slide: |
483 | |
484 | # trim whitespace in the scalar, the array, |
485 | # and all the values in the hash |
486 | foreach ($scalar, @array, @hash{keys %hash}) { |
487 | s/^\s+//; |
488 | s/\s+$//; |
489 | } |
490 | |
68dc0745 |
491 | =head2 How do I extract selected columns from a string? |
492 | |
493 | Use substr() or unpack(), both documented in L<perlfunc>. |
5a964f20 |
494 | If you prefer thinking in terms of columns instead of widths, |
495 | you can use this kind of thing: |
496 | |
497 | # determine the unpack format needed to split Linux ps output |
498 | # arguments are cut columns |
499 | my $fmt = cut2fmt(8, 14, 20, 26, 30, 34, 41, 47, 59, 63, 67, 72); |
500 | |
501 | sub cut2fmt { |
502 | my(@positions) = @_; |
503 | my $template = ''; |
504 | my $lastpos = 1; |
505 | for my $place (@positions) { |
506 | $template .= "A" . ($place - $lastpos) . " "; |
507 | $lastpos = $place; |
508 | } |
509 | $template .= "A*"; |
510 | return $template; |
511 | } |
68dc0745 |
512 | |
513 | =head2 How do I find the soundex value of a string? |
514 | |
515 | Use the standard Text::Soundex module distributed with perl. |
516 | |
517 | =head2 How can I expand variables in text strings? |
518 | |
519 | Let's assume that you have a string like: |
520 | |
521 | $text = 'this has a $foo in it and a $bar'; |
5a964f20 |
522 | |
523 | If those were both global variables, then this would |
524 | suffice: |
525 | |
68dc0745 |
526 | $text =~ s/\$(\w+)/${$1}/g; |
527 | |
5a964f20 |
528 | But since they are probably lexicals, or at least, they could |
529 | be, you'd have to do this: |
68dc0745 |
530 | |
531 | $text =~ s/(\$\w+)/$1/eeg; |
5a964f20 |
532 | die if $@; # needed on /ee, not /e |
68dc0745 |
533 | |
5a964f20 |
534 | It's probably better in the general case to treat those |
535 | variables as entries in some special hash. For example: |
536 | |
537 | %user_defs = ( |
538 | foo => 23, |
539 | bar => 19, |
540 | ); |
541 | $text =~ s/\$(\w+)/$user_defs{$1}/g; |
68dc0745 |
542 | |
92c2ed05 |
543 | See also ``How do I expand function calls in a string?'' in this section |
46fc3d4c |
544 | of the FAQ. |
545 | |
68dc0745 |
546 | =head2 What's wrong with always quoting "$vars"? |
547 | |
548 | The problem is that those double-quotes force stringification, |
549 | coercing numbers and references into strings, even when you |
550 | don't want them to be. |
551 | |
552 | If you get used to writing odd things like these: |
553 | |
554 | print "$var"; # BAD |
555 | $new = "$old"; # BAD |
556 | somefunc("$var"); # BAD |
557 | |
558 | You'll be in trouble. Those should (in 99.8% of the cases) be |
559 | the simpler and more direct: |
560 | |
561 | print $var; |
562 | $new = $old; |
563 | somefunc($var); |
564 | |
565 | Otherwise, besides slowing you down, you're going to break code when |
566 | the thing in the scalar is actually neither a string nor a number, but |
567 | a reference: |
568 | |
569 | func(\@array); |
570 | sub func { |
571 | my $aref = shift; |
572 | my $oref = "$aref"; # WRONG |
573 | } |
574 | |
575 | You can also get into subtle problems on those few operations in Perl |
576 | that actually do care about the difference between a string and a |
577 | number, such as the magical C<++> autoincrement operator or the |
578 | syscall() function. |
579 | |
5a964f20 |
580 | Stringification also destroys arrays. |
581 | |
582 | @lines = `command`; |
583 | print "@lines"; # WRONG - extra blanks |
584 | print @lines; # right |
585 | |
68dc0745 |
586 | =head2 Why don't my <<HERE documents work? |
587 | |
588 | Check for these three things: |
589 | |
590 | =over 4 |
591 | |
592 | =item 1. There must be no space after the << part. |
593 | |
594 | =item 2. There (probably) should be a semicolon at the end. |
595 | |
596 | =item 3. You can't (easily) have any space in front of the tag. |
597 | |
598 | =back |
599 | |
5a964f20 |
600 | If you want to indent the text in the here document, you |
601 | can do this: |
602 | |
603 | # all in one |
604 | ($VAR = <<HERE_TARGET) =~ s/^\s+//gm; |
605 | your text |
606 | goes here |
607 | HERE_TARGET |
608 | |
609 | But the HERE_TARGET must still be flush against the margin. |
610 | If you want that indented also, you'll have to quote |
611 | in the indentation. |
612 | |
613 | ($quote = <<' FINIS') =~ s/^\s+//gm; |
614 | ...we will have peace, when you and all your works have |
615 | perished--and the works of your dark master to whom you |
616 | would deliver us. You are a liar, Saruman, and a corrupter |
617 | of men's hearts. --Theoden in /usr/src/perl/taint.c |
618 | FINIS |
619 | $quote =~ s/\s*--/\n--/; |
620 | |
621 | A nice general-purpose fixer-upper function for indented here documents |
622 | follows. It expects to be called with a here document as its argument. |
623 | It looks to see whether each line begins with a common substring, and |
624 | if so, strips that off. Otherwise, it takes the amount of leading |
625 | white space found on the first line and removes that much off each |
626 | subsequent line. |
627 | |
628 | sub fix { |
629 | local $_ = shift; |
630 | my ($white, $leader); # common white space and common leading string |
631 | if (/^\s*(?:([^\w\s]+)(\s*).*\n)(?:\s*\1\2?.*\n)+$/) { |
632 | ($white, $leader) = ($2, quotemeta($1)); |
633 | } else { |
634 | ($white, $leader) = (/^(\s+)/, ''); |
635 | } |
636 | s/^\s*?$leader(?:$white)?//gm; |
637 | return $_; |
638 | } |
639 | |
c8db1d39 |
640 | This works with leading special strings, dynamically determined: |
5a964f20 |
641 | |
642 | $remember_the_main = fix<<' MAIN_INTERPRETER_LOOP'; |
643 | @@@ int |
644 | @@@ runops() { |
645 | @@@ SAVEI32(runlevel); |
646 | @@@ runlevel++; |
647 | @@@ while ( op = (*op->op_ppaddr)() ) ; |
648 | @@@ TAINT_NOT; |
649 | @@@ return 0; |
650 | @@@ } |
651 | MAIN_INTERPRETER_LOOP |
652 | |
653 | Or with a fixed amount of leading white space, with remaining |
654 | indentation correctly preserved: |
655 | |
656 | $poem = fix<<EVER_ON_AND_ON; |
657 | Now far ahead the Road has gone, |
658 | And I must follow, if I can, |
659 | Pursuing it with eager feet, |
660 | Until it joins some larger way |
661 | Where many paths and errands meet. |
662 | And whither then? I cannot say. |
663 | --Bilbo in /usr/src/perl/pp_ctl.c |
664 | EVER_ON_AND_ON |
665 | |
68dc0745 |
666 | =head1 Data: Arrays |
667 | |
668 | =head2 What is the difference between $array[1] and @array[1]? |
669 | |
670 | The former is a scalar value, the latter an array slice, which makes |
671 | it a list with one (scalar) value. You should use $ when you want a |
672 | scalar value (most of the time) and @ when you want a list with one |
673 | scalar value in it (very, very rarely; nearly never, in fact). |
674 | |
675 | Sometimes it doesn't make a difference, but sometimes it does. |
676 | For example, compare: |
677 | |
678 | $good[0] = `some program that outputs several lines`; |
679 | |
680 | with |
681 | |
682 | @bad[0] = `same program that outputs several lines`; |
683 | |
684 | The B<-w> flag will warn you about these matters. |
685 | |
686 | =head2 How can I extract just the unique elements of an array? |
687 | |
688 | There are several possible ways, depending on whether the array is |
689 | ordered and whether you wish to preserve the ordering. |
690 | |
691 | =over 4 |
692 | |
693 | =item a) If @in is sorted, and you want @out to be sorted: |
5a964f20 |
694 | (this assumes all true values in the array) |
68dc0745 |
695 | |
696 | $prev = 'nonesuch'; |
697 | @out = grep($_ ne $prev && ($prev = $_), @in); |
698 | |
c8db1d39 |
699 | This is nice in that it doesn't use much extra memory, simulating |
700 | uniq(1)'s behavior of removing only adjacent duplicates. It's less |
701 | nice in that it won't work with false values like undef, 0, or ""; |
702 | "0 but true" is ok, though. |
68dc0745 |
703 | |
704 | =item b) If you don't know whether @in is sorted: |
705 | |
706 | undef %saw; |
707 | @out = grep(!$saw{$_}++, @in); |
708 | |
709 | =item c) Like (b), but @in contains only small integers: |
710 | |
711 | @out = grep(!$saw[$_]++, @in); |
712 | |
713 | =item d) A way to do (b) without any loops or greps: |
714 | |
715 | undef %saw; |
716 | @saw{@in} = (); |
717 | @out = sort keys %saw; # remove sort if undesired |
718 | |
719 | =item e) Like (d), but @in contains only small positive integers: |
720 | |
721 | undef @ary; |
722 | @ary[@in] = @in; |
723 | @out = @ary; |
724 | |
725 | =back |
726 | |
5a964f20 |
727 | =head2 How can I tell whether a list or array contains a certain element? |
728 | |
729 | Hearing the word "in" is an I<in>dication that you probably should have |
730 | used a hash, not a list or array, to store your data. Hashes are |
731 | designed to answer this question quickly and efficiently. Arrays aren't. |
68dc0745 |
732 | |
5a964f20 |
733 | That being said, there are several ways to approach this. If you |
734 | are going to make this query many times over arbitrary string values, |
735 | the fastest way is probably to invert the original array and keep an |
68dc0745 |
736 | associative array lying about whose keys are the first array's values. |
737 | |
738 | @blues = qw/azure cerulean teal turquoise lapis-lazuli/; |
739 | undef %is_blue; |
740 | for (@blues) { $is_blue{$_} = 1 } |
741 | |
742 | Now you can check whether $is_blue{$some_color}. It might have been a |
743 | good idea to keep the blues all in a hash in the first place. |
744 | |
745 | If the values are all small integers, you could use a simple indexed |
746 | array. This kind of an array will take up less space: |
747 | |
748 | @primes = (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31); |
749 | undef @is_tiny_prime; |
750 | for (@primes) { $is_tiny_prime[$_] = 1; } |
751 | |
752 | Now you check whether $is_tiny_prime[$some_number]. |
753 | |
754 | If the values in question are integers instead of strings, you can save |
755 | quite a lot of space by using bit strings instead: |
756 | |
757 | @articles = ( 1..10, 150..2000, 2017 ); |
758 | undef $read; |
7b8d334a |
759 | for (@articles) { vec($read,$_,1) = 1 } |
68dc0745 |
760 | |
761 | Now check whether C<vec($read,$n,1)> is true for some C<$n>. |
762 | |
763 | Please do not use |
764 | |
765 | $is_there = grep $_ eq $whatever, @array; |
766 | |
767 | or worse yet |
768 | |
769 | $is_there = grep /$whatever/, @array; |
770 | |
771 | These are slow (checks every element even if the first matches), |
772 | inefficient (same reason), and potentially buggy (what if there are |
773 | regexp characters in $whatever?). |
774 | |
775 | =head2 How do I compute the difference of two arrays? How do I compute the intersection of two arrays? |
776 | |
777 | Use a hash. Here's code to do both and more. It assumes that |
778 | each element is unique in a given array: |
779 | |
780 | @union = @intersection = @difference = (); |
781 | %count = (); |
782 | foreach $element (@array1, @array2) { $count{$element}++ } |
783 | foreach $element (keys %count) { |
784 | push @union, $element; |
785 | push @{ $count{$element} > 1 ? \@intersection : \@difference }, $element; |
786 | } |
787 | |
788 | =head2 How do I find the first array element for which a condition is true? |
789 | |
790 | You can use this if you care about the index: |
791 | |
792 | for ($i=0; $i < @array; $i++) { |
793 | if ($array[$i] eq "Waldo") { |
794 | $found_index = $i; |
795 | last; |
796 | } |
797 | } |
798 | |
799 | Now C<$found_index> has what you want. |
800 | |
801 | =head2 How do I handle linked lists? |
802 | |
803 | In general, you usually don't need a linked list in Perl, since with |
804 | regular arrays, you can push and pop or shift and unshift at either end, |
5a964f20 |
805 | or you can use splice to add and/or remove arbitrary number of elements at |
806 | arbitrary points. Both pop and shift are both O(1) operations on perl's |
807 | dynamic arrays. In the absence of shifts and pops, push in general |
808 | needs to reallocate on the order every log(N) times, and unshift will |
809 | need to copy pointers each time. |
68dc0745 |
810 | |
811 | If you really, really wanted, you could use structures as described in |
812 | L<perldsc> or L<perltoot> and do just what the algorithm book tells you |
813 | to do. |
814 | |
815 | =head2 How do I handle circular lists? |
816 | |
817 | Circular lists could be handled in the traditional fashion with linked |
818 | lists, or you could just do something like this with an array: |
819 | |
820 | unshift(@array, pop(@array)); # the last shall be first |
821 | push(@array, shift(@array)); # and vice versa |
822 | |
823 | =head2 How do I shuffle an array randomly? |
824 | |
5a964f20 |
825 | Use this: |
826 | |
827 | # fisher_yates_shuffle( \@array ) : |
828 | # generate a random permutation of @array in place |
829 | sub fisher_yates_shuffle { |
830 | my $array = shift; |
831 | my $i; |
832 | for ($i = @$array; --$i; ) { |
833 | my $j = int rand ($i+1); |
834 | next if $i == $j; |
835 | @$array[$i,$j] = @$array[$j,$i]; |
836 | } |
837 | } |
838 | |
839 | fisher_yates_shuffle( \@array ); # permutes @array in place |
840 | |
841 | You've probably seen shuffling algorithms that works using splice, |
68dc0745 |
842 | randomly picking another element to swap the current element with: |
843 | |
844 | srand; |
845 | @new = (); |
846 | @old = 1 .. 10; # just a demo |
847 | while (@old) { |
848 | push(@new, splice(@old, rand @old, 1)); |
849 | } |
850 | |
5a964f20 |
851 | This is bad because splice is already O(N), and since you do it N times, |
852 | you just invented a quadratic algorithm; that is, O(N**2). This does |
853 | not scale, although Perl is so efficient that you probably won't notice |
854 | this until you have rather largish arrays. |
68dc0745 |
855 | |
856 | =head2 How do I process/modify each element of an array? |
857 | |
858 | Use C<for>/C<foreach>: |
859 | |
860 | for (@lines) { |
5a964f20 |
861 | s/foo/bar/; # change that word |
862 | y/XZ/ZX/; # swap those letters |
68dc0745 |
863 | } |
864 | |
865 | Here's another; let's compute spherical volumes: |
866 | |
5a964f20 |
867 | for (@volumes = @radii) { # @volumes has changed parts |
68dc0745 |
868 | $_ **= 3; |
869 | $_ *= (4/3) * 3.14159; # this will be constant folded |
870 | } |
871 | |
5a964f20 |
872 | If you want to do the same thing to modify the values of the hash, |
873 | you may not use the C<values> function, oddly enough. You need a slice: |
874 | |
875 | for $orbit ( @orbits{keys %orbits} ) { |
876 | ($orbit **= 3) *= (4/3) * 3.14159; |
877 | } |
878 | |
68dc0745 |
879 | =head2 How do I select a random element from an array? |
880 | |
881 | Use the rand() function (see L<perlfunc/rand>): |
882 | |
5a964f20 |
883 | # at the top of the program: |
68dc0745 |
884 | srand; # not needed for 5.004 and later |
5a964f20 |
885 | |
886 | # then later on |
68dc0745 |
887 | $index = rand @array; |
888 | $element = $array[$index]; |
889 | |
5a964f20 |
890 | Make sure you I<only call srand once per program, if then>. |
891 | If you are calling it more than once (such as before each |
892 | call to rand), you're almost certainly doing something wrong. |
893 | |
68dc0745 |
894 | =head2 How do I permute N elements of a list? |
895 | |
896 | Here's a little program that generates all permutations |
897 | of all the words on each line of input. The algorithm embodied |
5a964f20 |
898 | in the permute() function should work on any list: |
68dc0745 |
899 | |
900 | #!/usr/bin/perl -n |
5a964f20 |
901 | # tsc-permute: permute each word of input |
902 | permute([split], []); |
903 | sub permute { |
904 | my @items = @{ $_[0] }; |
905 | my @perms = @{ $_[1] }; |
906 | unless (@items) { |
907 | print "@perms\n"; |
68dc0745 |
908 | } else { |
5a964f20 |
909 | my(@newitems,@newperms,$i); |
910 | foreach $i (0 .. $#items) { |
911 | @newitems = @items; |
912 | @newperms = @perms; |
913 | unshift(@newperms, splice(@newitems, $i, 1)); |
914 | permute([@newitems], [@newperms]); |
68dc0745 |
915 | } |
916 | } |
917 | } |
918 | |
919 | =head2 How do I sort an array by (anything)? |
920 | |
921 | Supply a comparison function to sort() (described in L<perlfunc/sort>): |
922 | |
923 | @list = sort { $a <=> $b } @list; |
924 | |
925 | The default sort function is cmp, string comparison, which would |
926 | sort C<(1, 2, 10)> into C<(1, 10, 2)>. C<E<lt>=E<gt>>, used above, is |
927 | the numerical comparison operator. |
928 | |
929 | If you have a complicated function needed to pull out the part you |
930 | want to sort on, then don't do it inside the sort function. Pull it |
931 | out first, because the sort BLOCK can be called many times for the |
932 | same element. Here's an example of how to pull out the first word |
933 | after the first number on each item, and then sort those words |
934 | case-insensitively. |
935 | |
936 | @idx = (); |
937 | for (@data) { |
938 | ($item) = /\d+\s*(\S+)/; |
939 | push @idx, uc($item); |
940 | } |
941 | @sorted = @data[ sort { $idx[$a] cmp $idx[$b] } 0 .. $#idx ]; |
942 | |
943 | Which could also be written this way, using a trick |
944 | that's come to be known as the Schwartzian Transform: |
945 | |
946 | @sorted = map { $_->[0] } |
947 | sort { $a->[1] cmp $b->[1] } |
46fc3d4c |
948 | map { [ $_, uc((/\d+\s*(\S+)/ )[0] ] } @data; |
68dc0745 |
949 | |
950 | If you need to sort on several fields, the following paradigm is useful. |
951 | |
952 | @sorted = sort { field1($a) <=> field1($b) || |
953 | field2($a) cmp field2($b) || |
954 | field3($a) cmp field3($b) |
955 | } @data; |
956 | |
957 | This can be conveniently combined with precalculation of keys as given |
958 | above. |
959 | |
960 | See http://www.perl.com/CPAN/doc/FMTEYEWTK/sort.html for more about |
961 | this approach. |
962 | |
963 | See also the question below on sorting hashes. |
964 | |
965 | =head2 How do I manipulate arrays of bits? |
966 | |
967 | Use pack() and unpack(), or else vec() and the bitwise operations. |
968 | |
969 | For example, this sets $vec to have bit N set if $ints[N] was set: |
970 | |
971 | $vec = ''; |
972 | foreach(@ints) { vec($vec,$_,1) = 1 } |
973 | |
974 | And here's how, given a vector in $vec, you can |
975 | get those bits into your @ints array: |
976 | |
977 | sub bitvec_to_list { |
978 | my $vec = shift; |
979 | my @ints; |
980 | # Find null-byte density then select best algorithm |
981 | if ($vec =~ tr/\0// / length $vec > 0.95) { |
982 | use integer; |
983 | my $i; |
984 | # This method is faster with mostly null-bytes |
985 | while($vec =~ /[^\0]/g ) { |
986 | $i = -9 + 8 * pos $vec; |
987 | push @ints, $i if vec($vec, ++$i, 1); |
988 | push @ints, $i if vec($vec, ++$i, 1); |
989 | push @ints, $i if vec($vec, ++$i, 1); |
990 | push @ints, $i if vec($vec, ++$i, 1); |
991 | push @ints, $i if vec($vec, ++$i, 1); |
992 | push @ints, $i if vec($vec, ++$i, 1); |
993 | push @ints, $i if vec($vec, ++$i, 1); |
994 | push @ints, $i if vec($vec, ++$i, 1); |
995 | } |
996 | } else { |
997 | # This method is a fast general algorithm |
998 | use integer; |
999 | my $bits = unpack "b*", $vec; |
1000 | push @ints, 0 if $bits =~ s/^(\d)// && $1; |
1001 | push @ints, pos $bits while($bits =~ /1/g); |
1002 | } |
1003 | return \@ints; |
1004 | } |
1005 | |
1006 | This method gets faster the more sparse the bit vector is. |
1007 | (Courtesy of Tim Bunce and Winfried Koenig.) |
1008 | |
1009 | =head2 Why does defined() return true on empty arrays and hashes? |
1010 | |
1011 | See L<perlfunc/defined> in the 5.004 release or later of Perl. |
1012 | |
1013 | =head1 Data: Hashes (Associative Arrays) |
1014 | |
1015 | =head2 How do I process an entire hash? |
1016 | |
1017 | Use the each() function (see L<perlfunc/each>) if you don't care |
1018 | whether it's sorted: |
1019 | |
5a964f20 |
1020 | while ( ($key, $value) = each %hash) { |
68dc0745 |
1021 | print "$key = $value\n"; |
1022 | } |
1023 | |
1024 | If you want it sorted, you'll have to use foreach() on the result of |
1025 | sorting the keys as shown in an earlier question. |
1026 | |
1027 | =head2 What happens if I add or remove keys from a hash while iterating over it? |
1028 | |
1029 | Don't do that. |
1030 | |
1031 | =head2 How do I look up a hash element by value? |
1032 | |
1033 | Create a reverse hash: |
1034 | |
1035 | %by_value = reverse %by_key; |
1036 | $key = $by_value{$value}; |
1037 | |
1038 | That's not particularly efficient. It would be more space-efficient |
1039 | to use: |
1040 | |
1041 | while (($key, $value) = each %by_key) { |
1042 | $by_value{$value} = $key; |
1043 | } |
1044 | |
1045 | If your hash could have repeated values, the methods above will only |
1046 | find one of the associated keys. This may or may not worry you. |
1047 | |
1048 | =head2 How can I know how many entries are in a hash? |
1049 | |
1050 | If you mean how many keys, then all you have to do is |
1051 | take the scalar sense of the keys() function: |
1052 | |
3fe9a6f1 |
1053 | $num_keys = scalar keys %hash; |
68dc0745 |
1054 | |
1055 | In void context it just resets the iterator, which is faster |
1056 | for tied hashes. |
1057 | |
1058 | =head2 How do I sort a hash (optionally by value instead of key)? |
1059 | |
1060 | Internally, hashes are stored in a way that prevents you from imposing |
1061 | an order on key-value pairs. Instead, you have to sort a list of the |
1062 | keys or values: |
1063 | |
1064 | @keys = sort keys %hash; # sorted by key |
1065 | @keys = sort { |
1066 | $hash{$a} cmp $hash{$b} |
1067 | } keys %hash; # and by value |
1068 | |
1069 | Here we'll do a reverse numeric sort by value, and if two keys are |
1070 | identical, sort by length of key, and if that fails, by straight ASCII |
1071 | comparison of the keys (well, possibly modified by your locale -- see |
1072 | L<perllocale>). |
1073 | |
1074 | @keys = sort { |
1075 | $hash{$b} <=> $hash{$a} |
1076 | || |
1077 | length($b) <=> length($a) |
1078 | || |
1079 | $a cmp $b |
1080 | } keys %hash; |
1081 | |
1082 | =head2 How can I always keep my hash sorted? |
1083 | |
1084 | You can look into using the DB_File module and tie() using the |
1085 | $DB_BTREE hash bindings as documented in L<DB_File/"In Memory Databases">. |
5a964f20 |
1086 | The Tie::IxHash module from CPAN might also be instructive. |
68dc0745 |
1087 | |
1088 | =head2 What's the difference between "delete" and "undef" with hashes? |
1089 | |
1090 | Hashes are pairs of scalars: the first is the key, the second is the |
1091 | value. The key will be coerced to a string, although the value can be |
1092 | any kind of scalar: string, number, or reference. If a key C<$key> is |
1093 | present in the array, C<exists($key)> will return true. The value for |
1094 | a given key can be C<undef>, in which case C<$array{$key}> will be |
1095 | C<undef> while C<$exists{$key}> will return true. This corresponds to |
1096 | (C<$key>, C<undef>) being in the hash. |
1097 | |
1098 | Pictures help... here's the C<%ary> table: |
1099 | |
1100 | keys values |
1101 | +------+------+ |
1102 | | a | 3 | |
1103 | | x | 7 | |
1104 | | d | 0 | |
1105 | | e | 2 | |
1106 | +------+------+ |
1107 | |
1108 | And these conditions hold |
1109 | |
1110 | $ary{'a'} is true |
1111 | $ary{'d'} is false |
1112 | defined $ary{'d'} is true |
1113 | defined $ary{'a'} is true |
1114 | exists $ary{'a'} is true (perl5 only) |
1115 | grep ($_ eq 'a', keys %ary) is true |
1116 | |
1117 | If you now say |
1118 | |
1119 | undef $ary{'a'} |
1120 | |
1121 | your table now reads: |
1122 | |
1123 | |
1124 | keys values |
1125 | +------+------+ |
1126 | | a | undef| |
1127 | | x | 7 | |
1128 | | d | 0 | |
1129 | | e | 2 | |
1130 | +------+------+ |
1131 | |
1132 | and these conditions now hold; changes in caps: |
1133 | |
1134 | $ary{'a'} is FALSE |
1135 | $ary{'d'} is false |
1136 | defined $ary{'d'} is true |
1137 | defined $ary{'a'} is FALSE |
1138 | exists $ary{'a'} is true (perl5 only) |
1139 | grep ($_ eq 'a', keys %ary) is true |
1140 | |
1141 | Notice the last two: you have an undef value, but a defined key! |
1142 | |
1143 | Now, consider this: |
1144 | |
1145 | delete $ary{'a'} |
1146 | |
1147 | your table now reads: |
1148 | |
1149 | keys values |
1150 | +------+------+ |
1151 | | x | 7 | |
1152 | | d | 0 | |
1153 | | e | 2 | |
1154 | +------+------+ |
1155 | |
1156 | and these conditions now hold; changes in caps: |
1157 | |
1158 | $ary{'a'} is false |
1159 | $ary{'d'} is false |
1160 | defined $ary{'d'} is true |
1161 | defined $ary{'a'} is false |
1162 | exists $ary{'a'} is FALSE (perl5 only) |
1163 | grep ($_ eq 'a', keys %ary) is FALSE |
1164 | |
1165 | See, the whole entry is gone! |
1166 | |
1167 | =head2 Why don't my tied hashes make the defined/exists distinction? |
1168 | |
1169 | They may or may not implement the EXISTS() and DEFINED() methods |
1170 | differently. For example, there isn't the concept of undef with hashes |
1171 | that are tied to DBM* files. This means the true/false tables above |
1172 | will give different results when used on such a hash. It also means |
1173 | that exists and defined do the same thing with a DBM* file, and what |
1174 | they end up doing is not what they do with ordinary hashes. |
1175 | |
1176 | =head2 How do I reset an each() operation part-way through? |
1177 | |
5a964f20 |
1178 | Using C<keys %hash> in scalar context returns the number of keys in |
68dc0745 |
1179 | the hash I<and> resets the iterator associated with the hash. You may |
1180 | need to do this if you use C<last> to exit a loop early so that when you |
46fc3d4c |
1181 | re-enter it, the hash iterator has been reset. |
68dc0745 |
1182 | |
1183 | =head2 How can I get the unique keys from two hashes? |
1184 | |
1185 | First you extract the keys from the hashes into arrays, and then solve |
1186 | the uniquifying the array problem described above. For example: |
1187 | |
1188 | %seen = (); |
1189 | for $element (keys(%foo), keys(%bar)) { |
1190 | $seen{$element}++; |
1191 | } |
1192 | @uniq = keys %seen; |
1193 | |
1194 | Or more succinctly: |
1195 | |
1196 | @uniq = keys %{{%foo,%bar}}; |
1197 | |
1198 | Or if you really want to save space: |
1199 | |
1200 | %seen = (); |
1201 | while (defined ($key = each %foo)) { |
1202 | $seen{$key}++; |
1203 | } |
1204 | while (defined ($key = each %bar)) { |
1205 | $seen{$key}++; |
1206 | } |
1207 | @uniq = keys %seen; |
1208 | |
1209 | =head2 How can I store a multidimensional array in a DBM file? |
1210 | |
1211 | Either stringify the structure yourself (no fun), or else |
1212 | get the MLDBM (which uses Data::Dumper) module from CPAN and layer |
1213 | it on top of either DB_File or GDBM_File. |
1214 | |
1215 | =head2 How can I make my hash remember the order I put elements into it? |
1216 | |
1217 | Use the Tie::IxHash from CPAN. |
1218 | |
46fc3d4c |
1219 | use Tie::IxHash; |
1220 | tie(%myhash, Tie::IxHash); |
1221 | for ($i=0; $i<20; $i++) { |
1222 | $myhash{$i} = 2*$i; |
1223 | } |
1224 | @keys = keys %myhash; |
1225 | # @keys = (0,1,2,3,...) |
1226 | |
68dc0745 |
1227 | =head2 Why does passing a subroutine an undefined element in a hash create it? |
1228 | |
1229 | If you say something like: |
1230 | |
1231 | somefunc($hash{"nonesuch key here"}); |
1232 | |
1233 | Then that element "autovivifies"; that is, it springs into existence |
1234 | whether you store something there or not. That's because functions |
1235 | get scalars passed in by reference. If somefunc() modifies C<$_[0]>, |
1236 | it has to be ready to write it back into the caller's version. |
1237 | |
1238 | This has been fixed as of perl5.004. |
1239 | |
1240 | Normally, merely accessing a key's value for a nonexistent key does |
1241 | I<not> cause that key to be forever there. This is different than |
1242 | awk's behavior. |
1243 | |
fc36a67e |
1244 | =head2 How can I make the Perl equivalent of a C structure/C++ class/hash or array of hashes or arrays? |
68dc0745 |
1245 | |
1246 | Use references (documented in L<perlref>). Examples of complex data |
1247 | structures are given in L<perldsc> and L<perllol>. Examples of |
1248 | structures and object-oriented classes are in L<perltoot>. |
1249 | |
1250 | =head2 How can I use a reference as a hash key? |
1251 | |
1252 | You can't do this directly, but you could use the standard Tie::Refhash |
1253 | module distributed with perl. |
1254 | |
1255 | =head1 Data: Misc |
1256 | |
1257 | =head2 How do I handle binary data correctly? |
1258 | |
1259 | Perl is binary clean, so this shouldn't be a problem. For example, |
1260 | this works fine (assuming the files are found): |
1261 | |
1262 | if (`cat /vmunix` =~ /gzip/) { |
1263 | print "Your kernel is GNU-zip enabled!\n"; |
1264 | } |
1265 | |
1266 | On some systems, however, you have to play tedious games with "text" |
1267 | versus "binary" files. See L<perlfunc/"binmode">. |
1268 | |
1269 | If you're concerned about 8-bit ASCII data, then see L<perllocale>. |
1270 | |
54310121 |
1271 | If you want to deal with multibyte characters, however, there are |
68dc0745 |
1272 | some gotchas. See the section on Regular Expressions. |
1273 | |
1274 | =head2 How do I determine whether a scalar is a number/whole/integer/float? |
1275 | |
1276 | Assuming that you don't care about IEEE notations like "NaN" or |
1277 | "Infinity", you probably just want to use a regular expression. |
1278 | |
1279 | warn "has nondigits" if /\D/; |
5a964f20 |
1280 | warn "not a natural number" unless /^\d+$/; # rejects -3 |
1281 | warn "not an integer" unless /^-?\d+$/; # rejects +3 |
54310121 |
1282 | warn "not an integer" unless /^[+-]?\d+$/; |
68dc0745 |
1283 | warn "not a decimal number" unless /^-?\d+\.?\d*$/; # rejects .2 |
1284 | warn "not a decimal number" unless /^-?(?:\d+(?:\.\d*)?|\.\d+)$/; |
1285 | warn "not a C float" |
1286 | unless /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/; |
1287 | |
5a964f20 |
1288 | If you're on a POSIX system, Perl's supports the C<POSIX::strtod> |
1289 | function. Its semantics are somewhat cumbersome, so here's a C<getnum> |
1290 | wrapper function for more convenient access. This function takes |
1291 | a string and returns the number it found, or C<undef> for input that |
1292 | isn't a C float. The C<is_numeric> function is a front end to C<getnum> |
1293 | if you just want to say, ``Is this a float?'' |
1294 | |
1295 | sub getnum { |
1296 | use POSIX qw(strtod); |
1297 | my $str = shift; |
1298 | $str =~ s/^\s+//; |
1299 | $str =~ s/\s+$//; |
1300 | $! = 0; |
1301 | my($num, $unparsed) = strtod($str); |
1302 | if (($str eq '') || ($unparsed != 0) || $!) { |
1303 | return undef; |
1304 | } else { |
1305 | return $num; |
1306 | } |
1307 | } |
1308 | |
1309 | sub is_numeric { defined &getnum } |
1310 | |
68dc0745 |
1311 | Or you could check out |
1312 | http://www.perl.com/CPAN/modules/by-module/String/String-Scanf-1.1.tar.gz |
1313 | instead. The POSIX module (part of the standard Perl distribution) |
1314 | provides the C<strtol> and C<strtod> for converting strings to double |
1315 | and longs, respectively. |
1316 | |
1317 | =head2 How do I keep persistent data across program calls? |
1318 | |
1319 | For some specific applications, you can use one of the DBM modules. |
1320 | See L<AnyDBM_File>. More generically, you should consult the |
1321 | FreezeThaw, Storable, or Class::Eroot modules from CPAN. |
1322 | |
1323 | =head2 How do I print out or copy a recursive data structure? |
1324 | |
1325 | The Data::Dumper module on CPAN is nice for printing out |
1326 | data structures, and FreezeThaw for copying them. For example: |
1327 | |
1328 | use FreezeThaw qw(freeze thaw); |
9a4da931 |
1329 | ($new) = thaw freeze $old; |
68dc0745 |
1330 | |
1331 | Where $old can be (a reference to) any kind of data structure you'd like. |
1332 | It will be deeply copied. |
1333 | |
1334 | =head2 How do I define methods for every class/object? |
1335 | |
1336 | Use the UNIVERSAL class (see L<UNIVERSAL>). |
1337 | |
1338 | =head2 How do I verify a credit card checksum? |
1339 | |
1340 | Get the Business::CreditCard module from CPAN. |
1341 | |
1342 | =head1 AUTHOR AND COPYRIGHT |
1343 | |
5a964f20 |
1344 | Copyright (c) 1997, 1998 Tom Christiansen and Nathan Torkington. |
1345 | All rights reserved. |
1346 | |
1347 | When included as part of the Standard Version of Perl, or as part of |
1348 | its complete documentation whether printed or otherwise, this work |
1349 | may be distributed only under the terms of Perl's Artistic License. |
1350 | Any distribution of this file or derivatives thereof I<outside> |
1351 | of that package require that special arrangements be made with |
1352 | copyright holder. |
1353 | |
1354 | Irrespective of its distribution, all code examples in this file |
1355 | are hereby placed into the public domain. You are permitted and |
1356 | encouraged to use this code in your own programs for fun |
1357 | or for profit as you see fit. A simple comment in the code giving |
1358 | credit would be courteous but is not required. |