סקלרים ומחרוזות

ord

מחזיר את נקודת הקוד של Unicode של התו הראשון של מחרוזת.

ord לוקח מחרוזת, מסתכל על התו הראשון שלה, ומחזיר את נקודת הקוד המספרית של אותו תו כשלם. שימו לב תו, לא בית - אם המחרוזת היא מחרוזת תווים רחבים המכילה את האות é (U+00E9), ord מחזיר 233, ללא קשר לכמה בתים é תופס בזיכרון. עבור המחרוזת הריקה, ord מחזיר 0. אם EXPR מושמט, ord פועל על $_.

לכיוון ההפוך - להפיכת נקודת קוד חזרה לתו - ראו chr.

תקציר

ord EXPR
ord
ord($str)

מה מקבלים בחזרה

שלם אי־שלילי. עבור קלט ASCII הוא בטווח 0..127; עבור קלט Latin-1 0..255; עבור מחרוזת Unicode כללית כל דבר עד 0x10FFFF. ord לעולם אינו מחזיר מספר שלילי ולעולם אינו מחזיר ערך לא־שלם. רק התו הראשון של הארגומנט נבדק - תווים גוררים מתעלמים מהם. כדי לעבור על כל נקודת קוד של מחרוזת, שלבו עם split // או unpack "U*".

מצב גלובלי שהוא נוגע בו

ללא ארגומנט, ord קורא את $_. הוא אינו כותב ואינו קורא משתנה מיוחד אחר. הפרשנות של הקלט כתווים (לא בתים) תלויה האם הסקלר מסומן פנימית כ־UTF-8 - ראו מקרי קצה להלן.

דוגמאות

חיפוש ASCII בסיסי:

print ord("A");             # 65
print ord("0");             # 48
print ord("\n");             # 10

מחרוזת ריקה מחזירה אפס, התואם את החוזה ״אין תו ראשון״:

print ord("");              # 0

צורת ברירת־מחדל־ארגומנט בתוך לולאת while על $_:

while (<STDIN>) {
    last if ord == 4;       # stop on EOT (Ctrl-D) as first char
    print;
}

פענוח תו רחב. ord רואה את התו, לא את הבתים:

use utf8;
print ord("é");             # 233        (U+00E9)
print ord("€");             # 8364       (U+20AC)
print ord("😀");            # 128512     (U+1F600)

מעבר על כל נקודת קוד במחרוזת - שימושי לדיבוג הפתעות קידוד:

use utf8;
my $s = "héllo";
print join(",", map { ord } split //, $s), "\n";
# 104,233,108,108,111

שילוב עם chr לנסיעה חזור no-op על כל תו בודד:

my $c = "Z";
print chr(ord($c)) eq $c ? "same\n" : "changed\n";   # same

מקרי קצה

• סמנטיקת תו לעומת בית: ord מחזיר את נקודת הקוד של התו הראשון, שעבור סקלר עם דגל UTF-8 אינו זהה לבית הראשון. ord("\x{100}") מחזיר 256, אף על פי שאותו תו תופס שני בתים בזיכרון. כדי לבדוק את הבית הראשון במקום זאת, אלצו סמנטיקת בתים:

  use bytes;
  print ord("\x{100}");       # 196   (first UTF-8 byte, 0xC4)
  no bytes;
  print ord("\x{100}");       # 256
  

  פנו ל־use bytes רק כשאתם זקוקים באמת לבדיקה ברמת הבית; זוהי פרגמה לוקלית וכירורגית.

• סקלר שאינו UTF-8 המכיל בתים גבוהים: אם הסקלר הוא מחרוזת בתים פשוטה (ללא דגל UTF-8) והבית הראשון שלו הוא 0xC4, ord מחזיר 196, לא 256. הבית מתפרש כ־Latin-1. האם סקלר נתון מסומן עם UTF-8 תלוי באופן שבו הוא נבנה - use utf8 במקור, decode_utf8, שכבת קלט/פלט :utf8, chr של ערך מעל 255, וכן הלאה.

• undef: ord(undef) מחזיר 0 ו, תחת use warnings, פולט Use of uninitialized value in ord.

• ארגומנט מספרי: ord(65) ממיר את 65 למחרוזת "65" קודם, ואז לוקח את התו הראשון - כך שהוא מחזיר ord("6") == 54, לא 65. זה מפתיע אנשים; אם יש לכם שלם ואתם רוצים נסיעה חזור דרך תו, השתמשו ב־chr קודם או דלגו על ord לחלוטין.

• ארגומנט רב־תווי: רק התו הראשון משנה. ord("ABC") מחזיר 65; ה־B וה־C לעולם אינם נבדקים.

• נקודות קוד surrogate ולא־תווים: ord יחזיר בשמחה 0xD800..0xDFFF או 0xFFFE/0xFFFF אם אלה מופיעים בקלט. Perl אינו מסרב לאחסן אותם; ולידציה, אם דרושה, היא תפקיד הקורא.

• ערך מקסימלי: על בנייה סטנדרטית, ord יכול להחזיר עד 0x7FFFFFFF (31 ביט) עבור מחרוזת שהופקה על ידי chr של ערך בטווח זה. טקסט Unicode בעולם האמיתי מגיע לכל היותר ל־0x10FFFF.

• קדימות: הצורה האונרית ord $x נקשרת חזק יותר מ־, אך רפויה יותר מרוב האופרטורים האריתמטיים, אז ord $x + 1 מתפרסר כ־ord($x) + 1, לא ord($x + 1). הוסיפו סוגריים בספק.

הבדלים מהמקור

תאימות מלאה עם Perl 5.42 המקורי.

ראו גם

• chr - הפעולה ההפוכה; הופך נקודת קוד חזרה למחרוזת בת תו אחד

• sprintf - השתמשו ב־%c לפרמט שלם כתו שלו, או %x / %04x לרינדור תוצאת ord ב־hex

• unpack - unpack "U*" עבור כל נקודת קוד של מחרוזת; unpack "C*" עבור כל בית

• lc / uc - בצעו casefold לתו לפני לקיחת נקודת הקוד שלו כשאתם רוצים השוואות חסרות־רישיות

• $_ - ארגומנט ברירת המחדל כאשר ord נקרא ללא אחד