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

qq//#

בניית מחרוזת במרכאות־כפולות עם שיבוץ, במתחם הנבחר.

qq// היא הצורה הארוכה של ליטרל המחרוזת "...". היא מפיקה את אותה מחרוזת ש־"" הייתה מפיקה, כך ש־qq/hello $name\n/ ו־"hello $name\n" ניתנים להחלפה. תכלית ה־qq היא המתחם: כשהתוכן מכיל " (או רצפי backslash שיפריעו למרכאות הכפולות), בוחרים מתחם אחר ושומרים על המחרוזת קריאה במקום לשרשר \" בתוכה.

תקציר#

qq/STRING/
qq{STRING}
qq(STRING)
qq[STRING]
qq<STRING>
qqXSTRINGX        # any non-word, non-whitespace char works as delimiter

מה מוחזר#

מחרוזת סקלרית. משתנים המוזכרים בתוך משובצים בנקודה שבה qq// מוערך (לא בזמן פרסור); רצפי escape של backslash מורחבים. בתוצאה אין תו שורה חדשה מובלע - יש לכתוב \n בעצמכם.

בחירת מתחם#

כל תו שאינו תו מילה (/\w/) ואינו רווח לבן רשאי לבוא אחרי qq. ארבעת זוגות הסוגריים מקננים:

qq(foo (bar) baz)          # "foo (bar) baz" - inner () balanced
qq{ if ($x) { 1 } else { 0 } }
qq[a[b[c]d]e]
qq<<a<b>c>>

מתחמים שאינם סוגריים משתמשים באותו תו בשני הקצוות ואינם מקננים:

qq|one|two|                # SYNTAX ERROR - first | closes
qq/a\/b/                   # "a/b" - backslash escapes the delimiter

אם המתחם הוא תו מילה, נדרש רווח לבן בין qq לבין המתחם:

qq XfooX                   # OK - "foo"
qqXfooX                    # WRONG - parsed as identifier qqXfooX

# כמתחם אינו צריך רווח ולעתים שימושי עבור מחרוזות המכילות כל סימן פיסוק אחר:

qq#He said "hi" & waved.#  # "He said \"hi\" & waved."

התכונה extra_paired_delimiters (5.36+) מזהה קבוצה רחבה של זוגות סוגריים מ־Unicode כמתחמים מקננים; יש להפעיל אותה ב־use feature 'extra_paired_delimiters' כאשר רוצים, נאמר, גרשיים צרפתיים או סוגריי CJK.

מה משובץ#

  • סקלרים: $x, $hash{key}, $array[0], $ref->{k}[2].

  • מערכים: @arr מתרחב לפי הסדר, האיברים מאוחים על־ידי $" (ברירת מחדל " "). שקול ל־join $", @arr.

  • פרוסות: @h{qw(a b)}, @a[1..3].

  • הפניות חזרה עם חצים ותתי־סימון: $ref->{key}[0].

מה לא משובץ:

  • קריאות מתודה: $obj->meth בתוך qq// משבץ את $obj ומשאיר את הטקסט המילולי ->meth במחרוזת.

  • קריאות פונקציה: @{[ func() ]} הוא העקיפה הרגילה - הפניה־חזרה של הפניית מערך מריצה קוד שרירותי ומשבצת את התוצאה.

  • מערכי פיסוק מלבד @_, @+, @-: משובצים רק כשהם בסוגריים מסולסלים (@{*}). @* חשוף הוא @* מילולי.

my $obj = Some::Class->new;
qq/$obj->name/;                       # interpolates $obj, leaves "->name"
qq/@{[ $obj->name ]}/;                # calls the method, interpolates result

רצפי escape#

זמינים בתוך qq// (ובכל מקום אחר שבו מתרחש שיבוץ):

רצף

משמעות

\t

טאב (HT)

\n

תו שורה חדשה (סוף שורה וירטואלי לפלטפורמה)

\r

חזרת גררה (CR)

\f

הזנת טופס (FF)

\b

backspace (BS)

\a

התראה / פעמון (BEL)

\e

escape (ESC)

\0

NUL

\\

backslash מילולי

\"

מרכאות כפולות מילוליות

\x1b

תו הקסה, 0x00–0xFF

\x{263A}

תו הקסה, כל נקודת קוד (צורה בסוגריים מסולסלים)

\o{23072}

תו אוקטלי, כל נקודת קוד

\033

תו אוקטלי, 000–777 (עדיף \o{})

\cA

תו בקרה - 64 ב־xor עם התו הבא באותיות גדולות

\N{GREEK SMALL LETTER ALPHA}

תו Unicode בעל שם (צריך use charnames)

\N{U+03B1}

תו Unicode לפי נקודת קוד (תמיד Unicode, גם ב־EBCDIC)

מתאמי רישיות וציטוט חלים עד \E או סוף המחרוזת:

רצף

משמעות

\l

הופך לקטנה את התו הבא בלבד

\u

הופך ל־titlecase (לא לאות גדולה!) את התו הבא בלבד

\L

הופך לקטנות עד \E

\U

הופך לגדולות עד \E

\F

foldcase עד \E

\Q

ציטוט מטה־תווי regex עד \E (קורא ל־quotemeta)

\E

סיום ה־\L / \U / \F / \Q האחרון

\L, \U, \F, \Q מצטברים - כל אחד צריך \E משלו.

say "\u$name";                        # capitalise first letter
say "\U$name\E's account";            # uppercase $name, rest untouched
say "match $file literally: \Q$file\E";

\Q בתוך qq// מוחל אחרי השיבוץ, כך ש־qq/\Q$pat\E/ שווה ל־quotemeta($pat). (באופרטורי ציטוט regex qr// ו־m//, \Q מוחל אחרי השיבוץ אך לפני הידור ה־regex - ההבדל משמעותי כאשר $pat עצמו מכיל מטה־תווי regex שרוצים לשמר מילוליים.)

ל־Perl אין escape של \v בליטרלי מחרוזת - זה מטה־תו regex. יש להשתמש ב־\x0b, \cK, או \N{VT} עבור טאב אנכי.

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

  • $" - מפריד הרשימה בשימוש בעת שיבוץ מערכים ופרוסות. ברירת מחדל " ". ניתן לשנות ב־local $" = "," לתחום אחד.

אף משתנה גלובלי אחר של המפרש אינו משתתף בהערכת qq// עצמה. משתנים משובצים הם כמובן כל ערכיהם הנוכחיים בנקודה שבה qq// רץ.

דוגמאות#

שיבוץ פשוט, זהה במשמעותו לצורת "...":

my $name = "world";
my $s = qq/hello, $name!\n/;          # "hello, world!\n"

מחרוזת המכילה מרכאות כפולות - qq עם מתחם שונה נמנע מפסולת backslash:

my $msg = qq{He said "yes" and then "maybe".};
# vs:   "He said \"yes\" and then \"maybe\"."

קטע HTML רב־שורתי עם סוגריים מסולסלים מקוננים - הזוג () מקנן:

my $user = "rj";
my $html = qq(
  <p>Welcome, $user.</p>
  <p>You have @{[ scalar @inbox ]} messages.</p>
);

שיבוץ מערך עם מפריד מותאם אישית:

my @tags = qw(perl rust docs);
local $" = ", ";
say qq/tags: @tags/;                  # "tags: perl, rust, docs"

מלכודת קריאת־מתודה - -> הוא מילולי בתוך qq//:

my $obj = File::Spec->new;
qq/path is $obj->rel2abs('.')/;       # "path is <stringified $obj>->rel2abs('.')"
qq/path is @{[ $obj->rel2abs('.') ]}/;
                                      # actually calls rel2abs()

בניית קטע SQL כאשר $ident אינו אמין - \Q..\E שומר על %, _, ו־backslash משובצים כמילוליים תחת פסוקית LIKE רק אחרי שטיפלתם בפרמטריזציה כראויה; עבור escaping של SQL בפועל יש להשתמש בציטוט של הדרייבר, לא ב־\Q:

my $needle = "100% sure";
my $pat = qq/\Q$needle\E/;            # the regex-safe form
# $pat eq "100\\%\\ sure"

מתאמים מצטברים:

say qq/\Qfoo \ubar \Ubaz\E qux\E done/;
# "foo\ Bar\ BAZ qux done"
#  \Q quotes spaces/?; \u titlecases b; \U uppercases baz until \E;
#  outer \E ends \Q.

מקרי קצה#

  • בחירת מתחם בזמן פרסור. Perl בוחר את המתחם הסוגר ברגע שהוא קורא את הפותח. qq/.../ מצפה ל־/; אין דרך להחליף באמצע המחרוזת. אם נדרשים שני סוגי סוגריים, יש לבחור מתחם שאינו סוגר.

  • backslash בסוף מחרוזת עם מתחם שאינו סוגר. qq/a\/ הוא a/ (ה־backslash עושה escape למתחם, המחרוזת ממשיכה); כדי לקבל backslash מילולי מסיים, יש להחליף מתחם: qq{a\\}.

  • אין קינון למתחמים שאינם סוגרים. qq|a|b| היא המחרוזת a ואחריה המזהה b ואחריו | - שגיאת תחביר ברוב ההקשרים. יש לבחור מתחמי סוגריים כאשר התוכן מכיל את תו המתחם.

  • # כמתחם הוא מקרה מיוחד רק בגלל איך הערות נכנסות לתמונה: qq#...# היא מחרוזת, אבל qq #...# (עם רווח לבן) הוא האופרטור qq ואחריו הערה, כאשר המחרוזת נלקחת מהשורה הבאה. זה משקף את התנהגות כל האופרטורים ממשפחת q.

  • מחרוזת ריקה. qq// היא המחרוזת הריקה, זהה ל־"".

  • undef משובץ. מומר למחרוזת ריקה, ותחת use warnings, מפעיל אזהרת uninitialized בנקודת השיבוץ, לא בנקודה שבה ל־$var הושם undef.

  • $ או @ ואחריהם לא־מזהה. נשאר מילולי: qq/cost: \$5/ ו־qq/cost: $5/ שניהם מפיקים cost: $5 (אין משתנה בשם $5 במובן מזהה Perl 5 - $5 הוא לכידת regex, שכן קיימת, כך שהצורה השנייה משבצת את קבוצת לכידה 5, יהיה אשר יהיה ערכה כעת). עבור $ או @ מילולי, יש לבצע escape: \$, \@.

  • \N{...} ללא charnames. תווים בעלי שם דורשים ש־use charnames ':full' (או דומה) ייטען בתחום; בלעדיו מקבלים שגיאת זמן הידור. \N{U+HEX} והצורות בעלות־השם־היחיד שבסט :loose עובדות בלעדיו.

  • מיפוי רישיות רגיש ל־locale. עם use locale הכולל את LC_CTYPE, \l, \u, \L, \U משתמשים בטבלאות הרישיות של ה־locale הנוכחי. בלעדיו, טבלאות הרישיות של Unicode בשימוש עבור נקודות קוד מעל 0xFF, וכללי ASCII מתחת. \F משתמש ב־foldcase של Unicode ללא קשר ל־locale (פרט ל־locale של UTF-8, שבו הוא תואם ל־\L).

  • רמה אחת בלבד. תוצאת השיבוץ אינה נסרקת מחדש. my $v = '$x'; qq/$v/ היא המחרוזת $x בת ארבעת התווים, לא הערך של $x.

הבדלים מהמעלה־הזרם#

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

ראו גם#

  • q// - ליטרל במרכאות יחידות, ללא שיבוץ, אותם כללי מתחם

  • qw// - ליטרל של רשימת מילים, מפיק רשימת מחרוזות מפוצלות על רווח לבן

  • qx// - מחרוזת משובצת המבוצעת כפקודת shell, לוכדת את stdout

  • qr// - regex משובץ, מהודר פעם אחת ורב־שימושי

  • sprintf - יש להישען על כך כשהעבודה היא לפרמט מספרים או לרפד שדות, לא לשבץ משתנים בטקסט

  • quotemeta - הפונקציה ש־\Q..\E קוראת לה

  • join - מה ששיבוץ מערך עושה בסתר, עם $" כמפריד

  • $" - מפריד הרשימה בשימוש כאשר מערך משובץ למחרוזת במרכאות־כפולות

  • אופרטורי ציטוט ודמויי־ציטוט - הטבלה המלאה של q, qq, qx, qw, qr, m, s, tr וכללי המתחם וה־escape המשותפים להם