perluniintro.1

视频监控网络部分的协议ddns,的模块的实现代码,请大家大胆指正.

\&\*(L"EBCDIC-safe\*(R".
.Sh "Creating Unicode"
.IX Subsection "Creating Unicode"
To create Unicode characters in literals for code points above \f(CW0xFF\fR,
use the \f(CW\*(C`\ex{...}\*(C'\fR notation in double-quoted strings:
.PP
.Vb 1
\&    my $smiley = "\ex{263a}";
.Ve
.PP
Similarly, it can be used in regular expression literals
.PP
.Vb 1
\&    $smiley =~ /\ex{263a}/;
.Ve
.PP
At run-time you can use \f(CW\*(C`chr()\*(C'\fR:
.PP
.Vb 1
\&    my $hebrew_alef = chr(0x05d0);
.Ve
.PP
See \*(L"Further Resources\*(R" for how to find all these numeric codes.
.PP
Naturally, \f(CW\*(C`ord()\*(C'\fR will do the reverse: it turns a character into
a code point.
.PP
Note that \f(CW\*(C`\ex..\*(C'\fR (no \f(CW\*(C`{}\*(C'\fR and only two hexadecimal digits), \f(CW\*(C`\ex{...}\*(C'\fR,
and \f(CW\*(C`chr(...)\*(C'\fR for arguments less than \f(CW0x100\fR (decimal 256)
generate an eight-bit character for backward compatibility with older
Perls.  For arguments of \f(CW0x100\fR or more, Unicode characters are
always produced. If you want to force the production of Unicode
characters regardless of the numeric value, use \f(CW\*(C`pack("U", ...)\*(C'\fR
instead of \f(CW\*(C`\ex..\*(C'\fR, \f(CW\*(C`\ex{...}\*(C'\fR, or \f(CW\*(C`chr()\*(C'\fR.
.PP
You can also use the \f(CW\*(C`charnames\*(C'\fR pragma to invoke characters
by name in double-quoted strings:
.PP
.Vb 2
\&    use charnames \*(Aq:full\*(Aq;
\&    my $arabic_alef = "\eN{ARABIC LETTER ALEF}";
.Ve
.PP
And, as mentioned above, you can also \f(CW\*(C`pack()\*(C'\fR numbers into Unicode
characters:
.PP
.Vb 1
\&   my $georgian_an  = pack("U", 0x10a0);
.Ve
.PP
Note that both \f(CW\*(C`\ex{...}\*(C'\fR and \f(CW\*(C`\eN{...}\*(C'\fR are compile-time string
constants: you cannot use variables in them.  if you want similar
run-time functionality, use \f(CW\*(C`chr()\*(C'\fR and \f(CW\*(C`charnames::vianame()\*(C'\fR.
.PP
If you want to force the result to Unicode characters, use the special
\&\f(CW"U0"\fR prefix.  It consumes no arguments but causes the following bytes
to be interpreted as the \s-1UTF\-8\s0 encoding of Unicode characters:
.PP
.Vb 1
\&   my $chars = pack("U0W*", 0x80, 0x42);
.Ve
.PP
Likewise, you can stop such \s-1UTF\-8\s0 interpretation by using the special
\&\f(CW"C0"\fR prefix.
.Sh "Handling Unicode"
.IX Subsection "Handling Unicode"
Handling Unicode is for the most part transparent: just use the
strings as usual.  Functions like \f(CW\*(C`index()\*(C'\fR, \f(CW\*(C`length()\*(C'\fR, and
\&\f(CW\*(C`substr()\*(C'\fR will work on the Unicode characters; regular expressions
will work on the Unicode characters (see perlunicode and perlretut).
.PP
Note that Perl considers combining character sequences to be
separate characters, so for example
.PP
.Vb 2
\&    use charnames \*(Aq:full\*(Aq;
\&    print length("\eN{LATIN CAPITAL LETTER A}\eN{COMBINING ACUTE ACCENT}"), "\en";
.Ve
.PP
will print 2, not 1.  The only exception is that regular expressions
have \f(CW\*(C`\eX\*(C'\fR for matching a combining character sequence.
.PP
Life is not quite so transparent, however, when working with legacy
encodings, I/O, and certain special cases:
.Sh "Legacy Encodings"
.IX Subsection "Legacy Encodings"
When you combine legacy data and Unicode the legacy data needs
to be upgraded to Unicode.  Normally \s-1ISO\s0 8859\-1 (or \s-1EBCDIC\s0, if
applicable) is assumed.
.PP
The \f(CW\*(C`Encode\*(C'\fR module knows about many encodings and has interfaces
for doing conversions between those encodings:
.PP
.Vb 2
\&    use Encode \*(Aqdecode\*(Aq;
\&    $data = decode("iso\-8859\-3", $data); # convert from legacy to utf\-8
.Ve
.Sh "Unicode I/O"
.IX Subsection "Unicode I/O"
Normally, writing out Unicode data
.PP
.Vb 1
\&    print FH $some_string_with_unicode, "\en";
.Ve
.PP
produces raw bytes that Perl happens to use to internally encode the
Unicode string.  Perl's internal encoding depends on the system as
well as what characters happen to be in the string at the time. If
any of the characters are at code points \f(CW0x100\fR or above, you will get
a warning.  To ensure that the output is explicitly rendered in the
encoding you desire\*(--and to avoid the warning\*(--open the stream with
the desired encoding. Some examples:
.PP
.Vb 1
\&    open FH, ">:utf8", "file";
\&
\&    open FH, ">:encoding(ucs2)",      "file";
\&    open FH, ">:encoding(UTF\-8)",     "file";
\&    open FH, ">:encoding(shift_jis)", "file";
.Ve
.PP
and on already open streams, use \f(CW\*(C`binmode()\*(C'\fR:
.PP
.Vb 1
\&    binmode(STDOUT, ":utf8");
\&
\&    binmode(STDOUT, ":encoding(ucs2)");
\&    binmode(STDOUT, ":encoding(UTF\-8)");
\&    binmode(STDOUT, ":encoding(shift_jis)");
.Ve
.PP
The matching of encoding names is loose: case does not matter, and
many encodings have several aliases.  Note that the \f(CW\*(C`:utf8\*(C'\fR layer
must always be specified exactly like that; it is \fInot\fR subject to
the loose matching of encoding names. Also note that \f(CW\*(C`:utf8\*(C'\fR is unsafe for
input, because it accepts the data without validating that it is indeed valid
\&\s-1UTF8\s0.
.PP
See PerlIO for the \f(CW\*(C`:utf8\*(C'\fR layer, PerlIO::encoding and
Encode::PerlIO for the \f(CW\*(C`:encoding()\*(C'\fR layer, and
Encode::Supported for many encodings supported by the \f(CW\*(C`Encode\*(C'\fR
module.
.PP
Reading in a file that you know happens to be encoded in one of the
Unicode or legacy encodings does not magically turn the data into
Unicode in Perl's eyes.  To do that, specify the appropriate
layer when opening files
.PP
.Vb 2
\&    open(my $fh,\*(Aq<:encoding(utf8)\*(Aq, \*(Aqanything\*(Aq);
\&    my $line_of_unicode = <$fh>;
\&
\&    open(my $fh,\*(Aq<:encoding(Big5)\*(Aq, \*(Aqanything\*(Aq);
\&    my $line_of_unicode = <$fh>;
.Ve
.PP
The I/O layers can also be specified more flexibly with
the \f(CW\*(C`open\*(C'\fR pragma.  See open, or look at the following example.
.PP
.Vb 7
\&    use open \*(Aq:encoding(utf8)\*(Aq; # input/output default encoding will be UTF\-8
\&    open X, ">file";
\&    print X chr(0x100), "\en";
\&    close X;
\&    open Y, "<file";
\&    printf "%#x\en", ord(<Y>); # this should print 0x100
\&    close Y;
.Ve
.PP
With the \f(CW\*(C`open\*(C'\fR pragma you can use the \f(CW\*(C`:locale\*(C'\fR layer
.PP
.Vb 9
\&    BEGIN { $ENV{LC_ALL} = $ENV{LANG} = \*(Aqru_RU.KOI8\-R\*(Aq }
\&    # the :locale will probe the locale environment variables like LC_ALL
\&    use open OUT => \*(Aq:locale\*(Aq; # russki parusski
\&    open(O, ">koi8");
\&    print O chr(0x430); # Unicode CYRILLIC SMALL LETTER A = KOI8\-R 0xc1
\&    close O;
\&    open(I, "<koi8");
\&    printf "%#x\en", ord(<I>), "\en"; # this should print 0xc1
\&    close I;
.Ve
.PP
These methods install a transparent filter on the I/O stream that
converts data from the specified encoding when it is read in from the
stream.  The result is always Unicode.
.PP
The open pragma affects all the \f(CW\*(C`open()\*(C'\fR calls after the pragma by
setting default layers.  If you want to affect only certain
streams, use explicit layers directly in the \f(CW\*(C`open()\*(C'\fR call.
.PP
You can switch encodings on an already opened stream by using
\&\f(CW\*(C`binmode()\*(C'\fR; see \*(L"binmode\*(R" in perlfunc.
.PP
The \f(CW\*(C`:locale\*(C'\fR does not currently (as of Perl 5.8.0) work with
\&\f(CW\*(C`open()\*(C'\fR and \f(CW\*(C`binmode()\*(C'\fR, only with the \f(CW\*(C`open\*(C'\fR pragma.  The
\&\f(CW\*(C`:utf8\*(C'\fR and \f(CW\*(C`:encoding(...)\*(C'\fR methods do work with all of \f(CW\*(C`open()\*(C'\fR,
\&\f(CW\*(C`binmode()\*(C'\fR, and the \f(CW\*(C`open\*(C'\fR pragma.
.PP
Similarly, you may use these I/O layers on output streams to
automatically convert Unicode to the specified encoding when it is
written to the stream. For example, the following snippet copies the
contents of the file \*(L"text.jis\*(R" (encoded as \s-1ISO\-2022\-JP\s0, aka \s-1JIS\s0) to
the file \*(L"text.utf8\*(R", encoded as \s-1UTF\-8:\s0
.PP
.Vb 3
\&    open(my $nihongo, \*(Aq<:encoding(iso\-2022\-jp)\*(Aq, \*(Aqtext.jis\*(Aq);
\&    open(my $unicode, \*(Aq>:utf8\*(Aq,                  \*(Aqtext.utf8\*(Aq);
\&    while (<$nihongo>) { print $unicode $_ }
.Ve
.PP
The naming of encodings, both by the \f(CW\*(C`open()\*(C'\fR and by the \f(CW\*(C`open\*(C'\fR
pragma allows for flexible names: \f(CW\*(C`koi8\-r\*(C'\fR and \f(CW\*(C`KOI8R\*(C'\fR will both be
understood.
.PP
Common encodings recognized by \s-1ISO\s0, \s-1MIME\s0, \s-1IANA\s0, and various other
standardisation organisations are recognised; for a more detailed
list see Encode::Supported.
.PP
\&\f(CW\*(C`read()\*(C'\fR reads characters and returns the number of characters.
\&\f(CW\*(C`seek()\*(C'\fR and \f(CW\*(C`tell()\*(C'\fR operate on byte counts, as do \f(CW\*(C`sysread()\*(C'\fR
and \f(CW\*(C`sysseek()\*(C'\fR.
.PP
Notice that because of the default behaviour of not doing any
conversion upon input if there is no default layer,
it is easy to mistakenly write code that keeps on expanding a file
by repeatedly encoding the data:
.PP
.Vb 8
\&    # BAD CODE WARNING
\&    open F, "file";
\&    local $/; ## read in the whole file of 8\-bit characters
\&    $t = <F>;
\&    close F;
\&    open F, ">:encoding(utf8)", "file";
\&    print F $t; ## convert to UTF\-8 on output
\&    close F;
.Ve
.PP
If you run this code twice, the contents of the \fIfile\fR will be twice
\&\s-1UTF\-8\s0 encoded.  A \f(CW\*(C`use open \*(Aq:encoding(utf8)\*(Aq\*(C'\fR would have avoided the
bug, or explicitly opening also the \fIfile\fR for input as \s-1UTF\-8\s0.
.PP
\&\fB\s-1NOTE\s0\fR: the \f(CW\*(C`:utf8\*(C'\fR and \f(CW\*(C`:encoding\*(C'\fR features work only if your
Perl has been built with the new PerlIO feature (which is the default
on most systems).
.Sh "Displaying Unicode As Text"
.IX Subsection "Displaying Unicode As Text"
Sometimes you might want to display Perl scalars containing Unicode as
simple \s-1ASCII\s0 (or \s-1EBCDIC\s0) text.  The following subroutine converts
its argument so that Unicode characters with code points greater than
255 are displayed as \f(CW\*(C`\ex{...}\*(C'\fR, control characters (like \f(CW\*(C`\en\*(C'\fR) are
displayed as \f(CW\*(C`\ex..\*(C'\fR, and the rest of the characters as themselves:
.PP
.Vb 9
\&   sub nice_string {
\&       join("",
\&         map { $_ > 255 ?                  # if wide character...
\&               sprintf("\e\ex{%04X}", $_) :  # \ex{...}
\&               chr($_) =~ /[[:cntrl:]]/ ?  # else if control character ...
\&               sprintf("\e\ex%02X", $_) :    # \ex..
\&               quotemeta(chr($_))          # else quoted or as themselves
\&         } unpack("W*", $_[0]));           # unpack Unicode characters
\&   }
.Ve
.PP
For example,
.PP
.Vb 1
\&   nice_string("foo\ex{100}bar\en")
.Ve
.PP
returns the string
.PP
.Vb 1
\&   \*(Aqfoo\ex{0100}bar\ex0A\*(Aq
.Ve
.PP
which is ready to be printed.
.Sh "Special Cases"
.IX Subsection "Special Cases"
.IP "\(bu" 4
Bit Complement Operator ~ And \fIvec()\fR
.Sp
The bit complement operator \f(CW\*(C`~\*(C'\fR may produce surprising results if
used on strings containing characters with ordinal values above
255. In such a case, the results are consistent with the internal
encoding of the characters, but not with much else. So don't do
that. Similarly for \f(CW\*(C`vec()\*(C'\fR: you will be operating on the
internally-encoded bit patterns of the Unicode characters, not on
the code point values, which is very probably not what you want.
.IP "\(bu" 4
Peeking At Perl's Internal Encoding
.Sp
Normal users of Perl should never care how Perl encodes any particular
Unicode string (because the normal ways to get at the contents of a
string with Unicode\*(--via input and output\*(--should always be via
explicitly-defined I/O layers). But if you must, there are two
ways of looking behind the scenes.
.Sp
One way of peeking inside the internal encoding of Unicode characters
is to use \f(CW\*(C`unpack("C*", ...\*(C'\fR to get the bytes of whatever the string
encoding happens to be, or \f(CW\*(C`unpack("U0..", ...)\*(C'\fR to get the bytes of the
\&\s-1UTF\-8\s0 encoding:
.Sp
.Vb 2
\&    # this prints  c4 80  for the UTF\-8 bytes 0xc4 0x80
\&    print join(" ", unpack("U0(H2)*", pack("U", 0x100))), "\en";
.Ve
.Sp
Yet another way would be to use the Devel::Peek module:
.Sp
.Vb 1
\&    perl \-MDevel::Peek \-e \*(AqDump(chr(0x100))\*(Aq
.Ve
.Sp
That shows the \f(CW\*(C`UTF8\*(C'\fR flag in \s-1FLAGS\s0 and both the \s-1UTF\-8\s0 bytes
and Unicode characters in \f(CW\*(C`PV\*(C'\fR.  See also later in this document
the discussion about the \f(CW\*(C`utf8::is_utf8()\*(C'\fR function.
.Sh "Advanced Topics"
.IX Subsection "Advanced Topics"
.IP "\(bu" 4
String Equivalence
.Sp
The question of string equivalence turns somewhat complicated
in Unicode: what do you mean by \*(L"equal\*(R"?
.Sp
(Is \f(CW\*(C`LATIN CAPITAL LETTER A WITH ACUTE\*(C'\fR equal to
\&\f(CW\*(C`LATIN CAPITAL LETTER A\*(C'\fR?)
.Sp
The short answer is that by default Perl compares equivalence (\f(CW\*(C`eq\*(C'\fR,
\&\f(CW\*(C`ne\*(C'\fR) based only on code points of the characters.  In the above
case, the answer is no (because 0x00C1 != 0x0041).  But sometimes, any
\&\s-1CAPITAL\s0 \s-1LETTER\s0 As should be considered equal, or even As of any case.
.Sp
The long answer is that you need to consider character normalization
and casing issues: see Unicode::Normalize, Unicode Technical
Reports #15 and #21, \fIUnicode Normalization Forms\fR and \fICase
Mappings\fR, http://www.unicode.org/unicode/reports/tr15/ and
http://www.unicode.org/unicode/reports/tr21/
.Sp
As of Perl 5.8.0, the \*(L"Full\*(R" case-folding of \fICase