perluniintro - מקוון בענן

תָכְנִית:

שֵׁם

perluniintro - הקדמה של Perl Unicode

תיאור

מסמך זה נותן מושג כללי על Unicode וכיצד להשתמש ב-Unicode ב-Perl. לִרְאוֹת
"משאבים נוספים" להפניות לטיפולים מעמיקים יותר ביוניקוד.

Unicode
Unicode הוא תקן ערכת תווים אשר מתכנן לקוד את כל מערכות הכתיבה של
העולם, בתוספת סמלים רבים אחרים.

Unicode ו-ISO/IEC 10646 הם תקנים מתואמים המאחדים כמעט כל שאר המודרניים
תקני סט תווים, המכסים יותר מ-80 מערכות כתיבה ומאות שפות,
כולל כל השפות המודרניות החשובות מבחינה מסחרית. כל הדמויות בגדול
גם מילונים סיניים, יפניים וקוריאניים מקודדים. הסטנדרטים יהיו בסופו של דבר
מכסה כמעט את כל התווים ביותר מ-250 מערכות כתיבה ואלפי שפות.
Unicode 1.0 שוחרר באוקטובר 1991, ו-6.0 באוקטובר 2010.

Unicode אופי היא ישות מופשטת. זה לא קשור לשום מספר שלם מסוים
רוחב, במיוחד לא לשפת C "char". Unicode הוא ניטרלי שפה ותצוגה-
ניטראלי: הוא אינו מקודד את שפת הטקסט, ואינו מגדיר בדרך כלל
גופנים או פרטי פריסה גרפיים אחרים. Unicode פועל על תווים ועל טקסט בנוי
מהדמויות האלה.

Unicode מגדיר תווים כמו "אות רישיות LATIN A" או "אותיות קטנות יווניות אלפא" ו
מספרים ייחודיים עבור התווים, במקרה זה 0x0041 ו-0x03B1, בהתאמה. אלה
קוראים למספרים ייחודיים קוד נקודות. נקודת קוד היא בעצם המיקום של
תו בתוך קבוצת כל התווים האפשריים של Unicode, וכך בפרל, המונח
סידור משמש לעתים קרובות להחלפה עם זה.

תקן Unicode מעדיף להשתמש בסימון הקסדצימלי עבור נקודות הקוד. אם מספרים
כמו 0x0041 אינם מוכרים לך, תציץ בסעיף מאוחר יותר, "סימונים הקסדצימליים".
תקן Unicode משתמש בסימון "U+0041 LATIN CAPITAL LETTER A", כדי לתת את
נקודת קוד הקסדצימלית והשם הנורמטיבי של התו.

Unicode גם מגדיר מגוון נכסים עבור הדמויות, כמו "אותיות גדולות" או
"אותיות קטנות", "ספרה עשרונית" או "סימני פיסוק"; מאפיינים אלה אינם תלויים ב-
שמות הדמויות. יתר על כן, פעולות שונות על הדמויות כמו
מוגדרים רישיות, אותיות קטנות ואיסוף (מיון).

Unicode הגיוני "דמות" יכולה למעשה להיות מורכבת מיותר מאחד פנימי ממשי
"תו" או נקודת קוד. עבור שפות מערביות, זה מעוצב כראוי על ידי א בסיס
אופי (כמו "אות רישיות לטינית A") ואחריה אחד או יותר משנים (כמו
"שילוב מבטא חריף"). רצף זה של תו הבסיס והמתאמים נקרא a
שילוב אופי רצף. חלק מהשפות הלא-מערביות דורשות מודלים מסובכים יותר,
אז יוניקוד יצר את גרפמה אשכול קונספט, ששוכלל מאוחר יותר ל-
מוּרחָב גרפמה אשכול. לדוגמה, הברה הנגול קוריאנית נחשבת ליחיד
תו לוגי, אך לרוב מורכב משלושה תווי Unicode בפועל: מוביל
עיצור ואחריו תנועה פנימית ואחריו עיצור נגרר.

אם לקרוא לאשכולות הגרפמה המורחבים האלה "תווים" תלוי בנקודה שלך
נוף. אם אתה מתכנת, כנראה שאתה נוטה לראות כל רכיב ב-
רצפים כיחידה אחת, או "דמות". אולם מנקודת מבטו של המשתמש, המכלול
ניתן לראות את הרצף כ"דמות" אחת מכיוון שככל הנראה זה נראה ב-
ההקשר של שפת המשתמש. במסמך זה, אנו לוקחים את נקודת המבט של המתכנת:
"תו" אחת היא נקודת קוד אחת של Unicode.

עבור כמה שילובים של תו בסיס ושינויים, יש מורכב מראש תווים.
קיימת מקבילה לתו בודד, למשל, לרצף "LATIN CAPITAL
אות א' ואחריה "שילוב מבטא חריף". זה נקרא "אות רישיות לטיני א'
עם חריף". עם זאת, הדמויות המורכבות הללו זמינות רק לחלקן
שילובים, ונועדו בעיקר לתמוך בהמרות הלוך ושוב בין Unicode ו
תקנים מדור קודם (כמו ISO 8859). שימוש ברצפים, כפי שעושה יוניקוד, מאפשר צורך
פחות אבני בניין בסיסיות (נקודות קוד) כדי לבטא הרבה יותר גרפמה פוטנציאלית
אשכולות. כדי לתמוך בהמרה בין צורות שוות, שונות נוֹרמָלִיזָצִיָה צורות יש לו
גם מוגדר. לפיכך, "אות רישיות לטינית A עם חריפה" נמצא נוֹרמָלִיזָצִיָה טופס
מוּרכָּב, (בקיצור NFC), והרצף "אות רישיות LATIN A" ואחריו
"שילוב מבטא חריף" מייצג את אותו תו ב נוֹרמָלִיזָצִיָה טופס מפורק
(NFD).

בגלל תאימות לאחור עם קידודים מדור קודם, "מספר ייחודי לכל
הרעיון של תו" מתפרק מעט: במקום זאת, יש "לפחות מספר אחד לכל
דמות". אותה דמות יכולה להיות מיוצגת אחרת בכמה מורשת
קידודים. ההיפך אינו נכון: לנקודות קוד מסוימות אין תו מוקצה.
ראשית, ישנן נקודות קוד לא מוקצות בתוך בלוקים בשימוש אחר. שנית, שם
הם תווי בקרת Unicode מיוחדים שאינם מייצגים תווים אמיתיים.

כאשר יוניקוד הוגה לראשונה, חשבו שכל הדמויות בעולם יכולות להיות
מיוצג באמצעות מילה של 16 סיביות; כלומר מקסימום 0x10000 (או 65,536) תווים
יהיה צורך, מ-0x0000 ל-0xFFFF. עד מהרה זה התברר כשגוי, ומאז Unicode 2.0
(יולי 1996), Unicode הוגדר עד 21 סיביות (0x10FFFF), ו-Unicode
3.1 (מרץ 2001) הגדיר את התווים הראשונים מעל 0xFFFF. 0x10000 התווים הראשונים
נקראים ה מטוס 0, או בסיסי רב לשוני מטוס (BMP). עם Unicode 3.1, 17 (כן,
XNUMX) מטוסים בסך הכל הוגדרו - אבל הם לא כמעט מלאים בהגדרה
דמויות, עדיין.

כאשר שפה חדשה מקודדת, Unicode בדרך כלל יבחר "בלוק" של
נקודות קוד לא מוקצות רצופות עבור התווים שלו. עד כה, מספר נקודות הקוד
בלוקים אלה תמיד ניתן לחלוקה שווה ב-16. תוספות בבלוק, לא כרגע
נחוצים, נותרים לא מוקצים, לצמיחה עתידית. אבל היו מקרים שבהם א
שחרור מאוחר יותר נזקק ליותר נקודות קוד מהתוספות הזמינות, ובלוק חדש היה חייב
מוקצה למקום אחר, לא צמוד לזה הראשוני, כדי להתמודד עם ההצפה.
לפיכך, התברר בשלב מוקדם ש"בלוק" לא היה מנהל ארגון הולם,
וכך נוצר המאפיין "Script". (מאוחר יותר התווסף מאפיין סקריפט משופר בשם
ובכן, המאפיין "Script_Extensions".) נקודות הקוד האלה שנמצאות בבלוקים של גלישה
עדיין יכול להיות אותו סקריפט כמו אלה המקוריים. קונספט התסריט מתאים יותר
עם שפה טבעית: יש כתב "לטיני", כתב "יווני" וכן הלאה; ויש
מספר סקריפטים מלאכותיים, כמו "Common" עבור תווים המשמשים במספר רב
סקריפטים, כגון סמלים מתמטיים. תסריטים בדרך כלל משתרעים על חלקים מגוונים של כמה
בלוקים. למידע נוסף על סקריפטים, ראה "סקריפטים" ב-perlunicode. המחלקה
לתוך בלוקים קיים, אבל זה כמעט לגמרי מקרי - חפץ של איך
הדמויות הוקצו ועדיין הוקצו. (שים לב שלפסקה זו יש
הפשטה יתר על המידה למען תהיה זו הקדמה. יוניקוד לא ממש
מקודד שפות, אבל מערכות הכתיבה עבורן - התסריטים שלהן; ותסריט אחד יכול להיות
בשימוש על ידי שפות רבות. Unicode גם מקודד דברים שלא באמת עוסקים בשפות,
כגון סמלים כמו "תביעת מזוודות".)

נקודות הקוד של Unicode הן רק מספרים מופשטים. כדי להזין ולהוציא את התקצירים הללו
מספרים, המספרים חייבים להיות מוצפן or בסידרה איכשהו. Unicode מגדיר כמה
אופי הַצפָּנָה צורות, מתוכם UTF-8 הוא הפופולרי ביותר. UTF-8 הוא אורך משתנה
קידוד המקודד תווי Unicode כ-1 עד 4 בתים. קידודים אחרים כוללים UTF-16
ו-UTF-32 והגרסאות הגדולות והקטנות שלהם (UTF-8 אינו תלוי סדר בתים).
ISO/IEC 10646 מגדיר את צורות הקידוד UCS-2 ו-UCS-4.

למידע נוסף על קידודים--לדוגמה, כדי ללמוד מה פונדקאים ו בייט
להזמין סימנים (BOMs) הם--ראה perlunicode.

פרל Unicode תמיכה
החל מ-Perl v5.6.0, לפרל הייתה היכולת לטפל ב-Unicode באופן מקורי. פרל
v5.8.0, לעומת זאת, היא המהדורה המומלצת הראשונה לעבודה רצינית של Unicode. ה
מהדורת תחזוקה 5.6.1 תיקנה רבות מהבעיות של ה-Unicode הראשוני
יישום, אבל למשל ביטויים רגולריים עדיין לא עובדים עם Unicode ב
5.6.1. Perl v5.14.0 היא המהדורה הראשונה שבה תמיכת Unicode היא (כמעט) חלקה
ניתן לשילוב ללא כמה שיטות (היוצא מן הכלל הוא כמה הבדלים ב-quotemeta, ו
זה קבוע החל ב-Perl 5.16.0). כדי לאפשר תמיכה חלקה זו, עליך להשתמש ב-
feature 'unicode_strings'" (שנבחר אוטומטית אם אתה "משתמש ב-5.012" ומעלה).
ראה תכונה. (5.14 גם מתקן מספר באגים וסטיות מתקן Unicode.)

לפני Perl v5.8.0, נעשה שימוש ב-"use utf8" כדי להצהיר שפעולות ב-
הבלוק או הקובץ הנוכחי יהיו מודעים ל-Unicode. הדגם הזה נמצא כשגוי, או ב
הכי פחות מגושם: ה-"Unicodeness" נישא כעת עם הנתונים, במקום להיות מחובר אליו
הפעולות. החל מ-Perl v5.8.0, נותר רק מקרה אחד שבו יש "שימוש מפורש
utf8" נדרש: אם סקריפט Perl עצמו מקודד ב-UTF-8, אתה יכול להשתמש ב-UTF-8 ב-
שמות מזהים, ובמילוליות מחרוזת וביטוי רגולרי, על ידי אמירת "השתמש ב-utf8".
זו אינה ברירת המחדל מכיוון שסקריפטים עם נתונים מדור קודם של 8 סיביות יישברו. לִרְאוֹת
utf8.

פרל Unicode מספר סימוכין
Perl תומך גם במחרוזות לפני 5.6 של בתים מקוריים של שמונה סיביות וגם במחרוזות של Unicode
דמויות. העיקרון הכללי הוא שפרל מנסה לשמור על הנתונים שלה בתור בתים של שמונה סיביות
לכמה שיותר זמן, אבל ברגע שאי אפשר להימנע מ-Unicodeness, הנתונים כן
משודרג בשקיפות ל-Unicode. לפני Perl v5.14.0, השדרוג לא היה לגמרי
שקוף (ראה "באג Unicode"" ב-perlunicode), ולצורך תאימות לאחור,
לא מתקבלת שקיפות מלאה אלא אם כן "השתמש בתכונה 'unicode_strings'" (ראה תכונה) או
"השתמש ב-5.012" (או גבוה יותר) נבחר.

באופן פנימי, Perl משתמשת כרגע בכל מערכת התווים המקורית של שמונה סיביות
הפלטפורמה (לדוגמה Latin-1) היא, ברירת המחדל ל-UTF-8, לקידוד מחרוזות Unicode.
באופן ספציפי, אם כל נקודות הקוד במחרוזת הן 0xFF או פחות, Perl משתמש ב-native
ערכת תווים של שמונה סיביות. אחרת, הוא משתמש ב-UTF-8.

משתמש של Perl בדרך כלל לא צריך לדעת ולא אכפת לו איך Perl במקרה מקודד את זה
מחרוזות פנימיות, אבל זה הופך להיות רלוונטי בעת הפלט של מחרוזות Unicode לזרם
ללא שכבת PerlIO (אחת עם קידוד "ברירת המחדל"). במקרה כזה, הבתים הגולמיים
בשימוש פנימי (קבוצת התווים המקורית או UTF-8, בהתאם לכל מחרוזת).
יש להשתמש, ואזהרת "תו רחב" תופק אם המחרוזות האלה מכילות א
תו מעבר ל-0x00FF.

לדוגמה,

perl -e 'הדפס "\x{DF}\n", "\x{0100}\x{DF}\n"'

מייצר תערובת חסרת תועלת למדי של בתים מקוריים ו-UTF-8, כמו גם אזהרה:

תו רחב בדפוס ב...

לפלט UTF-8, השתמש בשכבת הפלט ":encoding" או ":utf8". הכנה

binmode(STDOUT, ":utf8");

לתוכנית לדוגמה זו מבטיחה שהפלט הוא UTF-8 לחלוטין, ומסירה את
אזהרת התוכנית.

אתה יכול לאפשר תיקון UTF-8 אוטומטי של נקודות האחיזה הסטנדרטיות שלך לקבצים, ברירת המחדל "open()"
שכבה, ו-@ARGV באמצעות מתג שורת הפקודה "-C" או "PERL_UNICODE"
משתנה סביבה, ראה perlrun לתיעוד של מתג "-C".

שים לב שזה אומר שפרל מצפה שתוכנות אחרות יפעלו באותה צורה: אם יש ל-Perl
הובילו להאמין ש-STDIN צריך להיות UTF-8, אבל אז STDIN מגיע מאחר
הפקודה אינה UTF-8, סביר להניח ש-Perl תתלונן על ה-UTF-8 השגוי.

כל התכונות המשלבות Unicode ו-I/O דורשות גם שימוש בתכונה החדשה של PerlIO.
עם זאת, כמעט כל פלטפורמות Perl 5.8 משתמשות ב-PerlIO: אתה יכול לראות אם שלך נמצא ליד
הפעלת "perl -V" ומחפשת "useperlio=define".

Unicode ו EBCDIC
Perl 5.8.0 הוסיפה תמיכה ב-Unicode בפלטפורמות EBCDIC. תמיכה זו הורשה
פג במהדורות מאוחרות יותר, אך הוקם לתחייה ב-5.22. התמיכה ביוניקוד היא קצת יותר
מורכב ליישום מכיוון שדרושות המרות נוספות. ראה perlebcdic למידע נוסף
מידע.

בפלטפורמות EBCDIC, טופס הקידוד הפנימי של Unicode הוא UTF-EBCDIC במקום UTF-8.
ההבדל הוא שכיוון ש-UTF-8 הוא "בטוח ל-ASCII" בכך שתווי ASCII מקודדים ל-UTF-8
כפי שהוא, בעוד UTF-EBCDIC הוא "בטוח ל-EBCDIC", בכך שכל התווים הבסיסיים (הכוללים
כל אלה שיש להם מקבילות ASCII (כמו "A", "0", "%", וכו ') זהים בשניהם
EBCDIC ו-UTF-EBCDIC. לעתים קרובות, תיעוד ישתמש במונח "UTF-8" בפירוש UTF-EBCDIC
גם כן. זה המקרה במסמך זה.

יוצרים Unicode
סעיף זה חל במלואו על Perls החל מגרסה 5.22. אזהרות שונות למוקדמות
מהדורות נמצאות בסעיף המשנה "אזהרות לשחרורים מוקדמים יותר" למטה.

כדי ליצור תווי Unicode במילולי, השתמש בסימון "\N{...}" במירכאות כפולות
מיתרים:

my $smiley_from_name = "\N{פנים מחייכות לבנים}";
my $smiley_from_code_point = "\N{U+263a}";

באופן דומה, ניתן להשתמש בהם במילולי ביטוי רגולרי

$smiley =~ /\N{פנים מחייכות לבנים}/;
$smiley =~ /\N{U+263a}/;

בזמן ריצה אתה יכול להשתמש ב:

השתמש בשמות שמות ();
$hebrew_alef_from_name שלי
= charnames::string_vianame("אות עברית ALEF");
my $hebrew_alef_from_code_point = charnames::string_vianame("U+05D0");

באופן טבעי, "ord()" יעשה הפוך: הוא הופך תו לנקודת קוד.

ישנן גם אפשרויות זמן ריצה אחרות. אתה יכול להשתמש ב-"pack()":

my $hebrew_alef_from_code_point = pack("U", 0x05d0);

או שאתה יכול להשתמש ב-"chr()", אם כי זה פחות נוח במקרה הכללי:

$hebrew_alef_from_code_point = chr(utf8::unicode_to_native(0x05d0));
utf8::upgrade($hebrew_alef_from_code_point);

"utf8::unicode_to_native()" ו-"utf8::upgrade()" אינם נחוצים אם הארגומנט הוא
מעל 0xFF, כך שניתן היה לכתוב את האמור לעיל בתור

$hebrew_alef_from_code_point = chr(0x05d0);

מכיוון ש-0x5d0 הוא מעל 255.

"\x{}" ו-"\o{}" יכולים לשמש גם כדי לציין נקודות קוד בזמן הידור ב-double-
מחרוזות quotish, אבל, עבור תאימות לאחור עם Perls ישנים יותר, אותם כללים חלים כמו
עם "chr()" עבור נקודות קוד קטנות מ-256.

"utf8::unicode_to_native()" משמש כך שקוד Perl ניתן לנייד לפלטפורמות EBCDIC.
אתה יכול להשמיט את זה אם אתה בֶּאֱמֶת בטוח שאף אחד לעולם לא ירצה להשתמש בקוד שלך על לא-
פלטפורמת ASCII. החל מ-Perl v5.22, קריאות אליו בפלטפורמות ASCII עוברות אופטימיזציה,
אז אין עונש ביצוע בכלל בהוספתו. או שאתה יכול פשוט להשתמש באחר
מבנים שלא דורשים זאת.

ראה "משאבים נוספים" כדי למצוא את כל השמות והקודים המספריים הללו.

מוקדם יותר משחרר אזהרות

בפלטפורמות EBCDIC, לפני v5.22, השימוש ב-"\N{U+...}" אינו פועל כראוי.

לפני גרסה 5.16, שימוש ב-"\N{...}" עם שם תו (בניגוד לנקודת קוד "U+...")
נדרש "השתמש בשמות שמות :מלא".

לפני גרסה 5.14, היו כמה באגים ב-"\N{...}" עם שם תו (בניגוד ל-
נקודת קוד "U+...").

"charnames::string_vianame()" הוצג בגרסה 5.14. לפני כן,
"charnames::vianame()" אמור לעבוד, אבל רק אם הארגומנט הוא בצורת "U+...". שֶׁלְךָ
ההימור הטוב ביותר שם עבור זמן ריצה Unicode לפי שם התו הוא כנראה:

השתמש בשמות שמות ();
$hebrew_alef_from_name שלי
= pack("U", charnames::vianame("HEBREW LETTER ALEF"));

טיפול Unicode
הטיפול ב-Unicode הוא לרוב שקוף: פשוט השתמש במחרוזות כרגיל.
פונקציות כמו "index()", "length()", ו-"substr()" יעבדו על תווי Unicode;
ביטויים רגולריים יעבדו על תווי Unicode (ראה perlunicode ו-perlretut).

שימו לב ש-Perl מחשיבה אשכולות גרפמים כדמויות נפרדות, כך למשל

print length("\N{LATIN CAPITAL LETTER A}\N{COMBIING Acute Acute}"),
"\n";

ידפיס 2, לא 1. החריג היחיד הוא שלביטויים רגולריים יש "\X" עבור
התאמת אשכול גרפמה מורחב. (לכן "\X" בביטוי רגולרי יתאים ל-
הרצף המלא של שתי התווים לדוגמה.)

עם זאת, החיים לא כל כך שקופים כאשר עובדים עם קידודים מדור קודם, I/O ו-
מקרים מיוחדים מסוימים:

מוֹרֶשֶׁת קידודים
כאשר אתה משלב נתונים מדור קודם ו-Unicode, יש לשדרג את הנתונים מדור קודם ל-Unicode.
בדרך כלל ההנחה היא שהנתונים מדור קודם הם ISO 8859-1 (או EBCDIC, אם רלוונטי).

מודול "קידוד" יודע על קידודים רבים ויש לו ממשקים לביצוע המרות
בין אותם קידודים:

השתמש ב-Encode 'פענוח';
$data = decode("iso-8859-3", $data); # המרה מדור קודם ל-utf-8

Unicode I / O
בדרך כלל, כתיבת נתוני Unicode

הדפס FH $some_string_with_unicode, "\n";

מייצרת בתים גולמיים שבהם Perl משתמש במקרה כדי לקודד פנימית את מחרוזת Unicode.
הקידוד הפנימי של Perl תלוי במערכת כמו גם באילו תווים נמצאים במקרה
המחרוזת באותו זמן. אם אחד מהתווים נמצא בנקודות קוד 0x100 ומעלה, אתה
יקבל אזהרה. כדי להבטיח שהפלט יוצג במפורש בקידוד לך
רצון - וכדי להימנע מהאזהרה - פתח את הזרם עם הקידוד הרצוי. כמה
דוגמאות:

פתח FH, ">:utf8", "קובץ";

פתח FH, ">:encoding(ucs2)", "קובץ";
פתוח FH, ">:encoding(UTF-8)", "קובץ";
פתח FH, ">:encoding(shift_jis)", "קובץ";

ובזרמים שכבר פתוחים, השתמש ב-"binmode()":

binmode(STDOUT, ":utf8");

binmode(STDOUT, ":encoding(ucs2)");
binmode(STDOUT, ":encoding(UTF-8)");
binmode(STDOUT, ":encoding(shift_jis)");

ההתאמה של שמות קידוד היא רופפת: רישיות לא משנה, ולקידודים רבים יש
כמה כינויים. שימו לב שתמיד יש לציין את שכבת ":utf8" בדיוק כך;
זה לֹא בכפוף להתאמה רופפת של שמות קידוד. שימו לב גם שכרגע
":utf8" אינו בטוח לקלט, מכיוון שהוא מקבל את הנתונים מבלי לאמת שכן
אכן UTF-8 תקף; עליך להשתמש במקום ":encoding(utf-8)" (עם או בלי מקף).

ראה PerlIO עבור שכבת ":utf8", קידוד PerlIO:: ו-Encode::PerlIO עבור
שכבת ":encoding()" ו-Encode::נתמכת עבור קידודים רבים הנתמכים על ידי ה-"Encode"
מודול.

קריאה בקובץ שאתה יודע מקודד במקרה באחד ה-Unicode או הדור המורשת
קידודים לא הופכים את הנתונים ליוניקוד בצורה קסומה בעיני פרל. לעשות את זה,
ציין את השכבה המתאימה בעת פתיחת קבצים

open(my $fh,'<:encoding(utf8)', 'כל דבר');
my $line_of_unicode = <$fh>;

open(my $fh,'<:encoding(Big5)', 'anything');
my $line_of_unicode = <$fh>;

ניתן גם לציין את שכבות ה-I/O בצורה גמישה יותר עם הפרגמה ה"פתוחה". ראה פתוח, או
תסתכל על הדוגמה הבאה.

השתמש ב-':encoding(utf8) פתוח'; # קידוד ברירת המחדל של קלט/פלט יהיה
# UTF-8
פתח X, ">קובץ";
הדפס X chr(0x100), "\n";
סגור X;
פתח את Y, "
printf "%#x\n", ord( ); # זה אמור להדפיס 0x100
לסגור Y;

עם הפרגמה "פתוחה" אתה יכול להשתמש בשכבת ":locale".

התחל { $ENV{LC_ALL} = $ENV{LANG} = 'ru_RU.KOI8-R' }
# ה-:locale יבדוק את משתני הסביבה המקומיים כמו
# LC_ALL
השתמש ב-open OUT => ':locale'; # russki parusski
open(O, ">koi8");
הדפס O chr(0x430); # Unicode אות קטנה CYRILLIC A = KOI8-R 0xc1
סגור O;
פתח (אני, "
printf "%#x\n", ord( ), "\n"; # זה אמור להדפיס 0xc1
סגור אני;

שיטות אלו מתקינות מסנן שקוף בזרם ה-I/O הממיר נתונים מה-
הקידוד שצוין כאשר הוא נקרא מהזרם. התוצאה היא תמיד Unicode.

הפרגמה הפתוחה משפיעה על כל הקריאות "open()" לאחר הפרגמה על ידי הגדרת שכבות ברירת מחדל.
אם אתה רוצה להשפיע רק על זרמים מסוימים, השתמש בשכבות מפורשות ישירות ב-"open()"
שיחה.

אתה יכול להחליף קידודים בזרם שכבר נפתח באמצעות "binmode()"; ראה "binmode"
ב-perlfunc.

ה-":locale" לא עובד כרגע עם "open()" ו-"binmode()", רק עם ה-"open"
פרגמה. השיטות ":utf8" ו-":encoding(...)" עובדות עם כל "open()",
"binmode()", והפרגמה "פתוחה".

באופן דומה, אתה יכול להשתמש בשכבות I/O אלה בזרמי פלט כדי להמיר את Unicode באופן אוטומטי
לקידוד שצוין כאשר הוא נכתב לזרם. לדוגמה, הדברים הבאים
snippet מעתיק את תוכן הקובץ "text.jis" (מקודד כ-ISO-2022-JP, aka JIS) ל
הקובץ "text.utf8", מקודד כ-UTF-8:

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

מתן שמות של קידודים, הן על ידי ה"פתוח()" והן על ידי הפרגמה "פתוחה" מאפשרת גמישות
שמות: "koi8-r" ו-"KOI8R" שניהם יובנו.

קידודים נפוצים המוכרים על ידי ISO, MIME, IANA וסטנדרטיזציה אחרת
ארגונים זוכים להכרה; לרשימה מפורטת יותר ראה Encode::Supported.

"read()" קורא תווים ומחזיר את מספר התווים. "seek()" ו-"tell()"
פועלים על ספירת בתים, וכך גם "sysread()" ו-"sysseek()".

שים לב שבגלל התנהגות ברירת המחדל של אי ביצוע המרה בקלט if
אין שכבת ברירת מחדל, קל לכתוב בטעות קוד שממשיך להרחיב את a
קובץ על ידי קידוד שוב ושוב של הנתונים:

# אזהרת קוד שגוי
פתח F, "קובץ";
$/ מקומי; ## קרא את כל הקובץ של תווים של 8 סיביות
$t = ;
סגור F;
פתח F, ">:encoding(utf8)", "קובץ";
הדפס F $t; ## המר ל-UTF-8 בפלט
סגור F;

אם תפעיל את הקוד הזה פעמיים, התוכן של פילה יקודד פעמיים UTF-8. "שימוש
open ':encoding(utf8)'" היה מונע את הבאג, או פותח במפורש גם את פילה
לקלט כ-UTF-8.

הערה: התכונות ":utf8" ו-":encoding" פועלות רק אם ה-Perl שלך נבנה עם
PerlIO, שהיא ברירת המחדל ברוב המערכות.

מציג Unicode As טקסט
לפעמים אולי תרצה להציג סקלרים של Perl המכילים Unicode בתור ASCII פשוט (או
EBCDIC) טקסט. תת-השגרה הבאה ממירה את הארגומנט שלה כך שתווי Unicode
עם נקודות קוד גדולות מ-255 מוצגות בתור "\x{...}", תווי בקרה (כמו
"\n") מוצגים בתור "\x..", ושאר התווים כעצמם:

sub nice_string {
לְהִצְטַרֵף("",
מפה { $_ > 255 # אם תו רחב...
? sprintf("\\x{%04X}", $_) # \x{...}
: chr($_) =~ /[[:cntrl:]]/ # אחר אם תו שליטה...
? sprintf("\\x%02X", $_) # \x..
: quotemeta(chr($_)) # else quote או כמו עצמם
} unpack("W*", $_[0])); # פרק את תווי Unicode
}

לדוגמה,

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

מחזירה את המחרוזת

'foo\x{0100}bar\x0A'

אשר מוכן להדפסה.

("\\x{}" משמש כאן במקום "\\N{}", מכיוון שסביר להניח שאתה רוצה לראות מה
הערכים המקומיים הם.)

מיוחד ארונות
· Bit Complement Operator ~ And vec()

אופרטור משלים הסיביות "~" עשוי להפיק תוצאות מפתיעות אם משתמשים בו על מחרוזות
המכיל תווים עם ערכים סידוריים מעל 255. במקרה כזה, התוצאות הן
תואם את הקידוד הפנימי של הדמויות, אבל לא עם הרבה יותר. לכן
אל תעשה את זה. באופן דומה עבור "vec()": אתה תפעל על המקודד הפנימי
דפוסי סיביות של תווי Unicode, לא על ערכי נקודת הקוד, וזה מאוד
כנראה לא מה שאתה רוצה.

· הצצה אל הקידוד הפנימי של פרל

למשתמשים רגילים של Perl לעולם לא יהיה אכפת איך Perl מקודדת מחרוזת Unicode מסוימת
(מכיוון שהדרכים הרגילות להגיע לתוכן של מחרוזת עם Unicode - דרך קלט
ופלט - צריך להיות תמיד באמצעות שכבות I/O מוגדרות במפורש). אבל אם אתה חייב,
יש שתי דרכים להסתכל מאחורי הקלעים.

דרך אחת להציץ בתוך הקידוד הפנימי של תווי Unicode היא להשתמש
"unpack("C*", ..." כדי לקבל את הבתים של מה שקידוד המחרוזת יהיה, או
"unpack("U0..", ...)" כדי לקבל את הבתים של קידוד UTF-8:

# זה מדפיס c4 80 עבור UTF-8 בתים 0xc4 0x80
print join(" ", unpack("U0(H2)*", pack("U", 0x100))), "\n";

דרך נוספת תהיה להשתמש במודול Devel::Peek:

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

זה מציג את הדגל "UTF8" ב-FLAGS וגם את ה-UTF-8 בתים ותווי Unicode ב-
"PV". ראה גם בהמשך מסמך זה את הדיון על "utf8::is_utf8()"
פונקציה.

מתקדם נושאים
· שקילות מיתרים

שאלת שווי המיתרים הופכת מעט מסובכת ביוניקוד: מה אתה עושה
מתכוון ב"שווה"?

(האם "אות רישיות לטינית A עם חריפה" שווה ל-"אות רישיות לטינית A"?)

התשובה הקצרה היא שבברירת מחדל Perl משווה שקילות ("eq", "ne") רק על בסיס
על נקודות קוד של התווים. במקרה שלעיל, התשובה היא לא (כי 0x00C1
!= 0x0041). אבל לפעמים, כל אות גדולה א' צריכה להיחשב שווה, או אפילו
א' של כל מקרה.

התשובה הארוכה היא שאתה צריך לשקול נורמליזציה של אופי ורישיון
בעיות: ראה Unicode::Normalize, Unicode Technical Report #15, Unicode Normalization
טפסיםhttp://www.unicode.org/unicode/reports/tr15> וקטעים על מיפוי מקרים ב
תקן Unicodehttp://www.unicode.org>.

החל מ-Perl 5.8.0, קיפול המארז "המלא" של מקרה מיפויים/מכסים מיוחדים is
מיושם, אבל באגים נשארים ב-"qr//i" איתם, לרוב מתוקנים עד 5.14, ו
בעצם לחלוטין עד 5.18.

· איסוף מחרוזות

אנשים אוהבים לראות את המיתרים שלהם ממוינים בצורה יפה - או כמו בלשון Unicode, מקובצים.
אבל שוב, למה אתה מתכוון באיסוף?

(האם "אות רישיות LATIN A WITH ACUTE" בא לפני או אחרי "אות גדולה LATIN A
עם קבר"?)

התשובה הקצרה היא שבברירת מחדל, Perl משווה מחרוזות ("lt", "le", "cmp", "ge",
"gt") מבוסס רק על נקודות הקוד של התווים. במקרה הנ"ל, התשובה
הוא "אחרי", שכן 0x00C1 > 0x00C0.

התשובה הארוכה היא ש"זה תלוי", ואי אפשר לתת תשובה טובה בלעדיה
לדעת (לכל הפחות) את הקשר השפה. ראה Unicode::Collate, ו Unicode
איסוף אַלגוֹרִיתְם <http://www.unicode.org/unicode/reports/tr10/>

שונות
· טווחי תווים וכיתות

טווחי תווים במחלקות תווים בסוגריים של ביטוי רגולרי (למשל, "/[az]/")
ובאופרטור "tr///" (הידוע גם בשם "y///") אינם מודעים ל-Unicode באופן קסם.
מה שזה אומר הוא ש"[א-זה-ז]" לא יתחיל באופן קסם להתכוון "הכל באלפביתי
אותיות" (לא שזה אומר שאפילו עבור תווים של 8 סיביות; עבור אלה, אם כן
באמצעות מקומיים (perllocale), השתמש ב-"/[[:alpha:]]/"; ואם לא, השתמש ב-8-bit-aware
המאפיין "\p{alpha}").

כל המאפיינים שמתחילים ב-"\p" (וההיפוך "\P") הם למעשה תו
מחלקות שמודעות ל-Unicode. יש עשרות כאלה, ראה perluniprops.

החל מגרסה 5.22, אתה יכול להשתמש בנקודות קוד Unicode כנקודות הסיום של רגילות
טווחי תווים של דפוס ביטוי, והטווח יכלול את כל קוד Unicode
נקודות שנמצאות בין אותן נקודות קצה, כולל.

qr/ [\N{U+03]-\N{U+20}] /x

כולל את נקודות הקוד "\N{U+03}", "\N{U+04}", ..., "\N{U+20}".

(מתוכנן להרחיב התנהגות זו לטווחים ב-"tr///" ב-Perl v5.24.)

· המרות מחרוזת למספר

Unicode אכן מגדיר עוד כמה תווים עשרוניים - ומספריים - מלבד ה
0 עד 9 מוכרים, כמו הספרות הערבית והאינדית. Perl לא תומך במחרוזת-
המרה למספר עבור ספרות שאינן ASCII 0 עד 9 (ו-ASCII "a" ל"f" עבור
הקסדצימלי). כדי לקבל המרות בטוחות מכל מחרוזת Unicode, השתמש ב"num()"ב
Unicode::UCD.

שאלות עם תשובות
· האם התסריטים הישנים שלי ישברו?

סביר מאוד שלא. אלא אם כן אתה מייצר תווי Unicode איכשהו, ישנים
יש לשמר את ההתנהגות. בערך ההתנהגות היחידה שהשתנתה ואיזו
יכול להתחיל לייצר Unicode היא ההתנהגות הישנה של "chr()" כאשר אספקת an
ארגומנט של יותר מ-255 יצר תו מודולו 255."chr(300)", למשל, היה
שווה ל "chr(45)" או "-" (ב-ASCII), עכשיו זה הוא אות בירה לטיני I עם BREVE.

· כיצד אוכל לגרום לסקריפטים שלי לעבוד עם Unicode?

יש צורך במעט מאוד עבודה מכיוון ששום דבר לא משתנה עד שאתה יוצר Unicode
נתונים. הדבר החשוב ביותר הוא קבלת קלט כמו Unicode; לשם כך, ראה את המוקדם
דיון ב-I/O. כדי לקבל תמיכה מלאה ב-Unicode, הוסף "שימוש בתכונה
'unicode_strings'" (או "השתמש ב-5.012" ומעלה) לסקריפט שלך.

· איך אני יודע אם המחרוזת שלי נמצאת ב-Unicode?

לא צריך להיות אכפת לך. אבל אתה יכול אם Perl שלך לפני 5.14.0 או שלא
ציינו "השתמש בתכונה 'unicode_strings'" או "השתמש ב-5.012" (או גבוה יותר) כי אחרת
הכללים עבור נקודות הקוד בטווח 128 עד 255 שונים בהתאם
אם המחרוזת שהם כלולים בתוכה נמצאת ב-Unicode או לא. (ראה "כאשר Unicode
לא קורה" ב-perlunicode.)

כדי לקבוע אם מחרוזת נמצאת ב-Unicode, השתמש ב:

להדפיס utf8::is_utf8($string) ? 1 : 0, "\n";

אבל שימו לב שזה לא אומר שאחד מהתווים במחרוזת נחוצים
UTF-8 מקודד, או שלכל אחד מהתווים יש נקודות קוד גדולות מ-0xFF (255)
או אפילו 0x80 (128), או שלמחרוזת יש תווים בכלל. כל ה-"is_utf8()"
עושה הוא להחזיר את הערך של הדגל הפנימי "utf8ness" המצורף למחרוזת $.
אם הדגל כבוי, הבתים בסקלאר מתפרשים כקידוד בתים בודדים.
אם הדגל פועל, הבייטים בסקלאר מתפרשים כ-(אורך משתנה,
נקודות קוד מקודדות ב-UTF-8 שעלולות להיות מרובות בתים של התווים. בתים שנוספו ל-a
מחרוזת מקודדת UTF-8 משודרגת אוטומטית ל-UTF-8. אם מעורבבים שאינם UTF-8 ו
סקלרים של UTF-8 ממוזגים (אינטרפולציה במירכאות כפולות, שרשור מפורש, או
החלפת פרמטר printf/sprintf), התוצאה תהיה מקודדת UTF-8 כאילו יש עותקים
ממחרוזות הבתים שודרגו ל-UTF-8: לדוגמה,

$a = "ab\x80c";
$b = "\x{100}";
הדפס "$a = $b\n";

מחרוזת הפלט תהיה מקודדת UTF-8 "ab\x80c = \x{100}\n", אבל $a יישאר בייט-
מוּצפָּן.

לפעמים אולי באמת צריך לדעת את אורך הבתים של מחרוזת במקום ה-
אורך תו. לשם כך השתמש בפונקציה "Encode::encode_utf8()" או ב-
פרגמת "bytes" והפונקציה "length()":

שלי $unicode = chr(0x100);
print length($unicode), "\n"; # ידפיס 1
דורש קידוד;
print length(Encode::encode_utf8($unicode)),"\n"; # ידפיס 2
השתמש בתים;
print length($unicode), "\n"; # ידפיס גם 2
# (ה-0xC4 0x80 של UTF-8)
ללא בתים;

· כיצד אוכל לגלות איזה קידוד יש לקובץ?

אתה יכול לנסות את Encode::Guess, אבל יש לו מספר מגבלות.

· כיצד אוכל לזהות נתונים שאינם תקפים בקידוד מסוים?

השתמש בחבילת "קידוד" כדי לנסות להמיר אותה. לדוגמה,

השתמש ב-Encode 'decode_utf8';

if (eval { decode_utf8($string, Encode::FB_CROAK); 1 }) {
# $string חוקי utf8
אחר} {
# $string אינו חוקי utf8
}

או השתמש ב-"unpack" כדי לנסות לפענח אותו:

להשתמש באזהרות;
@chars = unpack("C0U*", $string_of_bytes_that_I_think_is_utf8);

אם לא חוקי, מופקת אזהרת "תו UTF-8 שגוי". ה-"C0" פירושו "תהליך".
תו המחרוזת לכל תו". בלי זה, ה-"unpack("U*", ...)" יעבוד
במצב "U0" (ברירת המחדל אם מחרוזת הפורמט מתחילה ב-"U") והיא תחזור
הבתים המרכיבים את קידוד UTF-8 של מחרוזת המטרה, משהו שכן
תמיד עובד.

· כיצד אוכל להמיר נתונים בינאריים לקידוד מסוים, או להיפך?

זה כנראה לא שימושי כמו שאתה חושב. בדרך כלל, אתה לא צריך.

במובן מסוים, מה שאתה שואל לא הגיוני במיוחד: קידודים מיועדים
תווים ונתונים בינאריים אינם "תווים", ולכן המרת "נתונים" לחלקם
לקידוד אין משמעות אלא אם כן אתה יודע באיזו מערכת תווים וקידוד
נתונים בינאריים נמצאים, ובמקרה זה זה לא רק נתונים בינאריים, עכשיו נכון?

אם יש לך רצף גולמי של בתים שאתה יודע שצריך לפרש באמצעות a
קידוד מסוים, אתה יכול להשתמש ב"קידוד":

השתמש ב-Encode 'from_to';
from_to($data, "iso-8859-1", "utf-8"); # מ-1 לטינית ל-utf-8

הקריאה ל-"from_to()" משנה את הבתים ב-$data, אבל שום דבר מהותי לגבי ה-
אופי המחרוזת השתנה מבחינת פרל. גם לפני וגם אחרי
הקריאה, המחרוזת $data מכילה רק חבורה של בתים של 8 סיביות. מבחינת פרל
בעניין, הקידוד של המחרוזת נשאר כ"בתים של 8 סיביות מקוריים של המערכת".

אתה יכול לקשר את זה למודול 'תרגם' בדיוני:

השתמש בתרגום;
שלי $phrase = "כן";
Translate::from_to($phrase, 'אנגלית', 'דויטש');
הביטוי ## מכיל כעת "Ja"

תוכן המחרוזת משתנה, אך לא אופי המחרוזת. פרל לא
לדעת יותר לאחר השיחה מאשר לפני כן שתוכן המחרוזת מציין את
חִיוּבִי.

חזרה להמרת נתונים. אם יש לך (או רוצה) נתונים ב-8 סיביות המקוריות של המערכת שלך
קידוד (למשל Latin-1, EBCDIC וכו'), אתה יכול להשתמש ב-pack/unpack כדי להמיר אל/מ
Unicode.

$native_string = pack("W*", unpack("U*", $Unicode_string));
$Unicode_string = pack("U*", unpack("W*", $native_string));

אם יש לך רצף של בתים אתה לדעת הוא UTF-8 חוקי, אבל פרל עדיין לא יודע את זה,
אתה יכול גם להפוך את פרל למאמין:

השתמש ב-Encode 'decode_utf8';
$Unicode = decode_utf8($bytes);

או:

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

אתה יכול למצוא את הבתים המרכיבים רצף UTF-8 עם

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

ואתה יכול ליצור Unicode מעוצב היטב עם

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

· כיצד אוכל להציג Unicode? כיצד אוכל להזין Unicode?

לִרְאוֹתhttp://www.alanwood.net/unicode/> ו
<http://www.cl.cam.ac.uk/~mgk25/unicode.html>

· כיצד פועל Unicode עם אזורים מסורתיים?

אם המקום שלך הוא אזור UTF-8, החל מ-Perl v5.20, Perl עובד היטב עבור כולם
קטגוריות מלבד "LC_COLLATE" העוסקות במיון והאופרטור "cmp".

עבור אזורים אחרים, החל מ-Perl 5.16, אתה יכול לציין

השתמש במקום ':not_characters';

לגרום לפרל לעבוד איתם היטב. הקאץ' הוא שאתה צריך לתרגם מה
הגדרת תווים מקומיים אל/מ-Unicode בעצמך. ראה "Unicode I/O" לעיל כיצד לעשות זאת

השתמש ב-':locale' פתוח;

כדי להשיג זאת, אבל הפרטים המלאים נמצאים ב"Unicode ו-UTF-8" ב-perllocale,
כולל תקלות שמתרחשות אם אינך מציין ":not_characters".

הקסאדצימלי סִמוּן
תקן Unicode מעדיף להשתמש בסימון הקסדצימלי מכיוון שזה מראה בצורה ברורה יותר
החלוקה של Unicode לבלוקים של 256 תווים. הקסדצימלי הוא גם פשוט קצר יותר
מאשר עשרוני. אתה יכול להשתמש גם בסימון עשרוני, אבל ללמוד להשתמש רק בהקסדצימלי
עושה את החיים קלים יותר עם תקן Unicode. הסימון "U+HHHH" משתמש בהקסדצימלי, עבור
דוגמא.

הקידומת "0x" פירושה מספר הקסדצימלי, הספרות הן 0-9 ו af (או AF, case
לא משנה). כל ספרה הקסדצימלית מייצגת ארבעה ביטים, או חצי בייט. "הדפס
0x..., "\n"" יציג מספר הקסדצימלי בעשרוני, ו-"printf "%x\n", $decimal
הצג מספר עשרוני בהקסדצימלי. אם יש לך רק "ספרות hex" של הקסדצימלי
מספר, אתה יכול להשתמש בפונקציה "hex()".

הדפס 0x0009, "\n"; # 9
הדפס 0x000a, "\n"; מס' 10
הדפס 0x000f, "\n"; מס' 15
הדפס 0x0010, "\n"; # 16
הדפס 0x0011, "\n"; # 17
הדפס 0x0100, "\n"; # 256

הדפס 0x0041, "\n"; # 65

printf "%x\n", 65; מס' 41
printf "%#x\n", 65; # 0x41

print hex("41"), "\n"; מס' 65

עוד משאבים
· קונסורציום יוניקוד

<http://www.unicode.org/>

· שאלות נפוצות של Unicode

<http://www.unicode.org/unicode/faq/>

· מילון מונחים של יוניקוד

<http://www.unicode.org/glossary/>

· רשימת קריאה מומלצת ביוניקוד

לקונסורציום Unicode יש רשימה של מאמרים וספרים, שחלקם נותנים הרבה
טיפול מעמיק יותר ביוניקוד:http://unicode.org/resources/readinglist.html>

· משאבים שימושיים ביוניקוד

<http://www.unicode.org/unicode/onlinedat/resources.html>

· תמיכה ביוניקוד ורב לשוני ב-HTML, גופנים, דפדפני אינטרנט ויישומים אחרים

<http://www.alanwood.net/unicode/>

· UTF-8 ו-Unicode שאלות נפוצות עבור Unix/Linux

<http://www.cl.cam.ac.uk/~mgk25/unicode.html>

· ערכות תווים מדור קודם

<http://www.czyborra.com/>http://www.eki.ee/letter/>

· אתה יכול לחקור מידע שונה מקובצי הנתונים של Unicode באמצעות
מודול "Unicode::UCD".

UNICODE IN אולדר PERLS

אם אינך יכול לשדרג את ה-Perl שלך ל-5.8.0 ואילך, אתה עדיין יכול לעשות קצת Unicode
עיבוד באמצעות המודולים "Unicode::String", "Unicode::Map8" ו-"Unicode::Map",
זמין מ-CPAN. אם מותקן אצלך הקוד מחדש של GNU, אתה יכול גם להשתמש ב-Perl
חזית קצה "Convert::Recode" להמרות תווים.

להלן המרות מהירות מבייטים ISO 8859-1 (לטינית-1) ל-UTF-8 בתים ו
בחזרה, הקוד עובד אפילו עם גרסאות ישנות יותר של Perl 5.

# ISO 8859-1 ל-UTF-8
s/([\x80-\xFF])/chr(0xC0|ord($1)>>6).chr(0x80|ord($1)&0x3F)/eg;

# UTF-8 ל-ISO 8859-1
s/([\xC2\xC3])([\x80-\xBF])/chr(ord($1)<<6&0xC0|ord($2)&0x3F)/eg;

השתמש ב-perluniintro באינטרנט באמצעות שירותי onworks.net