This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Move typeglob test from glob.t to gv.t.
[perl5.git] / pod / perluniintro.pod
CommitLineData
ba62762e
JH
1=head1 NAME
2
07fcf8ff 3perluniintro - Perl Unicode introduction
ba62762e
JH
4
5=head1 DESCRIPTION
6
7This document gives a general idea of Unicode and how to use Unicode
8in Perl.
9
10=head2 Unicode
11
12Unicode is a character set standard with plans to cover all of the
13writing systems of the world, plus many other symbols.
14
15Unicode and ISO/IEC 10646 are coordinated standards that provide code
16points for the characters in almost all modern character set standards,
17covering more than 30 writing systems and hundreds of languages,
18including all commercially important modern languages. All characters
19in the largest Chinese, Japanese, and Korean dictionaries are also
20encoded. The standards will eventually cover almost all characters in
21more than 250 writing systems and thousands of languages.
22
23A Unicode I<character> is an abstract entity. It is not bound to any
24particular integer width, and especially not to the C language C<char>.
25Unicode is language neutral and display neutral: it doesn't encode the
26language of the text, and it doesn't define fonts or other graphical
27layout details. Unicode operates on characters and on text built from
28those characters.
29
30Unicode defines characters like C<LATIN CAPITAL LETTER A> or C<GREEK
31SMALL LETTER ALPHA>, and then unique numbers for those, hexadecimal
320x0041 or 0x03B1 for those particular characters. Such unique
33numbers are called I<code points>.
34
35The Unicode standard prefers using hexadecimal notation for the code
36points. (In case this notation, numbers like 0x0041, is unfamiliar to
37you, take a peek at a later section, L</"Hexadecimal Notation">.)
38The Unicode standard uses the notation C<U+0041 LATIN CAPITAL LETTER A>,
39which gives the hexadecimal code point, and the normative name of
40the character.
41
42Unicode also defines various I<properties> for the characters, like
43"uppercase" or "lowercase", "decimal digit", or "punctuation":
44these properties are independent of the names of the characters.
45Furthermore, various operations on the characters like uppercasing,
46lowercasing, and collating (sorting), are defined.
47
48A Unicode character consists either of a single code point, or a
49I<base character> (like C<LATIN CAPITAL LETTER A>), followed by one or
50more I<modifiers> (like C<COMBINING ACUTE ACCENT>). This sequence of
51a base character and modifiers is called a I<combining character
52sequence>.
53
54Whether to call these combining character sequences, as a whole,
55"characters" depends on your point of view. If you are a programmer, you
56probably would tend towards seeing each element in the sequences as one
57unit, one "character", but from the user viewpoint, the sequence as a
58whole is probably considered one "character", since that's probably what
59it looks like in the context of the user's language.
60
61With this "as a whole" view of characters, the number of characters is
62open-ended. But in the programmer's "one unit is one character" point of
63view, the concept of "characters" is more deterministic, and so we take
64that point of view in this document: one "character" is one Unicode
65code point, be it a base character or a combining character.
66
67For some of the combinations there are I<precomposed> characters,
68for example C<LATIN CAPITAL LETTER A WITH ACUTE> is defined as
69a single code point. These precomposed characters are, however,
70often available only for some combinations, and mainly they are
71meant to support round-trip conversions between Unicode and legacy
72standards (like the ISO 8859), and in general case the composing
73method is more extensible. To support conversion between the
74different compositions of the characters, various I<normalization
75forms> are also defined.
76
77Because of backward compatibility with legacy encodings, the "a unique
78number for every character" breaks down a bit: "at least one number
79for every character" is closer to truth. (This happens when the same
80character has been encoded in several legacy encodings.) The converse
81is also not true: not every code point has an assigned character.
82Firstly, there are unallocated code points within otherwise used
83blocks. Secondly, there are special Unicode control characters that
84do not represent true characters.
85
86A common myth about Unicode is that it would be "16-bit", that is,
870x10000 (or 65536) characters from 0x0000 to 0xFFFF. B<This is untrue.>
88Since Unicode 2.0 Unicode has been defined all the way up to 21 bits
89(0x10FFFF), and since 3.1 characters have been defined beyond 0xFFFF.
90The first 0x10000 characters are called the I<Plane 0>, or the I<Basic
91Multilingual Plane> (BMP). With the Unicode 3.1, 17 planes in all are
92defined (but nowhere near full of defined characters yet).
93
94Another myth is that the 256-character blocks have something to do
95with languages: a block per language. B<Also this is untrue.>
96The division into the blocks exists but it is almost completely
97accidental, an artifact of how the characters have been historically
98allocated. Instead, there is a concept called I<scripts>, which may
99be more useful: there is C<Latin> script, C<Greek> script, and so on.
100Scripts usually span several parts of several blocks. For further
101information see L<Unicode::UCD>.
102
103The Unicode code points are just abstract numbers. To input and
104output these abstract numbers, the numbers must be I<encoded> somehow.
105Unicode defines several I<character encoding forms>, of which I<UTF-8>
106is perhaps the most popular. UTF-8 is a variable length encoding that
107encodes Unicode characters as 1 to 6 bytes (only 4 with the currently
108defined characters). Other encodings are UTF-16 and UTF-32 and their
109big and little endian variants (UTF-8 is byteorder independent).
110The ISO/IEC 10646 defines the UCS-2 and UCS-4 encoding forms.
111
112For more information about encodings, for example to learn what
113I<surrogates> and I<byte order marks> (BOMs) are, see L<perlunicode>.
114
115=head2 Perl's Unicode Support
116
117Starting from Perl 5.6.0, Perl has had the capability of handling
118Unicode natively. The first recommended release for serious Unicode
119work is Perl 5.8.0, however. The maintenance release 5.6.1 fixed many
120of the problems of the initial implementation of Unicode, but for
121example regular expressions didn't really work with Unicode.
122
123B<Starting from Perl 5.8.0, the use of C<use utf8> is no longer
124necessary.> In earlier releases the C<utf8> pragma was used to declare
125that operations in the current block or file would be Unicode-aware.
126This model was found to be wrong, or at least clumsy: the Unicodeness
127is now carried with the data, not attached to the operations. (There
128is one remaining case where an explicit C<use utf8> is needed: if your
129Perl script is in UTF-8, you can use UTF-8 in your variable and
130subroutine names, and in your string and regular expression literals,
131by saying C<use utf8>. This is not the default because that would
132break existing scripts having legacy 8-bit data in them.)
133
134=head2 Perl's Unicode Model
135
136Perl supports both the old, pre-5.6, model of strings of eight-bit
137native bytes, and strings of Unicode characters. The principle is
138that Perl tries to keep its data as eight-bit bytes for as long as
139possible, but as soon as Unicodeness cannot be avoided, the data is
140transparently upgraded to Unicode.
141
142The internal encoding of Unicode in Perl is UTF-8. The internal
143encoding is normally hidden, however, and one need not and should not
144worry about the internal encoding at all: it is all just characters.
145
146Perl 5.8.0 will also support Unicode on EBCDIC platforms. There the
147support is somewhat harder to implement since additional conversions
148are needed at every step. Because of these difficulties the Unicode
149support won't be quite as full as in other, mainly ASCII-based,
150platforms (the Unicode support will be better than in the 5.6 series,
151which didn't work much at all for EBCDIC platform). On EBCDIC
152platforms the internal encoding form used is UTF-EBCDIC.
153
154=head2 Creating Unicode
155
156To create Unicode literals, use the C<\x{...}> notation in
157doublequoted strings:
158
159 my $smiley = "\x{263a}";
160
161Similarly for regular expression literals
162
163 $smiley =~ /\x{263a}/;
164
165At run-time you can use C<chr()>:
166
167 my $hebrew_alef = chr(0x05d0);
168
169(See L</"Further Resources"> for how to find all these numeric codes.)
170
171Naturally, C<ord()> will do the reverse: turn a character to a code point.
172
8a5e5dd5
JH
173Note that C<\x..> (no C<{}> and only two hexadecimal digits), C<\x{...}>
174and C<chr(...)> for arguments less than 0x100 (decimal 256) will
175generate an eight-bit character for backward compatibility with older
176Perls. For arguments of 0x100 or more, Unicode will always be
177produced. If you want UTF-8 always, use C<pack("U", ...)> instead of
178C<\x..>, C<\x{...}>, or C<chr()>.
ba62762e
JH
179
180You can also use the C<charnames> pragma to invoke characters
181by name in doublequoted strings:
182
183 use charnames ':full';
184 my $arabic_alef = "\N{ARABIC LETTER ALEF}";
185
186And, as mentioned above, you can also C<pack()> numbers into Unicode
187characters:
188
189 my $georgian_an = pack("U", 0x10a0);
190
8a5e5dd5
JH
191Note that both C<\x{...}> and C<\N{...}> are compile-time string
192constants: you cannot use variables in them. if you want similar
193run-time functionality, use C<chr()> and C<charnames::vianame()>.
194
ba62762e
JH
195=head2 Handling Unicode
196
197Handling Unicode is for the most part transparent: just use the
198strings as usual. Functions like C<index()>, C<length()>, and
199C<substr()> will work on the Unicode characters; regular expressions
200will work on the Unicode characters (see L<perlunicode> and L<perlretut>).
201
202Note that Perl does B<not> consider combining character sequences
203to be characters, such for example
204
205 use charnames ':full';
206 print length("\N{LATIN CAPITAL LETTER A}\N{COMBINING ACUTE ACCENT}"), "\n";
207
208will print 2, not 1. The only exception is that regular expressions
209have C<\X> for matching a combining character sequence.
210
211When life is not quite so transparent is working with legacy
212encodings, and I/O, and certain special cases.
213
214=head2 Legacy Encodings
215
216When you combine legacy data and Unicode the legacy data needs
217to be upgraded to Unicode. Normally ISO 8859-1 (or EBCDIC, if
218applicable) is assumed. You can override this assumption by
219using the C<encoding> pragma, for example
220
221 use encoding 'latin2'; # ISO 8859-2
222
223in which case literals (string or regular expression) and chr/ord
224in your whole script are assumed to produce Unicode characters from
225ISO 8859-2 code points. Note that the matching for the encoding
226names is forgiving: instead of C<latin2> you could have said
227C<Latin 2>, or C<iso8859-2>, and so forth. With just
228
229 use encoding;
230
231first the environment variable C<PERL_ENCODING> will be consulted,
232and if that doesn't exist, ISO 8859-1 (Latin 1) will be assumed.
233
234The C<Encode> module knows about many encodings and it has interfaces
235for doing conversions between those encodings:
236
237 use Encode 'from_to';
238 from_to($data, "iso-8859-3", "utf-8"); # from legacy to utf-8
239
240=head2 Unicode I/O
241
242Normally writing out Unicode data
243
1d7919c5 244 print FH chr(0x100), "\n";
ba62762e 245
1d7919c5
JH
246will print out the raw UTF-8 bytes, but you will get a warning
247out of that if you use C<-w> or C<use warnings>. To avoid the
248warning open the stream explicitly in UTF-8:
ba62762e 249
1d7919c5
JH
250 open FH, ">:utf8", "file";
251
252and on already open streams use C<binmode()>:
253
254 binmode(STDOUT, ":utf8");
255
256Reading in correctly formed UTF-8 data will not magically turn
ba62762e
JH
257the data into Unicode in Perl's eyes.
258
259You can use either the C<':utf8'> I/O discipline when opening files
260
261 open(my $fh,'<:utf8', 'anything');
262 my $line_of_utf8 = <$fh>;
263
264The I/O disciplines can also be specified more flexibly with
265the C<open> pragma; see L<open>:
266
1d7919c5
JH
267 use open ':utf8'; # input and output default discipline will be UTF-8
268 open X, ">file";
269 print X chr(0x100), "\n";
ba62762e 270 close X;
1d7919c5 271 open Y, "<file";
ba62762e
JH
272 printf "%#x\n", ord(<Y>); # this should print 0x100
273 close Y;
274
275With the C<open> pragma you can use the C<:locale> discipline
276
1ecefa54
JH
277 $ENV{LC_ALL} = $ENV{LANG} = 'ru_RU.KOI8-R';
278 # the :locale will probe the locale environment variables like LC_ALL
ba62762e
JH
279 use open OUT => ':locale'; # russki parusski
280 open(O, ">koi8");
281 print O chr(0x430); # Unicode CYRILLIC SMALL LETTER A = KOI8-R 0xc1
282 close O;
283 open(I, "<koi8");
284 printf "%#x\n", ord(<I>), "\n"; # this should print 0xc1
285 close I;
286
287or you can also use the C<':encoding(...)'> discipline
288
289 open(my $epic,'<:encoding(iso-8859-7)','iliad.greek');
290 my $line_of_iliad = <$epic>;
291
292Both of these methods install a transparent filter on the I/O stream that
293will convert data from the specified encoding when it is read in from the
294stream. In the first example the F<anything> file is assumed to be UTF-8
295encoded Unicode, in the second example the F<iliad.greek> file is assumed
296to be ISO-8858-7 encoded Greek, but the lines read in will be in both
297cases Unicode.
298
299The L<open> pragma affects all the C<open()> calls after the pragma by
300setting default disciplines. If you want to affect only certain
301streams, use explicit disciplines directly in the C<open()> call.
302
303You can switch encodings on an already opened stream by using
304C<binmode()>, see L<perlfunc/binmode>.
305
1ecefa54
JH
306The C<:locale> does not currently (as of Perl 5.8.0) work with
307C<open()> and C<binmode()>, only with the C<open> pragma. The
308C<:utf8> and C<:encoding(...)> do work with all of C<open()>,
309C<binmode()>, and the C<open> pragma.
ba62762e
JH
310
311Similarly, you may use these I/O disciplines on input streams to
312automatically convert data from the specified encoding when it is
313written to the stream.
314
315 open(my $unicode, '<:utf8', 'japanese.uni');
316 open(my $nihongo, '>:encoding(iso2022-jp)', 'japanese.jp');
317 while (<$unicode>) { print $nihongo }
318
319The naming of encodings, both by the C<open()> and by the C<open>
320pragma, is similarly understanding as with the C<encoding> pragma:
321C<koi8-r> and C<KOI8R> will both be understood.
322
323Common encodings recognized by ISO, MIME, IANA, and various other
324standardisation organisations are recognised, for a more detailed
325list see L<Encode>.
326
327C<read()> reads characters and returns the number of characters.
328C<seek()> and C<tell()> operate on byte counts, as do C<sysread()>
329and C<sysseek()>.
330
331Notice that because of the default behaviour "input is not UTF-8"
332it is easy to mistakenly write code that keeps on expanding a file
333by repeatedly encoding it in UTF-8:
334
335 # BAD CODE WARNING
336 open F, "file";
337 local $/; # read in the whole file
338 $t = <F>;
339 close F;
340 open F, ">:utf8", "file";
341 print F $t;
342 close F;
343
344If you run this code twice, the contents of the F<file> will be twice
1d7919c5
JH
345UTF-8 encoded. A C<use open ':utf8'> would have avoided the bug, or
346explicitly opening also the F<file> for input as UTF-8.
ba62762e 347
0c901d84
JH
348B<NOTE>: the C<:utf8> and C<:encoding> features work only if your
349Perl has been built with the new "perlio" feature. Almost all
350Perl 5.8 platforms do use "perlio", though: you can see whether
351yours is by running "perl -V" and looking for C<useperlio=define>.
352
1ecefa54
JH
353=head2 Displaying Unicode As Text
354
355Sometimes you might want to display Perl scalars containing Unicode as
356simple ASCII (or EBCDIC) text. The following subroutine will convert
357its argument so that Unicode characters with code points greater than
358255 are displayed as "\x{...}", control characters (like "\n") are
359displayed as "\x..", and the rest of the characters as themselves.
360
58c274a1
JF
361 sub nice_string {
362 join("",
363 map { $_ > 255 ? # if wide character...
364 sprintf("\\x{%x}", $_) : # \x{...}
365 chr($_) =~ /[[:cntrl:]]/ ? # else if control character ...
366 sprintf("\\x%02x", $_) : # \x..
367 chr($_) # else as themselves
368 } unpack("U*", $_[0])); # unpack Unicode characters
369 }
370
371For example,
372
373 nice_string("foo\x{100}bar\n")
374
375will return:
376
377 "foo\x{100}bar\x0a"
1ecefa54 378
ba62762e
JH
379=head2 Special Cases
380
381=over 4
382
383=item *
384
385Bit Complement Operator ~ And vec()
386
387The bit complement operator C<~> will produce surprising results if
388used on strings containing Unicode characters. The results are
389consistent with the internal UTF-8 encoding of the characters, but not
390with much else. So don't do that. Similarly for vec(): you will be
391operating on the UTF-8 bit patterns of the Unicode characters, not on
392the bytes, which is very probably not what you want.
393
394=item *
395
396Peeking At UTF-8
397
398One way of peeking inside the internal encoding of Unicode characters
399is to use C<unpack("C*", ...> to get the bytes, or C<unpack("H*", ...)>
400to display the bytes:
401
402 # this will print c4 80 for the UTF-8 bytes 0xc4 0x80
403 print join(" ", unpack("H*", pack("U", 0x100))), "\n";
404
405Yet another way would be to use the Devel::Peek module:
406
407 perl -MDevel::Peek -e 'Dump(chr(0x100))'
408
409That will show the UTF8 flag in FLAGS and both the UTF-8 bytes
410and Unicode characters in PV. See also later in this document
411the discussion about the C<is_utf8> function of the C<Encode> module.
412
413=back
414
415=head2 Advanced Topics
416
417=over 4
418
419=item *
420
421String Equivalence
422
423The question of string equivalence turns somewhat complicated
424in Unicode: what do you mean by equal?
425
07698885
RGS
426(Is C<LATIN CAPITAL LETTER A WITH ACUTE> equal to
427C<LATIN CAPITAL LETTER A>?)
ba62762e
JH
428
429The short answer is that by default Perl compares equivalence
430(C<eq>, C<ne>) based only on code points of the characters.
58c274a1 431In the above case, the answer is no (because 0x00C1 != 0x0041). But sometimes any
ba62762e
JH
432CAPITAL LETTER As being considered equal, or even any As of any case,
433would be desirable.
434
435The long answer is that you need to consider character normalization
436and casing issues: see L<Unicode::Normalize>, and Unicode Technical
437Reports #15 and #21, I<Unicode Normalization Forms> and I<Case
438Mappings>, http://www.unicode.org/unicode/reports/tr15/
439http://www.unicode.org/unicode/reports/tr21/
440
58c274a1 441As of Perl 5.8.0, regular expression case-ignoring matching
ba62762e
JH
442implements only 1:1 semantics: one character matches one character.
443In I<Case Mappings> both 1:N and N:1 matches are defined.
444
445=item *
446
447String Collation
448
449People like to see their strings nicely sorted, or as Unicode
450parlance goes, collated. But again, what do you mean by collate?
451
07698885
RGS
452(Does C<LATIN CAPITAL LETTER A WITH ACUTE> come before or after
453C<LATIN CAPITAL LETTER A WITH GRAVE>?)
ba62762e 454
58c274a1 455The short answer is that by default, Perl compares strings (C<lt>,
ba62762e 456C<le>, C<cmp>, C<ge>, C<gt>) based only on the code points of the
58c274a1 457characters. In the above case, the answer is "after", since 0x00C1 > 0x00C0.
ba62762e
JH
458
459The long answer is that "it depends", and a good answer cannot be
460given without knowing (at the very least) the language context.
461See L<Unicode::Collate>, and I<Unicode Collation Algorithm>
462http://www.unicode.org/unicode/reports/tr10/
463
464=back
465
466=head2 Miscellaneous
467
468=over 4
469
470=item *
471
472Character Ranges
473
474Character ranges in regular expression character classes (C</[a-z]/>)
475and in the C<tr///> (also known as C<y///>) operator are not magically
58c274a1 476Unicode-aware. What this means that C<[A-Za-z]> will not magically start
ba62762e
JH
477to mean "all alphabetic letters" (not that it does mean that even for
4788-bit characters, you should be using C</[[:alpha]]/> for that).
479
58c274a1
JF
480For specifying things like that in regular expressions, you can use the
481various Unicode properties, C<\pL> or perhaps C<\p{Alphabetic}>, in this particular case. You can
ba62762e
JH
482use Unicode code points as the end points of character ranges, but
483that means that particular code point range, nothing more. For
484further information, see L<perlunicode>.
485
486=item *
487
488String-To-Number Conversions
489
490Unicode does define several other decimal (and numeric) characters
491than just the familiar 0 to 9, such as the Arabic and Indic digits.
492Perl does not support string-to-number conversion for digits other
58c274a1 493than ASCII 0 to 9 (and ASCII a to f for hexadecimal).
ba62762e
JH
494
495=back
496
497=head2 Questions With Answers
498
499=over 4
500
501=item Will My Old Scripts Break?
502
503Very probably not. Unless you are generating Unicode characters
504somehow, any old behaviour should be preserved. About the only
505behaviour that has changed and which could start generating Unicode
506is the old behaviour of C<chr()> where supplying an argument more
507than 255 produced a character modulo 255 (for example, C<chr(300)>
508was equal to C<chr(45)>).
509
510=item How Do I Make My Scripts Work With Unicode?
511
512Very little work should be needed since nothing changes until you
513somehow generate Unicode data. The greatest trick will be getting
514input as Unicode, and for that see the earlier I/O discussion.
515
516=item How Do I Know Whether My String Is In Unicode?
517
518You shouldn't care. No, you really shouldn't. If you have
519to care (beyond the cases described above), it means that we
520didn't get the transparency of Unicode quite right.
521
522Okay, if you insist:
523
524 use Encode 'is_utf8';
525 print is_utf8($string) ? 1 : 0, "\n";
526
527But note that this doesn't mean that any of the characters in the
528string are necessary UTF-8 encoded, or that any of the characters have
529code points greater than 0xFF (255) or even 0x80 (128), or that the
530string has any characters at all. All the C<is_utf8()> does is to
531return the value of the internal "utf8ness" flag attached to the
532$string. If the flag is on, characters added to that string will be
533automatically upgraded to UTF-8 (and even then only if they really
534need to be upgraded, that is, if their code point is greater than 0xFF).
535
536Sometimes you might really need to know the byte length of a string
537instead of the character length. For that use the C<bytes> pragma
538and its only defined function C<length()>:
539
540 my $unicode = chr(0x100);
541 print length($unicode), "\n"; # will print 1
542 use bytes;
543 print length($unicode), "\n"; # will print 2 (the 0xC4 0x80 of the UTF-8)
544
545=item How Do I Detect Invalid UTF-8?
546
547Either
548
549 use Encode 'encode_utf8';
550 if (encode_utf8($string)) {
551 # valid
552 } else {
553 # invalid
554 }
555
556or
557
558 use warnings;
559 @chars = unpack("U0U*", "\xFF"); # will warn
560
561The warning will be C<Malformed UTF-8 character (byte 0xff) in
562unpack>. The "U0" means "expect strictly UTF-8 encoded Unicode".
563Without that the C<unpack("U*", ...)> would accept also data like
564C<chr(0xFF>).
565
566=item How Do I Convert Data Into UTF-8? Or Vice Versa?
567
568This probably isn't as useful (or simple) as you might think.
569Also, normally you shouldn't need to.
570
571In one sense what you are asking doesn't make much sense: UTF-8 is
572(intended as an) Unicode encoding, so converting "data" into UTF-8
573isn't meaningful unless you know in what character set and encoding
574the binary data is in, and in this case you can use C<Encode>.
575
576 use Encode 'from_to';
577 from_to($data, "iso-8859-1", "utf-8"); # from latin-1 to utf-8
578
579If you have ASCII (really 7-bit US-ASCII), you already have valid
580UTF-8, the lowest 128 characters of UTF-8 encoded Unicode and US-ASCII
581are equivalent.
582
583If you have Latin-1 (or want Latin-1), you can just use pack/unpack:
584
585 $latin1 = pack("C*", unpack("U*", $utf8));
586 $utf8 = pack("U*", unpack("C*", $latin1));
587
588(The same works for EBCDIC.)
589
590If you have a sequence of bytes you B<know> is valid UTF-8,
591but Perl doesn't know it yet, you can make Perl a believer, too:
592
593 use Encode 'decode_utf8';
594 $utf8 = decode_utf8($bytes);
595
596You can convert well-formed UTF-8 to a sequence of bytes, but if
597you just want to convert random binary data into UTF-8, you can't.
598Any random collection of bytes isn't well-formed UTF-8. You can
599use C<unpack("C*", $string)> for the former, and you can create
600well-formed Unicode/UTF-8 data by C<pack("U*", 0xff, ...)>.
601
602=item How Do I Display Unicode? How Do I Input Unicode?
603
604See http://www.hclrss.demon.co.uk/unicode/ and
605http://www.cl.cam.ac.uk/~mgk25/unicode.html
606
607=item How Does Unicode Work With Traditional Locales?
608
609In Perl, not very well. Avoid using locales through the C<locale>
610pragma. Use only one or the other.
611
612=back
613
614=head2 Hexadecimal Notation
615
616The Unicode standard prefers using hexadecimal notation because that
617shows better the division of Unicode into blocks of 256 characters.
618Hexadecimal is also simply shorter than decimal. You can use decimal
619notation, too, but learning to use hexadecimal just makes life easier
620with the Unicode standard.
621
622The C<0x> prefix means a hexadecimal number, the digits are 0-9 I<and>
623a-f (or A-F, case doesn't matter). Each hexadecimal digit represents
624four bits, or half a byte. C<print 0x..., "\n"> will show a
625hexadecimal number in decimal, and C<printf "%x\n", $decimal> will
626show a decimal number in hexadecimal. If you have just the
627"hexdigits" of a hexadecimal number, you can use the C<hex()>
628function.
629
630 print 0x0009, "\n"; # 9
631 print 0x000a, "\n"; # 10
632 print 0x000f, "\n"; # 15
633 print 0x0010, "\n"; # 16
634 print 0x0011, "\n"; # 17
635 print 0x0100, "\n"; # 256
636
637 print 0x0041, "\n"; # 65
638
639 printf "%x\n", 65; # 41
640 printf "%#x\n", 65; # 0x41
641
642 print hex("41"), "\n"; # 65
643
644=head2 Further Resources
645
646=over 4
647
648=item *
649
650Unicode Consortium
651
652 http://www.unicode.org/
653
654=item *
655
656Unicode FAQ
657
658 http://www.unicode.org/unicode/faq/
659
660=item *
661
662Unicode Glossary
663
664 http://www.unicode.org/glossary/
665
666=item *
667
668Unicode Useful Resources
669
670 http://www.unicode.org/unicode/onlinedat/resources.html
671
672=item *
673
674Unicode and Multilingual Support in HTML, Fonts, Web Browsers and Other Applications
675
676 http://www.hclrss.demon.co.uk/unicode/
677
678=item *
679
680UTF-8 and Unicode FAQ for Unix/Linux
681
682 http://www.cl.cam.ac.uk/~mgk25/unicode.html
683
684=item *
685
686Legacy Character Sets
687
688 http://www.czyborra.com/
689 http://www.eki.ee/letter/
690
691=item *
692
693The Unicode support files live within the Perl installation in the
694directory
695
696 $Config{installprivlib}/unicore
697
698in Perl 5.8.0 or newer, and
699
700 $Config{installprivlib}/unicode
701
702in the Perl 5.6 series. (The renaming to F<lib/unicore> was done to
703avoid naming conflicts with lib/Unicode in case-insensitive filesystems.)
704The main Unicode data file is F<Unicode.txt> (or F<Unicode.301> in
705Perl 5.6.1.) You can find the C<$Config{installprivlib}> by
706
707 perl "-V:installprivlib"
708
709Note that some of the files have been renamed from the Unicode
710standard since the Perl installation tries to live by the "8.3"
711filenaming restrictions. The renamings are shown in the
712accompanying F<rename> file.
713
714You can explore various information from the Unicode data files using
715the C<Unicode::UCD> module.
716
717=back
718
f6edf83b
JH
719=head1 UNICODE IN OLDER PERLS
720
721If you cannot upgrade your Perl to 5.8.0 or later, you can still
722do some Unicode processing by using the modules C<Unicode::String>,
723C<Unicode::Map8>, and C<Unicode::Map>, available from CPAN.
724If you have the GNU recode installed, you can also use the
725Perl frontend C<Convert::Recode> for character conversions.
726
ba62762e
JH
727=head1 SEE ALSO
728
729L<perlunicode>, L<Encode>, L<encoding>, L<open>, L<utf8>, L<bytes>,
730L<perlretut>, L<Unicode::Collate>, L<Unicode::Normalize>, L<Unicode::UCD>
731
732=head1 ACKNOWLEDGEMENTS
733
734Thanks to the kind readers of the perl5-porters@perl.org,
735perl-unicode@perl.org, linux-utf8@nl.linux.org, and unicore@unicode.org
736mailing lists for their valuable feedback.
737
738=head1 AUTHOR, COPYRIGHT, AND LICENSE
739
740Copyright 2001 Jarkko Hietaniemi <jhi@iki.fi>
741
742This document may be distributed under the same terms as Perl itself.