diff options
Diffstat (limited to 'Master/tlpkg/tlperl/lib/pods/perlrecharclass.pod')
-rw-r--r-- | Master/tlpkg/tlperl/lib/pods/perlrecharclass.pod | 850 |
1 files changed, 0 insertions, 850 deletions
diff --git a/Master/tlpkg/tlperl/lib/pods/perlrecharclass.pod b/Master/tlpkg/tlperl/lib/pods/perlrecharclass.pod deleted file mode 100644 index 06d206b2f8b..00000000000 --- a/Master/tlpkg/tlperl/lib/pods/perlrecharclass.pod +++ /dev/null @@ -1,850 +0,0 @@ -=head1 NAME -X<character class> - -perlrecharclass - Perl Regular Expression Character Classes - -=head1 DESCRIPTION - -The top level documentation about Perl regular expressions -is found in L<perlre>. - -This manual page discusses the syntax and use of character -classes in Perl regular expressions. - -A character class is a way of denoting a set of characters -in such a way that one character of the set is matched. -It's important to remember that: matching a character class -consumes exactly one character in the source string. (The source -string is the string the regular expression is matched against.) - -There are three types of character classes in Perl regular -expressions: the dot, backslash sequences, and the form enclosed in square -brackets. Keep in mind, though, that often the term "character class" is used -to mean just the bracketed form. Certainly, most Perl documentation does that. - -=head2 The dot - -The dot (or period), C<.> is probably the most used, and certainly -the most well-known character class. By default, a dot matches any -character, except for the newline. That default can be changed to -add matching the newline by using the I<single line> modifier: either -for the entire regular expression with the C</s> modifier, or -locally with C<(?s)>. (The experimental C<\N> backslash sequence, described -below, matches any character except newline without regard to the -I<single line> modifier.) - -Here are some examples: - - "a" =~ /./ # Match - "." =~ /./ # Match - "" =~ /./ # No match (dot has to match a character) - "\n" =~ /./ # No match (dot does not match a newline) - "\n" =~ /./s # Match (global 'single line' modifier) - "\n" =~ /(?s:.)/ # Match (local 'single line' modifier) - "ab" =~ /^.$/ # No match (dot matches one character) - -=head2 Backslash sequences -X<\w> X<\W> X<\s> X<\S> X<\d> X<\D> X<\p> X<\P> -X<\N> X<\v> X<\V> X<\h> X<\H> -X<word> X<whitespace> - -A backslash sequence is a sequence of characters, the first one of which is a -backslash. Perl ascribes special meaning to many such sequences, and some of -these are character classes. That is, they match a single character each, -provided that the character belongs to the specific set of characters defined -by the sequence. - -Here's a list of the backslash sequences that are character classes. They -are discussed in more detail below. (For the backslash sequences that aren't -character classes, see L<perlrebackslash>.) - - \d Match a decimal digit character. - \D Match a non-decimal-digit character. - \w Match a "word" character. - \W Match a non-"word" character. - \s Match a whitespace character. - \S Match a non-whitespace character. - \h Match a horizontal whitespace character. - \H Match a character that isn't horizontal whitespace. - \v Match a vertical whitespace character. - \V Match a character that isn't vertical whitespace. - \N Match a character that isn't a newline. Experimental. - \pP, \p{Prop} Match a character that has the given Unicode property. - \PP, \P{Prop} Match a character that doesn't have the Unicode property - -=head3 \N - -C<\N> is new in 5.12, and is experimental. It, like the dot, matches any -character that is not a newline. The difference is that C<\N> is not influenced -by the I<single line> regular expression modifier (see L</The dot> above). Note -that the form C<\N{...}> may mean something completely different. When the -C<{...}> is a L<quantifier|perlre/Quantifiers>, it means to match a non-newline -character that many times. For example, C<\N{3}> means to match 3 -non-newlines; C<\N{5,}> means to match 5 or more non-newlines. But if C<{...}> -is not a legal quantifier, it is presumed to be a named character. See -L<charnames> for those. For example, none of C<\N{COLON}>, C<\N{4F}>, and -C<\N{F4}> contain legal quantifiers, so Perl will try to find characters whose -names are respectively C<COLON>, C<4F>, and C<F4>. - -=head3 Digits - -C<\d> matches a single character considered to be a decimal I<digit>. -If the C</a> regular expression modifier is in effect, it matches [0-9]. -Otherwise, it -matches anything that is matched by C<\p{Digit}>, which includes [0-9]. -(An unlikely possible exception is that under locale matching rules, the -current locale might not have [0-9] matched by C<\d>, and/or might match -other characters whose code point is less than 256. Such a locale -definition would be in violation of the C language standard, but Perl -doesn't currently assume anything in regard to this.) - -What this means is that unless the C</a> modifier is in effect C<\d> not -only matches the digits '0' - '9', but also Arabic, Devanagari, and -digits from other languages. This may cause some confusion, and some -security issues. - -Some digits that C<\d> matches look like some of the [0-9] ones, but -have different values. For example, BENGALI DIGIT FOUR (U+09EA) looks -very much like an ASCII DIGIT EIGHT (U+0038). An application that -is expecting only the ASCII digits might be misled, or if the match is -C<\d+>, the matched string might contain a mixture of digits from -different writing systems that look like they signify a number different -than they actually do. L<Unicode::UCD/num()> can -be used to safely -calculate the value, returning C<undef> if the input string contains -such a mixture. - -What C<\p{Digit}> means (and hence C<\d> except under the C</a> -modifier) is C<\p{General_Category=Decimal_Number}>, or synonymously, -C<\p{General_Category=Digit}>. Starting with Unicode version 4.1, this -is the same set of characters matched by C<\p{Numeric_Type=Decimal}>. -But Unicode also has a different property with a similar name, -C<\p{Numeric_Type=Digit}>, which matches a completely different set of -characters. These characters are things such as C<CIRCLED DIGIT ONE> -or subscripts, or are from writing systems that lack all ten digits. - -The design intent is for C<\d> to exactly match the set of characters -that can safely be used with "normal" big-endian positional decimal -syntax, where, for example 123 means one 'hundred', plus two 'tens', -plus three 'ones'. This positional notation does not necessarily apply -to characters that match the other type of "digit", -C<\p{Numeric_Type=Digit}>, and so C<\d> doesn't match them. - -The Tamil digits (U+0BE6 - U+0BEF) can also legally be -used in old-style Tamil numbers in which they would appear no more than -one in a row, separated by characters that mean "times 10", "times 100", -etc. (See L<http://www.unicode.org/notes/tn21>.) - -Any character not matched by C<\d> is matched by C<\D>. - -=head3 Word characters - -A C<\w> matches a single alphanumeric character (an alphabetic character, or a -decimal digit) or a connecting punctuation character, such as an -underscore ("_"). It does not match a whole word. To match a whole -word, use C<\w+>. This isn't the same thing as matching an English word, but -in the ASCII range it is the same as a string of Perl-identifier -characters. - -=over - -=item If the C</a> modifier is in effect ... - -C<\w> matches the 63 characters [a-zA-Z0-9_]. - -=item otherwise ... - -=over - -=item For code points above 255 ... - -C<\w> matches the same as C<\p{Word}> matches in this range. That is, -it matches Thai letters, Greek letters, etc. This includes connector -punctuation (like the underscore) which connect two words together, or -diacritics, such as a C<COMBINING TILDE> and the modifier letters, which -are generally used to add auxiliary markings to letters. - -=item For code points below 256 ... - -=over - -=item if locale rules are in effect ... - -C<\w> matches the platform's native underscore character plus whatever -the locale considers to be alphanumeric. - -=item if Unicode rules are in effect or if on an EBCDIC platform ... - -C<\w> matches exactly what C<\p{Word}> matches. - -=item otherwise ... - -C<\w> matches [a-zA-Z0-9_]. - -=back - -=back - -=back - -Which rules apply are determined as described in L<perlre/Which character set modifier is in effect?>. - -There are a number of security issues with the full Unicode list of word -characters. See L<http://unicode.org/reports/tr36>. - -Also, for a somewhat finer-grained set of characters that are in programming -language identifiers beyond the ASCII range, you may wish to instead use the -more customized L</Unicode Properties>, C<\p{ID_Start}>, -C<\p{ID_Continue}>, C<\p{XID_Start}>, and C<\p{XID_Continue}>. See -L<http://unicode.org/reports/tr31>. - -Any character not matched by C<\w> is matched by C<\W>. - -=head3 Whitespace - -C<\s> matches any single character considered whitespace. - -=over - -=item If the C</a> modifier is in effect ... - -C<\s> matches the 5 characters [\t\n\f\r ]; that is, the horizontal tab, -the newline, the form feed, the carriage return, and the space. (Note -that it doesn't match the vertical tab, C<\cK> on ASCII platforms.) - -=item otherwise ... - -=over - -=item For code points above 255 ... - -C<\s> matches exactly the code points above 255 shown with an "s" column -in the table below. - -=item For code points below 256 ... - -=over - -=item if locale rules are in effect ... - -C<\s> matches whatever the locale considers to be whitespace. Note that -this is likely to include the vertical space, unlike non-locale C<\s> -matching. - -=item if Unicode rules are in effect or if on an EBCDIC platform ... - -C<\s> matches exactly the characters shown with an "s" column in the -table below. - -=item otherwise ... - -C<\s> matches [\t\n\f\r ]. -Note that this list doesn't include the non-breaking space. - -=back - -=back - -=back - -Which rules apply are determined as described in L<perlre/Which character set modifier is in effect?>. - -Any character not matched by C<\s> is matched by C<\S>. - -C<\h> matches any character considered horizontal whitespace; -this includes the platform's space and tab characters and several others -listed in the table below. C<\H> matches any character -not considered horizontal whitespace. They use the platform's native -character set, and do not consider any locale that may otherwise be in -use. - -C<\v> matches any character considered vertical whitespace; -this includes the platform's carriage return and line feed characters (newline) -plus several other characters, all listed in the table below. -C<\V> matches any character not considered vertical whitespace. -They use the platform's native character set, and do not consider any -locale that may otherwise be in use. - -C<\R> matches anything that can be considered a newline under Unicode -rules. It's not a character class, as it can match a multi-character -sequence. Therefore, it cannot be used inside a bracketed character -class; use C<\v> instead (vertical whitespace). It uses the platform's -native character set, and does not consider any locale that may -otherwise be in use. -Details are discussed in L<perlrebackslash>. - -Note that unlike C<\s> (and C<\d> and C<\w>), C<\h> and C<\v> always match -the same characters, without regard to other factors, such as the active -locale or whether the source string is in UTF-8 format. - -One might think that C<\s> is equivalent to C<[\h\v]>. This is not true. -The difference is that the vertical tab (C<"\x0b">) is not matched by -C<\s>; it is however considered vertical whitespace. - -The following table is a complete listing of characters matched by -C<\s>, C<\h> and C<\v> as of Unicode 6.0. - -The first column gives the Unicode code point of the character (in hex format), -the second column gives the (Unicode) name. The third column indicates -by which class(es) the character is matched (assuming no locale or EBCDIC code -page is in effect that changes the C<\s> matching). - - 0x0009 CHARACTER TABULATION h s - 0x000a LINE FEED (LF) vs - 0x000b LINE TABULATION v - 0x000c FORM FEED (FF) vs - 0x000d CARRIAGE RETURN (CR) vs - 0x0020 SPACE h s - 0x0085 NEXT LINE (NEL) vs [1] - 0x00a0 NO-BREAK SPACE h s [1] - 0x1680 OGHAM SPACE MARK h s - 0x180e MONGOLIAN VOWEL SEPARATOR h s - 0x2000 EN QUAD h s - 0x2001 EM QUAD h s - 0x2002 EN SPACE h s - 0x2003 EM SPACE h s - 0x2004 THREE-PER-EM SPACE h s - 0x2005 FOUR-PER-EM SPACE h s - 0x2006 SIX-PER-EM SPACE h s - 0x2007 FIGURE SPACE h s - 0x2008 PUNCTUATION SPACE h s - 0x2009 THIN SPACE h s - 0x200a HAIR SPACE h s - 0x2028 LINE SEPARATOR vs - 0x2029 PARAGRAPH SEPARATOR vs - 0x202f NARROW NO-BREAK SPACE h s - 0x205f MEDIUM MATHEMATICAL SPACE h s - 0x3000 IDEOGRAPHIC SPACE h s - -=over 4 - -=item [1] - -NEXT LINE and NO-BREAK SPACE may or may not match C<\s> depending -on the rules in effect. See -L<the beginning of this section|/Whitespace>. - -=back - -=head3 Unicode Properties - -C<\pP> and C<\p{Prop}> are character classes to match characters that fit given -Unicode properties. One letter property names can be used in the C<\pP> form, -with the property name following the C<\p>, otherwise, braces are required. -When using braces, there is a single form, which is just the property name -enclosed in the braces, and a compound form which looks like C<\p{name=value}>, -which means to match if the property "name" for the character has that particular -"value". -For instance, a match for a number can be written as C</\pN/> or as -C</\p{Number}/>, or as C</\p{Number=True}/>. -Lowercase letters are matched by the property I<Lowercase_Letter> which -has the short form I<Ll>. They need the braces, so are written as C</\p{Ll}/> or -C</\p{Lowercase_Letter}/>, or C</\p{General_Category=Lowercase_Letter}/> -(the underscores are optional). -C</\pLl/> is valid, but means something different. -It matches a two character string: a letter (Unicode property C<\pL>), -followed by a lowercase C<l>. - -If neither the C</a> modifier nor locale rules are in effect, the use of -a Unicode property will force the regular expression into using Unicode -rules. - -Note that almost all properties are immune to case-insensitive matching. -That is, adding a C</i> regular expression modifier does not change what -they match. There are two sets that are affected. The first set is -C<Uppercase_Letter>, -C<Lowercase_Letter>, -and C<Titlecase_Letter>, -all of which match C<Cased_Letter> under C</i> matching. -The second set is -C<Uppercase>, -C<Lowercase>, -and C<Titlecase>, -all of which match C<Cased> under C</i> matching. -(The difference between these sets is that some things, such as Roman -numerals, come in both upper and lower case, so they are C<Cased>, but -aren't considered to be letters, so they aren't C<Cased_Letter>s. They're -actually C<Letter_Number>s.) -This set also includes its subsets C<PosixUpper> and C<PosixLower>, both -of which under C</i> match C<PosixAlpha>. - -For more details on Unicode properties, see L<perlunicode/Unicode -Character Properties>; for a -complete list of possible properties, see -L<perluniprops/Properties accessible through \p{} and \P{}>, -which notes all forms that have C</i> differences. -It is also possible to define your own properties. This is discussed in -L<perlunicode/User-Defined Character Properties>. - -Unicode properties are defined (surprise!) only on Unicode code points. -A warning is raised and all matches fail on non-Unicode code points -(those above the legal Unicode maximum of 0x10FFFF). This can be -somewhat surprising, - - chr(0x110000) =~ \p{ASCII_Hex_Digit=True} # Fails. - chr(0x110000) =~ \p{ASCII_Hex_Digit=False} # Also fails! - -Even though these two matches might be thought of as complements, they -are so only on Unicode code points. - -=head4 Examples - - "a" =~ /\w/ # Match, "a" is a 'word' character. - "7" =~ /\w/ # Match, "7" is a 'word' character as well. - "a" =~ /\d/ # No match, "a" isn't a digit. - "7" =~ /\d/ # Match, "7" is a digit. - " " =~ /\s/ # Match, a space is whitespace. - "a" =~ /\D/ # Match, "a" is a non-digit. - "7" =~ /\D/ # No match, "7" is not a non-digit. - " " =~ /\S/ # No match, a space is not non-whitespace. - - " " =~ /\h/ # Match, space is horizontal whitespace. - " " =~ /\v/ # No match, space is not vertical whitespace. - "\r" =~ /\v/ # Match, a return is vertical whitespace. - - "a" =~ /\pL/ # Match, "a" is a letter. - "a" =~ /\p{Lu}/ # No match, /\p{Lu}/ matches upper case letters. - - "\x{0e0b}" =~ /\p{Thai}/ # Match, \x{0e0b} is the character - # 'THAI CHARACTER SO SO', and that's in - # Thai Unicode class. - "a" =~ /\P{Lao}/ # Match, as "a" is not a Laotian character. - -It is worth emphasizing that C<\d>, C<\w>, etc, match single characters, not -complete numbers or words. To match a number (that consists of digits), -use C<\d+>; to match a word, use C<\w+>. But be aware of the security -considerations in doing so, as mentioned above. - -=head2 Bracketed Character Classes - -The third form of character class you can use in Perl regular expressions -is the bracketed character class. In its simplest form, it lists the characters -that may be matched, surrounded by square brackets, like this: C<[aeiou]>. -This matches one of C<a>, C<e>, C<i>, C<o> or C<u>. Like the other -character classes, exactly one character is matched.* To match -a longer string consisting of characters mentioned in the character -class, follow the character class with a L<quantifier|perlre/Quantifiers>. For -instance, C<[aeiou]+> matches one or more lowercase English vowels. - -Repeating a character in a character class has no -effect; it's considered to be in the set only once. - -Examples: - - "e" =~ /[aeiou]/ # Match, as "e" is listed in the class. - "p" =~ /[aeiou]/ # No match, "p" is not listed in the class. - "ae" =~ /^[aeiou]$/ # No match, a character class only matches - # a single character. - "ae" =~ /^[aeiou]+$/ # Match, due to the quantifier. - - ------- - -* There is an exception to a bracketed character class matching a -single character only. When the class is to match caselessly under C</i> -matching rules, and a character inside the class matches a -multiple-character sequence caselessly under Unicode rules, the class -(when not L<inverted|/Negation>) will also match that sequence. For -example, Unicode says that the letter C<LATIN SMALL LETTER SHARP S> -should match the sequence C<ss> under C</i> rules. Thus, - - 'ss' =~ /\A\N{LATIN SMALL LETTER SHARP S}\z/i # Matches - 'ss' =~ /\A[aeioust\N{LATIN SMALL LETTER SHARP S}]\z/i # Matches - -=head3 Special Characters Inside a Bracketed Character Class - -Most characters that are meta characters in regular expressions (that -is, characters that carry a special meaning like C<.>, C<*>, or C<(>) lose -their special meaning and can be used inside a character class without -the need to escape them. For instance, C<[()]> matches either an opening -parenthesis, or a closing parenthesis, and the parens inside the character -class don't group or capture. - -Characters that may carry a special meaning inside a character class are: -C<\>, C<^>, C<->, C<[> and C<]>, and are discussed below. They can be -escaped with a backslash, although this is sometimes not needed, in which -case the backslash may be omitted. - -The sequence C<\b> is special inside a bracketed character class. While -outside the character class, C<\b> is an assertion indicating a point -that does not have either two word characters or two non-word characters -on either side, inside a bracketed character class, C<\b> matches a -backspace character. - -The sequences -C<\a>, -C<\c>, -C<\e>, -C<\f>, -C<\n>, -C<\N{I<NAME>}>, -C<\N{U+I<hex char>}>, -C<\r>, -C<\t>, -and -C<\x> -are also special and have the same meanings as they do outside a -bracketed character class. (However, inside a bracketed character -class, if C<\N{I<NAME>}> expands to a sequence of characters, only the first -one in the sequence is used, with a warning.) - -Also, a backslash followed by two or three octal digits is considered an octal -number. - -A C<[> is not special inside a character class, unless it's the start of a -POSIX character class (see L</POSIX Character Classes> below). It normally does -not need escaping. - -A C<]> is normally either the end of a POSIX character class (see -L</POSIX Character Classes> below), or it signals the end of the bracketed -character class. If you want to include a C<]> in the set of characters, you -must generally escape it. - -However, if the C<]> is the I<first> (or the second if the first -character is a caret) character of a bracketed character class, it -does not denote the end of the class (as you cannot have an empty class) -and is considered part of the set of characters that can be matched without -escaping. - -Examples: - - "+" =~ /[+?*]/ # Match, "+" in a character class is not special. - "\cH" =~ /[\b]/ # Match, \b inside in a character class - # is equivalent to a backspace. - "]" =~ /[][]/ # Match, as the character class contains. - # both [ and ]. - "[]" =~ /[[]]/ # Match, the pattern contains a character class - # containing just ], and the character class is - # followed by a ]. - -=head3 Character Ranges - -It is not uncommon to want to match a range of characters. Luckily, instead -of listing all characters in the range, one may use the hyphen (C<->). -If inside a bracketed character class you have two characters separated -by a hyphen, it's treated as if all characters between the two were in -the class. For instance, C<[0-9]> matches any ASCII digit, and C<[a-m]> -matches any lowercase letter from the first half of the ASCII alphabet. - -Note that the two characters on either side of the hyphen are not -necessarily both letters or both digits. Any character is possible, -although not advisable. C<['-?]> contains a range of characters, but -most people will not know which characters that means. Furthermore, -such ranges may lead to portability problems if the code has to run on -a platform that uses a different character set, such as EBCDIC. - -If a hyphen in a character class cannot syntactically be part of a range, for -instance because it is the first or the last character of the character class, -or if it immediately follows a range, the hyphen isn't special, and so is -considered a character to be matched literally. If you want a hyphen in -your set of characters to be matched and its position in the class is such -that it could be considered part of a range, you must escape that hyphen -with a backslash. - -Examples: - - [a-z] # Matches a character that is a lower case ASCII letter. - [a-fz] # Matches any letter between 'a' and 'f' (inclusive) or - # the letter 'z'. - [-z] # Matches either a hyphen ('-') or the letter 'z'. - [a-f-m] # Matches any letter between 'a' and 'f' (inclusive), the - # hyphen ('-'), or the letter 'm'. - ['-?] # Matches any of the characters '()*+,-./0123456789:;<=>? - # (But not on an EBCDIC platform). - - -=head3 Negation - -It is also possible to instead list the characters you do not want to -match. You can do so by using a caret (C<^>) as the first character in the -character class. For instance, C<[^a-z]> matches any character that is not a -lowercase ASCII letter, which therefore includes more than a million -Unicode code points. The class is said to be "negated" or "inverted". - -This syntax make the caret a special character inside a bracketed character -class, but only if it is the first character of the class. So if you want -the caret as one of the characters to match, either escape the caret or -else don't list it first. - -In inverted bracketed character classes, Perl ignores the Unicode rules -that normally say that certain characters should match a sequence of -multiple characters under caseless C</i> matching. Following those -rules could lead to highly confusing situations: - - "ss" =~ /^[^\xDF]+$/ui; # Matches! - -This should match any sequences of characters that aren't C<\xDF> nor -what C<\xDF> matches under C</i>. C<"s"> isn't C<\xDF>, but Unicode -says that C<"ss"> is what C<\xDF> matches under C</i>. So which one -"wins"? Do you fail the match because the string has C<ss> or accept it -because it has an C<s> followed by another C<s>? Perl has chosen the -latter. - -Examples: - - "e" =~ /[^aeiou]/ # No match, the 'e' is listed. - "x" =~ /[^aeiou]/ # Match, as 'x' isn't a lowercase vowel. - "^" =~ /[^^]/ # No match, matches anything that isn't a caret. - "^" =~ /[x^]/ # Match, caret is not special here. - -=head3 Backslash Sequences - -You can put any backslash sequence character class (with the exception of -C<\N> and C<\R>) inside a bracketed character class, and it will act just -as if you had put all characters matched by the backslash sequence inside the -character class. For instance, C<[a-f\d]> matches any decimal digit, or any -of the lowercase letters between 'a' and 'f' inclusive. - -C<\N> within a bracketed character class must be of the forms C<\N{I<name>}> -or C<\N{U+I<hex char>}>, and NOT be the form that matches non-newlines, -for the same reason that a dot C<.> inside a bracketed character class loses -its special meaning: it matches nearly anything, which generally isn't what you -want to happen. - - -Examples: - - /[\p{Thai}\d]/ # Matches a character that is either a Thai - # character, or a digit. - /[^\p{Arabic}()]/ # Matches a character that is neither an Arabic - # character, nor a parenthesis. - -Backslash sequence character classes cannot form one of the endpoints -of a range. Thus, you can't say: - - /[\p{Thai}-\d]/ # Wrong! - -=head3 POSIX Character Classes -X<character class> X<\p> X<\p{}> -X<alpha> X<alnum> X<ascii> X<blank> X<cntrl> X<digit> X<graph> -X<lower> X<print> X<punct> X<space> X<upper> X<word> X<xdigit> - -POSIX character classes have the form C<[:class:]>, where I<class> is -name, and the C<[:> and C<:]> delimiters. POSIX character classes only appear -I<inside> bracketed character classes, and are a convenient and descriptive -way of listing a group of characters. - -Be careful about the syntax, - - # Correct: - $string =~ /[[:alpha:]]/ - - # Incorrect (will warn): - $string =~ /[:alpha:]/ - -The latter pattern would be a character class consisting of a colon, -and the letters C<a>, C<l>, C<p> and C<h>. -POSIX character classes can be part of a larger bracketed character class. -For example, - - [01[:alpha:]%] - -is valid and matches '0', '1', any alphabetic character, and the percent sign. - -Perl recognizes the following POSIX character classes: - - alpha Any alphabetical character ("[A-Za-z]"). - alnum Any alphanumeric character. ("[A-Za-z0-9]") - ascii Any character in the ASCII character set. - blank A GNU extension, equal to a space or a horizontal tab ("\t"). - cntrl Any control character. See Note [2] below. - digit Any decimal digit ("[0-9]"), equivalent to "\d". - graph Any printable character, excluding a space. See Note [3] below. - lower Any lowercase character ("[a-z]"). - print Any printable character, including a space. See Note [4] below. - punct Any graphical character excluding "word" characters. Note [5]. - space Any whitespace character. "\s" plus the vertical tab ("\cK"). - upper Any uppercase character ("[A-Z]"). - word A Perl extension ("[A-Za-z0-9_]"), equivalent to "\w". - xdigit Any hexadecimal digit ("[0-9a-fA-F]"). - -Most POSIX character classes have two Unicode-style C<\p> property -counterparts. (They are not official Unicode properties, but Perl extensions -derived from official Unicode properties.) The table below shows the relation -between POSIX character classes and these counterparts. - -One counterpart, in the column labelled "ASCII-range Unicode" in -the table, matches only characters in the ASCII character set. - -The other counterpart, in the column labelled "Full-range Unicode", matches any -appropriate characters in the full Unicode character set. For example, -C<\p{Alpha}> matches not just the ASCII alphabetic characters, but any -character in the entire Unicode character set considered alphabetic. -An entry in the column labelled "backslash sequence" is a (short) -equivalent. - - [[:...:]] ASCII-range Full-range backslash Note - Unicode Unicode sequence - ----------------------------------------------------- - alpha \p{PosixAlpha} \p{XPosixAlpha} - alnum \p{PosixAlnum} \p{XPosixAlnum} - ascii \p{ASCII} - blank \p{PosixBlank} \p{XPosixBlank} \h [1] - or \p{HorizSpace} [1] - cntrl \p{PosixCntrl} \p{XPosixCntrl} [2] - digit \p{PosixDigit} \p{XPosixDigit} \d - graph \p{PosixGraph} \p{XPosixGraph} [3] - lower \p{PosixLower} \p{XPosixLower} - print \p{PosixPrint} \p{XPosixPrint} [4] - punct \p{PosixPunct} \p{XPosixPunct} [5] - \p{PerlSpace} \p{XPerlSpace} \s [6] - space \p{PosixSpace} \p{XPosixSpace} [6] - upper \p{PosixUpper} \p{XPosixUpper} - word \p{PosixWord} \p{XPosixWord} \w - xdigit \p{PosixXDigit} \p{XPosixXDigit} - -=over 4 - -=item [1] - -C<\p{Blank}> and C<\p{HorizSpace}> are synonyms. - -=item [2] - -Control characters don't produce output as such, but instead usually control -the terminal somehow: for example, newline and backspace are control characters. -In the ASCII range, characters whose code points are between 0 and 31 inclusive, -plus 127 (C<DEL>) are control characters. - -On EBCDIC platforms, it is likely that the code page will define C<[[:cntrl:]]> -to be the EBCDIC equivalents of the ASCII controls, plus the controls -that in Unicode have code pointss from 128 through 159. - -=item [3] - -Any character that is I<graphical>, that is, visible. This class consists -of all alphanumeric characters and all punctuation characters. - -=item [4] - -All printable characters, which is the set of all graphical characters -plus those whitespace characters which are not also controls. - -=item [5] - -C<\p{PosixPunct}> and C<[[:punct:]]> in the ASCII range match all -non-controls, non-alphanumeric, non-space characters: -C<[-!"#$%&'()*+,./:;<=E<gt>?@[\\\]^_`{|}~]> (although if a locale is in effect, -it could alter the behavior of C<[[:punct:]]>). - -The similarly named property, C<\p{Punct}>, matches a somewhat different -set in the ASCII range, namely -C<[-!"#%&'()*,./:;?@[\\\]_{}]>. That is, it is missing the nine -characters C<[$+E<lt>=E<gt>^`|~]>. -This is because Unicode splits what POSIX considers to be punctuation into two -categories, Punctuation and Symbols. - -C<\p{XPosixPunct}> and (under Unicode rules) C<[[:punct:]]>, match what -C<\p{PosixPunct}> matches in the ASCII range, plus what C<\p{Punct}> -matches. This is different than strictly matching according to -C<\p{Punct}>. Another way to say it is that -if Unicode rules are in effect, C<[[:punct:]]> matches all characters -that Unicode considers punctuation, plus all ASCII-range characters that -Unicode considers symbols. - -=item [6] - -C<\p{SpacePerl}> and C<\p{Space}> differ only in that in non-locale -matching, C<\p{Space}> additionally -matches the vertical tab, C<\cK>. Same for the two ASCII-only range forms. - -=back - -There are various other synonyms that can be used besides the names -listed in the table. For example, C<\p{PosixAlpha}> can be written as -C<\p{Alpha}>. All are listed in -L<perluniprops/Properties accessible through \p{} and \P{}>, -plus all characters matched by each ASCII-range property. - -Both the C<\p> counterparts always assume Unicode rules are in effect. -On ASCII platforms, this means they assume that the code points from 128 -to 255 are Latin-1, and that means that using them under locale rules is -unwise unless the locale is guaranteed to be Latin-1 or UTF-8. In contrast, the -POSIX character classes are useful under locale rules. They are -affected by the actual rules in effect, as follows: - -=over - -=item If the C</a> modifier, is in effect ... - -Each of the POSIX classes matches exactly the same as their ASCII-range -counterparts. - -=item otherwise ... - -=over - -=item For code points above 255 ... - -The POSIX class matches the same as its Full-range counterpart. - -=item For code points below 256 ... - -=over - -=item if locale rules are in effect ... - -The POSIX class matches according to the locale, except that -C<word> uses the platform's native underscore character, no matter what -the locale is. - -=item if Unicode rules are in effect or if on an EBCDIC platform ... - -The POSIX class matches the same as the Full-range counterpart. - -=item otherwise ... - -The POSIX class matches the same as the ASCII range counterpart. - -=back - -=back - -=back - -Which rules apply are determined as described in -L<perlre/Which character set modifier is in effect?>. - -It is proposed to change this behavior in a future release of Perl so that -whether or not Unicode rules are in effect would not change the -behavior: Outside of locale or an EBCDIC code page, the POSIX classes -would behave like their ASCII-range counterparts. If you wish to -comment on this proposal, send email to C<perl5-porters@perl.org>. - -=head4 Negation of POSIX character classes -X<character class, negation> - -A Perl extension to the POSIX character class is the ability to -negate it. This is done by prefixing the class name with a caret (C<^>). -Some examples: - - POSIX ASCII-range Full-range backslash - Unicode Unicode sequence - ----------------------------------------------------- - [[:^digit:]] \P{PosixDigit} \P{XPosixDigit} \D - [[:^space:]] \P{PosixSpace} \P{XPosixSpace} - \P{PerlSpace} \P{XPerlSpace} \S - [[:^word:]] \P{PerlWord} \P{XPosixWord} \W - -The backslash sequence can mean either ASCII- or Full-range Unicode, -depending on various factors as described in L<perlre/Which character set modifier is in effect?>. - -=head4 [= =] and [. .] - -Perl recognizes the POSIX character classes C<[=class=]> and -C<[.class.]>, but does not (yet?) support them. Any attempt to use -either construct raises an exception. - -=head4 Examples - - /[[:digit:]]/ # Matches a character that is a digit. - /[01[:lower:]]/ # Matches a character that is either a - # lowercase letter, or '0' or '1'. - /[[:digit:][:^xdigit:]]/ # Matches a character that can be anything - # except the letters 'a' to 'f'. This is - # because the main character class is composed - # of two POSIX character classes that are ORed - # together, one that matches any digit, and - # the other that matches anything that isn't a - # hex digit. The result matches all - # characters except the letters 'a' to 'f' and - # 'A' to 'F'. |