perlglossary.pod

来自「视频监控网络部分的协议ddns,的模块的实现代码,请大家大胆指正.」· POD 代码 · 共 1,930 行 · 第 1/5 页

=item flush

The act of emptying a L</buffer>, often before it's full.

=item FMTEYEWTK

Far More Than Everything You Ever Wanted To Know.  An exhaustive
treatise on one narrow topic, something of a super-L</FAQ>.  See Tom
for far more.

=item fork

To create a child L</process> identical to the parent process at its
moment of conception, at least until it gets ideas of its own.  A
thread with protected memory.

=item formal arguments

The generic names by which a L</subroutine> knows its
L<arguments|/argument>.  In many languages, formal arguments are
always given individual names, but in Perl, the formal arguments are
just the elements of an array.  The formal arguments to a Perl program
are C<$ARGV[0]>, C<$ARGV[1]>, and so on.  Similarly, the formal
arguments to a Perl subroutine are C<$_[0]>, C<$_[1]>, and so on.  You
may give the arguments individual names by assigning the values to a
L<my|perlfunc/my> list.  See also L</actual arguments>.

=item format

A specification of how many spaces and digits and things to put
somewhere so that whatever you're printing comes out nice and pretty.

=item freely available

Means you don't have to pay money to get it, but the copyright on it
may still belong to someone else (like Larry).

=item freely redistributable

Means you're not in legal trouble if you give a bootleg copy of it to
your friends and we find out about it.  In fact, we'd rather you gave
a copy to all your friends.

=item freeware

Historically, any software that you give away, particularly if you
make the source code available as well.  Now often called C<open
source software>.  Recently there has been a trend to use the term in
contradistinction to L</open source software>, to refer only to free
software released under the Free Software Foundation's GPL (General
Public License), but this is difficult to justify etymologically.

=item function

Mathematically, a mapping of each of a set of input values to a
particular output value.  In computers, refers to a L</subroutine> or
L</operator> that returns a L</value>.  It may or may not have input
values (called L<arguments|/argument>).

=item funny character

Someone like Larry, or one of his peculiar friends.  Also refers to
the strange prefixes that Perl requires as noun markers on its
variables.

=item garbage collection

A misnamed feature--it should be called, "expecting your mother to
pick up after you".  Strictly speaking, Perl doesn't do this, but it
relies on a reference-counting mechanism to keep things tidy.
However, we rarely speak strictly and will often refer to the
reference-counting scheme as a form of garbage collection.  (If it's
any comfort, when your interpreter exits, a "real" garbage collector
runs to make sure everything is cleaned up if you've been messy with
circular references and such.)

=back

=head2 G

=over 4

=item GID

Group ID--in Unix, the numeric group ID that the L</operating system>
uses to identify you and members of your L</group>.

=item glob

Strictly, the shell's C<*> character, which will match a "glob" of
characters when you're trying to generate a list of filenames.
Loosely, the act of using globs and similar symbols to do pattern
matching.  See also L</fileglob> and L</typeglob>.

=item global

Something you can see from anywhere, usually used of
L<variables|/variable> and L<subroutines|/subroutine> that are visible
everywhere in your program.  In Perl, only certain special variables
are truly global--most variables (and all subroutines) exist only in
the current L</package>.  Global variables can be declared with
L<our|perlfunc/our>.  See L<perlfunc/our>.

=item global destruction

The L</garbage collection> of globals (and the running of any
associated object destructors) that takes place when a Perl
L</interpreter> is being shut down.  Global destruction should not be
confused with the Apocalypse, except perhaps when it should.

=item glue language

A language such as Perl that is good at hooking things together that
weren't intended to be hooked together.

=item granularity

The size of the pieces you're dealing with, mentally speaking.

=item greedy

A L</subpattern> whose L</quantifier> wants to match as many things as
possible.

=item grep

Originally from the old Unix editor command for "Globally search for a
Regular Expression and Print it", now used in the general sense of any
kind of search, especially text searches.  Perl has a built-in
L<grep|perlfunc/grep> function that searches a list for elements
matching any given criterion, whereas the I<grep>(1) program searches
for lines matching a L</regular expression> in one or more files.

=item group

A set of users of which you are a member.  In some operating systems
(like Unix), you can give certain file access permissions to other
members of your group.

=item GV

An internal "glob value" typedef, holding a L</typeglob>.  The L</GV>
type is a subclass of L</SV>.

=back

=head2 H

=over 4

=item hacker

Someone who is brilliantly persistent in solving technical problems,
whether these involve golfing, fighting orcs, or programming.  Hacker
is a neutral term, morally speaking.  Good hackers are not to be
confused with evil L<crackers|/cracker> or clueless L<script
kiddies|/script kiddie>.  If you confuse them, we will presume that
you are either evil or clueless.

=item handler

A L</subroutine> or L</method> that is called by Perl when your
program needs to respond to some internal event, such as a L</signal>,
or an encounter with an operator subject to L</operator overloading>.
See also L</callback>.

=item hard reference

A L</scalar> L</value> containing the actual address of a
L</referent>, such that the referent's L</reference> count accounts
for it.  (Some hard references are held internally, such as the
implicit reference from one of a L</typeglob>'s variable slots to its
corresponding referent.)  A hard reference is different from a
L</symbolic reference>.

=item hash

An unordered association of L</key>/L</value> pairs, stored such that
you can easily use a string L</key> to look up its associated data
L</value>.  This glossary is like a hash, where the word to be defined
is the key, and the definition is the value.  A hash is also sometimes
septisyllabically called an "associative array", which is a pretty
good reason for simply calling it a "hash" instead.

=item hash table

A data structure used internally by Perl for implementing associative
arrays (hashes) efficiently.  See also L</bucket>.

=item header file

A file containing certain required definitions that you must include
"ahead" of the rest of your program to do certain obscure operations.
A C header file has a I<.h> extension.  Perl doesn't really have
header files, though historically Perl has sometimes used translated
I<.h> files with a I<.ph> extension.  See L<perlfunc/require>.
(Header files have been superseded by the L</module> mechanism.)

=item here document

So called because of a similar construct in L<shells|/shell> that
pretends that the L<lines|/line> following the L</command> are a
separate L</file> to be fed to the command, up to some terminating
string.  In Perl, however, it's just a fancy form of quoting.

=item hexadecimal

A number in base 16, "hex" for short.  The digits for 10 through 16
are customarily represented by the letters C<a> through C<f>.
Hexadecimal constants in Perl start with C<0x>.  See also
L<perlfunc/hex>.

=item home directory

The directory you are put into when you log in.  On a Unix system, the
name is often placed into C<$ENV{HOME}> or C<$ENV{LOGDIR}> by
I<login>, but you can also find it with C<(getpwuid($E<lt>))[7]>.
(Some platforms do not have a concept of a home directory.)

=item host

The computer on which a program or other data resides.

=item hubris

Excessive pride, the sort of thing Zeus zaps you for.  Also the
quality that makes you write (and maintain) programs that other people
won't want to say bad things about.  Hence, the third great virtue of
a programmer.  See also L</laziness> and L</impatience>.

=item HV

Short for a "hash value" typedef, which holds Perl's internal
representation of a hash.  The L</HV> type is a subclass of L</SV>.

=back

=head2 I

=over 4

=item identifier

A legally formed name for most anything in which a computer program
might be interested.  Many languages (including Perl) allow
identifiers that start with a letter and contain letters and digits.
Perl also counts the underscore character as a valid letter.  (Perl
also has more complicated names, such as L</qualified> names.)

=item impatience

The anger you feel when the computer is being lazy.  This makes you
write programs that don't just react to your needs, but actually
anticipate them.  Or at least that pretend to.  Hence, the second
great virtue of a programmer.  See also L</laziness> and L</hubris>.

=item implementation

How a piece of code actually goes about doing its job.  Users of the
code should not count on implementation details staying the same
unless they are part of the published L</interface>.

=item import

To gain access to symbols that are exported from another module.  See
L<perlfunc/use>.

=item increment

To increase the value of something by 1 (or by some other number, if
so specified).

=item indexing

In olden days, the act of looking up a L</key> in an actual index
(such as a phone book), but now merely the act of using any kind of
key or position to find the corresponding L</value>, even if no index
is involved.  Things have degenerated to the point that Perl's
L<index|perlfunc/index> function merely locates the position (index)
of one string in another.

=item indirect filehandle

An L</expression> that evaluates to something that can be used as a
L</filehandle>: a L</string> (filehandle name), a L</typeglob>, a
typeglob L</reference>, or a low-level L</IO> object.

=item indirect object

In English grammar, a short noun phrase between a verb and its direct
object indicating the beneficiary or recipient of the action.  In
Perl, C<print STDOUT "$foo\n";> can be understood as "verb
indirect-object object" where L</STDOUT> is the recipient of the
L<print|perlfunc/print> action, and C<"$foo"> is the object being
printed.  Similarly, when invoking a L</method>, you might place the
invocant between the method and its arguments:

  $gollum = new Pathetic::Creature "Smeagol";
  give $gollum "Fisssssh!";
  give $gollum "Precious!";

=item indirect object slot

The syntactic position falling between a method call and its arguments
when using the indirect object invocation syntax.  (The slot is
distinguished by the absence of a comma between it and the next
argument.) L</STDERR> is in the indirect object slot here:

  print STDERR "Awake!  Awake!  Fear, Fire,
      Foes!  Awake!\n";

=item indirection

If something in a program isn't the value you're looking for but
indicates where the value is, that's indirection.  This can be done
with either L<symbolic references|/symbolic reference> or L<hard
references|/hard reference>.

=item infix

An L</operator> that comes in between its L<operands|/operand>, such
as multiplication in C<24 * 7>.

=item inheritance

What you get from your ancestors, genetically or otherwise.  If you
happen to be a L</class>, your ancestors are called L<base
classes|/base class> and your descendants are called L<derived
classes|/derived class>.  See L</single inheritance> and L</multiple
inheritance>.

=item instance

Short for "an instance of a class", meaning an L</object> of that L</class>.

=item instance variable

An L</attribute> of an L</object>; data stored with the particular
object rather than with the class as a whole.

=item integer

A number with no fractional (decimal) part.  A counting number, like
1, 2, 3, and so on, but including 0 and the negatives.

=item interface

The services a piece of code promises to provide forever, in contrast to
its L</implementation>, which it should feel free to change whenever it
likes.

=item interpolation

The insertion of a scalar or list value somewhere in the middle of
another value, such that it appears to have been there all along.  In
Perl, variable interpolation happens in double-quoted strings and
patterns, and list interpolation occurs when constructing the list of
values to pass to a list operator or other such construct that takes a
L</LIST>.

=item interpreter

Strictly speaking, a program that reads a second program and does what
the second program says directly without turning the program into a
different form first, which is what L<compilers|/compiler> do.  Perl
is not an interpreter by this definition, because it contains a kind
of compiler that takes a program and turns it into a more executable
form (L<syntax trees|/syntax tree>) within the I<perl> process itself,
which the Perl L</run time> system then interprets.

=item invocant

The agent on whose behalf a L</method> is invoked.  In a L</class>
method, the invocant is a package name.  In an L</instance> method,
the invocant is an object reference.

=item invocation

The act of calling up a deity, daemon, program, method, subroutine, or
function to get it do what you think it's supposed to do.  We usually
"call" subroutines but "invoke" methods, since it sounds cooler.

=item I/O

Input from, or output to, a L</file> or L</device>.