Ilya Zakharevich

NAME

utf8 - Perl pragma to turn on UTF-8 and Unicode support

SYNOPSIS

    use utf8;
    no utf8;

DESCRIPTION

The utf8 pragma tells Perl to use UTF-8 as its internal string representation for the rest of the enclosing block. (The "no utf8" pragma tells Perl to switch back to ordinary byte-oriented processing for the rest of the enclosing block.) Under utf8, many operations that formerly operated on bytes change to operating on characters. For ASCII data this makes no difference, because UTF-8 stores ASCII in single bytes, but for any character greater than chr(127), the character is stored in a sequence of two or more bytes, all of which have the high bit set. But by and large, the user need not worry about this, because the utf8 pragma hides it from the user. A character under utf8 is logically just a number ranging from 0 to 2**32 or so. Larger characters encode to longer sequences of bytes, but again, this is hidden.

Use of the utf8 pragma has the following effects:

  • Strings and patterns may contain characters that have an ordinal value larger than 255. Presuming you use a Unicode editor to edit your program, these will typically occur directly within the literal strings as UTF-8 characters, but you can also specify a particular character with an extension of the \x notation. UTF-8 characters are specified by putting the hexidecimal code within curlies after the \x. For instance, a Unicode smiley face is \x{263A}. A character in the Latin-1 range (128..255) should be written \x{ab} rather than \xab, since the former will turn into a two-byte UTF-8 code, while the latter will continue to be interpreted as generating a 8-bit byte rather than a character. In fact, if -w is turned on, it will produce a warning that you might be generating invalid UTF-8.

  • Identifiers within the Perl script may contain Unicode alphanumeric characters, including ideographs. (You are currently on your own when it comes to using the canonical forms of characters--Perl doesn't (yet) attempt to canonicalize variable names for you.)

  • Regular expressions match characters instead of bytes. For instance, "." matches a character instead of a byte. (However, the \C pattern is provided to force a match a single byte ("char" in C, hence \C).)

  • Character classes in regular expressions match characters instead of bytes, and match against the character properties specified in the Unicode properties database. So \w can be used to match an ideograph, for instance.

  • Named Unicode properties and block ranges make be used as character classes via the new \p{} (matches property) and \P{} (doesn't match property) constructs. For instance, \p{Lu} matches any character with the Unicode uppercase property, while \p{M} matches any mark character. Single letter properties may omit the brackets, so that can be written \pM also. Many predefined character classes are available, such as \p{IsMirrored} and \p{InTibetan}.

  • The special pattern \X match matches any extended Unicode sequence (a "combining character sequence" in Standardese), where the first character is a base character and subsequent characters are mark characters that apply to the base character. It is equivalent to (?:\PM\pM*).

  • The tr/// operator translates characters instead of bytes. It can also be forced to translate between 8-bit codes and UTF-8 regardless of the surrounding utf8 state. For instance, if you know your input in Latin-1, you can say:

        use utf8;
        while (<>) {
            tr/\0-\xff//CU;         # latin1 char to utf8
            ...
        }

    Similarly you could translate your output with

        tr/\0-\x{ff}//UC;           # utf8 to latin1 char

    No, s/// doesn't take /U or /C (yet?).

  • Case translation operators use the Unicode case translation tables. Note that uc() translates to uppercase, while ucfirst translates to titlecase (for languages that make the distinction). Naturally the corresponding backslash sequences have the same semantics.

  • Most operators that deal with positions or lengths in the string will automatically switch to using character positions, including chop(), substr(), pos(), index(), rindex(), sprintf(), write(), and length(). Operators that specifically don't switch include vec(), pack(), and unpack(). Operators that really don't care include chomp(), as well as any other operator that treats a string as a bucket of bits, such as sort(), and the operators dealing with filenames.

  • The pack()/unpack() letters "c" and "C" do not change, since they're often used for byte-oriented formats. (Again, think "char" in the C language.) However, there is a new "U" specifier that will convert between UTF-8 characters and integers. (It works outside of the utf8 pragma too.)

  • The chr() and ord() functions work on characters. This is like pack("U") and unpack("U"), not like pack("C") and unpack("C"). In fact, the latter are how you now emulate byte-oriented chr() and ord() under utf8.

  • And finally, scalar reverse() reverses by character rather than by byte.

CAVEATS

As of yet, there is no method for automatically coercing input and output to some encoding other than UTF-8. This is planned in the near future, however.

In any event, you'll need to keep track of whether interfaces to other modules expect UTF-8 data or something else. The utf8 pragma does not magically mark strings for you in order to remember their encoding, nor will any automatic coercion happen (other than that eventually planned for I/O). If you want such automatic coercion, you can build yourself a set of pretty object-oriented modules. Expect it to run considerably slower than than this low-level support.

Use of locales with utf8 may lead to odd results. Currently there is some attempt to apply 8-bit locale info to characters in the range 0..255, but this is demonstrably incorrect for locales that use characters above that range (when mapped into Unicode). It will also tend to run slower. Avoidance of locales is strongly encouraged.




Hosting generously
sponsored by Bytemark