1 | =head1 NAME
|
---|
2 |
|
---|
3 | perlglossary - Perl Glossary
|
---|
4 |
|
---|
5 | =head1 DESCRIPTION
|
---|
6 |
|
---|
7 | A glossary of terms (technical and otherwise) used in the Perl documentation.
|
---|
8 | Other useful sources include the Free On-Line Dictionary of Computing
|
---|
9 | L<http://foldoc.doc.ic.ac.uk/foldoc/index.html>, the Jargon File
|
---|
10 | L<http://catb.org/~esr/jargon/>, and Wikipedia L<http://www.wikipedia.org/>.
|
---|
11 |
|
---|
12 | =head2 A
|
---|
13 |
|
---|
14 | =over 4
|
---|
15 |
|
---|
16 | =item accessor methods
|
---|
17 |
|
---|
18 | A L</method> used to indirectly inspect or update an L</object>'s
|
---|
19 | state (its L<instance variables|/instance variable>).
|
---|
20 |
|
---|
21 | =item actual arguments
|
---|
22 |
|
---|
23 | The L<scalar values|/scalar value> that you supply to a L</function>
|
---|
24 | or L</subroutine> when you call it. For instance, when you call
|
---|
25 | C<power("puff")>, the string C<"puff"> is the actual argument. See
|
---|
26 | also L</argument> and L</formal arguments>.
|
---|
27 |
|
---|
28 | =item address operator
|
---|
29 |
|
---|
30 | Some languages work directly with the memory addresses of values, but
|
---|
31 | this can be like playing with fire. Perl provides a set of asbestos
|
---|
32 | gloves for handling all memory management. The closest to an address
|
---|
33 | operator in Perl is the backslash operator, but it gives you a L</hard
|
---|
34 | reference>, which is much safer than a memory address.
|
---|
35 |
|
---|
36 | =item algorithm
|
---|
37 |
|
---|
38 | A well-defined sequence of steps, clearly enough explained that even a
|
---|
39 | computer could do them.
|
---|
40 |
|
---|
41 | =item alias
|
---|
42 |
|
---|
43 | A nickname for something, which behaves in all ways as though you'd
|
---|
44 | used the original name instead of the nickname. Temporary aliases are
|
---|
45 | implicitly created in the loop variable for C<foreach> loops, in the
|
---|
46 | C<$_> variable for L<map|perlfunc/map> or L<grep|perlfunc/grep>
|
---|
47 | operators, in C<$a> and C<$b> during L<sort|perlfunc/sort>'s
|
---|
48 | comparison function, and in each element of C<@_> for the L</actual
|
---|
49 | arguments> of a subroutine call. Permanent aliases are explicitly
|
---|
50 | created in L<packages|/package> by L<importing|/import> symbols or by
|
---|
51 | assignment to L<typeglobs|/typeglob>. Lexically scoped aliases for
|
---|
52 | package variables are explicitly created by the L<our|perlfunc/our>
|
---|
53 | declaration.
|
---|
54 |
|
---|
55 | =item alternatives
|
---|
56 |
|
---|
57 | A list of possible choices from which you may select only one, as in
|
---|
58 | "Would you like door A, B, or C?" Alternatives in regular expressions
|
---|
59 | are separated with a single vertical bar: C<|>. Alternatives in
|
---|
60 | normal Perl expressions are separated with a double vertical bar:
|
---|
61 | C<||>. Logical alternatives in L</Boolean> expressions are separated
|
---|
62 | with either C<||> or C<or>.
|
---|
63 |
|
---|
64 | =item anonymous
|
---|
65 |
|
---|
66 | Used to describe a L</referent> that is not directly accessible
|
---|
67 | through a named L</variable>. Such a referent must be indirectly
|
---|
68 | accessible through at least one L</hard reference>. When the last
|
---|
69 | hard reference goes away, the anonymous referent is destroyed without
|
---|
70 | pity.
|
---|
71 |
|
---|
72 | =item architecture
|
---|
73 |
|
---|
74 | The kind of computer you're working on, where one "kind" of computer
|
---|
75 | means all those computers sharing a compatible machine language.
|
---|
76 | Since Perl programs are (typically) simple text files, not executable
|
---|
77 | images, a Perl program is much less sensitive to the architecture it's
|
---|
78 | running on than programs in other languages, such as C, that are
|
---|
79 | compiled into machine code. See also L</platform> and L</operating
|
---|
80 | system>.
|
---|
81 |
|
---|
82 | =item argument
|
---|
83 |
|
---|
84 | A piece of data supplied to a L<program|/executable file>,
|
---|
85 | L</subroutine>, L</function>, or L</method> to tell it what it's
|
---|
86 | supposed to do. Also called a "parameter".
|
---|
87 |
|
---|
88 | =item ARGV
|
---|
89 |
|
---|
90 | The name of the array containing the L</argument> L</vector> from the
|
---|
91 | command line. If you use the empty C<< E<lt>E<gt> >> operator, L</ARGV> is
|
---|
92 | the name of both the L</filehandle> used to traverse the arguments and
|
---|
93 | the L</scalar> containing the name of the current input file.
|
---|
94 |
|
---|
95 | =item arithmetical operator
|
---|
96 |
|
---|
97 | A L</symbol> such as C<+> or C</> that tells Perl to do the arithmetic
|
---|
98 | you were supposed to learn in grade school.
|
---|
99 |
|
---|
100 | =item array
|
---|
101 |
|
---|
102 | An ordered sequence of L<values|/value>, stored such that you can
|
---|
103 | easily access any of the values using an integer L</subscript>
|
---|
104 | that specifies the value's L</offset> in the sequence.
|
---|
105 |
|
---|
106 | =item array context
|
---|
107 |
|
---|
108 | An archaic expression for what is more correctly referred to as
|
---|
109 | L</list context>.
|
---|
110 |
|
---|
111 | =item ASCII
|
---|
112 |
|
---|
113 | The American Standard Code for Information Interchange (a 7-bit
|
---|
114 | character set adequate only for poorly representing English text).
|
---|
115 | Often used loosely to describe the lowest 128 values of the various
|
---|
116 | ISO-8859-X character sets, a bunch of mutually incompatible 8-bit
|
---|
117 | codes best described as half ASCII. See also L</Unicode>.
|
---|
118 |
|
---|
119 | =item assertion
|
---|
120 |
|
---|
121 | A component of a L</regular expression> that must be true for the
|
---|
122 | pattern to match but does not necessarily match any characters itself.
|
---|
123 | Often used specifically to mean a L</zero width> assertion.
|
---|
124 |
|
---|
125 | =item assignment
|
---|
126 |
|
---|
127 | An L</operator> whose assigned mission in life is to change the value
|
---|
128 | of a L</variable>.
|
---|
129 |
|
---|
130 | =item assignment operator
|
---|
131 |
|
---|
132 | Either a regular L</assignment>, or a compound L</operator> composed
|
---|
133 | of an ordinary assignment and some other operator, that changes the
|
---|
134 | value of a variable in place, that is, relative to its old value. For
|
---|
135 | example, C<$a += 2> adds C<2> to C<$a>.
|
---|
136 |
|
---|
137 | =item associative array
|
---|
138 |
|
---|
139 | See L</hash>. Please.
|
---|
140 |
|
---|
141 | =item associativity
|
---|
142 |
|
---|
143 | Determines whether you do the left L</operator> first or the right
|
---|
144 | L</operator> first when you have "A L</operator> B L</operator> C" and
|
---|
145 | the two operators are of the same precedence. Operators like C<+> are
|
---|
146 | left associative, while operators like C<**> are right associative.
|
---|
147 | See L<perlop> for a list of operators and their associativity.
|
---|
148 |
|
---|
149 | =item asynchronous
|
---|
150 |
|
---|
151 | Said of events or activities whose relative temporal ordering is
|
---|
152 | indeterminate because too many things are going on at once. Hence, an
|
---|
153 | asynchronous event is one you didn't know when to expect.
|
---|
154 |
|
---|
155 | =item atom
|
---|
156 |
|
---|
157 | A L</regular expression> component potentially matching a
|
---|
158 | L</substring> containing one or more characters and treated as an
|
---|
159 | indivisible syntactic unit by any following L</quantifier>. (Contrast
|
---|
160 | with an L</assertion> that matches something of L</zero width> and may
|
---|
161 | not be quantified.)
|
---|
162 |
|
---|
163 | =item atomic operation
|
---|
164 |
|
---|
165 | When Democritus gave the word "atom" to the indivisible bits of
|
---|
166 | matter, he meant literally something that could not be cut: I<a->
|
---|
167 | (not) + I<tomos> (cuttable). An atomic operation is an action that
|
---|
168 | can't be interrupted, not one forbidden in a nuclear-free zone.
|
---|
169 |
|
---|
170 | =item attribute
|
---|
171 |
|
---|
172 | A new feature that allows the declaration of L<variables|/variable>
|
---|
173 | and L<subroutines|/subroutine> with modifiers as in C<sub foo : locked
|
---|
174 | method>. Also, another name for an L</instance variable> of an
|
---|
175 | L</object>.
|
---|
176 |
|
---|
177 | =item autogeneration
|
---|
178 |
|
---|
179 | A feature of L</operator overloading> of L<objects|/object>, whereby
|
---|
180 | the behavior of certain L<operators|/operator> can be reasonably
|
---|
181 | deduced using more fundamental operators. This assumes that the
|
---|
182 | overloaded operators will often have the same relationships as the
|
---|
183 | regular operators. See L<perlop>.
|
---|
184 |
|
---|
185 | =item autoincrement
|
---|
186 |
|
---|
187 | To add one to something automatically, hence the name of the C<++>
|
---|
188 | operator. To instead subtract one from something automatically is
|
---|
189 | known as an "autodecrement".
|
---|
190 |
|
---|
191 | =item autoload
|
---|
192 |
|
---|
193 | To load on demand. (Also called "lazy" loading.) Specifically, to
|
---|
194 | call an L<AUTOLOAD|perlsub/Autoloading> subroutine on behalf of an
|
---|
195 | undefined subroutine.
|
---|
196 |
|
---|
197 | =item autosplit
|
---|
198 |
|
---|
199 | To split a string automatically, as the B<-a> L</switch> does when
|
---|
200 | running under B<-p> or B<-n> in order to emulate L</awk>. (See also
|
---|
201 | the L<AutoSplit> module, which has nothing to do with the B<-a>
|
---|
202 | switch, but a lot to do with autoloading.)
|
---|
203 |
|
---|
204 | =item autovivification
|
---|
205 |
|
---|
206 | A Greco-Roman word meaning "to bring oneself to life". In Perl,
|
---|
207 | storage locations (L<lvalues|/lvalue>) spontaneously generate
|
---|
208 | themselves as needed, including the creation of any L</hard reference>
|
---|
209 | values to point to the next level of storage. The assignment
|
---|
210 | C<$a[5][5][5][5][5] = "quintet"> potentially creates five scalar
|
---|
211 | storage locations, plus four references (in the first four scalar
|
---|
212 | locations) pointing to four new anonymous arrays (to hold the last
|
---|
213 | four scalar locations). But the point of autovivification is that you
|
---|
214 | don't have to worry about it.
|
---|
215 |
|
---|
216 | =item AV
|
---|
217 |
|
---|
218 | Short for "array value", which refers to one of Perl's internal data
|
---|
219 | types that holds an L</array>. The L</AV> type is a subclass of
|
---|
220 | L</SV>.
|
---|
221 |
|
---|
222 | =item awk
|
---|
223 |
|
---|
224 | Descriptive editing term--short for "awkward". Also coincidentally
|
---|
225 | refers to a venerable text-processing language from which Perl derived
|
---|
226 | some of its high-level ideas.
|
---|
227 |
|
---|
228 | =back
|
---|
229 |
|
---|
230 | =head2 B
|
---|
231 |
|
---|
232 | =over 4
|
---|
233 |
|
---|
234 | =item backreference
|
---|
235 |
|
---|
236 | A substring L<captured|/capturing> by a subpattern within
|
---|
237 | unadorned parentheses in a L</regex>. Backslashed decimal numbers
|
---|
238 | (C<\1>, C<\2>, etc.) later in the same pattern refer back to the
|
---|
239 | corresponding subpattern in the current match. Outside the pattern,
|
---|
240 | the numbered variables (C<$1>, C<$2>, etc.) continue to refer to these
|
---|
241 | same values, as long as the pattern was the last successful match of
|
---|
242 | the current dynamic scope.
|
---|
243 |
|
---|
244 | =item backtracking
|
---|
245 |
|
---|
246 | The practice of saying, "If I had to do it all over, I'd do it
|
---|
247 | differently," and then actually going back and doing it all over
|
---|
248 | differently. Mathematically speaking, it's returning from an
|
---|
249 | unsuccessful recursion on a tree of possibilities. Perl backtracks
|
---|
250 | when it attempts to match patterns with a L</regular expression>, and
|
---|
251 | its earlier attempts don't pan out. See L<perlre/Backtracking>.
|
---|
252 |
|
---|
253 | =item backward compatibility
|
---|
254 |
|
---|
255 | Means you can still run your old program because we didn't break any
|
---|
256 | of the features or bugs it was relying on.
|
---|
257 |
|
---|
258 | =item bareword
|
---|
259 |
|
---|
260 | A word sufficiently ambiguous to be deemed illegal under L<use strict
|
---|
261 | 'subs'|strict/strict subs>. In the absence of that stricture, a
|
---|
262 | bareword is treated as if quotes were around it.
|
---|
263 |
|
---|
264 | =item base class
|
---|
265 |
|
---|
266 | A generic L</object> type; that is, a L</class> from which other, more
|
---|
267 | specific classes are derived genetically by L</inheritance>. Also
|
---|
268 | called a "superclass" by people who respect their ancestors.
|
---|
269 |
|
---|
270 | =item big-endian
|
---|
271 |
|
---|
272 | From Swift: someone who eats eggs big end first. Also used of
|
---|
273 | computers that store the most significant L</byte> of a word at a
|
---|
274 | lower byte address than the least significant byte. Often considered
|
---|
275 | superior to little-endian machines. See also L</little-endian>.
|
---|
276 |
|
---|
277 | =item binary
|
---|
278 |
|
---|
279 | Having to do with numbers represented in base 2. That means there's
|
---|
280 | basically two numbers, 0 and 1. Also used to describe a "non-text
|
---|
281 | file", presumably because such a file makes full use of all the binary
|
---|
282 | bits in its bytes. With the advent of L</Unicode>, this distinction,
|
---|
283 | already suspect, loses even more of its meaning.
|
---|
284 |
|
---|
285 | =item binary operator
|
---|
286 |
|
---|
287 | An L</operator> that takes two L<operands|/operand>.
|
---|
288 |
|
---|
289 | =item bind
|
---|
290 |
|
---|
291 | To assign a specific L</network address> to a L</socket>.
|
---|
292 |
|
---|
293 | =item bit
|
---|
294 |
|
---|
295 | An integer in the range from 0 to 1, inclusive. The smallest possible
|
---|
296 | unit of information storage. An eighth of a L</byte> or of a dollar.
|
---|
297 | (The term "Pieces of Eight" comes from being able to split the old
|
---|
298 | Spanish dollar into 8 bits, each of which still counted for money.
|
---|
299 | That's why a 25-cent piece today is still "two bits".)
|
---|
300 |
|
---|
301 | =item bit shift
|
---|
302 |
|
---|
303 | The movement of bits left or right in a computer word, which has the
|
---|
304 | effect of multiplying or dividing by a power of 2.
|
---|
305 |
|
---|
306 | =item bit string
|
---|
307 |
|
---|
308 | A sequence of L<bits|/bit> that is actually being thought of as a
|
---|
309 | sequence of bits, for once.
|
---|
310 |
|
---|
311 | =item bless
|
---|
312 |
|
---|
313 | In corporate life, to grant official approval to a thing, as in, "The
|
---|
314 | VP of Engineering has blessed our WebCruncher project." Similarly in
|
---|
315 | Perl, to grant official approval to a L</referent> so that it can
|
---|
316 | function as an L</object>, such as a WebCruncher object. See
|
---|
317 | L<perlfunc/"bless">.
|
---|
318 |
|
---|
319 | =item block
|
---|
320 |
|
---|
321 | What a L</process> does when it has to wait for something: "My process
|
---|
322 | blocked waiting for the disk." As an unrelated noun, it refers to a
|
---|
323 | large chunk of data, of a size that the L</operating system> likes to
|
---|
324 | deal with (normally a power of two such as 512 or 8192). Typically
|
---|
325 | refers to a chunk of data that's coming from or going to a disk file.
|
---|
326 |
|
---|
327 | =item BLOCK
|
---|
328 |
|
---|
329 | A syntactic construct consisting of a sequence of Perl
|
---|
330 | L<statements|/statement> that is delimited by braces. The C<if> and
|
---|
331 | C<while> statements are defined in terms of L<BLOCKs|/BLOCK>, for instance.
|
---|
332 | Sometimes we also say "block" to mean a lexical scope; that is, a
|
---|
333 | sequence of statements that act like a L</BLOCK>, such as within an
|
---|
334 | L<eval|perlfunc/eval> or a file, even though the statements aren't
|
---|
335 | delimited by braces.
|
---|
336 |
|
---|
337 | =item block buffering
|
---|
338 |
|
---|
339 | A method of making input and output efficient by passing one L</block>
|
---|
340 | at a time. By default, Perl does block buffering to disk files. See
|
---|
341 | L</buffer> and L</command buffering>.
|
---|
342 |
|
---|
343 | =item Boolean
|
---|
344 |
|
---|
345 | A value that is either L</true> or L</false>.
|
---|
346 |
|
---|
347 | =item Boolean context
|
---|
348 |
|
---|
349 | A special kind of L</scalar context> used in conditionals to decide
|
---|
350 | whether the L</scalar value> returned by an expression is L</true> or
|
---|
351 | L</false>. Does not evaluate as either a string or a number. See
|
---|
352 | L</context>.
|
---|
353 |
|
---|
354 | =item breakpoint
|
---|
355 |
|
---|
356 | A spot in your program where you've told the debugger to stop
|
---|
357 | L<execution|/execute> so you can poke around and see whether anything
|
---|
358 | is wrong yet.
|
---|
359 |
|
---|
360 | =item broadcast
|
---|
361 |
|
---|
362 | To send a L</datagram> to multiple destinations simultaneously.
|
---|
363 |
|
---|
364 | =item BSD
|
---|
365 |
|
---|
366 | A psychoactive drug, popular in the 80s, probably developed at
|
---|
367 | U. C. Berkeley or thereabouts. Similar in many ways to the
|
---|
368 | prescription-only medication called "System V", but infinitely more
|
---|
369 | useful. (Or, at least, more fun.) The full chemical name is
|
---|
370 | "Berkeley Standard Distribution".
|
---|
371 |
|
---|
372 | =item bucket
|
---|
373 |
|
---|
374 | A location in a L</hash table> containing (potentially) multiple
|
---|
375 | entries whose keys "hash" to the same hash value according to its hash
|
---|
376 | function. (As internal policy, you don't have to worry about it,
|
---|
377 | unless you're into internals, or policy.)
|
---|
378 |
|
---|
379 | =item buffer
|
---|
380 |
|
---|
381 | A temporary holding location for data. L<Block buffering|/block
|
---|
382 | buffering> means that the data is passed on to its destination
|
---|
383 | whenever the buffer is full. L<Line buffering|/line buffering> means
|
---|
384 | that it's passed on whenever a complete line is received. L<Command
|
---|
385 | buffering|/command buffering> means that it's passed every time you do
|
---|
386 | a L<print|perlfunc/print> command (or equivalent). If your output is
|
---|
387 | unbuffered, the system processes it one byte at a time without the use
|
---|
388 | of a holding area. This can be rather inefficient.
|
---|
389 |
|
---|
390 | =item built-in
|
---|
391 |
|
---|
392 | A L</function> that is predefined in the language. Even when hidden
|
---|
393 | by L</overriding>, you can always get at a built-in function by
|
---|
394 | L<qualifying|/qualified> its name with the C<CORE::> pseudo-package.
|
---|
395 |
|
---|
396 | =item bundle
|
---|
397 |
|
---|
398 | A group of related modules on L</CPAN>. (Also, sometimes refers to a
|
---|
399 | group of command-line switches grouped into one L</switch cluster>.)
|
---|
400 |
|
---|
401 | =item byte
|
---|
402 |
|
---|
403 | A piece of data worth eight L<bits|/bit> in most places.
|
---|
404 |
|
---|
405 | =item bytecode
|
---|
406 |
|
---|
407 | A pidgin-like language spoken among 'droids when they don't wish to
|
---|
408 | reveal their orientation (see L</endian>). Named after some similar
|
---|
409 | languages spoken (for similar reasons) between compilers and
|
---|
410 | interpreters in the late 20th century. These languages are
|
---|
411 | characterized by representing everything as a
|
---|
412 | non-architecture-dependent sequence of bytes.
|
---|
413 |
|
---|
414 | =back
|
---|
415 |
|
---|
416 | =head2 C
|
---|
417 |
|
---|
418 | =over 4
|
---|
419 |
|
---|
420 | =item C
|
---|
421 |
|
---|
422 | A language beloved by many for its inside-out L</type> definitions,
|
---|
423 | inscrutable L</precedence> rules, and heavy L</overloading> of the
|
---|
424 | function-call mechanism. (Well, actually, people first switched to C
|
---|
425 | because they found lowercase identifiers easier to read than upper.)
|
---|
426 | Perl is written in C, so it's not surprising that Perl borrowed a few
|
---|
427 | ideas from it.
|
---|
428 |
|
---|
429 | =item C preprocessor
|
---|
430 |
|
---|
431 | The typical C compiler's first pass, which processes lines beginning
|
---|
432 | with C<#> for conditional compilation and macro definition and does
|
---|
433 | various manipulations of the program text based on the current
|
---|
434 | definitions. Also known as I<cpp>(1).
|
---|
435 |
|
---|
436 | =item call by reference
|
---|
437 |
|
---|
438 | An L</argument>-passing mechanism in which the L</formal arguments>
|
---|
439 | refer directly to the L</actual arguments>, and the L</subroutine> can
|
---|
440 | change the actual arguments by changing the formal arguments. That
|
---|
441 | is, the formal argument is an L</alias> for the actual argument. See
|
---|
442 | also L</call by value>.
|
---|
443 |
|
---|
444 | =item call by value
|
---|
445 |
|
---|
446 | An L</argument>-passing mechanism in which the L</formal arguments>
|
---|
447 | refer to a copy of the L</actual arguments>, and the L</subroutine>
|
---|
448 | cannot change the actual arguments by changing the formal arguments.
|
---|
449 | See also L</call by reference>.
|
---|
450 |
|
---|
451 | =item callback
|
---|
452 |
|
---|
453 | A L</handler> that you register with some other part of your program
|
---|
454 | in the hope that the other part of your program will L</trigger> your
|
---|
455 | handler when some event of interest transpires.
|
---|
456 |
|
---|
457 | =item canonical
|
---|
458 |
|
---|
459 | Reduced to a standard form to facilitate comparison.
|
---|
460 |
|
---|
461 | =item capturing
|
---|
462 |
|
---|
463 | The use of parentheses around a L</subpattern> in a L</regular
|
---|
464 | expression> to store the matched L</substring> as a L</backreference>.
|
---|
465 | (Captured strings are also returned as a list in L</list context>.)
|
---|
466 |
|
---|
467 | =item character
|
---|
468 |
|
---|
469 | A small integer representative of a unit of orthography.
|
---|
470 | Historically, characters were usually stored as fixed-width integers
|
---|
471 | (typically in a byte, or maybe two, depending on the character set),
|
---|
472 | but with the advent of UTF-8, characters are often stored in a
|
---|
473 | variable number of bytes depending on the size of the integer that
|
---|
474 | represents the character. Perl manages this transparently for you,
|
---|
475 | for the most part.
|
---|
476 |
|
---|
477 | =item character class
|
---|
478 |
|
---|
479 | A square-bracketed list of characters used in a L</regular expression>
|
---|
480 | to indicate that any character of the set may occur at a given point.
|
---|
481 | Loosely, any predefined set of characters so used.
|
---|
482 |
|
---|
483 | =item character property
|
---|
484 |
|
---|
485 | A predefined L</character class> matchable by the C<\p>
|
---|
486 | L</metasymbol>. Many standard properties are defined for L</Unicode>.
|
---|
487 |
|
---|
488 | =item circumfix operator
|
---|
489 |
|
---|
490 | An L</operator> that surrounds its L</operand>, like the angle
|
---|
491 | operator, or parentheses, or a hug.
|
---|
492 |
|
---|
493 | =item class
|
---|
494 |
|
---|
495 | A user-defined L</type>, implemented in Perl via a L</package> that
|
---|
496 | provides (either directly or by inheritance) L<methods|/method> (that
|
---|
497 | is, L<subroutines|/subroutine>) to handle L<instances|/instance> of
|
---|
498 | the class (its L<objects|/object>). See also L</inheritance>.
|
---|
499 |
|
---|
500 | =item class method
|
---|
501 |
|
---|
502 | A L</method> whose L</invocant> is a L</package> name, not an
|
---|
503 | L</object> reference. A method associated with the class as a whole.
|
---|
504 |
|
---|
505 | =item client
|
---|
506 |
|
---|
507 | In networking, a L</process> that initiates contact with a L</server>
|
---|
508 | process in order to exchange data and perhaps receive a service.
|
---|
509 |
|
---|
510 | =item cloister
|
---|
511 |
|
---|
512 | A L</cluster> used to restrict the scope of a L</regular expression
|
---|
513 | modifier>.
|
---|
514 |
|
---|
515 | =item closure
|
---|
516 |
|
---|
517 | An L</anonymous> subroutine that, when a reference to it is generated
|
---|
518 | at run time, keeps track of the identities of externally visible
|
---|
519 | L<lexical variables|/lexical variable> even after those lexical
|
---|
520 | variables have supposedly gone out of L</scope>. They're called
|
---|
521 | "closures" because this sort of behavior gives mathematicians a sense
|
---|
522 | of closure.
|
---|
523 |
|
---|
524 | =item cluster
|
---|
525 |
|
---|
526 | A parenthesized L</subpattern> used to group parts of a L</regular
|
---|
527 | expression> into a single L</atom>.
|
---|
528 |
|
---|
529 | =item CODE
|
---|
530 |
|
---|
531 | The word returned by the L<ref|perlfunc/ref> function when you apply
|
---|
532 | it to a reference to a subroutine. See also L</CV>.
|
---|
533 |
|
---|
534 | =item code generator
|
---|
535 |
|
---|
536 | A system that writes code for you in a low-level language, such as
|
---|
537 | code to implement the backend of a compiler. See L</program
|
---|
538 | generator>.
|
---|
539 |
|
---|
540 | =item code subpattern
|
---|
541 |
|
---|
542 | A L</regular expression> subpattern whose real purpose is to execute
|
---|
543 | some Perl code, for example, the C<(?{...})> and C<(??{...})>
|
---|
544 | subpatterns.
|
---|
545 |
|
---|
546 | =item collating sequence
|
---|
547 |
|
---|
548 | The order into which L<characters|/character> sort. This is used by
|
---|
549 | L</string> comparison routines to decide, for example, where in this
|
---|
550 | glossary to put "collating sequence".
|
---|
551 |
|
---|
552 | =item command
|
---|
553 |
|
---|
554 | In L</shell> programming, the syntactic combination of a program name
|
---|
555 | and its arguments. More loosely, anything you type to a shell (a
|
---|
556 | command interpreter) that starts it doing something. Even more
|
---|
557 | loosely, a Perl L</statement>, which might start with a L</label> and
|
---|
558 | typically ends with a semicolon.
|
---|
559 |
|
---|
560 | =item command buffering
|
---|
561 |
|
---|
562 | A mechanism in Perl that lets you store up the output of each Perl
|
---|
563 | L</command> and then flush it out as a single request to the
|
---|
564 | L</operating system>. It's enabled by setting the C<$|>
|
---|
565 | (C<$AUTOFLUSH>) variable to a true value. It's used when you don't
|
---|
566 | want data sitting around not going where it's supposed to, which may
|
---|
567 | happen because the default on a L</file> or L</pipe> is to use
|
---|
568 | L</block buffering>.
|
---|
569 |
|
---|
570 | =item command name
|
---|
571 |
|
---|
572 | The name of the program currently executing, as typed on the command
|
---|
573 | line. In C, the L</command> name is passed to the program as the
|
---|
574 | first command-line argument. In Perl, it comes in separately as
|
---|
575 | C<$0>.
|
---|
576 |
|
---|
577 | =item command-line arguments
|
---|
578 |
|
---|
579 | The L<values|/value> you supply along with a program name when you
|
---|
580 | tell a L</shell> to execute a L</command>. These values are passed to
|
---|
581 | a Perl program through C<@ARGV>.
|
---|
582 |
|
---|
583 | =item comment
|
---|
584 |
|
---|
585 | A remark that doesn't affect the meaning of the program. In Perl, a
|
---|
586 | comment is introduced by a C<#> character and continues to the end of
|
---|
587 | the line.
|
---|
588 |
|
---|
589 | =item compilation unit
|
---|
590 |
|
---|
591 | The L</file> (or L</string>, in the case of L<eval|perlfunc/eval>)
|
---|
592 | that is currently being compiled.
|
---|
593 |
|
---|
594 | =item compile phase
|
---|
595 |
|
---|
596 | Any time before Perl starts running your main program. See also
|
---|
597 | L</run phase>. Compile phase is mostly spent in L</compile time>, but
|
---|
598 | may also be spent in L</run time> when C<BEGIN> blocks,
|
---|
599 | L<use|perlfunc/use> declarations, or constant subexpressions are being
|
---|
600 | evaluated. The startup and import code of any L<use|perlfunc/use>
|
---|
601 | declaration is also run during compile phase.
|
---|
602 |
|
---|
603 | =item compile time
|
---|
604 |
|
---|
605 | The time when Perl is trying to make sense of your code, as opposed to
|
---|
606 | when it thinks it knows what your code means and is merely trying to
|
---|
607 | do what it thinks your code says to do, which is L</run time>.
|
---|
608 |
|
---|
609 | =item compiler
|
---|
610 |
|
---|
611 | Strictly speaking, a program that munches up another program and spits
|
---|
612 | out yet another file containing the program in a "more executable"
|
---|
613 | form, typically containing native machine instructions. The I<perl>
|
---|
614 | program is not a compiler by this definition, but it does contain a
|
---|
615 | kind of compiler that takes a program and turns it into a more
|
---|
616 | executable form (L<syntax trees|/syntax tree>) within the I<perl>
|
---|
617 | process itself, which the L</interpreter> then interprets. There are,
|
---|
618 | however, extension L<modules|/module> to get Perl to act more like a
|
---|
619 | "real" compiler. See L<O>.
|
---|
620 |
|
---|
621 | =item composer
|
---|
622 |
|
---|
623 | A "constructor" for a L</referent> that isn't really an L</object>,
|
---|
624 | like an anonymous array or a hash (or a sonata, for that matter). For
|
---|
625 | example, a pair of braces acts as a composer for a hash, and a pair of
|
---|
626 | brackets acts as a composer for an array. See L<perlref/Making
|
---|
627 | References>.
|
---|
628 |
|
---|
629 | =item concatenation
|
---|
630 |
|
---|
631 | The process of gluing one cat's nose to another cat's tail. Also, a
|
---|
632 | similar operation on two L<strings|/string>.
|
---|
633 |
|
---|
634 | =item conditional
|
---|
635 |
|
---|
636 | Something "iffy". See L</Boolean context>.
|
---|
637 |
|
---|
638 | =item connection
|
---|
639 |
|
---|
640 | In telephony, the temporary electrical circuit between the caller's
|
---|
641 | and the callee's phone. In networking, the same kind of temporary
|
---|
642 | circuit between a L</client> and a L</server>.
|
---|
643 |
|
---|
644 | =item construct
|
---|
645 |
|
---|
646 | As a noun, a piece of syntax made up of smaller pieces. As a
|
---|
647 | transitive verb, to create an L</object> using a L</constructor>.
|
---|
648 |
|
---|
649 | =item constructor
|
---|
650 |
|
---|
651 | Any L</class method>, instance L</method>, or L</subroutine>
|
---|
652 | that composes, initializes, blesses, and returns an L</object>.
|
---|
653 | Sometimes we use the term loosely to mean a L</composer>.
|
---|
654 |
|
---|
655 | =item context
|
---|
656 |
|
---|
657 | The surroundings, or environment. The context given by the
|
---|
658 | surrounding code determines what kind of data a particular
|
---|
659 | L</expression> is expected to return. The three primary contexts are
|
---|
660 | L</list context>, L</scalar context>, and L</void context>. Scalar
|
---|
661 | context is sometimes subdivided into L</Boolean context>, L</numeric
|
---|
662 | context>, L</string context>, and L</void context>. There's also a
|
---|
663 | "don't care" scalar context (which is dealt with in Programming Perl,
|
---|
664 | Third Edition, Chapter 2, "Bits and Pieces" if you care).
|
---|
665 |
|
---|
666 | =item continuation
|
---|
667 |
|
---|
668 | The treatment of more than one physical L</line> as a single logical
|
---|
669 | line. L</Makefile> lines are continued by putting a backslash before
|
---|
670 | the L</newline>. Mail headers as defined by RFC 822 are continued by
|
---|
671 | putting a space or tab I<after> the newline. In general, lines in
|
---|
672 | Perl do not need any form of continuation mark, because L</whitespace>
|
---|
673 | (including newlines) is gleefully ignored. Usually.
|
---|
674 |
|
---|
675 | =item core dump
|
---|
676 |
|
---|
677 | The corpse of a L</process>, in the form of a file left in the
|
---|
678 | L</working directory> of the process, usually as a result of certain
|
---|
679 | kinds of fatal error.
|
---|
680 |
|
---|
681 | =item CPAN
|
---|
682 |
|
---|
683 | The Comprehensive Perl Archive Network. (See L<perlfaq2/What modules and extensions are available for Perl? What is CPAN? What does CPANE<sol>srcE<sol>... mean?>).
|
---|
684 |
|
---|
685 | =item cracker
|
---|
686 |
|
---|
687 | Someone who breaks security on computer systems. A cracker may be a
|
---|
688 | true L</hacker> or only a L</script kiddie>.
|
---|
689 |
|
---|
690 | =item current package
|
---|
691 |
|
---|
692 | The L</package> in which the current statement is compiled. Scan
|
---|
693 | backwards in the text of your program through the current L<lexical
|
---|
694 | scope|/lexical scoping> or any enclosing lexical scopes till you find
|
---|
695 | a package declaration. That's your current package name.
|
---|
696 |
|
---|
697 | =item current working directory
|
---|
698 |
|
---|
699 | See L</working directory>.
|
---|
700 |
|
---|
701 | =item currently selected output channel
|
---|
702 |
|
---|
703 | The last L</filehandle> that was designated with
|
---|
704 | L<select|perlfunc/select>(C<FILEHANDLE>); L</STDOUT>, if no filehandle
|
---|
705 | has been selected.
|
---|
706 |
|
---|
707 | =item CV
|
---|
708 |
|
---|
709 | An internal "code value" typedef, holding a L</subroutine>. The L</CV>
|
---|
710 | type is a subclass of L</SV>.
|
---|
711 |
|
---|
712 | =back
|
---|
713 |
|
---|
714 | =head2 D
|
---|
715 |
|
---|
716 | =over 4
|
---|
717 |
|
---|
718 | =item dangling statement
|
---|
719 |
|
---|
720 | A bare, single L</statement>, without any braces, hanging off an C<if>
|
---|
721 | or C<while> conditional. C allows them. Perl doesn't.
|
---|
722 |
|
---|
723 | =item data structure
|
---|
724 |
|
---|
725 | How your various pieces of data relate to each other and what shape
|
---|
726 | they make when you put them all together, as in a rectangular table or
|
---|
727 | a triangular-shaped tree.
|
---|
728 |
|
---|
729 | =item data type
|
---|
730 |
|
---|
731 | A set of possible values, together with all the operations that know
|
---|
732 | how to deal with those values. For example, a numeric data type has a
|
---|
733 | certain set of numbers that you can work with and various mathematical
|
---|
734 | operations that you can do on the numbers but would make little sense
|
---|
735 | on, say, a string such as C<"Kilroy">. Strings have their own
|
---|
736 | operations, such as L</concatenation>. Compound types made of a
|
---|
737 | number of smaller pieces generally have operations to compose and
|
---|
738 | decompose them, and perhaps to rearrange them. L<Objects|/object>
|
---|
739 | that model things in the real world often have operations that
|
---|
740 | correspond to real activities. For instance, if you model an
|
---|
741 | elevator, your elevator object might have an C<open_door()>
|
---|
742 | L</method>.
|
---|
743 |
|
---|
744 | =item datagram
|
---|
745 |
|
---|
746 | A packet of data, such as a L</UDP> message, that (from the viewpoint
|
---|
747 | of the programs involved) can be sent independently over the network.
|
---|
748 | (In fact, all packets are sent independently at the L</IP> level, but
|
---|
749 | L</stream> protocols such as L</TCP> hide this from your program.)
|
---|
750 |
|
---|
751 | =item DBM
|
---|
752 |
|
---|
753 | Stands for "Data Base Management" routines, a set of routines that
|
---|
754 | emulate an L</associative array> using disk files. The routines use a
|
---|
755 | dynamic hashing scheme to locate any entry with only two disk
|
---|
756 | accesses. DBM files allow a Perl program to keep a persistent
|
---|
757 | L</hash> across multiple invocations. You can L<tie|perlfunc/tie>
|
---|
758 | your hash variables to various DBM implementations--see L<AnyDBM_File>
|
---|
759 | and L<DB_File>.
|
---|
760 |
|
---|
761 | =item declaration
|
---|
762 |
|
---|
763 | An L</assertion> that states something exists and perhaps describes
|
---|
764 | what it's like, without giving any commitment as to how or where
|
---|
765 | you'll use it. A declaration is like the part of your recipe that
|
---|
766 | says, "two cups flour, one large egg, four or five tadpoles..." See
|
---|
767 | L</statement> for its opposite. Note that some declarations also
|
---|
768 | function as statements. Subroutine declarations also act as
|
---|
769 | definitions if a body is supplied.
|
---|
770 |
|
---|
771 | =item decrement
|
---|
772 |
|
---|
773 | To subtract a value from a variable, as in "decrement C<$x>" (meaning
|
---|
774 | to remove 1 from its value) or "decrement C<$x> by 3".
|
---|
775 |
|
---|
776 | =item default
|
---|
777 |
|
---|
778 | A L</value> chosen for you if you don't supply a value of your own.
|
---|
779 |
|
---|
780 | =item defined
|
---|
781 |
|
---|
782 | Having a meaning. Perl thinks that some of the things people try to
|
---|
783 | do are devoid of meaning, in particular, making use of variables that
|
---|
784 | have never been given a L</value> and performing certain operations on
|
---|
785 | data that isn't there. For example, if you try to read data past the
|
---|
786 | end of a file, Perl will hand you back an undefined value. See also
|
---|
787 | L</false> and L<perlfunc/defined>.
|
---|
788 |
|
---|
789 | =item delimiter
|
---|
790 |
|
---|
791 | A L</character> or L</string> that sets bounds to an arbitrarily-sized
|
---|
792 | textual object, not to be confused with a L</separator> or
|
---|
793 | L</terminator>. "To delimit" really just means "to surround" or "to
|
---|
794 | enclose" (like these parentheses are doing).
|
---|
795 |
|
---|
796 | =item dereference
|
---|
797 |
|
---|
798 | A fancy computer science term meaning "to follow a L</reference> to
|
---|
799 | what it points to". The "de" part of it refers to the fact that
|
---|
800 | you're taking away one level of L</indirection>.
|
---|
801 |
|
---|
802 | =item derived class
|
---|
803 |
|
---|
804 | A L</class> that defines some of its L<methods|/method> in terms of a
|
---|
805 | more generic class, called a L</base class>. Note that classes aren't
|
---|
806 | classified exclusively into base classes or derived classes: a class
|
---|
807 | can function as both a derived class and a base class simultaneously,
|
---|
808 | which is kind of classy.
|
---|
809 |
|
---|
810 | =item descriptor
|
---|
811 |
|
---|
812 | See L</file descriptor>.
|
---|
813 |
|
---|
814 | =item destroy
|
---|
815 |
|
---|
816 | To deallocate the memory of a L</referent> (first triggering its
|
---|
817 | C<DESTROY> method, if it has one).
|
---|
818 |
|
---|
819 | =item destructor
|
---|
820 |
|
---|
821 | A special L</method> that is called when an L</object> is thinking
|
---|
822 | about L<destroying|/destroy> itself. A Perl program's C<DESTROY>
|
---|
823 | method doesn't do the actual destruction; Perl just
|
---|
824 | L<triggers|/trigger> the method in case the L</class> wants to do any
|
---|
825 | associated cleanup.
|
---|
826 |
|
---|
827 | =item device
|
---|
828 |
|
---|
829 | A whiz-bang hardware gizmo (like a disk or tape drive or a modem or a
|
---|
830 | joystick or a mouse) attached to your computer, that the L</operating
|
---|
831 | system> tries to make look like a L</file> (or a bunch of files).
|
---|
832 | Under Unix, these fake files tend to live in the I</dev> directory.
|
---|
833 |
|
---|
834 | =item directive
|
---|
835 |
|
---|
836 | A L</pod> directive. See L<perlpod>.
|
---|
837 |
|
---|
838 | =item directory
|
---|
839 |
|
---|
840 | A special file that contains other files. Some L<operating
|
---|
841 | systems|/operating system> call these "folders", "drawers", or
|
---|
842 | "catalogs".
|
---|
843 |
|
---|
844 | =item directory handle
|
---|
845 |
|
---|
846 | A name that represents a particular instance of opening a directory to
|
---|
847 | read it, until you close it. See the L<opendir|perlfunc/opendir>
|
---|
848 | function.
|
---|
849 |
|
---|
850 | =item dispatch
|
---|
851 |
|
---|
852 | To send something to its correct destination. Often used
|
---|
853 | metaphorically to indicate a transfer of programmatic control to a
|
---|
854 | destination selected algorithmically, often by lookup in a table of
|
---|
855 | function L<references|/reference> or, in the case of object
|
---|
856 | L<methods|/method>, by traversing the inheritance tree looking for the
|
---|
857 | most specific definition for the method.
|
---|
858 |
|
---|
859 | =item distribution
|
---|
860 |
|
---|
861 | A standard, bundled release of a system of software. The default
|
---|
862 | usage implies source code is included. If that is not the case, it
|
---|
863 | will be called a "binary-only" distribution.
|
---|
864 |
|
---|
865 | =item dweomer
|
---|
866 |
|
---|
867 | An enchantment, illusion, phantasm, or jugglery. Said when Perl's
|
---|
868 | magical L</dwimmer> effects don't do what you expect, but rather seem
|
---|
869 | to be the product of arcane dweomercraft, sorcery, or wonder working.
|
---|
870 | [From Old English]
|
---|
871 |
|
---|
872 | =item dwimmer
|
---|
873 |
|
---|
874 | DWIM is an acronym for "Do What I Mean", the principle that something
|
---|
875 | should just do what you want it to do without an undue amount of fuss.
|
---|
876 | A bit of code that does "dwimming" is a "dwimmer". Dwimming can
|
---|
877 | require a great deal of behind-the-scenes magic, which (if it doesn't
|
---|
878 | stay properly behind the scenes) is called a L</dweomer> instead.
|
---|
879 |
|
---|
880 | =item dynamic scoping
|
---|
881 |
|
---|
882 | Dynamic scoping works over a dynamic scope, making variables visible
|
---|
883 | throughout the rest of the L</block> in which they are first used and
|
---|
884 | in any L<subroutines|/subroutine> that are called by the rest of the
|
---|
885 | block. Dynamically scoped variables can have their values temporarily
|
---|
886 | changed (and implicitly restored later) by a L<local|perlfunc/local>
|
---|
887 | operator. (Compare L</lexical scoping>.) Used more loosely to mean
|
---|
888 | how a subroutine that is in the middle of calling another subroutine
|
---|
889 | "contains" that subroutine at L</run time>.
|
---|
890 |
|
---|
891 | =back
|
---|
892 |
|
---|
893 | =head2 E
|
---|
894 |
|
---|
895 | =over 4
|
---|
896 |
|
---|
897 | =item eclectic
|
---|
898 |
|
---|
899 | Derived from many sources. Some would say I<too> many.
|
---|
900 |
|
---|
901 | =item element
|
---|
902 |
|
---|
903 | A basic building block. When you're talking about an L</array>, it's
|
---|
904 | one of the items that make up the array.
|
---|
905 |
|
---|
906 | =item embedding
|
---|
907 |
|
---|
908 | When something is contained in something else, particularly when that
|
---|
909 | might be considered surprising: "I've embedded a complete Perl
|
---|
910 | interpreter in my editor!"
|
---|
911 |
|
---|
912 | =item empty subclass test
|
---|
913 |
|
---|
914 | The notion that an empty L</derived class> should behave exactly like
|
---|
915 | its L</base class>.
|
---|
916 |
|
---|
917 | =item en passant
|
---|
918 |
|
---|
919 | When you change a L</value> as it is being copied. [From French, "in
|
---|
920 | passing", as in the exotic pawn-capturing maneuver in chess.]
|
---|
921 |
|
---|
922 | =item encapsulation
|
---|
923 |
|
---|
924 | The veil of abstraction separating the L</interface> from the
|
---|
925 | L</implementation> (whether enforced or not), which mandates that all
|
---|
926 | access to an L</object>'s state be through L<methods|/method> alone.
|
---|
927 |
|
---|
928 | =item endian
|
---|
929 |
|
---|
930 | See L</little-endian> and L</big-endian>.
|
---|
931 |
|
---|
932 | =item environment
|
---|
933 |
|
---|
934 | The collective set of L<environment variables|/environment variable>
|
---|
935 | your L</process> inherits from its parent. Accessed via C<%ENV>.
|
---|
936 |
|
---|
937 | =item environment variable
|
---|
938 |
|
---|
939 | A mechanism by which some high-level agent such as a user can pass its
|
---|
940 | preferences down to its future offspring (child L<processes|/process>,
|
---|
941 | grandchild processes, great-grandchild processes, and so on). Each
|
---|
942 | environment variable is a L</key>/L</value> pair, like one entry in a
|
---|
943 | L</hash>.
|
---|
944 |
|
---|
945 | =item EOF
|
---|
946 |
|
---|
947 | End of File. Sometimes used metaphorically as the terminating string
|
---|
948 | of a L</here document>.
|
---|
949 |
|
---|
950 | =item errno
|
---|
951 |
|
---|
952 | The error number returned by a L</syscall> when it fails. Perl refers
|
---|
953 | to the error by the name C<$!> (or C<$OS_ERROR> if you use the English
|
---|
954 | module).
|
---|
955 |
|
---|
956 | =item error
|
---|
957 |
|
---|
958 | See L</exception> or L</fatal error>.
|
---|
959 |
|
---|
960 | =item escape sequence
|
---|
961 |
|
---|
962 | See L</metasymbol>.
|
---|
963 |
|
---|
964 | =item exception
|
---|
965 |
|
---|
966 | A fancy term for an error. See L</fatal error>.
|
---|
967 |
|
---|
968 | =item exception handling
|
---|
969 |
|
---|
970 | The way a program responds to an error. The exception handling
|
---|
971 | mechanism in Perl is the L<eval|perlfunc/eval> operator.
|
---|
972 |
|
---|
973 | =item exec
|
---|
974 |
|
---|
975 | To throw away the current L</process>'s program and replace it with
|
---|
976 | another without exiting the process or relinquishing any resources
|
---|
977 | held (apart from the old memory image).
|
---|
978 |
|
---|
979 | =item executable file
|
---|
980 |
|
---|
981 | A L</file> that is specially marked to tell the L</operating system>
|
---|
982 | that it's okay to run this file as a program. Usually shortened to
|
---|
983 | "executable".
|
---|
984 |
|
---|
985 | =item execute
|
---|
986 |
|
---|
987 | To run a L<program|/executable file> or L</subroutine>. (Has nothing
|
---|
988 | to do with the L<kill|perlfunc/kill> built-in, unless you're trying to
|
---|
989 | run a L</signal handler>.)
|
---|
990 |
|
---|
991 | =item execute bit
|
---|
992 |
|
---|
993 | The special mark that tells the operating system it can run this
|
---|
994 | program. There are actually three execute bits under Unix, and which
|
---|
995 | bit gets used depends on whether you own the file singularly,
|
---|
996 | collectively, or not at all.
|
---|
997 |
|
---|
998 | =item exit status
|
---|
999 |
|
---|
1000 | See L</status>.
|
---|
1001 |
|
---|
1002 | =item export
|
---|
1003 |
|
---|
1004 | To make symbols from a L</module> available for L</import> by other modules.
|
---|
1005 |
|
---|
1006 | =item expression
|
---|
1007 |
|
---|
1008 | Anything you can legally say in a spot where a L</value> is required.
|
---|
1009 | Typically composed of L<literals|/literal>, L<variables|/variable>,
|
---|
1010 | L<operators|/operator>, L<functions|/function>, and L</subroutine>
|
---|
1011 | calls, not necessarily in that order.
|
---|
1012 |
|
---|
1013 | =item extension
|
---|
1014 |
|
---|
1015 | A Perl module that also pulls in compiled C or C++ code. More
|
---|
1016 | generally, any experimental option that can be compiled into Perl,
|
---|
1017 | such as multithreading.
|
---|
1018 |
|
---|
1019 | =back
|
---|
1020 |
|
---|
1021 | =head2 F
|
---|
1022 |
|
---|
1023 | =over 4
|
---|
1024 |
|
---|
1025 | =item false
|
---|
1026 |
|
---|
1027 | In Perl, any value that would look like C<""> or C<"0"> if evaluated
|
---|
1028 | in a string context. Since undefined values evaluate to C<"">, all
|
---|
1029 | undefined values are false, but not all false values are undefined.
|
---|
1030 |
|
---|
1031 | =item FAQ
|
---|
1032 |
|
---|
1033 | Frequently Asked Question (although not necessarily frequently
|
---|
1034 | answered, especially if the answer appears in the Perl FAQ shipped
|
---|
1035 | standard with Perl).
|
---|
1036 |
|
---|
1037 | =item fatal error
|
---|
1038 |
|
---|
1039 | An uncaught L</exception>, which causes termination of the L</process>
|
---|
1040 | after printing a message on your L</standard error> stream. Errors
|
---|
1041 | that happen inside an L<eval|perlfunc/eval> are not fatal. Instead,
|
---|
1042 | the L<eval|perlfunc/eval> terminates after placing the exception
|
---|
1043 | message in the C<$@> (C<$EVAL_ERROR>) variable. You can try to
|
---|
1044 | provoke a fatal error with the L<die|perlfunc/die> operator (known as
|
---|
1045 | throwing or raising an exception), but this may be caught by a
|
---|
1046 | dynamically enclosing L<eval|perlfunc/eval>. If not caught, the
|
---|
1047 | L<die|perlfunc/die> becomes a fatal error.
|
---|
1048 |
|
---|
1049 | =item field
|
---|
1050 |
|
---|
1051 | A single piece of numeric or string data that is part of a longer
|
---|
1052 | L</string>, L</record>, or L</line>. Variable-width fields are usually
|
---|
1053 | split up by L<separators|/separator> (so use L<split|perlfunc/split> to
|
---|
1054 | extract the fields), while fixed-width fields are usually at fixed
|
---|
1055 | positions (so use L<unpack|perlfunc/unpack>). L<Instance
|
---|
1056 | variables|/instance variable> are also known as fields.
|
---|
1057 |
|
---|
1058 | =item FIFO
|
---|
1059 |
|
---|
1060 | First In, First Out. See also L</LIFO>. Also, a nickname for a
|
---|
1061 | L</named pipe>.
|
---|
1062 |
|
---|
1063 | =item file
|
---|
1064 |
|
---|
1065 | A named collection of data, usually stored on disk in a L</directory>
|
---|
1066 | in a L</filesystem>. Roughly like a document, if you're into office
|
---|
1067 | metaphors. In modern filesystems, you can actually give a file more
|
---|
1068 | than one name. Some files have special properties, like directories
|
---|
1069 | and devices.
|
---|
1070 |
|
---|
1071 | =item file descriptor
|
---|
1072 |
|
---|
1073 | The little number the L</operating system> uses to keep track of which
|
---|
1074 | opened L</file> you're talking about. Perl hides the file descriptor
|
---|
1075 | inside a L</standard IE<sol>O> stream and then attaches the stream to
|
---|
1076 | a L</filehandle>.
|
---|
1077 |
|
---|
1078 | =item file test operator
|
---|
1079 |
|
---|
1080 | A built-in unary operator that you use to determine whether something
|
---|
1081 | is L</true> about a file, such as C<-o $filename> to test whether
|
---|
1082 | you're the owner of the file.
|
---|
1083 |
|
---|
1084 | =item fileglob
|
---|
1085 |
|
---|
1086 | A "wildcard" match on L<filenames|/filename>. See the
|
---|
1087 | L<glob|perlfunc/glob> function.
|
---|
1088 |
|
---|
1089 | =item filehandle
|
---|
1090 |
|
---|
1091 | An identifier (not necessarily related to the real name of a file)
|
---|
1092 | that represents a particular instance of opening a file until you
|
---|
1093 | close it. If you're going to open and close several different files
|
---|
1094 | in succession, it's fine to open each of them with the same
|
---|
1095 | filehandle, so you don't have to write out separate code to process
|
---|
1096 | each file.
|
---|
1097 |
|
---|
1098 | =item filename
|
---|
1099 |
|
---|
1100 | One name for a file. This name is listed in a L</directory>, and you
|
---|
1101 | can use it in an L<open|perlfunc/open> to tell the L</operating
|
---|
1102 | system> exactly which file you want to open, and associate the file
|
---|
1103 | with a L</filehandle> which will carry the subsequent identity of that
|
---|
1104 | file in your program, until you close it.
|
---|
1105 |
|
---|
1106 | =item filesystem
|
---|
1107 |
|
---|
1108 | A set of L<directories|/directory> and L<files|/file> residing on a
|
---|
1109 | partition of the disk. Sometimes known as a "partition". You can
|
---|
1110 | change the file's name or even move a file around from directory to
|
---|
1111 | directory within a filesystem without actually moving the file itself,
|
---|
1112 | at least under Unix.
|
---|
1113 |
|
---|
1114 | =item filter
|
---|
1115 |
|
---|
1116 | A program designed to take a L</stream> of input and transform it into
|
---|
1117 | a stream of output.
|
---|
1118 |
|
---|
1119 | =item flag
|
---|
1120 |
|
---|
1121 | We tend to avoid this term because it means so many things. It may
|
---|
1122 | mean a command-line L</switch> that takes no argument
|
---|
1123 | itself (such as Perl's B<-n> and B<-p>
|
---|
1124 | flags) or, less frequently, a single-bit indicator (such as the
|
---|
1125 | C<O_CREAT> and C<O_EXCL> flags used in
|
---|
1126 | L<sysopen|perlfunc/sysopen>).
|
---|
1127 |
|
---|
1128 | =item floating point
|
---|
1129 |
|
---|
1130 | A method of storing numbers in "scientific notation", such that the
|
---|
1131 | precision of the number is independent of its magnitude (the decimal
|
---|
1132 | point "floats"). Perl does its numeric work with floating-point
|
---|
1133 | numbers (sometimes called "floats"), when it can't get away with
|
---|
1134 | using L<integers|/integer>. Floating-point numbers are mere
|
---|
1135 | approximations of real numbers.
|
---|
1136 |
|
---|
1137 | =item flush
|
---|
1138 |
|
---|
1139 | The act of emptying a L</buffer>, often before it's full.
|
---|
1140 |
|
---|
1141 | =item FMTEYEWTK
|
---|
1142 |
|
---|
1143 | Far More Than Everything You Ever Wanted To Know. An exhaustive
|
---|
1144 | treatise on one narrow topic, something of a super-L</FAQ>. See Tom
|
---|
1145 | for far more.
|
---|
1146 |
|
---|
1147 | =item fork
|
---|
1148 |
|
---|
1149 | To create a child L</process> identical to the parent process at its
|
---|
1150 | moment of conception, at least until it gets ideas of its own. A
|
---|
1151 | thread with protected memory.
|
---|
1152 |
|
---|
1153 | =item formal arguments
|
---|
1154 |
|
---|
1155 | The generic names by which a L</subroutine> knows its
|
---|
1156 | L<arguments|/argument>. In many languages, formal arguments are
|
---|
1157 | always given individual names, but in Perl, the formal arguments are
|
---|
1158 | just the elements of an array. The formal arguments to a Perl program
|
---|
1159 | are C<$ARGV[0]>, C<$ARGV[1]>, and so on. Similarly, the formal
|
---|
1160 | arguments to a Perl subroutine are C<$_[0]>, C<$_[1]>, and so on. You
|
---|
1161 | may give the arguments individual names by assigning the values to a
|
---|
1162 | L<my|perlfunc/my> list. See also L</actual arguments>.
|
---|
1163 |
|
---|
1164 | =item format
|
---|
1165 |
|
---|
1166 | A specification of how many spaces and digits and things to put
|
---|
1167 | somewhere so that whatever you're printing comes out nice and pretty.
|
---|
1168 |
|
---|
1169 | =item freely available
|
---|
1170 |
|
---|
1171 | Means you don't have to pay money to get it, but the copyright on it
|
---|
1172 | may still belong to someone else (like Larry).
|
---|
1173 |
|
---|
1174 | =item freely redistributable
|
---|
1175 |
|
---|
1176 | Means you're not in legal trouble if you give a bootleg copy of it to
|
---|
1177 | your friends and we find out about it. In fact, we'd rather you gave
|
---|
1178 | a copy to all your friends.
|
---|
1179 |
|
---|
1180 | =item freeware
|
---|
1181 |
|
---|
1182 | Historically, any software that you give away, particularly if you
|
---|
1183 | make the source code available as well. Now often called C<open
|
---|
1184 | source software>. Recently there has been a trend to use the term in
|
---|
1185 | contradistinction to L</open source software>, to refer only to free
|
---|
1186 | software released under the Free Software Foundation's GPL (General
|
---|
1187 | Public License), but this is difficult to justify etymologically.
|
---|
1188 |
|
---|
1189 | =item function
|
---|
1190 |
|
---|
1191 | Mathematically, a mapping of each of a set of input values to a
|
---|
1192 | particular output value. In computers, refers to a L</subroutine> or
|
---|
1193 | L</operator> that returns a L</value>. It may or may not have input
|
---|
1194 | values (called L<arguments|/argument>).
|
---|
1195 |
|
---|
1196 | =item funny character
|
---|
1197 |
|
---|
1198 | Someone like Larry, or one of his peculiar friends. Also refers to
|
---|
1199 | the strange prefixes that Perl requires as noun markers on its
|
---|
1200 | variables.
|
---|
1201 |
|
---|
1202 | =item garbage collection
|
---|
1203 |
|
---|
1204 | A misnamed feature--it should be called, "expecting your mother to
|
---|
1205 | pick up after you". Strictly speaking, Perl doesn't do this, but it
|
---|
1206 | relies on a reference-counting mechanism to keep things tidy.
|
---|
1207 | However, we rarely speak strictly and will often refer to the
|
---|
1208 | reference-counting scheme as a form of garbage collection. (If it's
|
---|
1209 | any comfort, when your interpreter exits, a "real" garbage collector
|
---|
1210 | runs to make sure everything is cleaned up if you've been messy with
|
---|
1211 | circular references and such.)
|
---|
1212 |
|
---|
1213 | =back
|
---|
1214 |
|
---|
1215 | =head2 G
|
---|
1216 |
|
---|
1217 | =over 4
|
---|
1218 |
|
---|
1219 | =item GID
|
---|
1220 |
|
---|
1221 | Group ID--in Unix, the numeric group ID that the L</operating system>
|
---|
1222 | uses to identify you and members of your L</group>.
|
---|
1223 |
|
---|
1224 | =item glob
|
---|
1225 |
|
---|
1226 | Strictly, the shell's C<*> character, which will match a "glob" of
|
---|
1227 | characters when you're trying to generate a list of filenames.
|
---|
1228 | Loosely, the act of using globs and similar symbols to do pattern
|
---|
1229 | matching. See also L</fileglob> and L</typeglob>.
|
---|
1230 |
|
---|
1231 | =item global
|
---|
1232 |
|
---|
1233 | Something you can see from anywhere, usually used of
|
---|
1234 | L<variables|/variable> and L<subroutines|/subroutine> that are visible
|
---|
1235 | everywhere in your program. In Perl, only certain special variables
|
---|
1236 | are truly global--most variables (and all subroutines) exist only in
|
---|
1237 | the current L</package>. Global variables can be declared with
|
---|
1238 | L<our|perlfunc/our>. See L<perlfunc/our>.
|
---|
1239 |
|
---|
1240 | =item global destruction
|
---|
1241 |
|
---|
1242 | The L</garbage collection> of globals (and the running of any
|
---|
1243 | associated object destructors) that takes place when a Perl
|
---|
1244 | L</interpreter> is being shut down. Global destruction should not be
|
---|
1245 | confused with the Apocalypse, except perhaps when it should.
|
---|
1246 |
|
---|
1247 | =item glue language
|
---|
1248 |
|
---|
1249 | A language such as Perl that is good at hooking things together that
|
---|
1250 | weren't intended to be hooked together.
|
---|
1251 |
|
---|
1252 | =item granularity
|
---|
1253 |
|
---|
1254 | The size of the pieces you're dealing with, mentally speaking.
|
---|
1255 |
|
---|
1256 | =item greedy
|
---|
1257 |
|
---|
1258 | A L</subpattern> whose L</quantifier> wants to match as many things as
|
---|
1259 | possible.
|
---|
1260 |
|
---|
1261 | =item grep
|
---|
1262 |
|
---|
1263 | Originally from the old Unix editor command for "Globally search for a
|
---|
1264 | Regular Expression and Print it", now used in the general sense of any
|
---|
1265 | kind of search, especially text searches. Perl has a built-in
|
---|
1266 | L<grep|perlfunc/grep> function that searches a list for elements
|
---|
1267 | matching any given criterion, whereas the I<grep>(1) program searches
|
---|
1268 | for lines matching a L</regular expression> in one or more files.
|
---|
1269 |
|
---|
1270 | =item group
|
---|
1271 |
|
---|
1272 | A set of users of which you are a member. In some operating systems
|
---|
1273 | (like Unix), you can give certain file access permissions to other
|
---|
1274 | members of your group.
|
---|
1275 |
|
---|
1276 | =item GV
|
---|
1277 |
|
---|
1278 | An internal "glob value" typedef, holding a L</typeglob>. The L</GV>
|
---|
1279 | type is a subclass of L</SV>.
|
---|
1280 |
|
---|
1281 | =back
|
---|
1282 |
|
---|
1283 | =head2 H
|
---|
1284 |
|
---|
1285 | =over 4
|
---|
1286 |
|
---|
1287 | =item hacker
|
---|
1288 |
|
---|
1289 | Someone who is brilliantly persistent in solving technical problems,
|
---|
1290 | whether these involve golfing, fighting orcs, or programming. Hacker
|
---|
1291 | is a neutral term, morally speaking. Good hackers are not to be
|
---|
1292 | confused with evil L<crackers|/cracker> or clueless L<script
|
---|
1293 | kiddies|/script kiddie>. If you confuse them, we will presume that
|
---|
1294 | you are either evil or clueless.
|
---|
1295 |
|
---|
1296 | =item handler
|
---|
1297 |
|
---|
1298 | A L</subroutine> or L</method> that is called by Perl when your
|
---|
1299 | program needs to respond to some internal event, such as a L</signal>,
|
---|
1300 | or an encounter with an operator subject to L</operator overloading>.
|
---|
1301 | See also L</callback>.
|
---|
1302 |
|
---|
1303 | =item hard reference
|
---|
1304 |
|
---|
1305 | A L</scalar> L</value> containing the actual address of a
|
---|
1306 | L</referent>, such that the referent's L</reference> count accounts
|
---|
1307 | for it. (Some hard references are held internally, such as the
|
---|
1308 | implicit reference from one of a L</typeglob>'s variable slots to its
|
---|
1309 | corresponding referent.) A hard reference is different from a
|
---|
1310 | L</symbolic reference>.
|
---|
1311 |
|
---|
1312 | =item hash
|
---|
1313 |
|
---|
1314 | An unordered association of L</key>/L</value> pairs, stored such that
|
---|
1315 | you can easily use a string L</key> to look up its associated data
|
---|
1316 | L</value>. This glossary is like a hash, where the word to be defined
|
---|
1317 | is the key, and the definition is the value. A hash is also sometimes
|
---|
1318 | septisyllabically called an "associative array", which is a pretty
|
---|
1319 | good reason for simply calling it a "hash" instead.
|
---|
1320 |
|
---|
1321 | =item hash table
|
---|
1322 |
|
---|
1323 | A data structure used internally by Perl for implementing associative
|
---|
1324 | arrays (hashes) efficiently. See also L</bucket>.
|
---|
1325 |
|
---|
1326 | =item header file
|
---|
1327 |
|
---|
1328 | A file containing certain required definitions that you must include
|
---|
1329 | "ahead" of the rest of your program to do certain obscure operations.
|
---|
1330 | A C header file has a I<.h> extension. Perl doesn't really have
|
---|
1331 | header files, though historically Perl has sometimes used translated
|
---|
1332 | I<.h> files with a I<.ph> extension. See L<perlfunc/require>.
|
---|
1333 | (Header files have been superseded by the L</module> mechanism.)
|
---|
1334 |
|
---|
1335 | =item here document
|
---|
1336 |
|
---|
1337 | So called because of a similar construct in L<shells|/shell> that
|
---|
1338 | pretends that the L<lines|/line> following the L</command> are a
|
---|
1339 | separate L</file> to be fed to the command, up to some terminating
|
---|
1340 | string. In Perl, however, it's just a fancy form of quoting.
|
---|
1341 |
|
---|
1342 | =item hexadecimal
|
---|
1343 |
|
---|
1344 | A number in base 16, "hex" for short. The digits for 10 through 16
|
---|
1345 | are customarily represented by the letters C<a> through C<f>.
|
---|
1346 | Hexadecimal constants in Perl start with C<0x>. See also
|
---|
1347 | L<perlfunc/hex>.
|
---|
1348 |
|
---|
1349 | =item home directory
|
---|
1350 |
|
---|
1351 | The directory you are put into when you log in. On a Unix system, the
|
---|
1352 | name is often placed into C<$ENV{HOME}> or C<$ENV{LOGDIR}> by
|
---|
1353 | I<login>, but you can also find it with C<(getpwuid($E<lt>))[7]>.
|
---|
1354 | (Some platforms do not have a concept of a home directory.)
|
---|
1355 |
|
---|
1356 | =item host
|
---|
1357 |
|
---|
1358 | The computer on which a program or other data resides.
|
---|
1359 |
|
---|
1360 | =item hubris
|
---|
1361 |
|
---|
1362 | Excessive pride, the sort of thing Zeus zaps you for. Also the
|
---|
1363 | quality that makes you write (and maintain) programs that other people
|
---|
1364 | won't want to say bad things about. Hence, the third great virtue of
|
---|
1365 | a programmer. See also L</laziness> and L</impatience>.
|
---|
1366 |
|
---|
1367 | =item HV
|
---|
1368 |
|
---|
1369 | Short for a "hash value" typedef, which holds Perl's internal
|
---|
1370 | representation of a hash. The L</HV> type is a subclass of L</SV>.
|
---|
1371 |
|
---|
1372 | =back
|
---|
1373 |
|
---|
1374 | =head2 I
|
---|
1375 |
|
---|
1376 | =over 4
|
---|
1377 |
|
---|
1378 | =item identifier
|
---|
1379 |
|
---|
1380 | A legally formed name for most anything in which a computer program
|
---|
1381 | might be interested. Many languages (including Perl) allow
|
---|
1382 | identifiers that start with a letter and contain letters and digits.
|
---|
1383 | Perl also counts the underscore character as a valid letter. (Perl
|
---|
1384 | also has more complicated names, such as L</qualified> names.)
|
---|
1385 |
|
---|
1386 | =item impatience
|
---|
1387 |
|
---|
1388 | The anger you feel when the computer is being lazy. This makes you
|
---|
1389 | write programs that don't just react to your needs, but actually
|
---|
1390 | anticipate them. Or at least that pretend to. Hence, the second
|
---|
1391 | great virtue of a programmer. See also L</laziness> and L</hubris>.
|
---|
1392 |
|
---|
1393 | =item implementation
|
---|
1394 |
|
---|
1395 | How a piece of code actually goes about doing its job. Users of the
|
---|
1396 | code should not count on implementation details staying the same
|
---|
1397 | unless they are part of the published L</interface>.
|
---|
1398 |
|
---|
1399 | =item import
|
---|
1400 |
|
---|
1401 | To gain access to symbols that are exported from another module. See
|
---|
1402 | L<perlfunc/use>.
|
---|
1403 |
|
---|
1404 | =item increment
|
---|
1405 |
|
---|
1406 | To increase the value of something by 1 (or by some other number, if
|
---|
1407 | so specified).
|
---|
1408 |
|
---|
1409 | =item indexing
|
---|
1410 |
|
---|
1411 | In olden days, the act of looking up a L</key> in an actual index
|
---|
1412 | (such as a phone book), but now merely the act of using any kind of
|
---|
1413 | key or position to find the corresponding L</value>, even if no index
|
---|
1414 | is involved. Things have degenerated to the point that Perl's
|
---|
1415 | L<index|perlfunc/index> function merely locates the position (index)
|
---|
1416 | of one string in another.
|
---|
1417 |
|
---|
1418 | =item indirect filehandle
|
---|
1419 |
|
---|
1420 | An L</expression> that evaluates to something that can be used as a
|
---|
1421 | L</filehandle>: a L</string> (filehandle name), a L</typeglob>, a
|
---|
1422 | typeglob L</reference>, or a low-level L</IO> object.
|
---|
1423 |
|
---|
1424 | =item indirect object
|
---|
1425 |
|
---|
1426 | In English grammar, a short noun phrase between a verb and its direct
|
---|
1427 | object indicating the beneficiary or recipient of the action. In
|
---|
1428 | Perl, C<print STDOUT "$foo\n";> can be understood as "verb
|
---|
1429 | indirect-object object" where L</STDOUT> is the recipient of the
|
---|
1430 | L<print|perlfunc/print> action, and C<"$foo"> is the object being
|
---|
1431 | printed. Similarly, when invoking a L</method>, you might place the
|
---|
1432 | invocant between the method and its arguments:
|
---|
1433 |
|
---|
1434 | $gollum = new Pathetic::Creature "Smeagol";
|
---|
1435 | give $gollum "Fisssssh!";
|
---|
1436 | give $gollum "Precious!";
|
---|
1437 |
|
---|
1438 | =item indirect object slot
|
---|
1439 |
|
---|
1440 | The syntactic position falling between a method call and its arguments
|
---|
1441 | when using the indirect object invocation syntax. (The slot is
|
---|
1442 | distinguished by the absence of a comma between it and the next
|
---|
1443 | argument.) L</STDERR> is in the indirect object slot here:
|
---|
1444 |
|
---|
1445 | print STDERR "Awake! Awake! Fear, Fire,
|
---|
1446 | Foes! Awake!\n";
|
---|
1447 |
|
---|
1448 | =item indirection
|
---|
1449 |
|
---|
1450 | If something in a program isn't the value you're looking for but
|
---|
1451 | indicates where the value is, that's indirection. This can be done
|
---|
1452 | with either L<symbolic references|/symbolic reference> or L<hard
|
---|
1453 | references|/hard reference>.
|
---|
1454 |
|
---|
1455 | =item infix
|
---|
1456 |
|
---|
1457 | An L</operator> that comes in between its L<operands|/operand>, such
|
---|
1458 | as multiplication in C<24 * 7>.
|
---|
1459 |
|
---|
1460 | =item inheritance
|
---|
1461 |
|
---|
1462 | What you get from your ancestors, genetically or otherwise. If you
|
---|
1463 | happen to be a L</class>, your ancestors are called L<base
|
---|
1464 | classes|/base class> and your descendants are called L<derived
|
---|
1465 | classes|/derived class>. See L</single inheritance> and L</multiple
|
---|
1466 | inheritance>.
|
---|
1467 |
|
---|
1468 | =item instance
|
---|
1469 |
|
---|
1470 | Short for "an instance of a class", meaning an L</object> of that L</class>.
|
---|
1471 |
|
---|
1472 | =item instance variable
|
---|
1473 |
|
---|
1474 | An L</attribute> of an L</object>; data stored with the particular
|
---|
1475 | object rather than with the class as a whole.
|
---|
1476 |
|
---|
1477 | =item integer
|
---|
1478 |
|
---|
1479 | A number with no fractional (decimal) part. A counting number, like
|
---|
1480 | 1, 2, 3, and so on, but including 0 and the negatives.
|
---|
1481 |
|
---|
1482 | =item interface
|
---|
1483 |
|
---|
1484 | The services a piece of code promises to provide forever, in contrast to
|
---|
1485 | its L</implementation>, which it should feel free to change whenever it
|
---|
1486 | likes.
|
---|
1487 |
|
---|
1488 | =item interpolation
|
---|
1489 |
|
---|
1490 | The insertion of a scalar or list value somewhere in the middle of
|
---|
1491 | another value, such that it appears to have been there all along. In
|
---|
1492 | Perl, variable interpolation happens in double-quoted strings and
|
---|
1493 | patterns, and list interpolation occurs when constructing the list of
|
---|
1494 | values to pass to a list operator or other such construct that takes a
|
---|
1495 | L</LIST>.
|
---|
1496 |
|
---|
1497 | =item interpreter
|
---|
1498 |
|
---|
1499 | Strictly speaking, a program that reads a second program and does what
|
---|
1500 | the second program says directly without turning the program into a
|
---|
1501 | different form first, which is what L<compilers|/compiler> do. Perl
|
---|
1502 | is not an interpreter by this definition, because it contains a kind
|
---|
1503 | of compiler that takes a program and turns it into a more executable
|
---|
1504 | form (L<syntax trees|/syntax tree>) within the I<perl> process itself,
|
---|
1505 | which the Perl L</run time> system then interprets.
|
---|
1506 |
|
---|
1507 | =item invocant
|
---|
1508 |
|
---|
1509 | The agent on whose behalf a L</method> is invoked. In a L</class>
|
---|
1510 | method, the invocant is a package name. In an L</instance> method,
|
---|
1511 | the invocant is an object reference.
|
---|
1512 |
|
---|
1513 | =item invocation
|
---|
1514 |
|
---|
1515 | The act of calling up a deity, daemon, program, method, subroutine, or
|
---|
1516 | function to get it do what you think it's supposed to do. We usually
|
---|
1517 | "call" subroutines but "invoke" methods, since it sounds cooler.
|
---|
1518 |
|
---|
1519 | =item I/O
|
---|
1520 |
|
---|
1521 | Input from, or output to, a L</file> or L</device>.
|
---|
1522 |
|
---|
1523 | =item IO
|
---|
1524 |
|
---|
1525 | An internal I/O object. Can also mean L</indirect object>.
|
---|
1526 |
|
---|
1527 | =item IP
|
---|
1528 |
|
---|
1529 | Internet Protocol, or Intellectual Property.
|
---|
1530 |
|
---|
1531 | =item IPC
|
---|
1532 |
|
---|
1533 | Interprocess Communication.
|
---|
1534 |
|
---|
1535 | =item is-a
|
---|
1536 |
|
---|
1537 | A relationship between two L<objects|/object> in which one object is
|
---|
1538 | considered to be a more specific version of the other, generic object:
|
---|
1539 | "A camel is a mammal." Since the generic object really only exists in
|
---|
1540 | a Platonic sense, we usually add a little abstraction to the notion of
|
---|
1541 | objects and think of the relationship as being between a generic
|
---|
1542 | L</base class> and a specific L</derived class>. Oddly enough,
|
---|
1543 | Platonic classes don't always have Platonic relationships--see
|
---|
1544 | L</inheritance>.
|
---|
1545 |
|
---|
1546 | =item iteration
|
---|
1547 |
|
---|
1548 | Doing something repeatedly.
|
---|
1549 |
|
---|
1550 | =item iterator
|
---|
1551 |
|
---|
1552 | A special programming gizmo that keeps track of where you are in
|
---|
1553 | something that you're trying to iterate over. The C<foreach> loop in
|
---|
1554 | Perl contains an iterator; so does a hash, allowing you to
|
---|
1555 | L<each|perlfunc/each> through it.
|
---|
1556 |
|
---|
1557 | =item IV
|
---|
1558 |
|
---|
1559 | The integer four, not to be confused with six, Tom's favorite editor.
|
---|
1560 | IV also means an internal Integer Value of the type a L</scalar> can
|
---|
1561 | hold, not to be confused with an L</NV>.
|
---|
1562 |
|
---|
1563 | =back
|
---|
1564 |
|
---|
1565 | =head2 J
|
---|
1566 |
|
---|
1567 | =over 4
|
---|
1568 |
|
---|
1569 | =item JAPH
|
---|
1570 |
|
---|
1571 | "Just Another Perl Hacker," a clever but cryptic bit of Perl code that
|
---|
1572 | when executed, evaluates to that string. Often used to illustrate a
|
---|
1573 | particular Perl feature, and something of an ungoing Obfuscated Perl
|
---|
1574 | Contest seen in Usenix signatures.
|
---|
1575 |
|
---|
1576 | =back
|
---|
1577 |
|
---|
1578 | =head2 K
|
---|
1579 |
|
---|
1580 | =over 4
|
---|
1581 |
|
---|
1582 | =item key
|
---|
1583 |
|
---|
1584 | The string index to a L</hash>, used to look up the L</value>
|
---|
1585 | associated with that key.
|
---|
1586 |
|
---|
1587 | =item keyword
|
---|
1588 |
|
---|
1589 | See L</reserved words>.
|
---|
1590 |
|
---|
1591 | =back
|
---|
1592 |
|
---|
1593 | =head2 L
|
---|
1594 |
|
---|
1595 | =over 4
|
---|
1596 |
|
---|
1597 | =item label
|
---|
1598 |
|
---|
1599 | A name you give to a L</statement> so that you can talk about that
|
---|
1600 | statement elsewhere in the program.
|
---|
1601 |
|
---|
1602 | =item laziness
|
---|
1603 |
|
---|
1604 | The quality that makes you go to great effort to reduce overall energy
|
---|
1605 | expenditure. It makes you write labor-saving programs that other
|
---|
1606 | people will find useful, and document what you wrote so you don't have
|
---|
1607 | to answer so many questions about it. Hence, the first great virtue
|
---|
1608 | of a programmer. Also hence, this book. See also L</impatience> and
|
---|
1609 | L</hubris>.
|
---|
1610 |
|
---|
1611 | =item left shift
|
---|
1612 |
|
---|
1613 | A L</bit shift> that multiplies the number by some power of 2.
|
---|
1614 |
|
---|
1615 | =item leftmost longest
|
---|
1616 |
|
---|
1617 | The preference of the L</regular expression> engine to match the
|
---|
1618 | leftmost occurrence of a L</pattern>, then given a position at which a
|
---|
1619 | match will occur, the preference for the longest match (presuming the
|
---|
1620 | use of a L</greedy> quantifier). See L<perlre> for I<much> more on
|
---|
1621 | this subject.
|
---|
1622 |
|
---|
1623 | =item lexeme
|
---|
1624 |
|
---|
1625 | Fancy term for a L</token>.
|
---|
1626 |
|
---|
1627 | =item lexer
|
---|
1628 |
|
---|
1629 | Fancy term for a L</tokener>.
|
---|
1630 |
|
---|
1631 | =item lexical analysis
|
---|
1632 |
|
---|
1633 | Fancy term for L</tokenizing>.
|
---|
1634 |
|
---|
1635 | =item lexical scoping
|
---|
1636 |
|
---|
1637 | Looking at your I<Oxford English Dictionary> through a microscope.
|
---|
1638 | (Also known as L</static scoping>, because dictionaries don't change
|
---|
1639 | very fast.) Similarly, looking at variables stored in a private
|
---|
1640 | dictionary (namespace) for each scope, which are visible only from
|
---|
1641 | their point of declaration down to the end of the lexical scope in
|
---|
1642 | which they are declared. --Syn. L</static scoping>.
|
---|
1643 | --Ant. L</dynamic scoping>.
|
---|
1644 |
|
---|
1645 | =item lexical variable
|
---|
1646 |
|
---|
1647 | A L</variable> subject to L</lexical scoping>, declared by
|
---|
1648 | L<my|perlfunc/my>. Often just called a "lexical". (The
|
---|
1649 | L<our|perlfunc/our> declaration declares a lexically scoped name for a
|
---|
1650 | global variable, which is not itself a lexical variable.)
|
---|
1651 |
|
---|
1652 | =item library
|
---|
1653 |
|
---|
1654 | Generally, a collection of procedures. In ancient days, referred to a
|
---|
1655 | collection of subroutines in a I<.pl> file. In modern times, refers
|
---|
1656 | more often to the entire collection of Perl L<modules|/module> on your
|
---|
1657 | system.
|
---|
1658 |
|
---|
1659 | =item LIFO
|
---|
1660 |
|
---|
1661 | Last In, First Out. See also L</FIFO>. A LIFO is usually called a
|
---|
1662 | L</stack>.
|
---|
1663 |
|
---|
1664 | =item line
|
---|
1665 |
|
---|
1666 | In Unix, a sequence of zero or more non-newline characters terminated
|
---|
1667 | with a L</newline> character. On non-Unix machines, this is emulated
|
---|
1668 | by the C library even if the underlying L</operating system> has
|
---|
1669 | different ideas.
|
---|
1670 |
|
---|
1671 | =item line buffering
|
---|
1672 |
|
---|
1673 | Used by a L</standard IE<sol>O> output stream that flushes its
|
---|
1674 | L</buffer> after every L</newline>. Many standard I/O libraries
|
---|
1675 | automatically set up line buffering on output that is going to the
|
---|
1676 | terminal.
|
---|
1677 |
|
---|
1678 | =item line number
|
---|
1679 |
|
---|
1680 | The number of lines read previous to this one, plus 1. Perl keeps a
|
---|
1681 | separate line number for each source or input file it opens. The
|
---|
1682 | current source file's line number is represented by C<__LINE__>. The
|
---|
1683 | current input line number (for the file that was most recently read
|
---|
1684 | via C<< E<lt>FHE<gt> >>) is represented by the C<$.>
|
---|
1685 | (C<$INPUT_LINE_NUMBER>) variable. Many error messages report both
|
---|
1686 | values, if available.
|
---|
1687 |
|
---|
1688 | =item link
|
---|
1689 |
|
---|
1690 | Used as a noun, a name in a L</directory>, representing a L</file>. A
|
---|
1691 | given file can have multiple links to it. It's like having the same
|
---|
1692 | phone number listed in the phone directory under different names. As
|
---|
1693 | a verb, to resolve a partially compiled file's unresolved symbols into
|
---|
1694 | a (nearly) executable image. Linking can generally be static or
|
---|
1695 | dynamic, which has nothing to do with static or dynamic scoping.
|
---|
1696 |
|
---|
1697 | =item LIST
|
---|
1698 |
|
---|
1699 | A syntactic construct representing a comma-separated list of
|
---|
1700 | expressions, evaluated to produce a L</list value>. Each
|
---|
1701 | L</expression> in a L</LIST> is evaluated in L</list context> and
|
---|
1702 | interpolated into the list value.
|
---|
1703 |
|
---|
1704 | =item list
|
---|
1705 |
|
---|
1706 | An ordered set of scalar values.
|
---|
1707 |
|
---|
1708 | =item list context
|
---|
1709 |
|
---|
1710 | The situation in which an L</expression> is expected by its
|
---|
1711 | surroundings (the code calling it) to return a list of values rather
|
---|
1712 | than a single value. Functions that want a L</LIST> of arguments tell
|
---|
1713 | those arguments that they should produce a list value. See also
|
---|
1714 | L</context>.
|
---|
1715 |
|
---|
1716 | =item list operator
|
---|
1717 |
|
---|
1718 | An L</operator> that does something with a list of values, such as
|
---|
1719 | L<join|perlfunc/join> or L<grep|perlfunc/grep>. Usually used for
|
---|
1720 | named built-in operators (such as L<print|perlfunc/print>,
|
---|
1721 | L<unlink|perlfunc/unlink>, and L<system|perlfunc/system>) that do not
|
---|
1722 | require parentheses around their L</argument> list.
|
---|
1723 |
|
---|
1724 | =item list value
|
---|
1725 |
|
---|
1726 | An unnamed list of temporary scalar values that may be passed around
|
---|
1727 | within a program from any list-generating function to any function or
|
---|
1728 | construct that provides a L</list context>.
|
---|
1729 |
|
---|
1730 | =item literal
|
---|
1731 |
|
---|
1732 | A token in a programming language such as a number or L</string> that
|
---|
1733 | gives you an actual L</value> instead of merely representing possible
|
---|
1734 | values as a L</variable> does.
|
---|
1735 |
|
---|
1736 | =item little-endian
|
---|
1737 |
|
---|
1738 | From Swift: someone who eats eggs little end first. Also used of
|
---|
1739 | computers that store the least significant L</byte> of a word at a
|
---|
1740 | lower byte address than the most significant byte. Often considered
|
---|
1741 | superior to big-endian machines. See also L</big-endian>.
|
---|
1742 |
|
---|
1743 | =item local
|
---|
1744 |
|
---|
1745 | Not meaning the same thing everywhere. A global variable in Perl can
|
---|
1746 | be localized inside a L<dynamic scope|/dynamic scoping> via the
|
---|
1747 | L<local|perlfunc/local> operator.
|
---|
1748 |
|
---|
1749 | =item logical operator
|
---|
1750 |
|
---|
1751 | Symbols representing the concepts "and", "or", "xor", and "not".
|
---|
1752 |
|
---|
1753 | =item lookahead
|
---|
1754 |
|
---|
1755 | An L</assertion> that peeks at the string to the right of the current
|
---|
1756 | match location.
|
---|
1757 |
|
---|
1758 | =item lookbehind
|
---|
1759 |
|
---|
1760 | An L</assertion> that peeks at the string to the left of the current
|
---|
1761 | match location.
|
---|
1762 |
|
---|
1763 | =item loop
|
---|
1764 |
|
---|
1765 | A construct that performs something repeatedly, like a roller coaster.
|
---|
1766 |
|
---|
1767 | =item loop control statement
|
---|
1768 |
|
---|
1769 | Any statement within the body of a loop that can make a loop
|
---|
1770 | prematurely stop looping or skip an L</iteration>. Generally you
|
---|
1771 | shouldn't try this on roller coasters.
|
---|
1772 |
|
---|
1773 | =item loop label
|
---|
1774 |
|
---|
1775 | A kind of key or name attached to a loop (or roller coaster) so that
|
---|
1776 | loop control statements can talk about which loop they want to
|
---|
1777 | control.
|
---|
1778 |
|
---|
1779 | =item lvaluable
|
---|
1780 |
|
---|
1781 | Able to serve as an L</lvalue>.
|
---|
1782 |
|
---|
1783 | =item lvalue
|
---|
1784 |
|
---|
1785 | Term used by language lawyers for a storage location you can assign a
|
---|
1786 | new L</value> to, such as a L</variable> or an element of an
|
---|
1787 | L</array>. The "l" is short for "left", as in the left side of an
|
---|
1788 | assignment, a typical place for lvalues. An L</lvaluable> function or
|
---|
1789 | expression is one to which a value may be assigned, as in C<pos($x) =
|
---|
1790 | 10>.
|
---|
1791 |
|
---|
1792 | =item lvalue modifier
|
---|
1793 |
|
---|
1794 | An adjectival pseudofunction that warps the meaning of an L</lvalue>
|
---|
1795 | in some declarative fashion. Currently there are three lvalue
|
---|
1796 | modifiers: L<my|perlfunc/my>, L<our|perlfunc/our>, and
|
---|
1797 | L<local|perlfunc/local>.
|
---|
1798 |
|
---|
1799 | =back
|
---|
1800 |
|
---|
1801 | =head2 M
|
---|
1802 |
|
---|
1803 | =over 4
|
---|
1804 |
|
---|
1805 | =item magic
|
---|
1806 |
|
---|
1807 | Technically speaking, any extra semantics attached to a variable such
|
---|
1808 | as C<$!>, C<$0>, C<%ENV>, or C<%SIG>, or to any tied variable.
|
---|
1809 | Magical things happen when you diddle those variables.
|
---|
1810 |
|
---|
1811 | =item magical increment
|
---|
1812 |
|
---|
1813 | An L</increment> operator that knows how to bump up alphabetics as
|
---|
1814 | well as numbers.
|
---|
1815 |
|
---|
1816 | =item magical variables
|
---|
1817 |
|
---|
1818 | Special variables that have side effects when you access them or
|
---|
1819 | assign to them. For example, in Perl, changing elements of the
|
---|
1820 | C<%ENV> array also changes the corresponding environment variables
|
---|
1821 | that subprocesses will use. Reading the C<$!> variable gives you the
|
---|
1822 | current system error number or message.
|
---|
1823 |
|
---|
1824 | =item Makefile
|
---|
1825 |
|
---|
1826 | A file that controls the compilation of a program. Perl programs
|
---|
1827 | don't usually need a L</Makefile> because the Perl compiler has plenty
|
---|
1828 | of self-control.
|
---|
1829 |
|
---|
1830 | =item man
|
---|
1831 |
|
---|
1832 | The Unix program that displays online documentation (manual pages) for
|
---|
1833 | you.
|
---|
1834 |
|
---|
1835 | =item manpage
|
---|
1836 |
|
---|
1837 | A "page" from the manuals, typically accessed via the I<man>(1)
|
---|
1838 | command. A manpage contains a SYNOPSIS, a DESCRIPTION, a list of
|
---|
1839 | BUGS, and so on, and is typically longer than a page. There are
|
---|
1840 | manpages documenting L<commands|/command>, L<syscalls|/syscall>,
|
---|
1841 | L</library> L<functions|/function>, L<devices|/device>,
|
---|
1842 | L<protocols|/protocol>, L<files|/file>, and such. In this book, we
|
---|
1843 | call any piece of standard Perl documentation (like I<perlop> or
|
---|
1844 | I<perldelta>) a manpage, no matter what format it's installed in on
|
---|
1845 | your system.
|
---|
1846 |
|
---|
1847 | =item matching
|
---|
1848 |
|
---|
1849 | See L</pattern matching>.
|
---|
1850 |
|
---|
1851 | =item member data
|
---|
1852 |
|
---|
1853 | See L</instance variable>.
|
---|
1854 |
|
---|
1855 | =item memory
|
---|
1856 |
|
---|
1857 | This always means your main memory, not your disk. Clouding the issue
|
---|
1858 | is the fact that your machine may implement L</virtual> memory; that
|
---|
1859 | is, it will pretend that it has more memory than it really does, and
|
---|
1860 | it'll use disk space to hold inactive bits. This can make it seem
|
---|
1861 | like you have a little more memory than you really do, but it's not a
|
---|
1862 | substitute for real memory. The best thing that can be said about
|
---|
1863 | virtual memory is that it lets your performance degrade gradually
|
---|
1864 | rather than suddenly when you run out of real memory. But your
|
---|
1865 | program can die when you run out of virtual memory too, if you haven't
|
---|
1866 | thrashed your disk to death first.
|
---|
1867 |
|
---|
1868 | =item metacharacter
|
---|
1869 |
|
---|
1870 | A L</character> that is I<not> supposed to be treated normally. Which
|
---|
1871 | characters are to be treated specially as metacharacters varies
|
---|
1872 | greatly from context to context. Your L</shell> will have certain
|
---|
1873 | metacharacters, double-quoted Perl L<strings|/string> have other
|
---|
1874 | metacharacters, and L</regular expression> patterns have all the
|
---|
1875 | double-quote metacharacters plus some extra ones of their own.
|
---|
1876 |
|
---|
1877 | =item metasymbol
|
---|
1878 |
|
---|
1879 | Something we'd call a L</metacharacter> except that it's a sequence of
|
---|
1880 | more than one character. Generally, the first character in the
|
---|
1881 | sequence must be a true metacharacter to get the other characters in
|
---|
1882 | the metasymbol to misbehave along with it.
|
---|
1883 |
|
---|
1884 | =item method
|
---|
1885 |
|
---|
1886 | A kind of action that an L</object> can take if you tell it to. See
|
---|
1887 | L<perlobj>.
|
---|
1888 |
|
---|
1889 | =item minimalism
|
---|
1890 |
|
---|
1891 | The belief that "small is beautiful." Paradoxically, if you say
|
---|
1892 | something in a small language, it turns out big, and if you say it in
|
---|
1893 | a big language, it turns out small. Go figure.
|
---|
1894 |
|
---|
1895 | =item mode
|
---|
1896 |
|
---|
1897 | In the context of the L<stat> syscall, refers to the field holding
|
---|
1898 | the L</permission bits> and the type of the L</file>.
|
---|
1899 |
|
---|
1900 | =item modifier
|
---|
1901 |
|
---|
1902 | See L</statement modifier>, L</regular expression modifier>, and
|
---|
1903 | L</lvalue modifier>, not necessarily in that order.
|
---|
1904 |
|
---|
1905 | =item module
|
---|
1906 |
|
---|
1907 | A L</file> that defines a L</package> of (almost) the same name, which
|
---|
1908 | can either L</export> symbols or function as an L</object> class. (A
|
---|
1909 | module's main I<.pm> file may also load in other files in support of
|
---|
1910 | the module.) See the L<use|perlfunc/use> built-in.
|
---|
1911 |
|
---|
1912 | =item modulus
|
---|
1913 |
|
---|
1914 | An integer divisor when you're interested in the remainder instead of
|
---|
1915 | the quotient.
|
---|
1916 |
|
---|
1917 | =item monger
|
---|
1918 |
|
---|
1919 | Short for Perl Monger, a purveyor of Perl.
|
---|
1920 |
|
---|
1921 | =item mortal
|
---|
1922 |
|
---|
1923 | A temporary value scheduled to die when the current statement
|
---|
1924 | finishes.
|
---|
1925 |
|
---|
1926 | =item multidimensional array
|
---|
1927 |
|
---|
1928 | An array with multiple subscripts for finding a single element. Perl
|
---|
1929 | implements these using L<references|/reference>--see L<perllol> and
|
---|
1930 | L<perldsc>.
|
---|
1931 |
|
---|
1932 | =item multiple inheritance
|
---|
1933 |
|
---|
1934 | The features you got from your mother and father, mixed together
|
---|
1935 | unpredictably. (See also L</inheritance>, and L</single
|
---|
1936 | inheritance>.) In computer languages (including Perl), the notion
|
---|
1937 | that a given class may have multiple direct ancestors or L<base
|
---|
1938 | classes|/base class>.
|
---|
1939 |
|
---|
1940 | =back
|
---|
1941 |
|
---|
1942 | =head2 N
|
---|
1943 |
|
---|
1944 | =over 4
|
---|
1945 |
|
---|
1946 | =item named pipe
|
---|
1947 |
|
---|
1948 | A L</pipe> with a name embedded in the L</filesystem> so that it can
|
---|
1949 | be accessed by two unrelated L<processes|/process>.
|
---|
1950 |
|
---|
1951 | =item namespace
|
---|
1952 |
|
---|
1953 | A domain of names. You needn't worry about whether the names in one
|
---|
1954 | such domain have been used in another. See L</package>.
|
---|
1955 |
|
---|
1956 | =item network address
|
---|
1957 |
|
---|
1958 | The most important attribute of a socket, like your telephone's
|
---|
1959 | telephone number. Typically an IP address. See also L</port>.
|
---|
1960 |
|
---|
1961 | =item newline
|
---|
1962 |
|
---|
1963 | A single character that represents the end of a line, with the ASCII
|
---|
1964 | value of 012 octal under Unix (but 015 on a Mac), and represented by
|
---|
1965 | C<\n> in Perl strings. For Windows machines writing text files, and
|
---|
1966 | for certain physical devices like terminals, the single newline gets
|
---|
1967 | automatically translated by your C library into a line feed and a
|
---|
1968 | carriage return, but normally, no translation is done.
|
---|
1969 |
|
---|
1970 | =item NFS
|
---|
1971 |
|
---|
1972 | Network File System, which allows you to mount a remote filesystem as
|
---|
1973 | if it were local.
|
---|
1974 |
|
---|
1975 | =item null character
|
---|
1976 |
|
---|
1977 | A character with the ASCII value of zero. It's used by C to terminate
|
---|
1978 | strings, but Perl allows strings to contain a null.
|
---|
1979 |
|
---|
1980 | =item null list
|
---|
1981 |
|
---|
1982 | A L</list value> with zero elements, represented in Perl by C<()>.
|
---|
1983 |
|
---|
1984 | =item null string
|
---|
1985 |
|
---|
1986 | A L</string> containing no characters, not to be confused with a
|
---|
1987 | string containing a L</null character>, which has a positive length
|
---|
1988 | and is L</true>.
|
---|
1989 |
|
---|
1990 | =item numeric context
|
---|
1991 |
|
---|
1992 | The situation in which an expression is expected by its surroundings
|
---|
1993 | (the code calling it) to return a number. See also L</context> and
|
---|
1994 | L</string context>.
|
---|
1995 |
|
---|
1996 | =item NV
|
---|
1997 |
|
---|
1998 | Short for Nevada, no part of which will ever be confused with
|
---|
1999 | civilization. NV also means an internal floating-point Numeric Value
|
---|
2000 | of the type a L</scalar> can hold, not to be confused with an L</IV>.
|
---|
2001 |
|
---|
2002 | =item nybble
|
---|
2003 |
|
---|
2004 | Half a L</byte>, equivalent to one L</hexadecimal> digit, and worth
|
---|
2005 | four L<bits|/bit>.
|
---|
2006 |
|
---|
2007 | =back
|
---|
2008 |
|
---|
2009 | =head2 O
|
---|
2010 |
|
---|
2011 | =over 4
|
---|
2012 |
|
---|
2013 | =item object
|
---|
2014 |
|
---|
2015 | An L</instance> of a L</class>. Something that "knows" what
|
---|
2016 | user-defined type (class) it is, and what it can do because of what
|
---|
2017 | class it is. Your program can request an object to do things, but the
|
---|
2018 | object gets to decide whether it wants to do them or not. Some
|
---|
2019 | objects are more accommodating than others.
|
---|
2020 |
|
---|
2021 | =item octal
|
---|
2022 |
|
---|
2023 | A number in base 8. Only the digits 0 through 7 are allowed. Octal
|
---|
2024 | constants in Perl start with 0, as in 013. See also the
|
---|
2025 | L<oct|perlfunc/oct> function.
|
---|
2026 |
|
---|
2027 | =item offset
|
---|
2028 |
|
---|
2029 | How many things you have to skip over when moving from the beginning
|
---|
2030 | of a string or array to a specific position within it. Thus, the
|
---|
2031 | minimum offset is zero, not one, because you don't skip anything to
|
---|
2032 | get to the first item.
|
---|
2033 |
|
---|
2034 | =item one-liner
|
---|
2035 |
|
---|
2036 | An entire computer program crammed into one line of text.
|
---|
2037 |
|
---|
2038 | =item open source software
|
---|
2039 |
|
---|
2040 | Programs for which the source code is freely available and freely
|
---|
2041 | redistributable, with no commercial strings attached. For a more
|
---|
2042 | detailed definition, see L<http://www.opensource.org/osd.html>.
|
---|
2043 |
|
---|
2044 | =item operand
|
---|
2045 |
|
---|
2046 | An L</expression> that yields a L</value> that an L</operator>
|
---|
2047 | operates on. See also L</precedence>.
|
---|
2048 |
|
---|
2049 | =item operating system
|
---|
2050 |
|
---|
2051 | A special program that runs on the bare machine and hides the gory
|
---|
2052 | details of managing L<processes|/process> and L<devices|/device>.
|
---|
2053 | Usually used in a looser sense to indicate a particular culture of
|
---|
2054 | programming. The loose sense can be used at varying levels of
|
---|
2055 | specificity. At one extreme, you might say that all versions of Unix
|
---|
2056 | and Unix-lookalikes are the same operating system (upsetting many
|
---|
2057 | people, especially lawyers and other advocates). At the other
|
---|
2058 | extreme, you could say this particular version of this particular
|
---|
2059 | vendor's operating system is different from any other version of this
|
---|
2060 | or any other vendor's operating system. Perl is much more portable
|
---|
2061 | across operating systems than many other languages. See also
|
---|
2062 | L</architecture> and L</platform>.
|
---|
2063 |
|
---|
2064 | =item operator
|
---|
2065 |
|
---|
2066 | A gizmo that transforms some number of input values to some number of
|
---|
2067 | output values, often built into a language with a special syntax or
|
---|
2068 | symbol. A given operator may have specific expectations about what
|
---|
2069 | L<types|/type> of data you give as its arguments
|
---|
2070 | (L<operands|/operand>) and what type of data you want back from it.
|
---|
2071 |
|
---|
2072 | =item operator overloading
|
---|
2073 |
|
---|
2074 | A kind of L</overloading> that you can do on built-in
|
---|
2075 | L<operators|/operator> to make them work on L<objects|/object> as if
|
---|
2076 | the objects were ordinary scalar values, but with the actual semantics
|
---|
2077 | supplied by the object class. This is set up with the L<overload>
|
---|
2078 | L</pragma>.
|
---|
2079 |
|
---|
2080 | =item options
|
---|
2081 |
|
---|
2082 | See either L<switches|/switch> or L</regular expression modifier>.
|
---|
2083 |
|
---|
2084 | =item overloading
|
---|
2085 |
|
---|
2086 | Giving additional meanings to a symbol or construct. Actually, all
|
---|
2087 | languages do overloading to one extent or another, since people are
|
---|
2088 | good at figuring out things from L</context>.
|
---|
2089 |
|
---|
2090 | =item overriding
|
---|
2091 |
|
---|
2092 | Hiding or invalidating some other definition of the same name. (Not
|
---|
2093 | to be confused with L</overloading>, which adds definitions that must
|
---|
2094 | be disambiguated some other way.) To confuse the issue further, we use
|
---|
2095 | the word with two overloaded definitions: to describe how you can
|
---|
2096 | define your own L</subroutine> to hide a built-in L</function> of the
|
---|
2097 | same name (see L<perlsub/Overriding Built-in Functions>) and to
|
---|
2098 | describe how you can define a replacement L</method> in a L</derived
|
---|
2099 | class> to hide a L</base class>'s method of the same name (see
|
---|
2100 | L<perlobj>).
|
---|
2101 |
|
---|
2102 | =item owner
|
---|
2103 |
|
---|
2104 | The one user (apart from the superuser) who has absolute control over
|
---|
2105 | a L</file>. A file may also have a L</group> of users who may
|
---|
2106 | exercise joint ownership if the real owner permits it. See
|
---|
2107 | L</permission bits>.
|
---|
2108 |
|
---|
2109 | =back
|
---|
2110 |
|
---|
2111 | =head2 P
|
---|
2112 |
|
---|
2113 | =over 4
|
---|
2114 |
|
---|
2115 | =item package
|
---|
2116 |
|
---|
2117 | A L</namespace> for global L<variables|/variable>,
|
---|
2118 | L<subroutines|/subroutine>, and the like, such that they can be kept
|
---|
2119 | separate from like-named L<symbols|/symbol> in other namespaces. In a
|
---|
2120 | sense, only the package is global, since the symbols in the package's
|
---|
2121 | symbol table are only accessible from code compiled outside the
|
---|
2122 | package by naming the package. But in another sense, all package
|
---|
2123 | symbols are also globals--they're just well-organized globals.
|
---|
2124 |
|
---|
2125 | =item pad
|
---|
2126 |
|
---|
2127 | Short for L</scratchpad>.
|
---|
2128 |
|
---|
2129 | =item parameter
|
---|
2130 |
|
---|
2131 | See L</argument>.
|
---|
2132 |
|
---|
2133 | =item parent class
|
---|
2134 |
|
---|
2135 | See L</base class>.
|
---|
2136 |
|
---|
2137 | =item parse tree
|
---|
2138 |
|
---|
2139 | See L</syntax tree>.
|
---|
2140 |
|
---|
2141 | =item parsing
|
---|
2142 |
|
---|
2143 | The subtle but sometimes brutal art of attempting to turn your
|
---|
2144 | possibly malformed program into a valid L</syntax tree>.
|
---|
2145 |
|
---|
2146 | =item patch
|
---|
2147 |
|
---|
2148 | To fix by applying one, as it were. In the realm of hackerdom, a
|
---|
2149 | listing of the differences between two versions of a program as might
|
---|
2150 | be applied by the I<patch>(1) program when you want to fix a bug or
|
---|
2151 | upgrade your old version.
|
---|
2152 |
|
---|
2153 | =item PATH
|
---|
2154 |
|
---|
2155 | The list of L<directories|/directory> the system searches to find a
|
---|
2156 | program you want to L</execute>. The list is stored as one of your
|
---|
2157 | L<environment variables|/environment variable>, accessible in Perl as
|
---|
2158 | C<$ENV{PATH}>.
|
---|
2159 |
|
---|
2160 | =item pathname
|
---|
2161 |
|
---|
2162 | A fully qualified filename such as I</usr/bin/perl>. Sometimes
|
---|
2163 | confused with L</PATH>.
|
---|
2164 |
|
---|
2165 | =item pattern
|
---|
2166 |
|
---|
2167 | A template used in L</pattern matching>.
|
---|
2168 |
|
---|
2169 | =item pattern matching
|
---|
2170 |
|
---|
2171 | Taking a pattern, usually a L</regular expression>, and trying the
|
---|
2172 | pattern various ways on a string to see whether there's any way to
|
---|
2173 | make it fit. Often used to pick interesting tidbits out of a file.
|
---|
2174 |
|
---|
2175 | =item permission bits
|
---|
2176 |
|
---|
2177 | Bits that the L</owner> of a file sets or unsets to allow or disallow
|
---|
2178 | access to other people. These flag bits are part of the L</mode> word
|
---|
2179 | returned by the L<stat|perlfunc/stat> built-in when you ask about a
|
---|
2180 | file. On Unix systems, you can check the I<ls>(1) manpage for more
|
---|
2181 | information.
|
---|
2182 |
|
---|
2183 | =item Pern
|
---|
2184 |
|
---|
2185 | What you get when you do C<Perl++> twice. Doing it only once will
|
---|
2186 | curl your hair. You have to increment it eight times to shampoo your
|
---|
2187 | hair. Lather, rinse, iterate.
|
---|
2188 |
|
---|
2189 | =item pipe
|
---|
2190 |
|
---|
2191 | A direct L</connection> that carries the output of one L</process> to
|
---|
2192 | the input of another without an intermediate temporary file. Once the
|
---|
2193 | pipe is set up, the two processes in question can read and write as if
|
---|
2194 | they were talking to a normal file, with some caveats.
|
---|
2195 |
|
---|
2196 | =item pipeline
|
---|
2197 |
|
---|
2198 | A series of L<processes|/process> all in a row, linked by
|
---|
2199 | L<pipes|/pipe>, where each passes its output stream to the next.
|
---|
2200 |
|
---|
2201 | =item platform
|
---|
2202 |
|
---|
2203 | The entire hardware and software context in which a program runs. A
|
---|
2204 | program written in a platform-dependent language might break if you
|
---|
2205 | change any of: machine, operating system, libraries, compiler, or
|
---|
2206 | system configuration. The I<perl> interpreter has to be compiled
|
---|
2207 | differently for each platform because it is implemented in C, but
|
---|
2208 | programs written in the Perl language are largely
|
---|
2209 | platform-independent.
|
---|
2210 |
|
---|
2211 | =item pod
|
---|
2212 |
|
---|
2213 | The markup used to embed documentation into your Perl code. See
|
---|
2214 | L<perlpod>.
|
---|
2215 |
|
---|
2216 | =item pointer
|
---|
2217 |
|
---|
2218 | A L</variable> in a language like C that contains the exact memory
|
---|
2219 | location of some other item. Perl handles pointers internally so you
|
---|
2220 | don't have to worry about them. Instead, you just use symbolic
|
---|
2221 | pointers in the form of L<keys|/key> and L</variable> names, or L<hard
|
---|
2222 | references|/hard reference>, which aren't pointers (but act like
|
---|
2223 | pointers and do in fact contain pointers).
|
---|
2224 |
|
---|
2225 | =item polymorphism
|
---|
2226 |
|
---|
2227 | The notion that you can tell an L</object> to do something generic,
|
---|
2228 | and the object will interpret the command in different ways depending
|
---|
2229 | on its type. [E<lt>Gk many shapes]
|
---|
2230 |
|
---|
2231 | =item port
|
---|
2232 |
|
---|
2233 | The part of the address of a TCP or UDP socket that directs packets to
|
---|
2234 | the correct process after finding the right machine, something like
|
---|
2235 | the phone extension you give when you reach the company operator.
|
---|
2236 | Also, the result of converting code to run on a different platform
|
---|
2237 | than originally intended, or the verb denoting this conversion.
|
---|
2238 |
|
---|
2239 | =item portable
|
---|
2240 |
|
---|
2241 | Once upon a time, C code compilable under both BSD and SysV. In
|
---|
2242 | general, code that can be easily converted to run on another
|
---|
2243 | L</platform>, where "easily" can be defined however you like, and
|
---|
2244 | usually is. Anything may be considered portable if you try hard
|
---|
2245 | enough. See I<mobile home> or I<London Bridge>.
|
---|
2246 |
|
---|
2247 | =item porter
|
---|
2248 |
|
---|
2249 | Someone who "carries" software from one L</platform> to another.
|
---|
2250 | Porting programs written in platform-dependent languages such as C can
|
---|
2251 | be difficult work, but porting programs like Perl is very much worth
|
---|
2252 | the agony.
|
---|
2253 |
|
---|
2254 | =item POSIX
|
---|
2255 |
|
---|
2256 | The Portable Operating System Interface specification.
|
---|
2257 |
|
---|
2258 | =item postfix
|
---|
2259 |
|
---|
2260 | An L</operator> that follows its L</operand>, as in C<$x++>.
|
---|
2261 |
|
---|
2262 | =item pp
|
---|
2263 |
|
---|
2264 | An internal shorthand for a "push-pop" code, that is, C code
|
---|
2265 | implementing Perl's stack machine.
|
---|
2266 |
|
---|
2267 | =item pragma
|
---|
2268 |
|
---|
2269 | A standard module whose practical hints and suggestions are received
|
---|
2270 | (and possibly ignored) at compile time. Pragmas are named in all
|
---|
2271 | lowercase.
|
---|
2272 |
|
---|
2273 | =item precedence
|
---|
2274 |
|
---|
2275 | The rules of conduct that, in the absence of other guidance, determine
|
---|
2276 | what should happen first. For example, in the absence of parentheses,
|
---|
2277 | you always do multiplication before addition.
|
---|
2278 |
|
---|
2279 | =item prefix
|
---|
2280 |
|
---|
2281 | An L</operator> that precedes its L</operand>, as in C<++$x>.
|
---|
2282 |
|
---|
2283 | =item preprocessing
|
---|
2284 |
|
---|
2285 | What some helper L</process> did to transform the incoming data into a
|
---|
2286 | form more suitable for the current process. Often done with an
|
---|
2287 | incoming L</pipe>. See also L</C preprocessor>.
|
---|
2288 |
|
---|
2289 | =item procedure
|
---|
2290 |
|
---|
2291 | A L</subroutine>.
|
---|
2292 |
|
---|
2293 | =item process
|
---|
2294 |
|
---|
2295 | An instance of a running program. Under multitasking systems like
|
---|
2296 | Unix, two or more separate processes could be running the same program
|
---|
2297 | independently at the same time--in fact, the L<fork|perlfunc/fork>
|
---|
2298 | function is designed to bring about this happy state of affairs.
|
---|
2299 | Under other operating systems, processes are sometimes called
|
---|
2300 | "threads", "tasks", or "jobs", often with slight nuances in meaning.
|
---|
2301 |
|
---|
2302 | =item program generator
|
---|
2303 |
|
---|
2304 | A system that algorithmically writes code for you in a high-level
|
---|
2305 | language. See also L</code generator>.
|
---|
2306 |
|
---|
2307 | =item progressive matching
|
---|
2308 |
|
---|
2309 | L<Pattern matching|/pattern matching> that picks up where it left off before.
|
---|
2310 |
|
---|
2311 | =item property
|
---|
2312 |
|
---|
2313 | See either L</instance variable> or L</character property>.
|
---|
2314 |
|
---|
2315 | =item protocol
|
---|
2316 |
|
---|
2317 | In networking, an agreed-upon way of sending messages back and forth
|
---|
2318 | so that neither correspondent will get too confused.
|
---|
2319 |
|
---|
2320 | =item prototype
|
---|
2321 |
|
---|
2322 | An optional part of a L</subroutine> declaration telling the Perl
|
---|
2323 | compiler how many and what flavor of arguments may be passed as
|
---|
2324 | L</actual arguments>, so that you can write subroutine calls that
|
---|
2325 | parse much like built-in functions. (Or don't parse, as the case may
|
---|
2326 | be.)
|
---|
2327 |
|
---|
2328 | =item pseudofunction
|
---|
2329 |
|
---|
2330 | A construct that sometimes looks like a function but really isn't.
|
---|
2331 | Usually reserved for L</lvalue> modifiers like L<my|perlfunc/my>, for
|
---|
2332 | L</context> modifiers like L<scalar|perlfunc/scalar>, and for the
|
---|
2333 | pick-your-own-quotes constructs, C<q//>, C<qq//>, C<qx//>, C<qw//>,
|
---|
2334 | C<qr//>, C<m//>, C<s///>, C<y///>, and C<tr///>.
|
---|
2335 |
|
---|
2336 | =item pseudohash
|
---|
2337 |
|
---|
2338 | A reference to an array whose initial element happens to hold a
|
---|
2339 | reference to a hash. You can treat a pseudohash reference as either
|
---|
2340 | an array reference or a hash reference.
|
---|
2341 |
|
---|
2342 | =item pseudoliteral
|
---|
2343 |
|
---|
2344 | An L</operator> that looks something like a L</literal>, such as the
|
---|
2345 | output-grabbing operator, C<`>I<C<command>>C<`>.
|
---|
2346 |
|
---|
2347 | =item public domain
|
---|
2348 |
|
---|
2349 | Something not owned by anybody. Perl is copyrighted and is thus
|
---|
2350 | I<not> in the public domain--it's just L</freely available> and
|
---|
2351 | L</freely redistributable>.
|
---|
2352 |
|
---|
2353 | =item pumpkin
|
---|
2354 |
|
---|
2355 | A notional "baton" handed around the Perl community indicating who is
|
---|
2356 | the lead integrator in some arena of development.
|
---|
2357 |
|
---|
2358 | =item pumpking
|
---|
2359 |
|
---|
2360 | A L</pumpkin> holder, the person in charge of pumping the pump, or at
|
---|
2361 | least priming it. Must be willing to play the part of the Great
|
---|
2362 | Pumpkin now and then.
|
---|
2363 |
|
---|
2364 | =item PV
|
---|
2365 |
|
---|
2366 | A "pointer value", which is Perl Internals Talk for a C<char*>.
|
---|
2367 |
|
---|
2368 | =back
|
---|
2369 |
|
---|
2370 | =head2 Q
|
---|
2371 |
|
---|
2372 | =over 4
|
---|
2373 |
|
---|
2374 | =item qualified
|
---|
2375 |
|
---|
2376 | Possessing a complete name. The symbol C<$Ent::moot> is qualified;
|
---|
2377 | C<$moot> is unqualified. A fully qualified filename is specified from
|
---|
2378 | the top-level directory.
|
---|
2379 |
|
---|
2380 | =item quantifier
|
---|
2381 |
|
---|
2382 | A component of a L</regular expression> specifying how many times the
|
---|
2383 | foregoing L</atom> may occur.
|
---|
2384 |
|
---|
2385 | =back
|
---|
2386 |
|
---|
2387 | =head2 R
|
---|
2388 |
|
---|
2389 | =over 4
|
---|
2390 |
|
---|
2391 | =item readable
|
---|
2392 |
|
---|
2393 | With respect to files, one that has the proper permission bit set to
|
---|
2394 | let you access the file. With respect to computer programs, one
|
---|
2395 | that's written well enough that someone has a chance of figuring out
|
---|
2396 | what it's trying to do.
|
---|
2397 |
|
---|
2398 | =item reaping
|
---|
2399 |
|
---|
2400 | The last rites performed by a parent L</process> on behalf of a
|
---|
2401 | deceased child process so that it doesn't remain a L</zombie>. See
|
---|
2402 | the L<wait|perlfunc/wait> and L<waitpid|perlfunc/waitpid> function
|
---|
2403 | calls.
|
---|
2404 |
|
---|
2405 | =item record
|
---|
2406 |
|
---|
2407 | A set of related data values in a L</file> or L</stream>, often
|
---|
2408 | associated with a unique L</key> field. In Unix, often commensurate
|
---|
2409 | with a L</line>, or a blank-line-terminated set of lines (a
|
---|
2410 | "paragraph"). Each line of the I</etc/passwd> file is a record, keyed
|
---|
2411 | on login name, containing information about that user.
|
---|
2412 |
|
---|
2413 | =item recursion
|
---|
2414 |
|
---|
2415 | The art of defining something (at least partly) in terms of itself,
|
---|
2416 | which is a naughty no-no in dictionaries but often works out okay in
|
---|
2417 | computer programs if you're careful not to recurse forever, which is
|
---|
2418 | like an infinite loop with more spectacular failure modes.
|
---|
2419 |
|
---|
2420 | =item reference
|
---|
2421 |
|
---|
2422 | Where you look to find a pointer to information somewhere else. (See
|
---|
2423 | L</indirection>.) References come in two flavors, L<symbolic
|
---|
2424 | references|/symbolic reference> and L<hard references|/hard
|
---|
2425 | reference>.
|
---|
2426 |
|
---|
2427 | =item referent
|
---|
2428 |
|
---|
2429 | Whatever a reference refers to, which may or may not have a name.
|
---|
2430 | Common types of referents include scalars, arrays, hashes, and
|
---|
2431 | subroutines.
|
---|
2432 |
|
---|
2433 | =item regex
|
---|
2434 |
|
---|
2435 | See L</regular expression>.
|
---|
2436 |
|
---|
2437 | =item regular expression
|
---|
2438 |
|
---|
2439 | A single entity with various interpretations, like an elephant. To a
|
---|
2440 | computer scientist, it's a grammar for a little language in which some
|
---|
2441 | strings are legal and others aren't. To normal people, it's a pattern
|
---|
2442 | you can use to find what you're looking for when it varies from case
|
---|
2443 | to case. Perl's regular expressions are far from regular in the
|
---|
2444 | theoretical sense, but in regular use they work quite well. Here's a
|
---|
2445 | regular expression: C</Oh s.*t./>. This will match strings like "C<Oh
|
---|
2446 | say can you see by the dawn's early light>" and "C<Oh sit!>". See
|
---|
2447 | L<perlre>.
|
---|
2448 |
|
---|
2449 | =item regular expression modifier
|
---|
2450 |
|
---|
2451 | An option on a pattern or substitution, such as C</i> to render the
|
---|
2452 | pattern case insensitive. See also L</cloister>.
|
---|
2453 |
|
---|
2454 | =item regular file
|
---|
2455 |
|
---|
2456 | A L</file> that's not a L</directory>, a L</device>, a named L</pipe>
|
---|
2457 | or L</socket>, or a L</symbolic link>. Perl uses the C<-f> file test
|
---|
2458 | operator to identify regular files. Sometimes called a "plain" file.
|
---|
2459 |
|
---|
2460 | =item relational operator
|
---|
2461 |
|
---|
2462 | An L</operator> that says whether a particular ordering relationship
|
---|
2463 | is L</true> about a pair of L<operands|/operand>. Perl has both
|
---|
2464 | numeric and string relational operators. See L</collating sequence>.
|
---|
2465 |
|
---|
2466 | =item reserved words
|
---|
2467 |
|
---|
2468 | A word with a specific, built-in meaning to a L</compiler>, such as
|
---|
2469 | C<if> or L<delete|perlfunc/delete>. In many languages (not Perl),
|
---|
2470 | it's illegal to use reserved words to name anything else. (Which is
|
---|
2471 | why they're reserved, after all.) In Perl, you just can't use them to
|
---|
2472 | name L<labels|/label> or L<filehandles|/filehandle>. Also called
|
---|
2473 | "keywords".
|
---|
2474 |
|
---|
2475 | =item return value
|
---|
2476 |
|
---|
2477 | The L</value> produced by a L</subroutine> or L</expression> when
|
---|
2478 | evaluated. In Perl, a return value may be either a L</list> or a
|
---|
2479 | L</scalar>.
|
---|
2480 |
|
---|
2481 | =item RFC
|
---|
2482 |
|
---|
2483 | Request For Comment, which despite the timid connotations is the name
|
---|
2484 | of a series of important standards documents.
|
---|
2485 |
|
---|
2486 | =item right shift
|
---|
2487 |
|
---|
2488 | A L</bit shift> that divides a number by some power of 2.
|
---|
2489 |
|
---|
2490 | =item root
|
---|
2491 |
|
---|
2492 | The superuser (UID == 0). Also, the top-level directory of the
|
---|
2493 | filesystem.
|
---|
2494 |
|
---|
2495 | =item RTFM
|
---|
2496 |
|
---|
2497 | What you are told when someone thinks you should Read The Fine Manual.
|
---|
2498 |
|
---|
2499 | =item run phase
|
---|
2500 |
|
---|
2501 | Any time after Perl starts running your main program. See also
|
---|
2502 | L</compile phase>. Run phase is mostly spent in L</run time> but may
|
---|
2503 | also be spent in L</compile time> when L<require|perlfunc/require>,
|
---|
2504 | L<do|perlfunc/do> C<FILE>, or L<eval|perlfunc/eval> C<STRING>
|
---|
2505 | operators are executed or when a substitution uses the C</ee>
|
---|
2506 | modifier.
|
---|
2507 |
|
---|
2508 | =item run time
|
---|
2509 |
|
---|
2510 | The time when Perl is actually doing what your code says to do, as
|
---|
2511 | opposed to the earlier period of time when it was trying to figure out
|
---|
2512 | whether what you said made any sense whatsoever, which is L</compile
|
---|
2513 | time>.
|
---|
2514 |
|
---|
2515 | =item run-time pattern
|
---|
2516 |
|
---|
2517 | A pattern that contains one or more variables to be interpolated
|
---|
2518 | before parsing the pattern as a L</regular expression>, and that
|
---|
2519 | therefore cannot be analyzed at compile time, but must be re-analyzed
|
---|
2520 | each time the pattern match operator is evaluated. Run-time patterns
|
---|
2521 | are useful but expensive.
|
---|
2522 |
|
---|
2523 | =item RV
|
---|
2524 |
|
---|
2525 | A recreational vehicle, not to be confused with vehicular recreation.
|
---|
2526 | RV also means an internal Reference Value of the type a L</scalar> can
|
---|
2527 | hold. See also L</IV> and L</NV> if you're not confused yet.
|
---|
2528 |
|
---|
2529 | =item rvalue
|
---|
2530 |
|
---|
2531 | A L</value> that you might find on the right side of an
|
---|
2532 | L</assignment>. See also L</lvalue>.
|
---|
2533 |
|
---|
2534 | =back
|
---|
2535 |
|
---|
2536 | =head2 S
|
---|
2537 |
|
---|
2538 | =over 4
|
---|
2539 |
|
---|
2540 | =item scalar
|
---|
2541 |
|
---|
2542 | A simple, singular value; a number, L</string>, or L</reference>.
|
---|
2543 |
|
---|
2544 | =item scalar context
|
---|
2545 |
|
---|
2546 | The situation in which an L</expression> is expected by its
|
---|
2547 | surroundings (the code calling it) to return a single L</value> rather
|
---|
2548 | than a L</list> of values. See also L</context> and L</list context>.
|
---|
2549 | A scalar context sometimes imposes additional constraints on the
|
---|
2550 | return value--see L</string context> and L</numeric context>.
|
---|
2551 | Sometimes we talk about a L</Boolean context> inside conditionals, but
|
---|
2552 | this imposes no additional constraints, since any scalar value,
|
---|
2553 | whether numeric or L</string>, is already true or false.
|
---|
2554 |
|
---|
2555 | =item scalar literal
|
---|
2556 |
|
---|
2557 | A number or quoted L</string>--an actual L</value> in the text of your
|
---|
2558 | program, as opposed to a L</variable>.
|
---|
2559 |
|
---|
2560 | =item scalar value
|
---|
2561 |
|
---|
2562 | A value that happens to be a L</scalar> as opposed to a L</list>.
|
---|
2563 |
|
---|
2564 | =item scalar variable
|
---|
2565 |
|
---|
2566 | A L</variable> prefixed with C<$> that holds a single value.
|
---|
2567 |
|
---|
2568 | =item scope
|
---|
2569 |
|
---|
2570 | How far away you can see a variable from, looking through one. Perl
|
---|
2571 | has two visibility mechanisms: it does L</dynamic scoping> of
|
---|
2572 | L<local|perlfunc/local> L<variables|/variable>, meaning that the rest
|
---|
2573 | of the L</block>, and any L<subroutines|/subroutine> that are called
|
---|
2574 | by the rest of the block, can see the variables that are local to the
|
---|
2575 | block. Perl does L</lexical scoping> of L<my|perlfunc/my> variables,
|
---|
2576 | meaning that the rest of the block can see the variable, but other
|
---|
2577 | subroutines called by the block I<cannot> see the variable.
|
---|
2578 |
|
---|
2579 | =item scratchpad
|
---|
2580 |
|
---|
2581 | The area in which a particular invocation of a particular file or
|
---|
2582 | subroutine keeps some of its temporary values, including any lexically
|
---|
2583 | scoped variables.
|
---|
2584 |
|
---|
2585 | =item script
|
---|
2586 |
|
---|
2587 | A text L</file> that is a program intended to be L<executed|/execute>
|
---|
2588 | directly rather than L<compiled|/compiler> to another form of file
|
---|
2589 | before execution. Also, in the context of L</Unicode>, a writing
|
---|
2590 | system for a particular language or group of languages, such as Greek,
|
---|
2591 | Bengali, or Klingon.
|
---|
2592 |
|
---|
2593 | =item script kiddie
|
---|
2594 |
|
---|
2595 | A L</cracker> who is not a L</hacker>, but knows just enough to run
|
---|
2596 | canned scripts. A cargo-cult programmer.
|
---|
2597 |
|
---|
2598 | =item sed
|
---|
2599 |
|
---|
2600 | A venerable Stream EDitor from which Perl derives some of its ideas.
|
---|
2601 |
|
---|
2602 | =item semaphore
|
---|
2603 |
|
---|
2604 | A fancy kind of interlock that prevents multiple L<threads|/thread> or
|
---|
2605 | L<processes|/process> from using up the same resources simultaneously.
|
---|
2606 |
|
---|
2607 | =item separator
|
---|
2608 |
|
---|
2609 | A L</character> or L</string> that keeps two surrounding strings from
|
---|
2610 | being confused with each other. The L<split|perlfunc/split> function
|
---|
2611 | works on separators. Not to be confused with L<delimiters|/delimiter>
|
---|
2612 | or L<terminators|/terminator>. The "or" in the previous sentence
|
---|
2613 | separated the two alternatives.
|
---|
2614 |
|
---|
2615 | =item serialization
|
---|
2616 |
|
---|
2617 | Putting a fancy L</data structure> into linear order so that it can be
|
---|
2618 | stored as a L</string> in a disk file or database or sent through a
|
---|
2619 | L</pipe>. Also called marshalling.
|
---|
2620 |
|
---|
2621 | =item server
|
---|
2622 |
|
---|
2623 | In networking, a L</process> that either advertises a L</service> or
|
---|
2624 | just hangs around at a known location and waits for L<clients|/client>
|
---|
2625 | who need service to get in touch with it.
|
---|
2626 |
|
---|
2627 | =item service
|
---|
2628 |
|
---|
2629 | Something you do for someone else to make them happy, like giving them
|
---|
2630 | the time of day (or of their life). On some machines, well-known
|
---|
2631 | services are listed by the L<getservent|perlfunc/getservent> function.
|
---|
2632 |
|
---|
2633 | =item setgid
|
---|
2634 |
|
---|
2635 | Same as L</setuid>, only having to do with giving away L</group>
|
---|
2636 | privileges.
|
---|
2637 |
|
---|
2638 | =item setuid
|
---|
2639 |
|
---|
2640 | Said of a program that runs with the privileges of its L</owner>
|
---|
2641 | rather than (as is usually the case) the privileges of whoever is
|
---|
2642 | running it. Also describes the bit in the mode word (L</permission
|
---|
2643 | bits>) that controls the feature. This bit must be explicitly set by
|
---|
2644 | the owner to enable this feature, and the program must be carefully
|
---|
2645 | written not to give away more privileges than it ought to.
|
---|
2646 |
|
---|
2647 | =item shared memory
|
---|
2648 |
|
---|
2649 | A piece of L</memory> accessible by two different
|
---|
2650 | L<processes|/process> who otherwise would not see each other's memory.
|
---|
2651 |
|
---|
2652 | =item shebang
|
---|
2653 |
|
---|
2654 | Irish for the whole McGillicuddy. In Perl culture, a portmanteau of
|
---|
2655 | "sharp" and "bang", meaning the C<#!> sequence that tells the system
|
---|
2656 | where to find the interpreter.
|
---|
2657 |
|
---|
2658 | =item shell
|
---|
2659 |
|
---|
2660 | A L</command>-line L</interpreter>. The program that interactively
|
---|
2661 | gives you a prompt, accepts one or more L<lines|/line> of input, and
|
---|
2662 | executes the programs you mentioned, feeding each of them their proper
|
---|
2663 | L<arguments|/argument> and input data. Shells can also execute
|
---|
2664 | scripts containing such commands. Under Unix, typical shells include
|
---|
2665 | the Bourne shell (I</bin/sh>), the C shell (I</bin/csh>), and the Korn
|
---|
2666 | shell (I</bin/ksh>). Perl is not strictly a shell because it's not
|
---|
2667 | interactive (although Perl programs can be interactive).
|
---|
2668 |
|
---|
2669 | =item side effects
|
---|
2670 |
|
---|
2671 | Something extra that happens when you evaluate an L</expression>.
|
---|
2672 | Nowadays it can refer to almost anything. For example, evaluating a
|
---|
2673 | simple assignment statement typically has the "side effect" of
|
---|
2674 | assigning a value to a variable. (And you thought assigning the value
|
---|
2675 | was your primary intent in the first place!) Likewise, assigning a
|
---|
2676 | value to the special variable C<$|> (C<$AUTOFLUSH>) has the side
|
---|
2677 | effect of forcing a flush after every L<write|perlfunc/write> or
|
---|
2678 | L<print|perlfunc/print> on the currently selected filehandle.
|
---|
2679 |
|
---|
2680 | =item signal
|
---|
2681 |
|
---|
2682 | A bolt out of the blue; that is, an event triggered by the
|
---|
2683 | L</operating system>, probably when you're least expecting it.
|
---|
2684 |
|
---|
2685 | =item signal handler
|
---|
2686 |
|
---|
2687 | A L</subroutine> that, instead of being content to be called in the
|
---|
2688 | normal fashion, sits around waiting for a bolt out of the blue before
|
---|
2689 | it will deign to L</execute>. Under Perl, bolts out of the blue are
|
---|
2690 | called signals, and you send them with the L<kill|perlfunc/kill>
|
---|
2691 | built-in. See L<perlvar/%SIG> and L<perlipc/Signals>.
|
---|
2692 |
|
---|
2693 | =item single inheritance
|
---|
2694 |
|
---|
2695 | The features you got from your mother, if she told you that you don't
|
---|
2696 | have a father. (See also L</inheritance> and L</multiple
|
---|
2697 | inheritance>.) In computer languages, the notion that
|
---|
2698 | L<classes|/class> reproduce asexually so that a given class can only
|
---|
2699 | have one direct ancestor or L</base class>. Perl supplies no such
|
---|
2700 | restriction, though you may certainly program Perl that way if you
|
---|
2701 | like.
|
---|
2702 |
|
---|
2703 | =item slice
|
---|
2704 |
|
---|
2705 | A selection of any number of L<elements|/element> from a L</list>,
|
---|
2706 | L</array>, or L</hash>.
|
---|
2707 |
|
---|
2708 | =item slurp
|
---|
2709 |
|
---|
2710 | To read an entire L</file> into a L</string> in one operation.
|
---|
2711 |
|
---|
2712 | =item socket
|
---|
2713 |
|
---|
2714 | An endpoint for network communication among multiple
|
---|
2715 | L<processes|/process> that works much like a telephone or a post
|
---|
2716 | office box. The most important thing about a socket is its L</network
|
---|
2717 | address> (like a phone number). Different kinds of sockets have
|
---|
2718 | different kinds of addresses--some look like filenames, and some
|
---|
2719 | don't.
|
---|
2720 |
|
---|
2721 | =item soft reference
|
---|
2722 |
|
---|
2723 | See L</symbolic reference>.
|
---|
2724 |
|
---|
2725 | =item source filter
|
---|
2726 |
|
---|
2727 | A special kind of L</module> that does L</preprocessing> on your
|
---|
2728 | script just before it gets to the L</tokener>.
|
---|
2729 |
|
---|
2730 | =item stack
|
---|
2731 |
|
---|
2732 | A device you can put things on the top of, and later take them back
|
---|
2733 | off in the opposite order in which you put them on. See L</LIFO>.
|
---|
2734 |
|
---|
2735 | =item standard
|
---|
2736 |
|
---|
2737 | Included in the official Perl distribution, as in a standard module, a
|
---|
2738 | standard tool, or a standard Perl L</manpage>.
|
---|
2739 |
|
---|
2740 | =item standard error
|
---|
2741 |
|
---|
2742 | The default output L</stream> for nasty remarks that don't belong in
|
---|
2743 | L</standard output>. Represented within a Perl program by the
|
---|
2744 | L</filehandle> L</STDERR>. You can use this stream explicitly, but the
|
---|
2745 | L<die|perlfunc/die> and L<warn|perlfunc/warn> built-ins write to your
|
---|
2746 | standard error stream automatically.
|
---|
2747 |
|
---|
2748 | =item standard I/O
|
---|
2749 |
|
---|
2750 | A standard C library for doing L<buffered|/buffer> input and output to
|
---|
2751 | the L</operating system>. (The "standard" of standard I/O is only
|
---|
2752 | marginally related to the "standard" of standard input and output.)
|
---|
2753 | In general, Perl relies on whatever implementation of standard I/O a
|
---|
2754 | given operating system supplies, so the buffering characteristics of a
|
---|
2755 | Perl program on one machine may not exactly match those on another
|
---|
2756 | machine. Normally this only influences efficiency, not semantics. If
|
---|
2757 | your standard I/O package is doing block buffering and you want it to
|
---|
2758 | L</flush> the buffer more often, just set the C<$|> variable to a true
|
---|
2759 | value.
|
---|
2760 |
|
---|
2761 | =item standard input
|
---|
2762 |
|
---|
2763 | The default input L</stream> for your program, which if possible
|
---|
2764 | shouldn't care where its data is coming from. Represented within a
|
---|
2765 | Perl program by the L</filehandle> L</STDIN>.
|
---|
2766 |
|
---|
2767 | =item standard output
|
---|
2768 |
|
---|
2769 | The default output L</stream> for your program, which if possible
|
---|
2770 | shouldn't care where its data is going. Represented within a Perl
|
---|
2771 | program by the L</filehandle> L</STDOUT>.
|
---|
2772 |
|
---|
2773 | =item stat structure
|
---|
2774 |
|
---|
2775 | A special internal spot in which Perl keeps the information about the
|
---|
2776 | last L</file> on which you requested information.
|
---|
2777 |
|
---|
2778 | =item statement
|
---|
2779 |
|
---|
2780 | A L</command> to the computer about what to do next, like a step in a
|
---|
2781 | recipe: "Add marmalade to batter and mix until mixed." A statement is
|
---|
2782 | distinguished from a L</declaration>, which doesn't tell the computer
|
---|
2783 | to do anything, but just to learn something.
|
---|
2784 |
|
---|
2785 | =item statement modifier
|
---|
2786 |
|
---|
2787 | A L</conditional> or L</loop> that you put after the L</statement>
|
---|
2788 | instead of before, if you know what we mean.
|
---|
2789 |
|
---|
2790 | =item static
|
---|
2791 |
|
---|
2792 | Varying slowly compared to something else. (Unfortunately, everything
|
---|
2793 | is relatively stable compared to something else, except for certain
|
---|
2794 | elementary particles, and we're not so sure about them.) In
|
---|
2795 | computers, where things are supposed to vary rapidly, "static" has a
|
---|
2796 | derogatory connotation, indicating a slightly dysfunctional
|
---|
2797 | L</variable>, L</subroutine>, or L</method>. In Perl culture, the
|
---|
2798 | word is politely avoided.
|
---|
2799 |
|
---|
2800 | =item static method
|
---|
2801 |
|
---|
2802 | No such thing. See L</class method>.
|
---|
2803 |
|
---|
2804 | =item static scoping
|
---|
2805 |
|
---|
2806 | No such thing. See L</lexical scoping>.
|
---|
2807 |
|
---|
2808 | =item static variable
|
---|
2809 |
|
---|
2810 | No such thing. Just use a L</lexical variable> in a scope larger than
|
---|
2811 | your L</subroutine>.
|
---|
2812 |
|
---|
2813 | =item status
|
---|
2814 |
|
---|
2815 | The L</value> returned to the parent L</process> when one of its child
|
---|
2816 | processes dies. This value is placed in the special variable C<$?>.
|
---|
2817 | Its upper eight L<bits|/bit> are the exit status of the defunct
|
---|
2818 | process, and its lower eight bits identify the signal (if any) that
|
---|
2819 | the process died from. On Unix systems, this status value is the same
|
---|
2820 | as the status word returned by I<wait>(2). See L<perlfunc/system>.
|
---|
2821 |
|
---|
2822 | =item STDERR
|
---|
2823 |
|
---|
2824 | See L</standard error>.
|
---|
2825 |
|
---|
2826 | =item STDIN
|
---|
2827 |
|
---|
2828 | See L</standard input>.
|
---|
2829 |
|
---|
2830 | =item STDIO
|
---|
2831 |
|
---|
2832 | See L</standard IE<sol>O>.
|
---|
2833 |
|
---|
2834 | =item STDOUT
|
---|
2835 |
|
---|
2836 | See L</standard output>.
|
---|
2837 |
|
---|
2838 | =item stream
|
---|
2839 |
|
---|
2840 | A flow of data into or out of a process as a steady sequence of bytes
|
---|
2841 | or characters, without the appearance of being broken up into packets.
|
---|
2842 | This is a kind of L</interface>--the underlying L</implementation> may
|
---|
2843 | well break your data up into separate packets for delivery, but this
|
---|
2844 | is hidden from you.
|
---|
2845 |
|
---|
2846 | =item string
|
---|
2847 |
|
---|
2848 | A sequence of characters such as "He said !@#*&%@#*?!". A string does
|
---|
2849 | not have to be entirely printable.
|
---|
2850 |
|
---|
2851 | =item string context
|
---|
2852 |
|
---|
2853 | The situation in which an expression is expected by its surroundings
|
---|
2854 | (the code calling it) to return a L</string>. See also L</context>
|
---|
2855 | and L</numeric context>.
|
---|
2856 |
|
---|
2857 | =item stringification
|
---|
2858 |
|
---|
2859 | The process of producing a L</string> representation of an abstract
|
---|
2860 | object.
|
---|
2861 |
|
---|
2862 | =item struct
|
---|
2863 |
|
---|
2864 | C keyword introducing a structure definition or name.
|
---|
2865 |
|
---|
2866 | =item structure
|
---|
2867 |
|
---|
2868 | See L</data structure>.
|
---|
2869 |
|
---|
2870 | =item subclass
|
---|
2871 |
|
---|
2872 | See L</derived class>.
|
---|
2873 |
|
---|
2874 | =item subpattern
|
---|
2875 |
|
---|
2876 | A component of a L</regular expression> pattern.
|
---|
2877 |
|
---|
2878 | =item subroutine
|
---|
2879 |
|
---|
2880 | A named or otherwise accessible piece of program that can be invoked
|
---|
2881 | from elsewhere in the program in order to accomplish some sub-goal of
|
---|
2882 | the program. A subroutine is often parameterized to accomplish
|
---|
2883 | different but related things depending on its input
|
---|
2884 | L<arguments|/argument>. If the subroutine returns a meaningful
|
---|
2885 | L</value>, it is also called a L</function>.
|
---|
2886 |
|
---|
2887 | =item subscript
|
---|
2888 |
|
---|
2889 | A L</value> that indicates the position of a particular L</array>
|
---|
2890 | L</element> in an array.
|
---|
2891 |
|
---|
2892 | =item substitution
|
---|
2893 |
|
---|
2894 | Changing parts of a string via the C<s///> operator. (We avoid use of
|
---|
2895 | this term to mean L</variable interpolation>.)
|
---|
2896 |
|
---|
2897 | =item substring
|
---|
2898 |
|
---|
2899 | A portion of a L</string>, starting at a certain L</character>
|
---|
2900 | position (L</offset>) and proceeding for a certain number of
|
---|
2901 | characters.
|
---|
2902 |
|
---|
2903 | =item superclass
|
---|
2904 |
|
---|
2905 | See L</base class>.
|
---|
2906 |
|
---|
2907 | =item superuser
|
---|
2908 |
|
---|
2909 | The person whom the L</operating system> will let do almost anything.
|
---|
2910 | Typically your system administrator or someone pretending to be your
|
---|
2911 | system administrator. On Unix systems, the L</root> user. On Windows
|
---|
2912 | systems, usually the Administrator user.
|
---|
2913 |
|
---|
2914 | =item SV
|
---|
2915 |
|
---|
2916 | Short for "scalar value". But within the Perl interpreter every
|
---|
2917 | L</referent> is treated as a member of a class derived from SV, in an
|
---|
2918 | object-oriented sort of way. Every L</value> inside Perl is passed
|
---|
2919 | around as a C language C<SV*> pointer. The SV L</struct> knows its
|
---|
2920 | own "referent type", and the code is smart enough (we hope) not to try
|
---|
2921 | to call a L</hash> function on a L</subroutine>.
|
---|
2922 |
|
---|
2923 | =item switch
|
---|
2924 |
|
---|
2925 | An option you give on a command line to influence the way your program
|
---|
2926 | works, usually introduced with a minus sign. The word is also used as
|
---|
2927 | a nickname for a L</switch statement>.
|
---|
2928 |
|
---|
2929 | =item switch cluster
|
---|
2930 |
|
---|
2931 | The combination of multiple command-line switches (e.g., B<-a -b -c>)
|
---|
2932 | into one switch (e.g., B<-abc>). Any switch with an additional
|
---|
2933 | L</argument> must be the last switch in a cluster.
|
---|
2934 |
|
---|
2935 | =item switch statement
|
---|
2936 |
|
---|
2937 | A program technique that lets you evaluate an L</expression> and then,
|
---|
2938 | based on the value of the expression, do a multiway branch to the
|
---|
2939 | appropriate piece of code for that value. Also called a "case
|
---|
2940 | structure", named after the similar Pascal construct. Most switch
|
---|
2941 | statements in Perl are spelled C<for>. See L<perlsyn/Basic BLOCKs and
|
---|
2942 | Switch Statements>.
|
---|
2943 |
|
---|
2944 | =item symbol
|
---|
2945 |
|
---|
2946 | Generally, any L</token> or L</metasymbol>. Often used more
|
---|
2947 | specifically to mean the sort of name you might find in a L</symbol
|
---|
2948 | table>.
|
---|
2949 |
|
---|
2950 | =item symbol table
|
---|
2951 |
|
---|
2952 | Where a L</compiler> remembers symbols. A program like Perl must
|
---|
2953 | somehow remember all the names of all the L<variables|/variable>,
|
---|
2954 | L<filehandles|/filehandle>, and L<subroutines|/subroutine> you've
|
---|
2955 | used. It does this by placing the names in a symbol table, which is
|
---|
2956 | implemented in Perl using a L</hash table>. There is a separate
|
---|
2957 | symbol table for each L</package> to give each package its own
|
---|
2958 | L</namespace>.
|
---|
2959 |
|
---|
2960 | =item symbolic debugger
|
---|
2961 |
|
---|
2962 | A program that lets you step through the L<execution|/execute> of your
|
---|
2963 | program, stopping or printing things out here and there to see whether
|
---|
2964 | anything has gone wrong, and if so, what. The "symbolic" part just
|
---|
2965 | means that you can talk to the debugger using the same symbols with
|
---|
2966 | which your program is written.
|
---|
2967 |
|
---|
2968 | =item symbolic link
|
---|
2969 |
|
---|
2970 | An alternate filename that points to the real L</filename>, which in
|
---|
2971 | turn points to the real L</file>. Whenever the L</operating system>
|
---|
2972 | is trying to parse a L</pathname> containing a symbolic link, it
|
---|
2973 | merely substitutes the new name and continues parsing.
|
---|
2974 |
|
---|
2975 | =item symbolic reference
|
---|
2976 |
|
---|
2977 | A variable whose value is the name of another variable or subroutine.
|
---|
2978 | By L<dereferencing|/dereference> the first variable, you can get at
|
---|
2979 | the second one. Symbolic references are illegal under L<use strict
|
---|
2980 | 'refs'|strict/strict refs>.
|
---|
2981 |
|
---|
2982 | =item synchronous
|
---|
2983 |
|
---|
2984 | Programming in which the orderly sequence of events can be determined;
|
---|
2985 | that is, when things happen one after the other, not at the same time.
|
---|
2986 |
|
---|
2987 | =item syntactic sugar
|
---|
2988 |
|
---|
2989 | An alternative way of writing something more easily; a shortcut.
|
---|
2990 |
|
---|
2991 | =item syntax
|
---|
2992 |
|
---|
2993 | From Greek, "with-arrangement". How things (particularly symbols) are
|
---|
2994 | put together with each other.
|
---|
2995 |
|
---|
2996 | =item syntax tree
|
---|
2997 |
|
---|
2998 | An internal representation of your program wherein lower-level
|
---|
2999 | L<constructs|/construct> dangle off the higher-level constructs
|
---|
3000 | enclosing them.
|
---|
3001 |
|
---|
3002 | =item syscall
|
---|
3003 |
|
---|
3004 | A L</function> call directly to the L</operating system>. Many of the
|
---|
3005 | important subroutines and functions you use aren't direct system
|
---|
3006 | calls, but are built up in one or more layers above the system call
|
---|
3007 | level. In general, Perl programmers don't need to worry about the
|
---|
3008 | distinction. However, if you do happen to know which Perl functions
|
---|
3009 | are really syscalls, you can predict which of these will set the C<$!>
|
---|
3010 | (C<$ERRNO>) variable on failure. Unfortunately, beginning programmers
|
---|
3011 | often confusingly employ the term "system call" to mean what happens
|
---|
3012 | when you call the Perl L<system|perlfunc/system> function, which
|
---|
3013 | actually involves many syscalls. To avoid any confusion, we nearly
|
---|
3014 | always use say "syscall" for something you could call indirectly via
|
---|
3015 | Perl's L<syscall|perlfunc/syscall> function, and never for something
|
---|
3016 | you would call with Perl's L<system|perlfunc/system> function.
|
---|
3017 |
|
---|
3018 | =back
|
---|
3019 |
|
---|
3020 | =head2 T
|
---|
3021 |
|
---|
3022 | =over 4
|
---|
3023 |
|
---|
3024 | =item tainted
|
---|
3025 |
|
---|
3026 | Said of data derived from the grubby hands of a user and thus unsafe
|
---|
3027 | for a secure program to rely on. Perl does taint checks if you run a
|
---|
3028 | L</setuid> (or L</setgid>) program, or if you use the B<-T> switch.
|
---|
3029 |
|
---|
3030 | =item TCP
|
---|
3031 |
|
---|
3032 | Short for Transmission Control Protocol. A protocol wrapped around
|
---|
3033 | the Internet Protocol to make an unreliable packet transmission
|
---|
3034 | mechanism appear to the application program to be a reliable
|
---|
3035 | L</stream> of bytes. (Usually.)
|
---|
3036 |
|
---|
3037 | =item term
|
---|
3038 |
|
---|
3039 | Short for a "terminal", that is, a leaf node of a L</syntax tree>. A
|
---|
3040 | thing that functions grammatically as an L</operand> for the operators
|
---|
3041 | in an expression.
|
---|
3042 |
|
---|
3043 | =item terminator
|
---|
3044 |
|
---|
3045 | A L</character> or L</string> that marks the end of another string.
|
---|
3046 | The C<$/> variable contains the string that terminates a
|
---|
3047 | L<readline|perlfunc/readline> operation, which L<chomp|perlfunc/chomp>
|
---|
3048 | deletes from the end. Not to be confused with
|
---|
3049 | L<delimiters|/delimiter> or L<separators|/separator>. The period at
|
---|
3050 | the end of this sentence is a terminator.
|
---|
3051 |
|
---|
3052 | =item ternary
|
---|
3053 |
|
---|
3054 | An L</operator> taking three L<operands|/operand>. Sometimes
|
---|
3055 | pronounced L</trinary>.
|
---|
3056 |
|
---|
3057 | =item text
|
---|
3058 |
|
---|
3059 | A L</string> or L</file> containing primarily printable characters.
|
---|
3060 |
|
---|
3061 | =item thread
|
---|
3062 |
|
---|
3063 | Like a forked process, but without L</fork>'s inherent memory
|
---|
3064 | protection. A thread is lighter weight than a full process, in that a
|
---|
3065 | process could have multiple threads running around in it, all fighting
|
---|
3066 | over the same process's memory space unless steps are taken to protect
|
---|
3067 | threads from each other. See L<threads>.
|
---|
3068 |
|
---|
3069 | =item tie
|
---|
3070 |
|
---|
3071 | The bond between a magical variable and its implementation class. See
|
---|
3072 | L<perlfunc/tie> and L<perltie>.
|
---|
3073 |
|
---|
3074 | =item TMTOWTDI
|
---|
3075 |
|
---|
3076 | There's More Than One Way To Do It, the Perl Motto. The notion that
|
---|
3077 | there can be more than one valid path to solving a programming problem
|
---|
3078 | in context. (This doesn't mean that more ways are always better or
|
---|
3079 | that all possible paths are equally desirable--just that there need
|
---|
3080 | not be One True Way.) Pronounced TimToady.
|
---|
3081 |
|
---|
3082 | =item token
|
---|
3083 |
|
---|
3084 | A morpheme in a programming language, the smallest unit of text with
|
---|
3085 | semantic significance.
|
---|
3086 |
|
---|
3087 | =item tokener
|
---|
3088 |
|
---|
3089 | A module that breaks a program text into a sequence of
|
---|
3090 | L<tokens|/token> for later analysis by a parser.
|
---|
3091 |
|
---|
3092 | =item tokenizing
|
---|
3093 |
|
---|
3094 | Splitting up a program text into L<tokens|/token>. Also known as
|
---|
3095 | "lexing", in which case you get "lexemes" instead of tokens.
|
---|
3096 |
|
---|
3097 | =item toolbox approach
|
---|
3098 |
|
---|
3099 | The notion that, with a complete set of simple tools that work well
|
---|
3100 | together, you can build almost anything you want. Which is fine if
|
---|
3101 | you're assembling a tricycle, but if you're building a defranishizing
|
---|
3102 | comboflux regurgalator, you really want your own machine shop in which
|
---|
3103 | to build special tools. Perl is sort of a machine shop.
|
---|
3104 |
|
---|
3105 | =item transliterate
|
---|
3106 |
|
---|
3107 | To turn one string representation into another by mapping each
|
---|
3108 | character of the source string to its corresponding character in the
|
---|
3109 | result string. See
|
---|
3110 | L<perlop/trE<sol>SEARCHLISTE<sol>REPLACEMENTLISTE<sol>cds>.
|
---|
3111 |
|
---|
3112 | =item trigger
|
---|
3113 |
|
---|
3114 | An event that causes a L</handler> to be run.
|
---|
3115 |
|
---|
3116 | =item trinary
|
---|
3117 |
|
---|
3118 | Not a stellar system with three stars, but an L</operator> taking
|
---|
3119 | three L<operands|/operand>. Sometimes pronounced L</ternary>.
|
---|
3120 |
|
---|
3121 | =item troff
|
---|
3122 |
|
---|
3123 | A venerable typesetting language from which Perl derives the name of
|
---|
3124 | its C<$%> variable and which is secretly used in the production of
|
---|
3125 | Camel books.
|
---|
3126 |
|
---|
3127 | =item true
|
---|
3128 |
|
---|
3129 | Any scalar value that doesn't evaluate to 0 or C<"">.
|
---|
3130 |
|
---|
3131 | =item truncating
|
---|
3132 |
|
---|
3133 | Emptying a file of existing contents, either automatically when
|
---|
3134 | opening a file for writing or explicitly via the
|
---|
3135 | L<truncate|perlfunc/truncate> function.
|
---|
3136 |
|
---|
3137 | =item type
|
---|
3138 |
|
---|
3139 | See L</data type> and L</class>.
|
---|
3140 |
|
---|
3141 | =item type casting
|
---|
3142 |
|
---|
3143 | Converting data from one type to another. C permits this. Perl does
|
---|
3144 | not need it. Nor want it.
|
---|
3145 |
|
---|
3146 | =item typed lexical
|
---|
3147 |
|
---|
3148 | A L</lexical variable> that is declared with a L</class> type: C<my
|
---|
3149 | Pony $bill>.
|
---|
3150 |
|
---|
3151 | =item typedef
|
---|
3152 |
|
---|
3153 | A type definition in the C language.
|
---|
3154 |
|
---|
3155 | =item typeglob
|
---|
3156 |
|
---|
3157 | Use of a single identifier, prefixed with C<*>. For example, C<*name>
|
---|
3158 | stands for any or all of C<$name>, C<@name>, C<%name>, C<&name>, or
|
---|
3159 | just C<name>. How you use it determines whether it is interpreted as
|
---|
3160 | all or only one of them. See L<perldata/Typeglobs and Filehandles>.
|
---|
3161 |
|
---|
3162 | =item typemap
|
---|
3163 |
|
---|
3164 | A description of how C types may be transformed to and from Perl types
|
---|
3165 | within an L</extension> module written in L</XS>.
|
---|
3166 |
|
---|
3167 | =back
|
---|
3168 |
|
---|
3169 | =head2 U
|
---|
3170 |
|
---|
3171 | =over 4
|
---|
3172 |
|
---|
3173 | =item UDP
|
---|
3174 |
|
---|
3175 | User Datagram Protocol, the typical way to send L<datagrams|/datagram>
|
---|
3176 | over the Internet.
|
---|
3177 |
|
---|
3178 | =item UID
|
---|
3179 |
|
---|
3180 | A user ID. Often used in the context of L</file> or L</process>
|
---|
3181 | ownership.
|
---|
3182 |
|
---|
3183 | =item umask
|
---|
3184 |
|
---|
3185 | A mask of those L</permission bits> that should be forced off when
|
---|
3186 | creating files or directories, in order to establish a policy of whom
|
---|
3187 | you'll ordinarily deny access to. See the L<umask|perlfunc/umask>
|
---|
3188 | function.
|
---|
3189 |
|
---|
3190 | =item unary operator
|
---|
3191 |
|
---|
3192 | An operator with only one L</operand>, like C<!> or
|
---|
3193 | L<chdir|perlfunc/chdir>. Unary operators are usually prefix
|
---|
3194 | operators; that is, they precede their operand. The C<++> and C<-->
|
---|
3195 | operators can be either prefix or postfix. (Their position I<does>
|
---|
3196 | change their meanings.)
|
---|
3197 |
|
---|
3198 | =item Unicode
|
---|
3199 |
|
---|
3200 | A character set comprising all the major character sets of the world,
|
---|
3201 | more or less. See L<http://www.unicode.org>.
|
---|
3202 |
|
---|
3203 | =item Unix
|
---|
3204 |
|
---|
3205 | A very large and constantly evolving language with several alternative
|
---|
3206 | and largely incompatible syntaxes, in which anyone can define anything
|
---|
3207 | any way they choose, and usually do. Speakers of this language think
|
---|
3208 | it's easy to learn because it's so easily twisted to one's own ends,
|
---|
3209 | but dialectical differences make tribal intercommunication nearly
|
---|
3210 | impossible, and travelers are often reduced to a pidgin-like subset of
|
---|
3211 | the language. To be universally understood, a Unix shell programmer
|
---|
3212 | must spend years of study in the art. Many have abandoned this
|
---|
3213 | discipline and now communicate via an Esperanto-like language called
|
---|
3214 | Perl.
|
---|
3215 |
|
---|
3216 | In ancient times, Unix was also used to refer to some code that a
|
---|
3217 | couple of people at Bell Labs wrote to make use of a PDP-7 computer
|
---|
3218 | that wasn't doing much of anything else at the time.
|
---|
3219 |
|
---|
3220 | =back
|
---|
3221 |
|
---|
3222 | =head2 V
|
---|
3223 |
|
---|
3224 | =over 4
|
---|
3225 |
|
---|
3226 | =item value
|
---|
3227 |
|
---|
3228 | An actual piece of data, in contrast to all the variables, references,
|
---|
3229 | keys, indexes, operators, and whatnot that you need to access the
|
---|
3230 | value.
|
---|
3231 |
|
---|
3232 | =item variable
|
---|
3233 |
|
---|
3234 | A named storage location that can hold any of various kinds of
|
---|
3235 | L</value>, as your program sees fit.
|
---|
3236 |
|
---|
3237 | =item variable interpolation
|
---|
3238 |
|
---|
3239 | The L</interpolation> of a scalar or array variable into a string.
|
---|
3240 |
|
---|
3241 | =item variadic
|
---|
3242 |
|
---|
3243 | Said of a L</function> that happily receives an indeterminate number
|
---|
3244 | of L</actual arguments>.
|
---|
3245 |
|
---|
3246 | =item vector
|
---|
3247 |
|
---|
3248 | Mathematical jargon for a list of L<scalar values|/scalar value>.
|
---|
3249 |
|
---|
3250 | =item virtual
|
---|
3251 |
|
---|
3252 | Providing the appearance of something without the reality, as in:
|
---|
3253 | virtual memory is not real memory. (See also L</memory>.) The
|
---|
3254 | opposite of "virtual" is "transparent", which means providing the
|
---|
3255 | reality of something without the appearance, as in: Perl handles the
|
---|
3256 | variable-length UTF-8 character encoding transparently.
|
---|
3257 |
|
---|
3258 | =item void context
|
---|
3259 |
|
---|
3260 | A form of L</scalar context> in which an L</expression> is not
|
---|
3261 | expected to return any L</value> at all and is evaluated for its
|
---|
3262 | L</side effects> alone.
|
---|
3263 |
|
---|
3264 | =item v-string
|
---|
3265 |
|
---|
3266 | A "version" or "vector" L</string> specified with a C<v> followed by a
|
---|
3267 | series of decimal integers in dot notation, for instance,
|
---|
3268 | C<v1.20.300.4000>. Each number turns into a L</character> with the
|
---|
3269 | specified ordinal value. (The C<v> is optional when there are at
|
---|
3270 | least three integers.)
|
---|
3271 |
|
---|
3272 | =back
|
---|
3273 |
|
---|
3274 | =head2 W
|
---|
3275 |
|
---|
3276 | =over 4
|
---|
3277 |
|
---|
3278 | =item warning
|
---|
3279 |
|
---|
3280 | A message printed to the L</STDERR> stream to the effect that something
|
---|
3281 | might be wrong but isn't worth blowing up over. See L<perlfunc/warn>
|
---|
3282 | and the L<warnings> pragma.
|
---|
3283 |
|
---|
3284 | =item watch expression
|
---|
3285 |
|
---|
3286 | An expression which, when its value changes, causes a breakpoint in
|
---|
3287 | the Perl debugger.
|
---|
3288 |
|
---|
3289 | =item whitespace
|
---|
3290 |
|
---|
3291 | A L</character> that moves your cursor but doesn't otherwise put
|
---|
3292 | anything on your screen. Typically refers to any of: space, tab, line
|
---|
3293 | feed, carriage return, or form feed.
|
---|
3294 |
|
---|
3295 | =item word
|
---|
3296 |
|
---|
3297 | In normal "computerese", the piece of data of the size most
|
---|
3298 | efficiently handled by your computer, typically 32 bits or so, give or
|
---|
3299 | take a few powers of 2. In Perl culture, it more often refers to an
|
---|
3300 | alphanumeric L</identifier> (including underscores), or to a string of
|
---|
3301 | nonwhitespace L<characters|/character> bounded by whitespace or string
|
---|
3302 | boundaries.
|
---|
3303 |
|
---|
3304 | =item working directory
|
---|
3305 |
|
---|
3306 | Your current L</directory>, from which relative pathnames are
|
---|
3307 | interpreted by the L</operating system>. The operating system knows
|
---|
3308 | your current directory because you told it with a
|
---|
3309 | L<chdir|perlfunc/chdir> or because you started out in the place where
|
---|
3310 | your parent L</process> was when you were born.
|
---|
3311 |
|
---|
3312 | =item wrapper
|
---|
3313 |
|
---|
3314 | A program or subroutine that runs some other program or subroutine for
|
---|
3315 | you, modifying some of its input or output to better suit your
|
---|
3316 | purposes.
|
---|
3317 |
|
---|
3318 | =item WYSIWYG
|
---|
3319 |
|
---|
3320 | What You See Is What You Get. Usually used when something that
|
---|
3321 | appears on the screen matches how it will eventually look, like Perl's
|
---|
3322 | L<format|perlfunc/format> declarations. Also used to mean the
|
---|
3323 | opposite of magic because everything works exactly as it appears, as
|
---|
3324 | in the three-argument form of L<open|perlfunc/open>.
|
---|
3325 |
|
---|
3326 | =back
|
---|
3327 |
|
---|
3328 | =head2 X
|
---|
3329 |
|
---|
3330 | =over 4
|
---|
3331 |
|
---|
3332 | =item XS
|
---|
3333 |
|
---|
3334 | An extraordinarily exported, expeditiously excellent, expressly
|
---|
3335 | eXternal Subroutine, executed in existing C or C++ or in an exciting
|
---|
3336 | new extension language called (exasperatingly) XS. Examine L<perlxs>
|
---|
3337 | for the exact explanation or L<perlxstut> for an exemplary unexacting
|
---|
3338 | one.
|
---|
3339 |
|
---|
3340 | =item XSUB
|
---|
3341 |
|
---|
3342 | An external L</subroutine> defined in L</XS>.
|
---|
3343 |
|
---|
3344 | =back
|
---|
3345 |
|
---|
3346 | =head2 Y
|
---|
3347 |
|
---|
3348 | =over 4
|
---|
3349 |
|
---|
3350 | =item yacc
|
---|
3351 |
|
---|
3352 | Yet Another Compiler Compiler. A parser generator without which Perl
|
---|
3353 | probably would not have existed. See the file I<perly.y> in the Perl
|
---|
3354 | source distribution.
|
---|
3355 |
|
---|
3356 | =back
|
---|
3357 |
|
---|
3358 | =head2 Z
|
---|
3359 |
|
---|
3360 | =over 4
|
---|
3361 |
|
---|
3362 | =item zero width
|
---|
3363 |
|
---|
3364 | A subpattern L</assertion> matching the L</null string> between
|
---|
3365 | L<characters|/character>.
|
---|
3366 |
|
---|
3367 | =item zombie
|
---|
3368 |
|
---|
3369 | A process that has died (exited) but whose parent has not yet received
|
---|
3370 | proper notification of its demise by virtue of having called
|
---|
3371 | L<wait|perlfunc/wait> or L<waitpid|perlfunc/waitpid>. If you
|
---|
3372 | L<fork|perlfunc/fork>, you must clean up after your child processes
|
---|
3373 | when they exit, or else the process table will fill up and your system
|
---|
3374 | administrator will Not Be Happy with you.
|
---|
3375 |
|
---|
3376 | =back
|
---|
3377 |
|
---|
3378 | =head1 AUTHOR AND COPYRIGHT
|
---|
3379 |
|
---|
3380 | Based on the Glossary of Programming Perl, Third Edition,
|
---|
3381 | by Larry Wall, Tom Christiansen & Jon Orwant.
|
---|
3382 | Copyright (c) 2000, 1996, 1991 O'Reilly Media, Inc.
|
---|
3383 | This document may be distributed under the same terms as Perl itself.
|
---|