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