קדימות#

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

הטבלה המלאה#

אופרטורים הדוקים יותר בראש, רופפים יותר בתחתית. אותה שורה = אותה קדימות; שילוב שני אופרטורים מאותה שורה משתמש באסוציאטיביות. none = לא־אסוציאטיבי (שילוב שניים מהם ללא סוגריים הוא שגיאה או אזהרת זמן־פענוח).

שורה	אסוציאטיביות	אופרטורים
1	שמאל	מונחים, אופרטורי רשימה (שמאלה)
2	שמאל	`->`
3	ללא	`++` `--`
4	ימין	`**`
5	ימין	`!` `~` `\` `+` אונרי `-` אונרי
6	שמאל	`=~` `!~`
7	שמאל	`*` `/` `%` `x`
8	שמאל	`+` `-` `.`
9	שמאל	`<<` `>>`
10	ללא	אופרטורים אונריים בעלי שם
11	ללא	`<` `<=` `>` `>=` `lt` `le` `gt` `ge`
12	ללא	`==` `!=` `<=>` `eq` `ne` `cmp`
13	שמאל	`&`
14	שמאל	`\|` `^`
15	שמאל	`&&`
16	שמאל	`\|\|` `//`
17	ללא	`..` `...`
18	ימין	`?:`
19	ימין	`=` `+=` `-=` `*=` `/=` וכו«
20	שמאל	`,` `=>`
21	ללא	אופרטורי רשימה (ימינה)
22	ימין	`not`
23	שמאל	`and`
24	שמאל	`or` `xor`

כמה כללי אצבע:

השוואה ולוגיקה. השוואה (שורות 11–12) הדוקה יותר מ־&&/||/// (שורות 15–16), כך ש־$a < $b && $c > $d עובד ללא סוגריים פנימיים.
ביטים לעומת השוואה. &, |, ^ (שורות 13–14) רופפים יותר מהשוואה. $x & 0xFF == 0 מפוענח כ־$x & (0xFF == 0). כמעט תמיד הקיפו את אופרטורי הביטים בסוגריים.
לוגיקה סמלית לעומת לוגיקה במילים. &&/||/! הדוקים (שורות 5, 15, 16). and/or/not רופפים מאוד (שורות 22–24). אותה משמעות לוגית; קשירה שונה. פרק הלוגיקה מראה היכן כל אחד מתאים.
= רופף. שורה 19 - כמעט כל דבר נקשר הדוק יותר מהשמה. זו הסיבה ש־my $fh = open ... or die עובד: or (שורה 24) רופף אפילו יותר מ־=, כך שה־open מסיים את ההשמה לפני ש־or מחליט.
אופרטורי רשימה תוחמים את הטבלה. שורה 1 מביטה שמאלה, שורה 21 מביטה ימינה. אופרטור רשימה כמו print או sort בולע את כל מה שמימינו, עד לאופרטור הראשון שנקשר רופף יותר משורה 21 - שהוא רק not/and/or/xor. סעיף האונרי־בעל־שם שלהלן מנגיד זאת עם מקרה הארגומנט־היחיד של שורה 10.

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

הגדלה / הקטנה לאחר ולפני#

שורה 3 (++ ו־--) לא־אסוציאטיבית. הצורות שלפני ושלאחר נבדלות במתי תופעת־הלוואי מתרחשת:

++$x - להגדיל תחילה, ואז להניב את הערך החדש.
$x++ - להניב את הערך הנוכחי, ואז להגדיל.

my $x = 5;
my $a = ++$x;        # $x is now 6, $a is 6
my $b = $x++;        # $a was 6, $x++ yields 6 then increments,
                     # so $b is 6 and $x is now 7

++ על מחרוזת מבצע את ההגדלה הקסומה של Perl:

my $s = "aa";
$s++;                # "ab"
$s++;                # "ac"
# ...
$s = "az"; $s++;     # "ba"  - carries like base-26
$s = "Aa"; $s++;     # "Ab"  - case is preserved per-position
$s = "Az9"; $s++;    # "Ba0" - digits and letters carry independently

ההגדלה־הקסומה היא מה שגורם ל־'a'..'zz' לייצר את כל 702 הצירופים בני שתי האותיות בטווח.

אופרטורים אונריים בעלי שם#

שורה 10 מכילה קטגוריה הנקראת אופרטורים אונריים בעלי שם. אלה אינם אופרטורים סמליים - הם פונקציות מובנות שלוקחות ארגומנט אחד בדיוק ומפענחות בקדימות בסגנון אופרטור (בין היסטי ביטים להשוואה) ולא כאופרטורי רשימה מלאים.

ההשלכה המעשית היא כלל פענוח אחד:

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

defined $x + 1            # parses as: ( defined($x) ) + 1
                          # - NOT  defined($x + 1)
length $s > 3             # parses as: ( length($s) ) > 3
-e $f && -r _             # both file tests are named-unary;
                          # `&&` combines two boolean results

השוו עם אופרטור רשימה (print, sort, push, …), שנמצא בשורה 1 / 21 ובולע את שאר הביטוי:

print "n=", $n, "\n"      # print's argument list is "n=", $n, "\n"
                          # all three commas belong to print

אם אתם רוצים שפונקציה מובנית אונרית־בעלת־שם תיקח ארגומנט מורכב יותר, הקיפו בסוגריים:

defined($x + 1)           # explicit: argument is the sum $x+1
length($s . "x")          # length of $s with "x" appended

הצורה החד־משמעית זמינה תמיד. כשמתעורר ספק, הקיפו בסוגריים.

רשימת המובנות האונריות בעלות השם#

מובנות אלה מפענחות בקדימות שורה 10. כל אחת מקשרת לעמוד הפירוט שלה ב־perlfunc - כלל הפענוח שלעיל הוא הדבר היחיד שעליכם לדעת עליהן כאופרטורים; התנהגות הפונקציה שלהן נמצאת במדריך העיון perlfunc.

defined, exists, ref, scalar, length, uc, lc, ucfirst, lcfirst, chr, ord, hex, oct, int, abs, sqrt, sin, cos, log, exp, rand, srand, alarm, sleep, caller, wantarray, chroot, readlink, umask, lstat, stat (כשניתן בדיוק ארגומנט אחד), בתוספת כל אופרטורי בדיקת הקובץ (-e, -r, -w, -x, -f, -d, -l, -s, והשאר - ראו את סעיף אופרטורי בדיקת הקובץ שלהלן).

מסגור ה״אופרטור״ בתיעוד Perl הקלאסי הוא היסטורי. במונחי Perl מודרני, אלה פונקציות שפענוח הארגומנט שלהן ממקם אותן בין היסט ביטים להשוואה בטבלת הקדימות. השם הוא מה שהוא; ההתנהגות היא מה שמשנה.

אופרטורי בדיקת קובץ#

בדיקות קובץ הן אופרטורים אונריים (קדימות אונרית־בעלת־שם) שבוחנים תכונה של קובץ או מטפל קובץ. הם מתחילים במקף ואות בודדת. כולם מחזירים בוליאני פרט ל־-s (גודל קובץ בבתים), -M/-A/-C (גיל בימים, שברי), והבדיקות בזמן־קריאה -T/-B (בוליאני אך מעט איטי יותר משום שהם קוראים את הקובץ).

אופרטור	בדיקה	מחזיר
`-e`	exists	בוליאני
`-r`	ניתן לקריאה על־ידי ה־UID האפקטיבי	בוליאני
`-w`	ניתן לכתיבה על־ידי ה־UID האפקטיבי	בוליאני
`-x`	ניתן להרצה על־ידי ה־UID האפקטיבי	בוליאני
`-o`	בבעלות ה־UID האפקטיבי	בוליאני
`-R`	ניתן לקריאה על־ידי ה־UID האמיתי	בוליאני
`-W`	ניתן לכתיבה על־ידי ה־UID האמיתי	בוליאני
`-X`	ניתן להרצה על־ידי ה־UID האמיתי	בוליאני
`-O`	בבעלות ה־UID האמיתי	בוליאני
`-z`	גודל אפס	בוליאני
`-s`	גודל שאינו אפס	גודל בבתים או שקר
`-f`	קובץ רגיל	בוליאני
`-d`	ספרייה	בוליאני
`-l`	קישור סימבולי	בוליאני
`-p`	pipe בעל שם (FIFO)	בוליאני
`-S`	socket	בוליאני
`-b`	קובץ מיוחד מסוג בלוק	בוליאני
`-c`	קובץ מיוחד מסוג תו	בוליאני
`-t`	TTY (מסוף)	בוליאני
`-u`	ביט setuid	בוליאני
`-g`	ביט setgid	בוליאני
`-k`	ביט sticky	בוליאני
`-T`	קובץ טקסט (היוריסטי)	בוליאני
`-B`	קובץ בינארי (היוריסטי)	בוליאני
`-M`	זמן שינוי (גיל מתחילת הסקריפט, ימים)	מספר
`-A`	זמן גישה (ימים)	מספר
`-C`	זמן שינוי inode (ימים)	מספר

if (-e $file) { ... }                # exists
if (-f $path && -r $path) { ... }    # regular file and readable
my $size = -s $file;                 # size in bytes
if (-d $path) { ... }                # is a directory

בדיקות קובץ מוערמות. -f -w -r $file היא קיצור עבור (-f $file) && (-w $file) && (-r $file) - השרשרת משתמשת מחדש באותו יעד. הפסאודו־מטפל _ (קו תחתון בודד) משתמש מחדש במטמון ה־stat של בדיקת הקובץ הקודמת כדי להימנע מקריאות מערכת stat() נוספות:

if (-f $file && -r _) { ... }        # one stat() call, two checks

ה־_ הגורר הוא הניב הסטנדרטי לכל שרשרת של בדיקות קובץ על אותו נתיב.

ראו גם#

כל עמוד אחר במדריך עיון זה מקשר לשורות טבלה זו מתוך סעיף הקדימות שלו. ההפניה הצולבת היא מכוונת - כשעליכם לשלב אופרטור עם אחר, טבלה זו היא התשובה.
אינדקס perlfunc - כל שם ברשימה האונרית־בעלת־השם מתועד שם.