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

rindex

מציאת המיקום של המופע האחרון של תת־מחרוזת בתוך מחרוזת.

rindex הוא המקבילה מימין־לשמאל של index. הוא סורק את STR עבור SUBSTR ומחזיר את ה־offset מבוסס־האפס של ההתאמה הימנית ביותר, או -1 אם לא קיימת התאמה. כאשר POSITION ניתן, החיפוש מוגבל להתאמות שה־offset ההתחלתי שלהן קטן או שווה ל־POSITION - כלומר, המופע האחרון באותו מיקום או לפניו.

תקציר

rindex $str, $substr
rindex $str, $substr, $position

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

מספר שלם. אפס או חיובי מסמן את ה־offset מבוסס־האפס של ההתאמה הימנית ביותר; -1 מסמן ש־SUBSTR אינו מופיע ב־STR (כפוף לאילוץ POSITION, אם יש).

Offsets נמדדים בתווים כאשר STR מחזיק מחרוזת תווים, ובבתים כאשר STR הוא מחרוזת בתים. זה תואם את index ואת שאר ה־builtins של מחרוזות ב־Perl - היחידה היא מה שהמחרוזת עצמה משתמשת בו.

כיצד POSITION מעצב את החיפוש

POSITION הוא חסם עליון על ה־offset ההתחלתי של ההתאמה, לא על המקום שבו הסריקה מתחילה. התוצאה מקיימת:

• result <= POSITION

• result + length(SUBSTR) <= length(STR) (כמו תמיד)

באופן קונקרטי:

• POSITION מושמט או undef - חיפוש בכל המחרוזת; החזרת ההתאמה הימנית ביותר.

• POSITION גדול או שווה ל־length(STR) - מתנהג כאילו POSITION היה length(STR); כל המחרוזת נשקלת.

• POSITION קטן מ־0 - מתנהג כאילו POSITION היה 0; רק התאמה שמתחילה ב־offset 0 יכולה לקיים את האילוץ, ולכן ערך ההחזרה הוא 0 כאשר STR מתחיל ב־SUBSTR ו־-1 אחרת.

• SUBSTR ריק - כל offset מ־0 עד length(STR) הוא מיקום התאמה תקף, ולכן rindex מחזיר min(POSITION, length(STR)) (או length(STR) כאשר POSITION מושמט).

יש לחשוב על POSITION כ־״מצא את ההתאמה האחרונה כאן או לפני״, לא כ־״התחל לסרוק כאן״.

דוגמאות

חיפוש מימין־לשמאל בסיסי:

rindex("banana", "a");         # 5  (the final 'a')
rindex("banana", "na");        # 4  (last "na")
rindex("banana", "z");         # -1 (not found)

צעידה אחורה דרך כל מופע על־ידי שימוש בכל תוצאה, פחות אחד, כ־POSITION הבא:

my $str = "banana";
my $pos = length($str);
while ((my $hit = rindex($str, "a", $pos - 1)) >= 0) {
    print "match at $hit\n";   # 5, 3, 1
    $pos = $hit;
}

POSITION כחסם עליון - ההתאמה חייבת להתחיל באותו מקום או לפניו:

rindex("banana", "na", 3);     # 4? No: 4 > 3, so the match at 4
                               #   is excluded; returns 2
rindex("banana", "na", 4);     # 4  (match starting at 4 is allowed)

SUBSTR ריק מתאים בכל offset, ולכן התוצאה היא המיקום המוגבל:

rindex("banana", "", 4);       # 4
rindex("banana", "");          # 6  (length of "banana")

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

my $path = "/usr/local/bin/perl";
my $slash = rindex($path, "/");
my $file  = substr($path, $slash + 1);   # "perl"

מקרי קצה

• תת־מחרוזת ארוכה מהמחרוזת: rindex("abc", "abcd") מחזיר -1. אף התאמה לא יכולה להתאים.

• תת־מחרוזת שווה למחרוזת: rindex("abc", "abc") מחזיר 0. ההתאמה האחרונה (והיחידה) מתחילה ב־offset 0.

• POSITION מעבר לסוף: rindex($str, $sub, 9999) מתנהג כאילו POSITION היה length($str) - כל המחרוזת נסרקת.

• POSITION שלילי: מטופל כ־0. rindex("abc", "b", -5) מחזיר -1 (אף התאמה לא יכולה להתחיל ב־offset 0 או מוקדם יותר); rindex("abc", "a", -5) מחזיר 0.

• POSITION הוא undef: זהה להשמטתו. תחת use warnings זה מנפיק אזהרת uninitialized.

• STR ריק, SUBSTR לא־ריק: מחזיר -1.

• STR ריק, SUBSTR ריק: מחזיר 0.

• Unicode: עבור מחרוזות תווים (אלה שהמפענח יודע שהן טקסט), offsets סופרים תווים, לא בתים. מחרוזת שהוחלפה לסמנטיקת בתים דרך use bytes או encode_utf8 תדווח על offsets של בתים במקום. הכלל משקף את index ו־substr.

• ארגומנטים מוכתמים: התוצאה יורשת taint מ־STR ומ־SUBSTR תחת -T.

הבדלים מ־upstream

תואם מלא ל־upstream Perl 5.42.

ראו גם

• index - המקבילה משמאל־לימין; מוסכמות ארגומנטים זהות, מחזיר את המופע הראשון

• substr - בדרך־כלל הקריאה הבאה לאחר rindex מוצלח, כדי לחתוך את האזור המותאם או את מה שבא אחריו

• length - שימושי בעת חישוב החיתוך הנגרר: substr($s, $hit + length($sub))

• pos - לסריקה מונעת regex כאשר נחוץ מצב ההתאמה של המנוע ולא offset של תת־מחרוזת יחידה

• split - כשרוצים את כל מקטע המופרד על־ידי SUBSTR, לא רק את האחרון

• reverse - בשילוב עם index הוא נחשב לעיתים בטעות לתחליף ל־rindex; rindex ברור ומהיר יותר