gloss.htm

编程珍珠,里面很多好用的代码,大家可以参考学习呵呵,

inheritance) <em class="emphasis">methods</em> (that is,
<em class="emphasis">subroutines</em>) to handle
<em class="emphasis">instances</em> of the class (its
<em class="emphasis">objects</em>).  See also
<em class="emphasis">inheritance</em>.
</p>
</dd>
</dl>

<dl>
<dt>class method</dt>
<dd>
<p>
<a name="INDEX-"></a><a name="INDEX-"></a>
A <em class="emphasis">method</em> whose <em class="emphasis">invocant</em> is a
<em class="emphasis">package</em> name, not an <em class="emphasis">object</em>
reference.  A method associated with the class as a whole.
</p>
</dd>
</dl>

<dl>
<dt>client</dt>
<dd>
<p>
<a name="INDEX-"></a>
In networking, a <em class="emphasis">process</em> that initiates contact
with a <em class="emphasis">server</em> process in order to exchange data
and perhaps receive a service.
</p>
</dd>
</dl>

<dl>
<dt>cloister</dt>
<dd>
<p>
<a name="INDEX-"></a><a name="INDEX-"></a>
A <em class="emphasis">cluster</em> used to restrict the scope of a
<em class="emphasis">regular expression modifier</em>.
</p>
</dd>
</dl>

<dl>
<dt>closure</dt>
<dd>
<p>
<a name="INDEX-"></a>
An <em class="emphasis">anonymous</em> subroutine that, when a reference
to it is generated at run time, keeps track of the identities of
externally visible <em class="emphasis">lexical variables</em> even after
those lexical variables have supposedly gone out of
<em class="emphasis">scope</em>.  They're called "closures" because this
sort of behavior gives mathematicians a sense of closure.
</p>
</dd>
</dl>

<dl>
<dt>cluster</dt>
<dd>
<p>
A parenthesized <em class="emphasis">subpattern</em> used to group parts
of a <em class="emphasis">regular expression</em>
into a single <em class="emphasis">atom</em>.
</p>
</dd>
</dl>

<dl>
<dt>CODE</dt>
<dd>
<p>
The word returned by the <tt class="literal">ref</tt> function when you apply it to
a reference to a subroutine.  See also <em class="emphasis">CV</em>.
</p>
</dd>
</dl>

<dl>
<dt>code generator</dt>
<dd>
<p>
<a name="INDEX-"></a>
A system that writes code for you in a low-level language, such as code
to implement the&nbsp;backend of a compiler.  See <em class="emphasis">program
generator</em>.
</p>
</dd>
</dl>

<dl>
<dt>code subpattern</dt>
<dd>
<p>
<a name="INDEX-"></a>
A <em class="emphasis">regular expression</em> subpattern whose real
purpose is to execute some Perl code, for example, the
<tt class="literal">(?{...})</tt> and <tt class="literal">(??{...})</tt>
subpatterns.
</p>
</dd>
</dl>

<dl>
<dt>collating sequence</dt>
<dd>
<p>
<a name="INDEX-"></a>
The order into which <em class="emphasis">characters</em> sort.  This is
used by <em class="emphasis">string</em> comparison routines to decide, for
example, where in this glossary to put "collating sequence".
</p>
</dd>
</dl>

<dl>
<dt>command</dt>
<dd>
<p>
<a name="INDEX-"></a>
In <em class="emphasis">shell</em> programming, the syntactic combination
of a program name and its arguments.  More loosely, anything you type
to a shell (a command interpreter) that starts it doing something.
Even more loosely, a Perl <em class="emphasis">statement</em>, which might
start with a <em class="emphasis">label</em> and typically ends with a
semicolon.
</p>
</dd>
</dl>

<a name="INDEX-"></a>
<dl>
<dt>command buffering</dt>
<dd>
<p>
<a name="INDEX-"></a><a name="INDEX-"></a>
A mechanism in Perl that lets you store up the output of each Perl
<em class="emphasis">command</em> and then flush it out as a single request
to the <em class="emphasis">operating system</em>.  It's enabled by setting
the <tt class="literal">$|</tt> (<tt class="literal">$AUTOFLUSH</tt>) variable to
a true value.  It's used when you don't want data sitting around not
going where it's supposed to, which may happen because the default on
a <em class="emphasis">file</em> or <em class="emphasis">pipe</em> is to use
<em class="emphasis">block buffering</em>.
</p>
</dd>
</dl>

<dl>
<dt>command name</dt>
<dd>
<p>
T<a name="INDEX-"></a>
he name of the program currently executing, as typed on the command
line.  In C, the <em class="emphasis">command</em> name is passed to the
program as the first command-line argument.  In Perl, it comes in
separately as <tt class="literal">$0</tt>.
</p>
</dd>
</dl>

<dl>
<dt>command-line arguments</dt>
<dd>
<p>
<a name="INDEX-"></a><a name="INDEX-"></a>
The <em class="emphasis">values</em> you supply along with a program name
when you tell a <em class="emphasis">shell</em> to execute a
<em class="emphasis">command</em>.  These values are passed to a Perl
program through <tt class="literal">@ARGV</tt>.
</p>
</dd>
</dl>

<dl>
<dt>comment</dt>
<dd>
<p>
<a name="INDEX-"></a>
A remark that doesn't affect the meaning of the program.  In Perl, a
comment is introduced by a <tt class="literal">#</tt> character and
continues to the end of the line.
</p>
</dd>
</dl>

<dl>
<dt>compilation unit</dt>
<dd>
<p>
<a name="INDEX-"></a>
The <em class="emphasis">file</em> (or <em class="emphasis">string</em>, in the case of <tt class="literal">eval</tt>) that is currently being
compiled.
</p>
</dd>
</dl>

<dl>
<dt>compile phase</dt>
<dd>
<p>
<a name="INDEX-"></a>
Any time before Perl starts running your main program.  See also
<em class="emphasis">run phase</em>.  Compile phase is mostly spent in
<em class="emphasis">compile time</em>, but may also be spent in
<em class="emphasis">run time</em> when <tt class="literal">BEGIN</tt> blocks,
<tt class="literal">use</tt> declarations, or constant subexpressions are
being evaluated.  The startup and import code of any
<tt class="literal">use</tt> declaration is also run during compile phase.
</p>
</dd>
</dl>

<dl>
<dt>compile time</dt>
<dd>
<p>
<a name="INDEX-"></a>
The time when Perl is trying to make sense of your code, as opposed
to when it thinks it knows what your code means and is merely trying
to do what it thinks your code says to do, which is <em class="emphasis">run
time</em>.
</p>
</dd>
</dl>

<dl>
<dt>compiler</dt>
<dd>
<p>
<a name="INDEX-"></a>
Strictly speaking, a program that munches up another program and spits
out yet another file containing the program in a "more executable"
form, typically containing native machine instructions.  The
<em class="emphasis">perl</em> program is not a compiler by this
definition, but it does contain a kind of compiler that takes a
program and turns it into a more executable form (<em class="emphasis">syntax
trees</em>) within the <em class="emphasis">perl</em> process itself,
which the <em class="emphasis">interpreter</em> then interprets.  There
are, however, extension <em class="emphasis">modules</em> to get Perl to
act more like a "real" compiler.  See <a href="ch18_01.htm">Chapter 18, "Compiling"</a>.
</p>
</dd>
</dl>

<dl>
<dt>composer</dt>
<dd>
<p>
<a name="INDEX-"></a>
A "constructor" for a <em class="emphasis">referent</em> that isn't really
an <em class="emphasis">object</em>, like an anonymous array or a hash
(or a sonata, for that matter).  For example, a pair of braces
acts as a composer for a hash, and a pair of brackets acts as a
composer for an array.  See the section "Creating References" in
<a href="ch08_01.htm">Chapter 8, "References"</a>.
</p>
</dd>
</dl>

<dl>
<dt>concatenation</dt>
<dd>
<p>
<a name="INDEX-"></a>
The process of gluing one cat's nose to another cat's tail.
Also, a similar operation on two <em class="emphasis">strings</em>.
</p>
</dd>
</dl>

<dl>
<dt>conditional</dt>
<dd>
<p>
Something "iffy".  See <em class="emphasis">Boolean context</em>.
</p>
</dd>
</dl>

<dl>
<dt>connection</dt>
<dd>
<p>
<a name="INDEX-"></a><a name="INDEX-"></a>
In telephony, the temporary electrical circuit between the caller's
and the callee's phone.  In networking, the same kind of temporary
circuit between a <em class="emphasis">client</em> and a <em class="emphasis">server</em>.
</p>
</dd>
</dl>

<dl>
<dt>construct</dt>
<dd>
<p>
As a noun, a piece of syntax made up of smaller pieces.  As a transitive
verb, to create an <em class="emphasis">object</em> using a <em class="emphasis">constructor</em>.
</p>
</dd>
</dl>

<dl>
<dt>constructor</dt>
<dd>
<p>
<a name="INDEX-"></a>
Any <em class="emphasis">class method</em>, <em class="emphasis">instance method</em>, or <em class="emphasis">subroutine</em> that
composes, initializes, blesses, and returns an <em class="emphasis">object</em>.  Sometimes
we use the term loosely to mean a <em class="emphasis">composer</em>.
</p>
</dd>
</dl>

<dl>
<dt>context</dt>
<dd>
<p>
<a name="INDEX-"></a><a name="INDEX-"></a><a name="INDEX-"></a><a name="INDEX-"></a><a name="INDEX-"></a><a name="INDEX-"></a>
The surroundings, or environment.  The context given by the
surrounding code determines what kind of data a particular
<em class="emphasis">expression</em> is expected to return.  The three
primary contexts are <em class="emphasis">list context</em>,
<em class="emphasis">scalar context</em>, and <em class="emphasis">void
context</em>.  Scalar context is sometimes subdivided into
<em class="emphasis">Boolean context</em>, <em class="emphasis">numeric
context</em>, <em class="emphasis">string context</em>, and
<em class="emphasis">void context</em>.  There's
also a "don't care" context (which is dealt with in <a href="ch02_01.htm">Chapter 2, "Bits and Pieces"</a>, if you care).
</p>
</dd>
</dl>

<dl>
<dt>continuation</dt>
<dd>
<p>
<a name="INDEX-"></a>
The treatment of more than one physical <em class="emphasis">line</em> as a
single logical line.  <em class="emphasis">Makefile</em> lines are
continued by putting a backslash before the
<em class="emphasis">newline</em>.  Mail headers as defined by RFC 822 are
continued by putting a space or tab <em class="emphasis">after</em> the
newline.  In general, lines in Perl do not need any form of
continuation mark, because <em class="emphasis">whitespace</em> (including
newlines) is gleefully ignored.  Usually.
</p>
</dd>
</dl>

<dl>
<dt>core dump</dt>
<dd>
<p>
<a name="INDEX-"></a>
The corpse of a <em class="emphasis">process</em>, in the form of a file
left in the <em class="emphasis">working directory</em> of the process,
usually as a result of certain kinds of fatal error.
</p>
</dd>
</dl>

<dl>
<dt>CPAN</dt>
<dd>
<p>
<a name="INDEX-"></a>
The Comprehensive Perl Archive Network.  (See the Preface and
<a href="ch22_01.htm">Chapter 22, "CPAN"</a>, for details.)
</p>
</dd>
</dl>

<dl>
<dt>cracker</dt>
<dd>
<p>
<a name="INDEX-"></a><a name="INDEX-"></a>
Someone who breaks security on computer systems.  A cracker may be a true
<em class="emphasis">hacker</em> or only a <em class="emphasis">script kiddie</em>.
</p>
</dd>
</dl>

<dl>
<dt>current package</dt>
<dd>
<p>
<a name="INDEX-"></a><a name="INDEX-"></a>
The <em class="emphasis">package</em> in which the current statement is
compiled.  Scan backwards in the text of your program through the current
<em class="emphasis">lexical scope</em> or any enclosing lexical scopes
till you find a package declaration.  That's your current package
name.
</p>
</dd>
</dl>

<dl>
<dt>current working directory</dt>
<dd>
<p>
See <em class="emphasis">working directory</em>.
</p>
</dd>
</dl>

<dl>
<dt>currently selected output channel</dt>
<dd>
<p>
<a name="INDEX-"></a><a name="INDEX-"></a>
The last <em class="emphasis">filehandle</em> that was designated with <tt class="literal">select(FILEHANDLE)</tt>;
<tt class="literal">STDOUT</tt>, if no filehandle has been selected.
</p>
</dd>
</dl>

<dl>
<dt>CV</dt>
<dd>
<p>
<a name="INDEX-"></a>
An internal "code value" typedef, holding a <em class="emphasis">subroutine</em>.  The <tt class="literal">CV</tt> type is a subclass of <em class="emphasis">SV</em>.
</p>
</dd>
</dl>

<dl>
<dt>dangling statement</dt>
<dd>
<p>
<a name="INDEX-"></a><a name="INDEX-"></a>
A bare, single <em class="emphasis">statement</em>, without any braces, hanging off an
<tt class="literal">if</tt> or <tt class="literal">while</tt> conditional.  C allows them.  Perl doesn't.
</p>
</dd>
</dl>

<dl>
<dt>data structure</dt>
<dd>
<p>
<a name="INDEX-"></a>
How your various pieces of data relate to each other and what shape
they make when you put them all together, as in a rectangular table
or a triangular-shaped tree.
</p>
</dd>
</dl>

<dl>
<dt>data type</dt>
<dd>
<p>
<a name="INDEX-"></a><a name="INDEX-"></a>
A set of possible values, together with all the operations that
know how to deal with those values.  For example, a numeric data
type has a certain set of numbers that you can work with and various
mathematical operations that you can do on the numbers but would
make little sense on, say, a string such as
<tt class="literal">"Kilroy"</tt>.  Strings have their own operations,
such as <em class="emphasis">concatenation</em>.  Compound
types made of a number of smaller pieces generally have operations
to compose and decompose them, and perhaps to rearrange them.
<em class="emphasis">Objects</em> that model things in the real world
often have operations that correspond to real activities.  For
instance, if you model an elevator, your elevator object might
have an <tt class="literal">open_door()</tt><em class="emphasis">method</em>.
</p>
</dd>
</dl>

<dl>
<dt>datagram</dt>
<dd>
<p>
<a name="INDEX-"></a>
A packet of data, such as a <em class="emphasis">UDP</em> message, that
(from the viewpoint of the programs involved) can be sent
independently over the network.  (In fact, all packets are sent
independently at the <em class="emphasis">IP</em> level, but
<em class="emphasis">stream</em> protocols such as <em class="emphasis">TCP</em>
hide this from your program.)
</p>
</dd>
</dl>

<dl>
<dt>DBM</dt>