Cari di Perl 
     Perl Tutorial
Daftar Isi ☛
(Sebelumnya) Perl locale handling (internat ...Unicode support in Perl (Berikutnya)
Language Reference

Perl Unicode introduction

Daftar Isi

NAME

perluniintro - Perl Unicode introduction

DESCRIPTION

This document gives a general idea of Unicode and how to use Unicodein Perl. See Further Resources for references to more in-depthtreatments of Unicode.

Unicode

Unicode is a character set standard which plans to codify all of thewriting systems of the world, plus many other symbols.

Unicode and ISO/IEC 10646 are coordinated standards that unifyalmost all other modern character set standards,covering more than 80 writing systems and hundreds of languages,including all commercially-important modern languages. All charactersin the largest Chinese, Japanese, and Korean dictionaries are alsoencoded. The standards will eventually cover almost all characters inmore than 250 writing systems and thousands of languages.Unicode 1.0 was released in October 1991, and 6.0 in October 2010.

A Unicode character is an abstract entity. It is not bound to anyparticular integer width, especially not to the C language char.Unicode is language-neutral and display-neutral: it does not encode thelanguage of the text, and it does not generally define fonts or other graphicallayout details. Unicode operates on characters and on text built fromthose characters.

Unicode defines characters like LATIN CAPITAL LETTER A or GREEKSMALL LETTER ALPHA and unique numbers for the characters, in thiscase 0x0041 and 0x03B1, respectively. These unique numbers are calledcode points. A code point is essentially the position of thecharacter within the set of all possible Unicode characters, and thus inPerl, the term ordinal is often used interchangeably with it.

The Unicode standard prefers using hexadecimal notation for the codepoints. If numbers like 0x0041 are unfamiliar to you, take a peekat a later section, Hexadecimal Notation. The Unicode standarduses the notation U+0041 LATIN CAPITAL LETTER A, to give thehexadecimal code point and the normative name of the character.

Unicode also defines various properties for the characters, like"uppercase" or "lowercase", "decimal digit", or "punctuation";these properties are independent of the names of the characters.Furthermore, various operations on the characters like uppercasing,lowercasing, and collating (sorting) are defined.

A Unicode logical "character" can actually consist of more than one internalactual "character" or code point. For Western languages, this is adequatelymodelled by a base character (like LATIN CAPITAL LETTER A) followedby one or more modifiers (like COMBINING ACUTE ACCENT). This sequence ofbase character and modifiers is called a combining charactersequence. Some non-western languages require more complicatedmodels, so Unicode created the grapheme cluster concept, which waslater further refined into the extended grapheme cluster. Forexample, a Korean Hangul syllable is considered a single logicalcharacter, but most often consists of three actualUnicode characters: a leading consonant followed by an interior vowel followedby a trailing consonant.

Whether to call these extended grapheme clusters "characters" depends on yourpoint of view. If you are a programmer, you probably would tend towards seeingeach element in the sequences as one unit, or "character". However fromthe user's point of view, the whole sequence could be seen as one"character" since that's probably what it looks like in the context of theuser's language. In this document, we take the programmer's point ofview: one "character" is one Unicode code point.

For some combinations of base character and modifiers, there areprecomposed characters. There is a single character equivalent, forexample, to the sequence LATIN CAPITAL LETTER A followed byCOMBINING ACUTE ACCENT. It is called LATIN CAPITAL LETTER A WITHACUTE. These precomposed characters are, however, only available forsome combinations, and are mainly meant to support round-tripconversions between Unicode and legacy standards (like ISO 8859). Usingsequences, as Unicode does, allows for needing fewer basic building blocks(code points) to express many more potential grapheme clusters. Tosupport conversion between equivalent forms, various normalizationforms are also defined. Thus, LATIN CAPITAL LETTER A WITH ACUTE isin Normalization Form Composed, (abbreviated NFC), and the sequenceLATIN CAPITAL LETTER A followed by COMBINING ACUTE ACCENTrepresents the same character in Normalization Form Decomposed (NFD).

Because of backward compatibility with legacy encodings, the "a uniquenumber for every character" idea breaks down a bit: instead, there is"at least one number for every character". The same character couldbe represented differently in several legacy encodings. Theconverse is not also true: some code points do not have an assignedcharacter. Firstly, there are unallocated code points withinotherwise used blocks. Secondly, there are special Unicode controlcharacters that do not represent true characters.

When Unicode was first conceived, it was thought that all the world'scharacters could be represented using a 16-bit word; that is a maximum of0x10000 (or 65536) characters from 0x0000 to 0xFFFF would beneeded. This soon proved to be false, and since Unicode 2.0 (July1996), Unicode has been defined all the way up to 21 bits (0x10FFFF),and Unicode 3.1 (March 2001) defined the first characters above 0xFFFF.The first 0x10000 characters are called the Plane 0, or theBasic Multilingual Plane (BMP). With Unicode 3.1, 17 (yes,seventeen) planes in all were defined--but they are nowhere near full ofdefined characters, yet.

When a new language is being encoded, Unicode generally will choose ablock of consecutive unallocated code points for its characters. Sofar, the number of code points in these blocks has always been evenlydivisible by 16. Extras in a block, not currently needed, are leftunallocated, for future growth. But there have been occasions whena later relase needed more code points than the available extras, and anew block had to allocated somewhere else, not contiguous to the initialone, to handle the overflow. Thus, it became apparent early on that"block" wasn't an adequate organizing principal, and so the Scriptproperty was created. (Later an improved script property was added aswell, the Script_Extensions property.) Those code points that are inoverflow blocks can stillhave the same script as the original ones. The script concept fits moreclosely with natural language: there is Latin script, Greekscript, and so on; and there are several artificial scripts, likeCommon for characters that are used in multiple scripts, such asmathematical symbols. Scripts usually span varied parts of severalblocks. For more information about scripts, see Scripts in perlunicode.The division into blocks exists, but it is almost completelyaccidental--an artifact of how the characters have been and still areallocated. (Note that this paragraph has oversimplified things for thesake of this being an introduction. Unicode doesn't really encodelanguages, but the writing systems for them--their scripts; and onescript can be used by many languages. Unicode also encodes things thataren't really about languages, such as symbols like BAGGAGE CLAIM.)

The Unicode code points are just abstract numbers. To input andoutput these abstract numbers, the numbers must be encoded orserialised somehow. Unicode defines several character encodingforms, of which UTF-8 is perhaps the most popular. UTF-8 is avariable length encoding that encodes Unicode characters as 1 to 6bytes. Other encodingsinclude UTF-16 and UTF-32 and their big- and little-endian variants(UTF-8 is byte-order independent) The ISO/IEC 10646 defines the UCS-2and UCS-4 encoding forms.

For more information about encodings--for instance, to learn whatsurrogates and byte order marks (BOMs) are--see perlunicode.

Perl's Unicode Support

Starting from Perl 5.6.0, Perl has had the capacity to handle Unicodenatively. Perl 5.8.0, however, is the first recommended release forserious Unicode work. The maintenance release 5.6.1 fixed many of theproblems of the initial Unicode implementation, but for exampleregular expressions still do not work with Unicode in 5.6.1.Perl 5.14.0 is the first release where Unicode support is(almost) seamlessly integrable without some gotchas (the exception beingsome differences in quotemeta, which is fixedstarting in Perl 5.16.0). To enable thisseamless support, you should use feature 'unicode_strings' (which isautomatically selected if you use 5.012 or higher). See feature.(5.14 also fixes a number of bugs and departures from the Unicodestandard.)

Before Perl 5.8.0, the use of use utf8 was used to declarethat operations in the current block or file would be Unicode-aware.This model was found to be wrong, or at least clumsy: the "Unicodeness"is now carried with the data, instead of being attached to theoperations.Starting with Perl 5.8.0, only one case remains where an explicit useutf8 is needed: if your Perl script itself is encoded in UTF-8, you canuse UTF-8 in your identifier names, and in string and regular expressionliterals, by saying use utf8. This is not the default becausescripts with legacy 8-bit data in them would break. See utf8.

Perl's Unicode Model

Perl supports both pre-5.6 strings of eight-bit native bytes, andstrings of Unicode characters. The general principle is that Perl triesto keep its data as eight-bit bytes for as long as possible, but as soonas Unicodeness cannot be avoided, the data is transparently upgradedto Unicode. Prior to Perl 5.14, the upgrade was not completelytransparent (see The Unicode Bug in perlunicode), and for backwardscompatibility, full transparency is not gained unless use feature'unicode_strings' (see feature) or use 5.012 (or higher) isselected.

Internally, Perl currently uses either whatever the native eight-bitcharacter set of the platform (for example Latin-1) is, defaulting toUTF-8, to encode Unicode strings. Specifically, if all code points inthe string are 0xFF or less, Perl uses the native eight-bitcharacter set. Otherwise, it uses UTF-8.

A user of Perl does not normally need to know nor care how Perlhappens to encode its internal strings, but it becomes relevant whenoutputting Unicode strings to a stream without a PerlIO layer (one withthe "default" encoding). In such a case, the raw bytes used internally(the native character set or UTF-8, as appropriate for each string)will be used, and a "Wide character" warning will be issued if thosestrings contain a character beyond 0x00FF.

For example,

  1.   perl -e 'print "\x{DF}\n", "\x{0100}\x{DF}\n"'
    2.

produces a fairly useless mixture of native bytes and UTF-8, as wellas a warning:

  1.  Wide character in print at ...
    2.

To output UTF-8, use the :encoding or :utf8 output layer. Prepending

  1.   binmode(STDOUT, ":utf8");
    2.

to this sample program ensures that the output is completely UTF-8,and removes the program's warning.

You can enable automatic UTF-8-ification of your standard filehandles, default open() layer, and @ARGV by using eitherthe -C command line switch or the PERL_UNICODE environmentvariable, see perlrun for the documentation of the -C switch.

Note that this means that Perl expects other software to work the sameway:if Perl has been led to believe that STDIN should be UTF-8, but thenSTDIN coming in from another command is not UTF-8, Perl will likelycomplain about the malformed UTF-8.

All features that combine Unicode and I/O also require using the newPerlIO feature. Almost all Perl 5.8 platforms do use PerlIO, though:you can see whether yours is by running "perl -V" and looking foruseperlio=define.

Unicode and EBCDIC

Perl 5.8.0 also supports Unicode on EBCDIC platforms. There,Unicode support is somewhat more complex to implement sinceadditional conversions are needed at every step.

Later Perl releases have added code that will not work on EBCDIC platforms, andno one has complained, so the divergence has continued. If you want to runPerl on an EBCDIC platform, send email to [email protected]

On EBCDIC platforms, the internal Unicode encoding form is UTF-EBCDICinstead of UTF-8. The difference is that as UTF-8 is "ASCII-safe" inthat ASCII characters encode to UTF-8 as-is, while UTF-EBCDIC is"EBCDIC-safe".

Creating Unicode

To create Unicode characters in literals for code points above 0xFF,use the \x{...} notation in double-quoted strings:

  1.  my $smiley = "\x{263a}";
    2.

Similarly, it can be used in regular expression literals

  1.  $smiley =~ /\x{263a}/;
    2.

At run-time you can use chr():

  1.  my $hebrew_alef = chr(0x05d0);
    2.

See Further Resources for how to find all these numeric codes.

Naturally, ord() will do the reverse: it turns a character intoa code point.

Note that \x.. (no {} and only two hexadecimal digits), \x{...},and chr(...) for arguments less than 0x100 (decimal 256)generate an eight-bit character for backward compatibility with olderPerls. For arguments of 0x100 or more, Unicode characters arealways produced. If you want to force the production of Unicodecharacters regardless of the numeric value, use pack("U", ...)instead of \x.., \x{...}, or chr().

You can invoke charactersby name in double-quoted strings:

  1.  my $arabic_alef = "\N{ARABIC LETTER ALEF}";
    2.

And, as mentioned above, you can also pack() numbers into Unicodecharacters:

  1.    my $georgian_an  = pack("U", 0x10a0);
    2.

Note that both \x{...} and \N{...} are compile-time stringconstants: you cannot use variables in them. if you want similarrun-time functionality, use chr() and charnames::string_vianame().

If you want to force the result to Unicode characters, use the special"U0" prefix. It consumes no arguments but causes the following bytesto be interpreted as the UTF-8 encoding of Unicode characters:

  1.    my $chars = pack("U0W*", 0x80, 0x42);
    2.

Likewise, you can stop such UTF-8 interpretation by using the special"C0" prefix.

Handling Unicode

Handling Unicode is for the most part transparent: just use thestrings as usual. Functions like index(), length(), andsubstr() will work on the Unicode characters; regular expressionswill work on the Unicode characters (see perlunicode and perlretut).

Note that Perl considers grapheme clusters to be separate characters, so forexample

  1.  print length("\N{LATIN CAPITAL LETTER A}\N{COMBINING ACUTE ACCENT}"),
    2.  
  2.    "\n";
    3.

will print 2, not 1. The only exception is that regular expressionshave \X for matching an extended grapheme cluster. (Thus \X in aregular expression would match the entire sequence of both the examplecharacters.)

Life is not quite so transparent, however, when working with legacyencodings, I/O, and certain special cases:

Legacy Encodings

When you combine legacy data and Unicode, the legacy data needsto be upgraded to Unicode. Normally the legacy data is assumed to beISO 8859-1 (or EBCDIC, if applicable).

The Encode module knows about many encodings and has interfacesfor doing conversions between those encodings:

  1.  use Encode 'decode';
    2.  
  2.  $data = decode("iso-8859-3", $data); # convert from legacy to utf-8
    3.

Unicode I/O

Normally, writing out Unicode data

  1.  print FH $some_string_with_unicode, "\n";
    2.

produces raw bytes that Perl happens to use to internally encode theUnicode string. Perl's internal encoding depends on the system aswell as what characters happen to be in the string at the time. Ifany of the characters are at code points 0x100 or above, you will geta warning. To ensure that the output is explicitly rendered in theencoding you desire--and to avoid the warning--open the stream withthe desired encoding. Some examples:

  1.  open FH, ">:utf8", "file";
    2.  
  2.  
  3.  open FH, ">:encoding(ucs2)",  "file";
    4.  
  4.  open FH, ">:encoding(UTF-8)", "file";
    5.  
  5.  open FH, ">:encoding(shift_jis)", "file";
    6.

and on already open streams, use binmode():

  1.  binmode(STDOUT, ":utf8");
    2.  
  2.  
  3.  binmode(STDOUT, ":encoding(ucs2)");
    4.  
  4.  binmode(STDOUT, ":encoding(UTF-8)");
    5.  
  5.  binmode(STDOUT, ":encoding(shift_jis)");
    6.

The matching of encoding names is loose: case does not matter, andmany encodings have several aliases. Note that the :utf8 layermust always be specified exactly like that; it is not subject tothe loose matching of encoding names. Also note that currently :utf8 is unsafe forinput, because it accepts the data without validating that it is indeed validUTF-8; you should instead use :encoding(utf-8) (with or without ahyphen).

See PerlIO for the :utf8 layer, PerlIO::encoding andEncode::PerlIO for the :encoding() layer, andEncode::Supported for many encodings supported by the Encodemodule.

Reading in a file that you know happens to be encoded in one of theUnicode or legacy encodings does not magically turn the data intoUnicode in Perl's eyes. To do that, specify the appropriatelayer when opening files

  1.  open(my $fh,'<:encoding(utf8)', 'anything');
    2.  
  2.  my $line_of_unicode = <$fh>;
    3.  
  3.  
  4.  open(my $fh,'<:encoding(Big5)', 'anything');
    5.  
  5.  my $line_of_unicode = <$fh>;
    6.

The I/O layers can also be specified more flexibly withthe open pragma. See open, or look at the following example.

  1.  use open ':encoding(utf8)'; # input/output default encoding will be
    2.  
  2.  # UTF-8
    3.  
  3.  open X, ">file";
    4.  
  4.  print X chr(0x100), "\n";
    5.  
  5.  close X;
    6.  
  6.  open Y, "<file";
    7.  
  7.  printf "%#x\n", ord(<Y>); # this should print 0x100
    8.  
  8.  close Y;
    9.

With the open pragma you can use the :locale layer

  1.  BEGIN { $ENV{LC_ALL} = $ENV{LANG} = 'ru_RU.KOI8-R' }
    2.  
  2.  # the :locale will probe the locale environment variables like
    3.  
  3.  # LC_ALL
    4.  
  4.  use open OUT => ':locale'; # russki parusski
    5.  
  5.  open(O, ">koi8");
    6.  
  6.  print O chr(0x430); # Unicode CYRILLIC SMALL LETTER A = KOI8-R 0xc1
    7.  
  7.  close O;
    8.  
  8.  open(I, "<koi8");
    9.  
  9.  printf "%#x\n", ord(<I>), "\n"; # this should print 0xc1
    10.  
  10.  close I;
    11.

These methods install a transparent filter on the I/O stream thatconverts data from the specified encoding when it is read in from thestream. The result is always Unicode.

The open pragma affects all the open() calls after the pragma bysetting default layers. If you want to affect only certainstreams, use explicit layers directly in the open() call.

You can switch encodings on an already opened stream by usingbinmode(); see binmode.

The :locale does not currently (as of Perl 5.8.0) work withopen() and binmode(), only with the open pragma. The:utf8 and :encoding(...) methods do work with all of open(),binmode(), and the open pragma.

Similarly, you may use these I/O layers on output streams toautomatically convert Unicode to the specified encoding when it iswritten to the stream. For example, the following snippet copies thecontents of the file "text.jis" (encoded as ISO-2022-JP, aka JIS) tothe file "text.utf8", encoded as UTF-8:

  1.  open(my $nihongo, '<:encoding(iso-2022-jp)', 'text.jis');
    2.  
  2.  open(my $unicode, '>:utf8',  'text.utf8');
    3.  
  3.  while (<$nihongo>) { print $unicode $_ }
    4.

The naming of encodings, both by the open() and by the openpragma allows for flexible names: koi8-r and KOI8R will both beunderstood.

Common encodings recognized by ISO, MIME, IANA, and various otherstandardisation organisations are recognised; for a more detailedlist see Encode::Supported.

read() reads characters and returns the number of characters.seek() and tell() operate on byte counts, as do sysread()and sysseek().

Notice that because of the default behaviour of not doing anyconversion upon input if there is no default layer,it is easy to mistakenly write code that keeps on expanding a fileby repeatedly encoding the data:

  1.  # BAD CODE WARNING
    2.  
  2.  open F, "file";
    3.  
  3.  local $/; ## read in the whole file of 8-bit characters
    4.  
  4.  $t = <F>;
    5.  
  5.  close F;
    6.  
  6.  open F, ">:encoding(utf8)", "file";
    7.  
  7.  print F $t; ## convert to UTF-8 on output
    8.  
  8.  close F;
    9.

If you run this code twice, the contents of the file will be twiceUTF-8 encoded. A use open ':encoding(utf8)' would have avoided thebug, or explicitly opening also the file for input as UTF-8.

NOTE: the :utf8 and :encoding features work only if yourPerl has been built with the new PerlIO feature (which is the defaulton most systems).

Displaying Unicode As Text

Sometimes you might want to display Perl scalars containing Unicode assimple ASCII (or EBCDIC) text. The following subroutine convertsits argument so that Unicode characters with code points greater than255 are displayed as \x{...}, control characters (like \n) aredisplayed as \x.., and the rest of the characters as themselves:

  1.  sub nice_string {
    2.  
  2.  join("",
    3.  
  3.    map { $_ > 255 ?  # if wide character...
    4.  
  4.   sprintf("\x{%04X}", $_) :  # \x{...}
    5.  
  5.   chr($_) =~ /[[:cntrl:]]/ ?  # else if control character...
    6.  
  6.   sprintf("\x%02X", $_) : # \x..
    7.  
  7.   quotemeta(chr($_))  # else quoted or as themselves
    8.  
  8.  } unpack("W*", $_[0]));   # unpack Unicode characters
    9.  
  9.    }
    10.

For example,

  1.    nice_string("foo\x{100}bar\n")
    2.

returns the string

  1.    'foo\x{0100}bar\x0A'
    2.

which is ready to be printed.

Special Cases

  • Bit Complement Operator ~ And vec()

    The bit complement operator ~ may produce surprising results ifused on strings containing characters with ordinal values above255. In such a case, the results are consistent with the internalencoding of the characters, but not with much else. So don't dothat. Similarly for vec(): you will be operating on theinternally-encoded bit patterns of the Unicode characters, not onthe code point values, which is very probably not what you want.

  • Peeking At Perl's Internal Encoding

    Normal users of Perl should never care how Perl encodes any particularUnicode string (because the normal ways to get at the contents of astring with Unicode--via input and output--should always be viaexplicitly-defined I/O layers). But if you must, there are twoways of looking behind the scenes.

    One way of peeking inside the internal encoding of Unicode charactersis to use unpack("C*", ... to get the bytes of whatever the stringencoding happens to be, or unpack("U0..", ...) to get the bytes of theUTF-8 encoding:

    1.  # this prints  c4 80  for the UTF-8 bytes 0xc4 0x80
      2.  
    2.  print join(" ", unpack("U0(H2)*", pack("U", 0x100))), "\n";
      3.

    Yet another way would be to use the Devel::Peek module:

    1.  perl -MDevel::Peek -e 'Dump(chr(0x100))'
      2.

    That shows the UTF8 flag in FLAGS and both the UTF-8 bytesand Unicode characters in PV. See also later in this documentthe discussion about the utf8::is_utf8() function.

Advanced Topics

  • String Equivalence

    The question of string equivalence turns somewhat complicatedin Unicode: what do you mean by "equal"?

    (Is LATIN CAPITAL LETTER A WITH ACUTE equal toLATIN CAPITAL LETTER A?)

    The short answer is that by default Perl compares equivalence (eq,ne) based only on code points of the characters. In the abovecase, the answer is no (because 0x00C1 != 0x0041). But sometimes, anyCAPITAL LETTER A's should be considered equal, or even A's of any case.

    The long answer is that you need to consider character normalizationand casing issues: see Unicode::Normalize, Unicode Technical Report #15,Unicode Normalization Forms andsections on case mapping in the Unicode Standard.

    As of Perl 5.8.0, the "Full" case-folding of CaseMappings/SpecialCasing is implemented, but bugs remain in qr//i with them,mostly fixed by 5.14.

  • String Collation

    People like to see their strings nicely sorted--or as Unicodeparlance goes, collated. But again, what do you mean by collate?

    (Does LATIN CAPITAL LETTER A WITH ACUTE come before or afterLATIN CAPITAL LETTER A WITH GRAVE?)

    The short answer is that by default, Perl compares strings (lt,le, cmp, ge, gt) based only on the code points of thecharacters. In the above case, the answer is "after", since0x00C1 > 0x00C0.

    The long answer is that "it depends", and a good answer cannot begiven without knowing (at the very least) the language context.See Unicode::Collate, and Unicode Collation Algorithmhttp://www.unicode.org/unicode/reports/tr10/

Miscellaneous

  • Character Ranges and Classes

    Character ranges in regular expression bracketed character classes ( e.g.,/[a-z]/) and in the tr/// (also known as y///) operator are notmagically Unicode-aware. What this means is that [A-Za-z] will notmagically start to mean "all alphabetic letters" (not that it does mean thateven for 8-bit characters; for those, if you are using locales (perllocale),use /[[:alpha:]]/; and if not, use the 8-bit-aware property \p{alpha}).

    All the properties that begin with \p (and its inverse \P) are actuallycharacter classes that are Unicode-aware. There are dozens of them, seeperluniprops.

    You can use Unicode code points as the end points of character ranges, and therange will include all Unicode code points that lie between those end points.

  • String-To-Number Conversions

    Unicode does define several other decimal--and numeric--charactersbesides the familiar 0 to 9, such as the Arabic and Indic digits.Perl does not support string-to-number conversion for digits otherthan ASCII 0 to 9 (and ASCII a to f for hexadecimal).To get safe conversions from any Unicode string, usenum() in Unicode::UCD.

Questions With Answers

  • Will My Old Scripts Break?

    Very probably not. Unless you are generating Unicode characterssomehow, old behaviour should be preserved. About the only behaviourthat has changed and which could start generating Unicode is the oldbehaviour of chr() where supplying an argument more than 255produced a character modulo 255. chr(300), for example, was equalto chr(45) or "-" (in ASCII), now it is LATIN CAPITAL LETTER I WITHBREVE.

  • How Do I Make My Scripts Work With Unicode?

    Very little work should be needed since nothing changes until yougenerate Unicode data. The most important thing is getting input asUnicode; for that, see the earlier I/O discussion.To get full seamless Unicode support, adduse feature 'unicode_strings' (or use 5.012 or higher) to yourscript.

  • How Do I Know Whether My String Is In Unicode?

    You shouldn't have to care. But you may if your Perl is before 5.14.0or you haven't specified use feature 'unicode_strings' or use5.012 (or higher) because otherwise the semantics of the code pointsin the range 128 to 255 are different depending onwhether the string they are contained within is in Unicode or not.(See When Unicode Does Not Happen in perlunicode.)

    To determine if a string is in Unicode, use:

    1.  print utf8::is_utf8($string) ? 1 : 0, "\n";
      2.

    But note that this doesn't mean that any of the characters in thestring are necessary UTF-8 encoded, or that any of the characters havecode points greater than 0xFF (255) or even 0x80 (128), or that thestring has any characters at all. All the is_utf8() does is toreturn the value of the internal "utf8ness" flag attached to the$string. If the flag is off, the bytes in the scalar are interpretedas a single byte encoding. If the flag is on, the bytes in the scalarare interpreted as the (variable-length, potentially multi-byte) UTF-8 encodedcode points of the characters. Bytes added to a UTF-8 encoded string areautomatically upgraded to UTF-8. If mixed non-UTF-8 and UTF-8 scalarsare merged (double-quoted interpolation, explicit concatenation, orprintf/sprintf parameter substitution), the result will be UTF-8 encodedas if copies of the byte strings were upgraded to UTF-8: for example,

    1.  $a = "ab\x80c";
      2.  
    2.  $b = "\x{100}";
      3.  
    3.  print "$a = $b\n";
      4.

    the output string will be UTF-8-encoded ab\x80c = \x{100}\n, but$a will stay byte-encoded.

    Sometimes you might really need to know the byte length of a stringinstead of the character length. For that use either theEncode::encode_utf8() function or the bytes pragmaand the length() function:

    1.  my $unicode = chr(0x100);
      2.  
    2.  print length($unicode), "\n"; # will print 1
      3.  
    3.  require Encode;
      4.  
    4.  print length(Encode::encode_utf8($unicode)),"\n"; # will print 2
      5.  
    5.  use bytes;
      6.  
    6.  print length($unicode), "\n"; # will also print 2
      7.  
    7.   # (the 0xC4 0x80 of the UTF-8)
      8.  
    8.  no bytes;
      9.

  • How Do I Find Out What Encoding a File Has?

    You might try Encode::Guess, but it has a number of limitations.

  • How Do I Detect Data That's Not Valid In a Particular Encoding?

    Use the Encode package to try converting it.For example,

    1.  use Encode 'decode_utf8';
      2.  
    2.  
    3.  if (eval { decode_utf8($string, Encode::FB_CROAK); 1 }) {
      4.  
    4.  # $string is valid utf8
      5.  
    5.  } else {
      6.  
    6.  # $string is not valid utf8
      7.  
    7.  }
      8.

    Or use unpack to try decoding it:

    1.  use warnings;
      2.  
    2.  @chars = unpack("C0U*", $string_of_bytes_that_I_think_is_utf8);
      3.

    If invalid, a Malformed UTF-8 character warning is produced. The "C0" means"process the string character per character". Without that, theunpack("U*", ...) would work in U0 mode (the default if the formatstring starts with U) and it would return the bytes making up the UTF-8encoding of the target string, something that will always work.

  • How Do I Convert Binary Data Into a Particular Encoding, Or Vice Versa?

    This probably isn't as useful as you might think.Normally, you shouldn't need to.

    In one sense, what you are asking doesn't make much sense: encodingsare for characters, and binary data are not "characters", so converting"data" into some encoding isn't meaningful unless you know in whatcharacter set and encoding the binary data is in, in which case it'snot just binary data, now is it?

    If you have a raw sequence of bytes that you know should beinterpreted via a particular encoding, you can use Encode:

    1.  use Encode 'from_to';
      2.  
    2.  from_to($data, "iso-8859-1", "utf-8"); # from latin-1 to utf-8
      3.

    The call to from_to() changes the bytes in $data, but nothingmaterial about the nature of the string has changed as far as Perl isconcerned. Both before and after the call, the string $datacontains just a bunch of 8-bit bytes. As far as Perl is concerned,the encoding of the string remains as "system-native 8-bit bytes".

    You might relate this to a fictional 'Translate' module:

    1.    use Translate;
      2.  
    2.    my $phrase = "Yes";
      3.  
    3.    Translate::from_to($phrase, 'english', 'deutsch');
      4.  
    4.    ## phrase now contains "Ja"
      5.

    The contents of the string changes, but not the nature of the string.Perl doesn't know any more after the call than before that thecontents of the string indicates the affirmative.

    Back to converting data. If you have (or want) data in your system'snative 8-bit encoding (e.g. Latin-1, EBCDIC, etc.), you can usepack/unpack to convert to/from Unicode.

    1.  $native_string  = pack("W*", unpack("U*", $Unicode_string));
      2.  
    2.  $Unicode_string = pack("U*", unpack("W*", $native_string));
      3.

    If you have a sequence of bytes you know is valid UTF-8,but Perl doesn't know it yet, you can make Perl a believer, too:

    1.  use Encode 'decode_utf8';
      2.  
    2.  $Unicode = decode_utf8($bytes);
      3.

    or:

    1.  $Unicode = pack("U0a*", $bytes);
      2.

    You can find the bytes that make up a UTF-8 sequence with

    1.  @bytes = unpack("C*", $Unicode_string)
      2.

    and you can create well-formed Unicode with

    1.  $Unicode_string = pack("U*", 0xff, ...)
      2.

  • How Do I Display Unicode? How Do I Input Unicode?

    See http://www.alanwood.net/unicode/ andhttp://www.cl.cam.ac.uk/~mgk25/unicode.html

  • How Does Unicode Work With Traditional Locales?

    Starting in Perl 5.16, you can specify

    1.  use locale ':not_characters';
      2.

    to get Perl to work well with tradtional locales. The catch is that youhave to translate from the locale character set to/from Unicodeyourself. See Unicode I/O above for how to

    1.  use open ':locale';
      2.

    to accomplish this, but full details are in Unicode and UTF-8 in perllocale, including gotchas that happen if you don't specifiy:not_characters.

Hexadecimal Notation

The Unicode standard prefers using hexadecimal notation becausethat more clearly shows the division of Unicode into blocks of 256 characters.Hexadecimal is also simply shorter than decimal. You can use decimalnotation, too, but learning to use hexadecimal just makes life easierwith the Unicode standard. The U+HHHH notation uses hexadecimal,for example.

The 0x prefix means a hexadecimal number, the digits are 0-9 anda-f (or A-F, case doesn't matter). Each hexadecimal digit representsfour bits, or half a byte. print 0x..., "\n" will show ahexadecimal number in decimal, and printf "%x\n", $decimal willshow a decimal number in hexadecimal. If you have just the"hex digits" of a hexadecimal number, you can use the hex() function.

  1.  print 0x0009, "\n"; # 9
    2.  
  2.  print 0x000a, "\n"; # 10
    3.  
  3.  print 0x000f, "\n"; # 15
    4.  
  4.  print 0x0010, "\n"; # 16
    5.  
  5.  print 0x0011, "\n"; # 17
    6.  
  6.  print 0x0100, "\n"; # 256
    7.  
  7.  
  8.  print 0x0041, "\n"; # 65
    9.  
  9.  
  10.  printf "%x\n",  65; # 41
    11.  
  11.  printf "%#x\n", 65; # 0x41
    12.  
  12.  
  13.  print hex("41"), "\n"; # 65
    14.

Further Resources

UNICODE IN OLDER PERLS

If you cannot upgrade your Perl to 5.8.0 or later, you can stilldo some Unicode processing by using the modules Unicode::String,Unicode::Map8, and Unicode::Map, available from CPAN.If you have the GNU recode installed, you can also use thePerl front-end Convert::Recode for character conversions.

The following are fast conversions from ISO 8859-1 (Latin-1) bytesto UTF-8 bytes and back, the code works even with older Perl 5 versions.

  1.  # ISO 8859-1 to UTF-8
    2.  
  2.  s/([\x80-\xFF])/chr(0xC0|ord($1)>>6).chr(0x80|ord($1)&0x3F)/eg;
    3.  
  3.  
  4.  # UTF-8 to ISO 8859-1
    5.  
  5.  s/([\xC2\xC3])([\x80-\xBF])/chr(ord($1)<<6&0xC0|ord($2)&0x3F)/eg;
    6.

SEE ALSO

perlunitut, perlunicode, Encode, open, utf8, bytes,perlretut, perlrun, Unicode::Collate, Unicode::Normalize,Unicode::UCD

ACKNOWLEDGMENTS

Thanks to the kind readers of the [email protected],[email protected], [email protected], and [email protected] lists for their valuable feedback.

AUTHOR, COPYRIGHT, AND LICENSE

Copyright 2001-2011 Jarkko Hietaniemi <[email protected]>

This document may be distributed under the same terms as Perl itself.

Page index
 
Source : perldoc.perl.org - Official documentation for the Perl programming language
Site maintained by Jon Allen (JJ)     See the project page for more details
Documentation maintained by the Perl 5 Porters
(Sebelumnya) Perl locale handling (internat ...Unicode support in Perl (Berikutnya)