perl56delta - מקוון בענן

תָכְנִית:

שֵׁם

perl56delta - מה חדש עבור perl v5.6.0

תיאור

מסמך זה מתאר הבדלים בין המהדורה 5.005 לגרסה 5.6.0.

ליבה שיפורים

מְתוּרגְמָן שיבוט, חוטים, ו מקביליות
Perl 5.6.0 מציגה את התחלות התמיכה בהפעלת מספר מתורגמנים
במקביל בשרשורים שונים. בשילוב עם ה perl_clone() קריאת API, אשר
ניתן להשתמש כדי לשכפל באופן סלקטיבי את המצב של כל מתורגמן נתון, זה אפשרי
להרכיב קטע קוד פעם אחת במפרש, לשכפל את המתורגמן פעם אחת או יותר,
ולהריץ את כל המתורגמנים שנוצרו בשרשורים נפרדים.

בפלטפורמת Windows, תכונה זו משמשת לחיקוי מזלג() ברמת המתורגמן.
ראה perlfork לפרטים על כך.

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

ניתן להפעיל תמיכה בשיבוט מתורגמנים ובמקבילות מתורגמנים באמצעות ה
-אפשרות ה-Dusethreads Configure (ראה win32/Makefile כיצד להפעיל אותו ב-Windows.)
קובץ ההפעלה של perl שיתקבל יהיה זהה מבחינה תפקודית לזה שנבנה איתו
-ריבוי, אבל ה perl_clone() קריאת API תהיה זמינה רק בראשון.

-Dusethreads מאפשר את מאקרו ה-cpp USE_ITHREADS כברירת מחדל, אשר בתורו מאפשר Perl
שינויים בקוד המקור המספקים הפרדה ברורה בין עץ ה-op לבין הנתונים שהוא
פועל עם. הראשון אינו ניתן לשינוי, ולכן ניתן לחלוק אותו בין an
מתורגמן וכל השיבוטים שלו, בעוד שהאחרון נחשב מקומי לכל אחד
מתורגמן, ולכן מועתק עבור כל שיבוט.

שים לב שבניית Perl עם האפשרות -Dusemultiplicity Configure מספיקה אם אתה
רוצה להריץ מרובים עצמאי מתורגמנים במקביל בשרשורים שונים.
-Dusethreads מספק רק את הפונקציונליות הנוספת של perl_clone() קריאת API ו
תמיכה אחרת לריצה שיבוט מתורגמנים במקביל.

הערה: זוהי תכונה ניסיונית. פרטי היישום הם
נתון לשינוי.

מבחינה מילונית סקופד אזהרה קטגוריות
כעת אתה יכול לשלוט בפירוט של אזהרות הנפלטות על ידי perl ברמה עדינה יותר באמצעות
פרגמת "השתמש באזהרות". לאזהרות ול-perllexwarn יש תיעוד בשפע על זה
תכונה.

Unicode ו UTF-8 תמיכה
Perl משתמשת כעת ב-UTF-8 כייצוג פנימי עבור מחרוזות תווים. ה-"utf8" ו
פרגמות "בתים" משמשות לשליטה בתמיכה זו בהיקף המילוני הנוכחי. לִרְאוֹת
perlunicode, utf8 ובייטים למידע נוסף.

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

הערה: יש לראות בכך תכונה ניסיונית. יישום
הפרטים עשויים להשתנות.

תמיכה ל אינטרפולציה בשם תווים
ה-"\N" החדש משלב תווים בעלי שם בתוך מחרוזות. לדוגמה, "היי!
"\N{פרצוף מחייך לבן}" מוערך למחרוזת עם סמיילי יוניקוד בסוף.

"שֶׁלָנוּ" הצהרות
הצהרה "שלנו" מציגה ערך שניתן להבין בצורה הטובה ביותר כבעל היקף מילוני
כינוי סימבולי למשתנה גלובלי בחבילה שהיה עדכני במקום בו היה המשתנה
מוּצהָר. זה שימושי בעיקר כאלטרנטיבה לפרגמה "vars", אבל גם מספק
ההזדמנות להציג הקלדה ותכונות אחרות עבור משתנים כאלה. ראה "שלנו" ב
perlfunc.

תמיכה ל מחרוזות מיוצג as a וקטור of סידורים
מילוליות מהצורה "v1.2.3.4" מנותחות כעת כמחרוזת המורכבת מתווים עם
סידורים שצוינו. זוהי דרך חלופית וקריאה יותר לבנות (אפשר
מחרוזות יוניקוד) במקום אינטרפולציה של תווים, כמו ב-"\x{1}\x{2}\x{3}\x{4}". ה-
ניתן להשמיט את "v" מוביל אם יש יותר משני סידורים, אז 1.2.3 מנותח את
זהה ל-"v1.2.3".

מחרוזות הכתובות בצורה זו שימושיות גם כדי לייצג "מספרי גרסאות". זה קל
להשוות "מספרים" של גרסאות כאלה (שהם בעצם רק מחרוזות רגילות) באמצעות כל אחד מה-
אופרטורים רגילים להשוואת מחרוזות "eq", "ne", "lt", "gt" וכו', או לבצע מחרוזת סיבית
פעולות עליהם באמצעות "|", "&" וכו'.

בשילוב עם משתנה הקסם החדש $^V (המכיל את גרסת perl בתור a
string), מילוליות כאלה יכולות לשמש כדרך קריאה לבדוק אם אתה מפעיל את a
גרסה מסוימת של Perl:

# זה ינתח גם בגרסאות ישנות יותר של Perl
if ($^V ו-$^V gt v5.6.0) {
# תכונות חדשות נתמכות
}

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

דורש 5.006; # בדיקת זמן ריצה עבור גרסה 5.6
השתמש ב-5.006_001; # בדיקת זמן קומפילציה עבור גרסה 5.6.1

כמו כן, "sprintf" ו-"printf" תומכים בדגל הפורמט הספציפי של Perl %v כדי להדפיס סידורים של
תווים במחרוזות שרירותיות:

printf "v%vd", $^V; # מדפיס את הגרסה הנוכחית, כגון "v5.5.650"
printf "%*vX", ":", $addr; # פורמטים של כתובת IPv6
printf "%*vb", " ", $bits; # מציג מחרוזת סיביות

ראה "בוני ערך סקלארי" ב-perldata למידע נוסף.

מְשׁוּפָּר פרל גרסה סִפְרוּר מערכת
החל מגרסה 5.6.0 של Perl, מוסכמות מספר הגרסה שונתה ל-a
סכימת "מספר שלם מנוקד" הנפוצה יותר בפרויקטים של קוד פתוח.

גרסאות תחזוקה של v5.6.0 ישוחררו כ-v5.6.1, v5.6.2 וכו'.
סדרות פיתוח בעקבות v5.6.0 ימוספרו v5.7.x, החל ב-v5.7.0, ו
מהדורת הייצור העיקרית הבאה לאחר v5.6.0 תהיה v5.8.0.

מודול האנגלית מגדיר כעת את $PERL_VERSION ל-$^V (ערך מחרוזת) במקום ל-$] (a
ערך מספרי). (זוהי אי התאמה פוטנציאלית. שלח לנו דוח באמצעות perlbug if
אתה מושפע מזה.)

תחביר v1.2.3 גם הוא חוקי כעת בפרל. ראה "תמיכה במחרוזות המיוצגות בתור א
וקטור של סידורים" למידע נוסף על כך.

כדי להתמודד עם השימוש של מערכת הגרסה החדשה של לפחות שלוש ספרות משמעותיות עבור כל אחת מהן
רכיב הגרסה, השיטה המשמשת להגדלת מספר החתרנות השתנתה גם היא
מְעַט. אנו מניחים שגרסאות ישנות מגרסה 5.6.0 הגדילו את החתרנות
רכיב בכפולות של 10. גרסאות לאחר v5.6.0 יגדילו אותן ב-1. לפיכך,
באמצעות הסימון החדש, 5.005_03 הוא "זהה" לגרסה 5.5.30, והתחזוקה הראשונה
הגרסה הבאה אחרי v5.6.0 תהיה v5.6.1 (שיש לקרוא אותה כשוות ערך ל-a
ערך נקודה צפה של 5.006_001 בפורמט הישן יותר, מאוחסן ב-$]).

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

sub mymethod: שיטה נעולה;
...
sub mymethod: שיטה נעולה {
...
}

sub othermethod :locked :method;
...
sub othermethod :locked :method {
...
}

(שים לב שרק ה-":" הראשון הוא חובה, והרווח הלבן המקיף את ה-":" הוא
אופציונאלי.)

AutoSplit.pm ו SelfLoader.pm עודכנו כדי לשמור על התכונות עם הסטאבים
הם מספקים. ראה תכונות.

שלח ו בספרייה ידיות יכול be מחייה אוטומטית
בדומה לאופן שבו מבנים כגון "$x->[0]" מייצרים הפניה אוטומטית, מטפלים בבונים
(לִפְתוֹחַ(), opendir (), צינור(), socketpair(), sysopen(), שקע (), ו לְקַבֵּל()) עכשיו
autovivify קובץ או ספרייה נקודת אחיזה אם הידית שהועברה אליהם היא לא אתחול
משתנה סקלרי. זה מאפשר את המבנים כגון "open(my $fh, ...)" ו-"open(local
$fh,...)" שישמש ליצירת נקודות אחיזה של קבצים שייסגרו בצורה נוחה אוטומטית
כאשר ההיקף מסתיים, בתנאי שלא יהיו התייחסויות אחרות אליהם. זה במידה רבה
מבטל את הצורך ב-typeglobs בעת פתיחת ידיות קבצים שיש להעביר, כמו
בדוגמה הבאה:

sub myopen {
פתח את ה-$fh שלי, "@_"
או למות "לא יכול לפתוח את '@_': $!";
החזר $fh;
}

{
שלי $f = myopen("
הדפס <$f>;
# $f נסגר כאן באופן מרומז
}

לִפְתוֹחַ() עם יותר מֵאֲשֶׁר שתיים טיעונים
If לִפְתוֹחַ() מועבר שלושה ארגומנטים במקום שניים, הארגומנט השני משמש כ-
מצב והארגומנט השלישי נחשב לשם הקובץ. זה שימושי בעיקר עבור
הגנה מפני התנהגות קסם לא מכוונת של הצורה המסורתית של שני טיעונים. לִרְאוֹת
"פתוח" ב-perlfunc.

64 סיבית תמיכה
כל פלטפורמה שיש לה מספרים שלמים של 64 סיביות

(1) מקורי כ-longs או ints
(2) באמצעות דגלי מהדר מיוחדים
(3) באמצעות long long או int64_t

מסוגל להשתמש ב-"quads" (מספרים שלמים של 64 סיביות) באופן הבא:

· קבועים (עשרוני, הקסדצימלי, אוקטלי, בינארי) בקוד

· טיעונים ל אוקטובר () ו hex ()

· טיעונים ל הדפס(), printf () ו sprintf () (קידומות דגל ll, L, q)

· מודפס ככזה

· חבילה() ו לִפְרוֹק() פורמטים "q" ו-"Q".

· בחשבון בסיסי: + - * / % (הערה: פועל קרוב לגבולות המספר השלם
ערכים עשויים להניב תוצאות מפתיעות)

· באריתמטיקה של סיביות: & | ^ ~ << >> (הערה: פעם אלה נאלצו להיות ברוחב של 32 סיביות
אך כעת פועלים על רוחב המקור המלא.)

· vec()

שים לב שאם לא יש לך את המקרה (א) תצטרך להגדיר ולהרכיב את Perl באמצעות
הדגל -Duse64bitint Configure.

הערה: הדגלים Configure -Duselonglong ו-Duse64bits היו
הוצא משימוש. השתמש במקום זאת ב-Duse64bitint.

למעשה ישנם שני מצבים של 64 סיביות: הראשון מושג באמצעות Configure
-Duse64bitint והשני באמצעות Configure -Duse64bitall. ההבדל הוא זה
הראשון הוא מינימלי והשני מקסימלי. הראשון עובד ביותר מקומות מאשר
השני.

ה-"use64bitint" עושה רק כמה שנדרש כדי להכניס מספרים שלמים של 64 סיביות לפרל (זה
יכול להיות, למשל, שימוש ב"ארוכים ארוכים") בעוד שהזיכרון שלך עדיין עשוי להיות מוגבל ל-2
ג'יגה-בייט (מכיוון שהמצביעים שלך עדיין יכולים להיות 32 סיביות). שימו לב שהשם "64bitint"
לא מרמז שהמהדר C שלך ישתמש ב-"int" של 64 סיביות (יכול להיות, אבל זה לא
חייב): ה-"use64bitint" אומר שתוכל לקבל סקלאר רחב של 64 סיביות
ערכים.

ה-"use64bitall" הולך עד הסוף על ידי ניסיון להחליף גם מספרים שלמים (אם הוא יכול),
משתוקק (ומצביע) להיות 64 סיביות. זה עלול ליצור אי-תואם בינארי אפילו יותר
Perl מאשר -Duse64bitint: ייתכן שקובץ ההפעלה המתקבל לא יפעל כלל בתיבה של 32 סיביות, או
ייתכן שתצטרך לאתחל/להגדיר מחדש/לבנות מחדש את מערכת ההפעלה שלך כדי להיות מודע ל-64 סיביות.

מערכות מקוריות של 64 סיביות כמו Alpha ו-Cray אינן זקוקות לא -Duse64bitint ולא -Duse64bitall.

אחרון חביב: שימו לב שבגלל ההרגל של פרל להשתמש תמיד במספרי נקודה צפה,
ה-quads עדיין לא מספרים שלמים אמיתיים. כאשר quads מציפים את הגבולות שלהם
(0...18_446_744_073_709_551_615 unsigned,
-9_223_372_036_854_775_808...9_223_372_036_854_775_807 signed), they are silently promoted
למספרי נקודה צפה, ולאחר מכן הם יתחילו לאבד דיוק (בתחתון שלהם
ספרות).

הערה: תמיכה ב-64 סיביות עדיין ניסיונית ברוב הפלטפורמות.
התמיכה הקיימת מכסה רק את מודל הנתונים LP64. בפרט, ה
מודל הנתונים LLP64 אינו נתמך עדיין. ספריות ומערכת של 64 סיביות
ממשקי API בפלטפורמות רבות לא התייצבו - הקילומטראז' שלך עשוי להשתנות.

גדול פילה תמיכה
אם יש לך מערכות קבצים שתומכות ב"קבצים גדולים" (קבצים גדולים מ-2 גיגה-בייט), אתה
עשוי כעת גם להיות מסוגל ליצור ולגשת אליהם מ-Perl.

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

אם התמיכה בקבצים גדולים מופעלת, ויש לך קבוע Fcntl O_LARGEFILE, ה-
O_LARGEFILE מתווסף אוטומטית לדגלים של sysopen().

היזהר כי אלא אם כן מערכת הקבצים שלך תומכת גם ב"קבצים דלילים" המבקשים לכלול מספר רב של קבצים
פטה-בייט עשוי להיות לא מומלץ.

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

לבסוף, בנוסף למגבלות גודל הקבצים המקסימליות של התהליך/התהליך שלך, ייתכן שיש לך
מגבלות מכסה על מערכות הקבצים שלך שמונעות ממך (מזהה המשתמש שלך או מזהה קבוצת המשתמש שלך).
באמצעות קבצים גדולים.

התאמת מגבלות התהליך/משתמש/קבוצה/מערכת הקבצים/מערכת ההפעלה שלך היא מחוץ לתחום
של שפת הליבה של פרל. עבור מגבלות תהליך, תוכל לנסות להגדיל את המגבלות באמצעות שלך
הפקודה limits/limit/ulimit של shell לפני הפעלת Perl. הרחבת BSD::Resource (לא
כלול בהפצה הסטנדרטית של Perl) עשוי להיות שימושי, הוא מציע את
ממשק getrlimit/setrlimit שניתן להשתמש בו כדי להתאים את מגבלות השימוש במשאבי התהליך,
כולל מגבלת גודל הקבצים המקסימלית.

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

"יותר חלקים"
אתה יכול "להגדיר -Dusemorebits" כדי להפעיל גם את תמיכת 64 סיביות וגם את הכפול הארוך
תומכים.

משופר תמיכה ל סוג() שגרות
כעת ניתן להשתמש בתתי שגרות של Perl עם אב טיפוס של "($$)", ו-XSUBs באופן כללי.
תתי שגרות. בכל מקרה, שני האלמנטים שיש להשוות מועברים כרגיל
פרמטרים ב-@_. ראה "מיין" ב-perlfunc.

עבור תת-שגרות מיון ללא אב טיפוס, ההתנהגות ההיסטורית של העברת האלמנטים להיות
לעומת המשתנים הגלובליים $a ו-$b נשארים ללא שינוי.

"סוג $coderef @foo" מותר
סוג() לא קיבל התייחסות לשגרת משנה כפונקציית ההשוואה קודם לכן
גרסאות. זה מותר כעת.

שלח גלוביות יושם כלפי פנים
Perl משתמש כעת ביישום File::Glob של גלוב () מפעיל באופן אוטומטי. זֶה
נמנע משימוש בתהליך csh חיצוני והבעיות הקשורות אליו.

הערה: כרגע זוהי תכונה ניסיונית. ממשקים ו
היישום נתון לשינויים.

תמיכה ל לבדוק אבני
בנוסף ל-"BEGIN", "INIT", "END", "DSTROY" ו-"AUTOLOAD", תת-שגרות בשם "CHECK"
עכשיו מיוחדים. אלה עומדים בתור במהלך ההידור ומתנהגים בדומה לבלוקים END,
אלא שהם נקראים בסוף ההידור ולא בסוף הביצוע.
אי אפשר להתקשר אליהם ישירות.

POSIX אופי בכיתה תחביר [: :] נתמך
לדוגמה כדי להתאים תווים אלפביתיים השתמש /[[:alpha:]]/. ראה perlre לפרטים.

מוטב פסאודו-אקראי מספר גנרטור
ב-5.005_0x ומעלה, perl's ראנד () הפונקציה השתמשה בספריית C שורה(3) פונקציה. כפי ש
של 5.005_52, הגדר בדיקות עבור draand48(), אַקרַאִי(), ו ראנד () (בסדר הזה) ובוחרות
הראשון שהוא מוצא.

שינויים אלה אמורים לגרום למספרים אקראיים טובים יותר מ ראנד ().

מְשׁוּפָּר "qw//" מפעיל
האופרטור "qw//" מוערך כעת בזמן ההידור לרשימה אמיתית במקום להיות
הוחלף בקריאה לזמן ריצה ל-"split()". זה מסיר את ההתנהגות המבלבלת של
"qw//" בהקשר סקלרי, שירש את ההתנהגות הזו מ לְפַצֵל().

כָּך:

$foo = ($bar) = qw(abc); הדפס "$foo|$bar\n";

כעת מדפיס כראוי "3|a", במקום "2|a".

מוטב במקרה הגרוע ביותר התנהגות of has has
שינויים קטנים באלגוריתם הגיבוב יושמו על מנת לשפר את
הפצה של סיביות מסדר נמוך יותר בערך הגיבוב. זה צפוי להניב טוב יותר
ביצועים על מקשים שהם רצפים חוזרים.

חבילה() פוּרמָט 'Z' נתמך
סוג הפורמט החדש 'Z' שימושי לאריזה ופירוק מחרוזות עם סיומת אפס. לִרְאוֹת
"אריזה" ב-perlfunc.

חבילה() פוּרמָט מתקן '!' נתמך
משנה סוג הפורמט החדש '!' שימושי לאריזה ופריקה של מכנסיים קצרים, אינטס,
ומתגעגע. ראה "חבילה" ב-perlfunc.

חבילה() ו לִפְרוֹק() תמיכה נספר מחרוזות
תו התבנית '/' יכול לשמש כדי לציין סוג מחרוזת שנספרה לארוז או
פורק. ראה "חבילה" ב-perlfunc.

תגובות in חבילה() תבניות
התו '#' בתבנית מציג הערה עד סוף השורה. זֶה
מקל על תיעוד של חבילה() תבניות.

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

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

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

כדי להשתמש בתכונה זו, אתה צריך את חבילת Devel::WeakRef מ-CPAN, המכילה
תיעוד נוסף.

הערה: זוהי תכונה ניסיונית. פרטים כפופים לשינויים.

בינרי מספרים נתמך
מספרים בינאריים נתמכים כעת בתור מילוליים, בפורמטים s?printf, ו-"oct()":

$answer = 0b101010;
printf "התשובה היא: %b\n", oct("0b101010");

ערך שגרות
תתי שגרות יכולות כעת להחזיר ערכי lvalus הניתנים לשינוי. ראה "תתי שגרות Lvalue" ב-perlsub.

הערה: זוהי תכונה ניסיונית. פרטים כפופים לשינויים.

כמה החצים אולי be הושמט in שיחות דרך אזכור
Perl מאפשרת כעת להשמיט את החץ במבנים רבים הכוללים קריאות תת-שגרתיות
באמצעות הפניות. לדוגמה, "$foo[10]->('foo')" עשוי להיכתב כעת
"$foo[10]('foo')". זה דומה למדי לאופן שבו ניתן להשמיט את החץ
"$foo[10]->{'foo'}". עם זאת, שים לב שהחץ עדיין נדרש עבור
"Foo(10)->('בר')".

בוליאני משימה מפעילי יש לו משפטי ערכים
מבנים כגון "($a ||= 2) += 1" מותרים כעת.

קיים () is נתמך on תת-נוהל שמות
השמיים קיים () ה-buildin עובד כעת על שמות תתי-שגרה. תת שגרה נחשבת לקיימת
אם הוא הוכרז (גם אם במרומז). ראה "קיים" ב-perlfunc לדוגמאות.

קיים () ו מחק () יש לו נתמך on מערך אלמנטים
השמיים קיים () ו מחק () המבנים עובדים כעת גם על מערכים פשוטים. ההתנהגות היא
דומה לזה של רכיבי hash.

קיים () ניתן להשתמש כדי לבדוק אם רכיב מערך אותחל. זה נמנע
רכיבי מערך מעוררים חיים שאינם קיימים. אם המערך קשור, ה- קיים() שיטה
בחבילה הקשורה המתאימה תופעל.

מחק () ניתן להשתמש כדי להסיר אלמנט מהמערך ולהחזיר אותו. אלמנט המערך
במיקום זה חוזר למצבו הלא-מאתחל, כך שבדיקה לאותו אלמנט
עם קיים () יחזיר false. אם במקרה האלמנט הוא זה שבסוף, ה-
גודל המערך גם מתכווץ עד לאלמנט הגבוה ביותר שבודק נכון עבורו קיים (), או
0 אם לא נמצא כזה. אם המערך קשור, ה- לִמְחוֹק() שיטה בהתאמה
חבילה קשורה תופעל.

ראה "קיים" ב-perlfunc ו-"מחק" ב-perlfunc לדוגמאות.

פסאודו-hashes לעבוד מוטב
הפנייה לסירוגין של סוגים מסוימים של ערכי התייחסות בפסאודו-hash, כגון "$ph->{foo}[1]",
נפסל בטעות. זה תוקן.

כאשר מוחל על אלמנט פסאודו-hash, קיים () כעת מדווח אם הערך שצוין
קיים, לא רק אם המפתח תקף.

מחק () עובד כעת על פסאודו-hashes. כאשר ניתן אלמנט או פרוסה פסאודו-hash הוא מוחק
הערכים המתאימים למפתחות (אך לא למפתחות עצמם). ראה "פסאודו-hashes:
שימוש במערך כ-hash" ב-perlref.

פרוסות פסאודו-hash עם מפתחות קבועים מותאמות כעת לחיפושי מערך בזמן ההידור.

הקצאות רשימה לפרוסות פסאודו-hash נתמכות כעת.

פרגמת "שדות" מספקת כעת דרכים ליצור פסאודו-hashes, באמצעות fields::new() ו
fields::phash(). ראה שדות.

הערה: סוג הנתונים הפסאודו-hash ממשיך להיות ניסיוני.
להגביל את עצמך לרכיבי הממשק שמסופקים על ידי ה
fields pragma תספק הגנה מכל שינוי עתידי.

מכני עם סלילה אוטומטית שְׁטִיפָה of תפוקה מאגרים
מזלג(), exec (), מערכת(), qx// וצינור לִפְתוֹחַ()s עכשיו לשטוף מאגרים של כל הקבצים שנפתחו עבור
פלט בעת ניסיון הפעולה. זה בעיקר מבטל חציצה מבלבלת
תקלות שסבלו ממשתמשים שלא מודעים לאופן שבו Perl מטפלת פנימית ב-I/O.

זה לא נתמך בפלטפורמות מסוימות כמו Solaris שבהן זה נכון
היישום של fflush(NULL) אינו זמין.

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

איפה אפשרי, נאגר נתונים מושלך החל מ- מְרוּמֶה קלט ידית קבצים
"open(NEW, "<&OLD")" מנסה כעת למחוק את כל הנתונים שנקראו בעבר ו
מאוחסן ב-"OLD" לפני שופכים את הידית. בפלטפורמות בהן מותר לעשות זאת, ה
פעולת הקריאה הבאה ב-"NEW" תחזיר את אותם נתונים כמו הפעולה המתאימה
"ישן". בעבר, זה היה מחזיר את הנתונים מתחילת הדיסק הבא
לחסום במקום זאת.

eof() יש ל מה היא אותו זקן קסם as <>
"eof()" יחזיר true אם עדיין לא נעשה ניסיון לקרוא מ-"<>". "eof()" יש
שונה לקסם קטן משלו, כעת הוא פותח את הקבצים "<>".

binmode() יכול be מְשׁוּמָשׁ ל סט :crlf ו :גלם מצבי
binmode() מקבל כעת טיעון שני שמציין דיסציפלינה לטיפול ב
שְׁאֵלָה. שתי הפסבדו-דיסציפלינות ":raw" ו-":crlf" נתמכות כעת ב-DOS-
פלטפורמות נגזרות. ראה "binmode" ב-perlfunc ופתח.

"-T" בדיקת קבצים מזהה UTF-8 מוצפן קבצים as "טֶקסט"
האלגוריתם המשמש עבור בדיקת הקבצים "-T" שופר כדי לזהות נכון את UTF-8
תוכן כ"טקסט".

מערכת(), תיקונים אחוריים ו מקטרת לפתוח עַכשָׁיו לשקף exec () כישלון
ב-Unix ובפלטפורמות דומות, מערכת(), qx() ו-open(FOO, "cmd |") וכו', מיושמים
באמצעות מזלג() ו exec (). כאשר הבסיס exec () נכשל, גרסאות קודמות לא דיווחו
השגיאה כראוי, שכן exec () במקרה היה בתהליך אחר.

תהליך הילד מתקשר כעת עם ההורה לגבי השגיאה בהפעלת ה-
פקודה חיצונית, המאפשרת למבנים אלה לחזור עם ערך השגיאה הרגיל שלהם ו
הגדר $!.

מְשׁוּפָּר אבחון
מספרי קווים אינם מדוכאים עוד (בנסיבות סבירות ביותר) במהלך הגלובלי
שלב ההרס.

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

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

$foo::a ו-$foo::b פטורים כעת מהאזהרות של "שגיאות הקלדה אפשריות" רק אם סוג() is
נתקל בחבילה "foo".

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

אבחונים רבים מדווחים כעת על הפעולה הפנימית שבה עוררה האזהרה, כמו
לכן:

שימוש בערך לא מאותחל בשרשור (.) בשורה 1 (הערך 1).
שימוש בערך לא מאותחל בהדפסה ב- (eval 1) שורה 1.

אבחון המתרחש בתוך eval עשוי לדווח גם על הקובץ ומספר השורה שבו
eval ממוקם, בנוסף למספר הרצף eval ומספר השורה בתוך
הטקסט המוערך עצמו. לדוגמה:

אין מספיק ארגומנטים לסקלרים בשורה 4 (eval 5)[newlib/perl1411db.pl:2] ב-EOF

אבחון לעקוב STDERR
פלט אבחון עובר כעת לאיזה קובץ שהידית "STDERR" מפנה אליו, במקום זאת
של ללכת תמיד אל "stderr" של ספריית זמן הריצה הבסיסית של C.

עוד עִקבִי קרוב למנהל התנהגות
במערכות התומכות בדגל close-on-exc על ידיות קבצים, הדגל מוגדר כעת עבור כל
ידיות שנוצרו על ידי צינור(), socketpair(), שקע (), ו לְקַבֵּל(), אם זה מתחייב על ידי
הערך של $^F שעשוי להיות בתוקף. גרסאות קודמות התרשלו להגדיר את הדגל עבור
ידיות שנוצרו עם אופרטורים אלה. ראה "צינור" ב-perlfunc, "socketpair" ב-perlfunc,
"שקע" ב-perlfunc, "accept" ב-perlfunc ו-"$^F" ב-perlvar.

syswrite() קלות שימוש
ארגומנט האורך של "syswrite()" הפך לאופציונלי.

מוטב תחביר בדיקות on בסוגריים יונירי מפעילי
ביטויים כגון:

print defined(&foo,&bar,&baz);
print uc("foo","bar","baz");
undef($foo,&bar);

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

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

הדפס מוגדר &foo, &bar, &baz;
הדפס uc "foo", "בר", "baz";
undef $foo, &bar;

נותר ללא שינוי. ראה פרלופ.

קצת מפעילי תמיכה מלא יליד מספר שלם רוחב
אופרטורי הסיביות (& | ^ ~ << >>) פועלים כעת ברוחב האינטגרלי המקורי המלא (המדויק
גודלו זמין ב-$Config{ivsize}). לדוגמה, אם הפלטפורמה שלך היא אחת מהן
64 סיביות מקוריות או אם Perl הוגדרה להשתמש במספרים שלמים של 64 סיביות, פעולות אלו
חל על 8 בתים (בניגוד ל-4 בתים בפלטפורמות של 32 סיביות). לניידות, הקפד לעשות זאת
מסווה את הסיביות העודפות בתוצאה של "~", למשל, "~$x & 0xffffffff".

מְשׁוּפָּר אבטחה מאפיינים
פעולות שעלולות להיות לא בטוחות יותר פוגעות בתוצאות שלהן לשיפור האבטחה.

השדות "passwd" ו-"shell" המוחזרים על ידי ה- getpwent (), getpwnam(), ו getpwuid () יש לו
נגוע כעת, מכיוון שהמשתמש יכול להשפיע על הסיסמה המוצפנת שלו ועל מעטפת הכניסה שלו.

המשתנה שונה על ידי shread(), והודעות שהוחזרו על ידי msgrcv() (והמטרה שלו-
ממשק מכוון IPC::SysV::Msg::rcv) נגועים גם הם, מכיוון שאחרים לא מהימנים
תהליכים יכולים לשנות הודעות ומקטעי זיכרון משותפים למטרות מרושעות משלהם.

עוד פונקציונלי חשוף אב טיפוס (*)
אבות-טיפוס Bareword עברו רציונליות כדי לאפשר להשתמש בהם כדי לעקוף את המבנה המובנה
שמקבלים מילים חשופות ומפרשות אותן בצורה מיוחדת, כמו "לדרוש" או "לעשות".

ארגומנטים עם אב טיפוס כ-"*" יהיו גלויים כעת בתוך תת-השגרה כפשוטה
סקלרי או כהתייחסות ל-typeglob. ראה "אבטיפוס" ב-perlsub.

"לִדרוֹשׁ" ו "לַעֲשׂוֹת" אולי be נעקר
ניתן לעקוף פעולות "דרוש" ו-"עשה 'קובץ'" באופן מקומי על ידי ייבוא ​​תתי שגרות של
אותו שם בחבילה הנוכחית (או באופן גלובלי על ידי ייבואם לתוך
CORE::GLOBAL:: מרחב שמות). עקיפה של "דרוש" תשפיע גם על "שימוש", בתנאי ש
ביטול גלוי בזמן ההידור. ראה "עקיפה של פונקציות מובנות" ב-perlsub.

$^X משתנים אולי עַכשָׁיו יש שמות עוד מֵאֲשֶׁר אחד אופי
בעבר, $^X היה שם נרדף ל${"\cX"}, אבל $^XY היה שגיאת תחביר. עכשיו משתנה
שמות שמתחילים בתו בקרה עשויים להיות ארוכים באופן שרירותי. עם זאת, עבור
סיבות תאימות, משתנים אלה צריך ייכתב עם סוגרים מפורשים, בתור "${^XY}"
לדוגמה. "${^XYZ}" הוא שם נרדף ל${"\cXYZ"}. שמות משתנים עם יותר מאחד
תו שליטה, כגון "${^XY^Z}", אינם חוקיים.

התחביר הישן לא השתנה. כמו קודם, `^X' עשוי להיות שליטה מילולית-X
תו או הרצף בן שתי התווים 'caret' בתוספת 'X'. כאשר הפלטה מושמטת, ה
שם המשתנה נעצר אחרי תו הבקרה. כך "$^XYZ" ממשיך להיות שם נרדף
עם "$^X . "YZ"" כמו קודם.

כמו קודם, ייתכן שלמשתנים לקסיקליים אין שמות שמתחילים בתווי בקרה. כפי ש
לפני כן, משתנים ששמותיהם מתחילים בתו שליטה תמיד נאלצים להימצא בתוכם
חבילה 'ראשית'. כל המשתנים הללו שמורים להרחבות עתידיות, מלבד אלו
התחל עם "^_", אשר עשוי לשמש על ידי תוכניות משתמש ומובטח שלא ירכשו
משמעות מיוחדת בכל גרסה עתידית של Perl.

חדש משתנה $^C משקף "-ג" להחליף
ל-$^C יש ערך בוליאני המשקף אם perl מופעל במצב קומפילציה בלבד (כלומר
באמצעות המתג "-c")). מכיוון שחסימות BEGIN מבוצעות בתנאים כאלה, זה
משתנה מאפשר לקוד perl לקבוע אם פעולות הגיוניות רק במהלך רגיל
הריצה מוצדקת. ראה perlvar.

חדש משתנה $^V מכיל פרל גרסה as a מחרוזת
$^V מכיל את מספר הגרסה של Perl כמחרוזת המורכבת מתווים שהסידורים שלהם
להתאים את מספרי הגרסה, כלומר v5.6.0. זה עשוי לשמש בהשוואות מחרוזות.

ראה "תמיכה במחרוזות המיוצגות כווקטור של סידורים" לדוגמא.

אופציונלי Y2K אזהרות
אם Perl בנוי עם מאקרו cpp "PERL_Y2KWARN" מוגדר, הוא פולט אזהרות אופציונליות
כאשר משרשרים את המספר 19 למספר אחר.

התנהגות זו חייבת להיות מופעלת במיוחד בעת הפעלת Configure. לִרְאוֹת תתקין ו
README.Y2K.

מערכים עַכשָׁיו תמיד אינטרפולציה אל תוך ציטוט כפול מחרוזות
במחרוזות במירכאות כפולות, מערכים כעת משתלבים, לא משנה מה. ההתנהגות קודם לכן
גרסאות של perl 5 הייתה שמערכים היו מתערבים למחרוזות אם המערך היה כזה
שהוזכר לפני הידור של המחרוזת, אחרת פרל תעלה קומפילציה קטלנית-
שגיאת זמן. בגרסאות 5.000 עד 5.003, השגיאה הייתה

ליטרל @example מחייב כעת קו נטוי אחורי

בגירסאות 5.004_01 עד 5.6.0, השגיאה הייתה

במחרוזת, @example now חייב להיכתב כ-\@example

הרעיון כאן היה לגרום לאנשים להרגל לכתוב "fred\@example.com" כשהם
רצו סימן "@" מילולי, בדיוק כפי שתמיד כתבו "תחזיר לי את ה-\$5 שלי" מתי
הם רצו סימן "$" מילולי.

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

אינטרפולציה בלתי מכוונת אפשרית של @example במחרוזת

זה מזהיר אותך ש"[מוגן בדוא"ל]" הולך להפוך ל-"fred.com" אם לא תעשה זאת
נטוי לאחור את ה-"@". לִרְאוֹת http://perl.plover.com/at-error.html לפרטים נוספים אודות
היסטוריה כאן.

@- ו @+ לספק התחלה/סיום קיזוז of regex גפרורים
משתני הקסם החדשים @- ו-@+ מספקים את הקיזוז ההתחלה והסיום, בהתאמה,
של $&, $1, $2 וכו'. ראה perlvar לפרטים.

מודולים ו פרגמטה

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

B חבילת Perl Compiler עברה עיבוד מקיף עבור מהדורה זו. עוד מה
חבילת הבדיקות הסטנדרטית של Perl עוברת כשהיא מופעלת תחת המהדר, אבל עדיין יש א
דרך משמעותית ללכת להשגת קובצי הפעלה מאוחדים באיכות ייצור.

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

בנצ 'מרק
בסך הכל, תוצאות Benchmark מציגות שגיאה ממוצעת נמוכה יותר ודיוק תזמון טוב יותר.

כעת תוכל להריץ בדיקות עבור n שניות במקום לנחש את המספר הנכון של בדיקות
run: למשל, timethese(-5, ...) יפעיל כל קוד למשך 5 שניות מעבד לפחות. אפס כמו
"מספר החזרות" פירושו "לפחות 3 שניות CPU". לפורמט הפלט יש
גם השתנה. לדוגמה:

השתמש ב-Benchmark;$x=3;timethese(-5,{a=>sub{$x*$x},b=>sub{$x**2}})

כעת יוציא משהו כזה:

אמת מידה: הפעלת a, b, כל אחד לפחות למשך 5 שניות CPU...
א: 5 שניות שעון קיר (5.77 usr + 0.00 sys = 5.77 CPU) @ 200551.91/s (n=1156516)
ב: 4 שניות שעון קיר (5.00 usr + 0.02 sys = 5.02 CPU) @ 159605.18/s (n=800686)

תכונות חדשות: "כל אחד לפחות ל-N שניות מעבד...", "שעון קיר שניות", וה-"@
פעולות/מעבד שני (n=פעולות)".

timethese() כעת מחזירה הפניה ל-hash של אובייקטי Benchmark המכילים את הבדיקה
תוצאות, כתובות על שמות הבדיקות.

timethis() כעת מחזירה את שדה האיטרציות באובייקט תוצאת Benchmark במקום
0.

timethese(), timethis(), וחדש cmpthese() (ראה להלן) יכול גם לקבל פורמט
מפרט של 'אין' כדי לדכא פלט.

פונקציה חדשה תחשיב את זה() הוא בדיוק כמו timeit() אלא שזה לוקח TIME במקום
COUNT.

פונקציה חדשה cmpthese() מדפיס תרשים המשווה את התוצאות של כל בדיקה שהוחזרה
מ timethese() שִׂיחָה. עבור כל זוג אפשרי של בדיקות, אחוז המהירות
ההבדל (iters/sec או seconds/iters) מוצג.

לפרטים נוספים, ראה Benchmark.

ByteLoader
ByteLoader הוא הרחבה ייעודית ליצור ולהפעיל Perl bytecode. לִרְאוֹת
ByteLoader.

קבוע
כעת ניתן להשתמש בהפניות.

הגרסה החדשה מאפשרת גם קו תחתון מוביל בשמות קבועים, אך פוסלת א
קו תחתון מוביל כפול (כמו ב-"__LINE__"). כמה שמות אחרים אסורים או
הזהיר מפני, כולל BEGIN, END וכו'. כמה שמות שנאלצו להיכנס לראשי::
נהג להיכשל בשקט במקרים מסוימים; עכשיו הם קטלניים (מחוץ לראשי::) ו- an
אזהרה אופציונלית (בתוך הראשי::). היכולת לזהות אם קבוע היה
הוגדר בשם נתון נוסף.

ראה קבוע.

שמות שמות
פרגמה זו מיישמת את המחרוזת "\N" הבריחה. ראה שמות שמות.

נתונים :: Dumper
ניתן לציין הגדרה של "Maxdepth" כדי להימנע מכניסה עמוקה מדי לנתונים עמוקים
מבנים. ראה Data::Dumper.

יישום XSUB של מזבלה() נקרא כעת באופן אוטומטי אם ההגדרה "Useqq".
אינו בשימוש.

השלכת אובייקטים "qr//" פועלת כהלכה.

DB "DB" הוא מודול ניסיוני שחושף הפשטה נקייה לניפוי באגים של Perl
ה-API.

DB_קובץ
כעת ניתן לבנות DB_File עם Berkeley DB גרסאות 1, 2 או 3. ראה
"ext/DB_File/Changes".

פיתוח :: DProf
Devel::DProf, פרופיל קוד מקור של Perl נוסף. ראה Devel::DProf and
dprofpp.

התפתח :: הצצה
מודול Devel::Peek מספק גישה לייצוג הפנימי של Perl
משתנים ונתונים. זהו כלי ניפוי נתונים עבור מתכנת XS.

ערך Dump
מודול Dumpvalue מספק השלכות מסך של נתוני Perl.

DynaLoader
DynaLoader תומך כעת ב- a dl_unload_file() לתפקד בפלטפורמות התומכות
פריקת אובייקטים משותפים באמצעות dlclose().

Perl יכול גם לארגן באופן אופציונלי לפרוק את כל האובייקטים המשותפים של ההרחבה שנטענו על ידי
פרל. כדי לאפשר זאת, בנה את Perl עם האפשרות Configure
"-Accflags=-DDL_UNLOAD_ALL_AT_EXIT". (זה אולי שימושי אם אתה משתמש ב- Apache עם
mod_perl.)

אנגלית
$PERL_VERSION מייצג כעת $^V (ערך מחרוזת) ולא עבור $] (מספרי
ערך).

Env Env תומך כעת בגישה למשתני סביבה כמו PATH כמשתני מערך.

Fcntl
נוספו קבועי Fcntl נוספים: F_SETLK64, F_SETLKW64, O_LARGEFILE עבור קובץ גדול (עוד
יותר מ-4GB) גישה (הערה: ה-O_LARGEFILE מתווסף אוטומטית sysopen() דגלים אם
הוגדרה תמיכה בקבצים גדולים, כמו ברירת המחדל), נעילת Free/Net/OpenBSD
דגלי התנהגות F_FLOCK, F_POSIX, Linux F_SHLCK ו-O_ACCMODE: המסכה המשולבת של
O_RDONLY, O_WRONLY ו-O_RDWR. ה לְחַפֵּשׂ()/sysseek() קבועים SEEK_SET, SEEK_CUR,
ו-SEEK_END זמינים באמצעות התג ":seek". ה chmod()/stat () קבועים S_IF*
ופונקציות S_IS* זמינות באמצעות התג ":mode".

קובץ::השוואה
A compare_text() נוספה פונקציה, המאפשרת פונקציות השוואה מותאמות אישית.
ראה File::Compare.

קובץ :: מצא
File::Find פועל כעת כהלכה כאשר מבוקש() הפונקציה נטענת אוטומטית או שהיא a
התייחסות סמלית.

באג שגרם ל-File::Find לאבד מעקב אחר ספריית העבודה בעת גיזום למעלה-
ספריות ברמה תוקנה.

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

ראה File::Find.

קובץ :: גלוב
הרחבה זו מיישמת העברת קבצים בסגנון BSD. כברירת מחדל, זה יהיה גם בשימוש
ליישום הפנימי של ה גלוב () מַפעִיל. ראה File::Glob.

קובץ :: מפרט
שיטות חדשות נוספו למודול File::Spec: devnull() מחזיר את השם של
התקן null (/dev/null ב-Unix) ו tmpdir() שם הספרייה הזמנית
(בדרך כלל / Tmp על יוניקס). יש עכשיו גם שיטות להמיר בין מוחלט ל
שמות קבצים יחסית: abs2rel() ו rel2abs(). להתאמה למערכות הפעלה
שמציינים שמות אמצעי אחסון בנתיבי קבצים, ה splitpath(), splitdir(), ו catdir()
נוספו שיטות.

קובץ::מפרט::פונקציות
מודולי File::Spec::Functions החדשים מספקים ממשק פונקציות לקובץ::Spec
מודול. מאפשר קיצור

$fullname = catfile($dir1, $dir2, $file);

במקום

$fullname = File::Spec->catfile($dir1, $dir2, $file);

Getopt :: ארוך
Getopt:: הרישוי הארוך השתנה כדי לאפשר את הרישיון האמנותי של Perl כמו גם את
GPL. פעם זה היה GPL בלבד, מה שהפריע ליישומים שאינם GPL שרצו
כדי להשתמש ב-Getopt::Long.

Getopt::Long מעודדת שימוש ב-Pod::Usage להפקת הודעות עזרה. לדוגמה:

השתמש ב-Getopt::Long;
השתמש ב-Pod::Usage;
$man שלי = 0;
ה-$help שלי = 0;
GetOptions('help|?' => \$help, man => \$man) או pod2usage(2);
pod2usage(1) אם $help;
pod2usage(-exitstatus => 0, -verbose => 2) if $man;

__סוֹף__

=head1 NAME

דוגמה - באמצעות Getopt::Long ו-Pod::Usage

=ראש1 תקציר

לדוגמה [אפשרויות] [קובץ ...]

אפשרויות:
-עזרה הודעת עזרה קצרה
-איש תיעוד מלא

=head1 אפשרויות

=מעל 8

=פריט ב<-עזרה>

הדפס הודעת עזרה קצרה וצא.

=פריט ב<-אדם>

מדפיס את הדף הידני ויוצא.

=חזרה

=head1 תיאור

ב יקרא את קבצי הקלט הנתונים ויעשה משהו
שימושי עם התוכן שבו.

=חתוך

ראה Pod::שימוש לפרטים.

באג שמנע מהקריאה לאחור <> להיות מוגדרת כראשונה
הטיעון תוקן.

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

IO לִכתוֹב() ו syswrite() יקבל כעת טופס של טיעון יחיד של השיחה, עבור
עקביות עם פרל syswrite().

כעת תוכל ליצור IO::Socket::INET מבוסס TCP מבלי לאלץ ניסיון חיבור.
זה מאפשר לך להגדיר את האפשרויות שלו (כמו להפוך אותו ללא חסימה) ואז להתקשר
להתחבר () ידנית.

באג שמנע את IO::Socket::protocol() אביזר מאי פעם להחזיר את
הערך הנכון תוקן.

IO::Socket::connect משתמש כעת ב-IO לא חוסם במקום אזעקה() לעשות להתחבר
פסקי זמן.

IO::Socket::accept משתמש כעת בחר() במקום אזעקה() לביצוע פסקי זמן.

IO::Socket::INET->חדש כעת קובע $! נכון על כישלון. $@ עדיין מוגדר לאחור
תאימות.

JPL Java Perl Lingo מופץ כעת עם Perl. ראה jpl/README למידע נוסף.

lib "השתמש ב-lib" כעת מנכה את כל הערכים הכפולים הנגררים. "no lib" מסיר את כל השמות
ערכים.

מתמטיקה :: BigInt
הפעולות "<<", ">>", "&", "|" ו-"~" נתמכות כעת ב- bigints.

מתמטיקה::מורכבת
שיטות העזר Re, Im, arg, abs, rho ותטא יכולות כעת גם לפעול כמוטטורים
(הגישה $z->מִחָדָשׁ(), מוטטור $z->Re(3)).

שיטת המחלקה "display_format" ושיטת האובייקט המתאימה
"display_format", בנוסף לקבל ארגומנט אחד בלבד, כעת יכול לקבל גם א
hash של פרמטר. מפתחות מזוהים של גיבוב פרמטר הם "סגנון", התואם
מקרה פרמטר אחד הישן, ושני פרמטרים חדשים: "פורמט", שהוא א
printf ()מחרוזת פורמט בסגנון (ברירת המחדל היא "%15g", אתה יכול לחזור ל-
ברירת מחדל על ידי הגדרת מחרוזת הפורמט ל-"undef") המשמשת עבור שני חלקי הקומפלקס
מספר, ו-"polar_pretty_print" (ברירת המחדל ל-true), השולט אם ניסיון
נעשה כדי לנסות לזהות כפולות קטנות ורציונלים של pi (2pi, pi/2) ב-
ארגומנט (זווית) של מספר מרוכב קוטבי.

השינוי שעלול להפריע הוא שבהקשר של רשימה, שתי השיטות כעת לַחֲזוֹר מה היא
פרמטר שירים, במקום רק הערך של הפרמטר "סגנון".

Math::Trig
מעט טריגונומטריה רדיאלית (גלילית וכדורית), קואורדינטה רדיאלית
המרות, ומרחק המעגל הגדול נוספו.

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

Pod::InputObjects מגדיר כמה אובייקטי קלט הדרושים ל-Pod::Parser, ולמתקדמים
משתמשים של Pod::Parser שצריכים יותר על פקודה מלבד השם והטקסט שלה.

נכון לגרסה 5.6.0 של Perl, Pod::Parser הוא כעת "מנתח הבסיס" שאושר רשמית
קוד" מומלץ לשימוש על ידי כל מתרגמי pod2xxx. Pod::Text (pod2text) ו
Pod::Man (pod2man) כבר הומר לשימוש ב-Pod::Parser ומאמצים כדי
convert Pod::HTML (pod2html) כבר בעיצומו. לכל שאלה או הערה
על ניתוח ותרגום נושאים וכלי עזר של תרמילים, אנא השתמש ב-
[מוגן בדוא"ל] רשימת תפוצה.

למידע נוסף, ראה Pod::Parser ו-Pod::InputObjects.

Pod::Checker, Podchecker
כלי זה בודק את התחביר הנכון של קבצי הפוד, לפי perlpod. ברור
שגיאות מסומנות ככאלה, בעוד אזהרות מודפסות על טעויות שיכולות להיות
מטופל בחן. רשימת הבדיקה עדיין לא הושלמה. ראה Pod::Checker.

Pod::ParseUtils, Pod::Find
מודולים אלה מספקים קבוצה של גיזמו שימושיים בעיקר עבור מתרגמי תרמילים.
Pod::Find חוצה מבני ספריות ומחזיר קבצי פוד שנמצאו, יחד עם שלהם
שמות קנוניים (כמו "File::Spec::Unix"). Pod::ParseUtils מכיל Pod::רשימה (מוֹעִיל
לאחסון מידע רשימת תרמילים), Pod::היפר-קישור (לניתוח התוכן של "L<>"
רצפים) ו Pod::Cache (לשמור מידע על קבצי פוד, למשל, צמתי קישור).

Pod::Select, Podselect
Pod::Select היא תת מחלקה של Pod::Parser המספקת פונקציה בשם "podselect()"
לסנן קטעים שצוינו על ידי המשתמש של תיעוד תרמילים גולמיים מזרם קלט.
podselect הוא סקריפט המספק גישה ל-Pod::Select מתוך סקריפטים אחרים להיות
משמש כמסנן. ראה Pod::Select.

Pod::Usage, pod2usage
Pod::Usage מספק את הפונקציה "pod2usage()כדי להדפיס הודעות שימוש עבור Perl
סקריפט המבוסס על תיעוד הפוד המוטבע שלו. ה pod2usage() הפונקציה היא בדרך כלל
שימושי לכל מחברי התסריט מכיוון שהוא מאפשר להם לכתוב ולתחזק מקור יחיד
(הפודים) לתיעוד, ובכך מסיר את הצורך ליצור ולתחזק מיותר
טקסט הודעת שימוש המורכב ממידע שכבר נמצא בתרמילים.

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

לפרטים ודוגמאות, ראה Pod::Usage.

Pod::Text ו-Pod::Man
Pod::הטקסט נכתב מחדש לשימוש ב-Pod::Parser. בזמן pod2text() עדיין זמין
עבור תאימות לאחור, למודול יש כעת ממשק מועדף חדש. לִרְאוֹת
Pod::טקסט לפרטים. מודול ה-Pod::Text החדש מסווג בקלות לתת-סיווג לשינויים
לפלט, ושתי תת-מחלקות כאלה (Pod::Text::Termcap עבור מודגשות בסגנון דף אדם
קו תחתון באמצעות מידע של termcap, ו-Pod::Text::Color עבור סימון עם צבע ANSI
רצפים) הם כעת סטנדרטיים.

pod2man הפך למודול, Pod::Man, המשתמש גם ב-Pod::Parser. בתוך ה
תהליך, מספר באגים מצטיינים הקשורים לציטוטים בכותרות הסעיפים, ציטוט של
קוד בריחה, ורשימות מקוננות תוקנו. pod2man הוא כעת תסריט מעטפת
סביב מודול זה.

SDBM_File
למודול זה נוספה שיטה EXISTS (ו sdbm_exists() נוספה ל
ספריית ה-sdbm הבסיסית), כך שניתן כעת לקרוא קיים ב-SDBM_File קשור hash ו
לקבל את התוצאה הנכונה, במקום שגיאת זמן ריצה.

באג שאולי גרם לאובדן נתונים כאשר במקרה נקרא יותר מבלוק דיסק אחד
ממסד הנתונים ביחיד לְהָבִיא() תוקן.

סיס :: סיסלוג
Sys::Syslog משתמש כעת ב-XSUBs כדי לגשת למתקנים מ-syslog.h כך שהוא לא דורש יותר
syslog.ph להתקיים.

Sys::שם מארח
Sys::Hostname משתמש כעת ב-XSUBs כדי לקרוא לספריית C gethostname () or uname() אם הם
קיימים.

מונח::ANSIColor
Term::ANSIColor הוא מודול פשוט מאוד כדי לספק גישה קלה וקריאה ל-
רצפי בריחה של צבע ANSI והדגשה, נתמכים על ידי רוב מסוף ה-ANSI
אמולטורים. זה כלול כעת כסטנדרט.

זמן :: מקומי
השמיים timelocal() ו timegm() פונקציות המשמשות להחזרת תוצאות מזויפות בשקט כאשר ה
התאריך נפל מחוץ לטווח המספרים השלמים של המכונה. הם עכשיו בעקביות קִרקוּר() אם
התאריך נופל בטווח שאינו נתמך.

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

Win32::FsType
Win32::GetOSVersion

שאר הפונקציות נשארות ללא שינוי וממשיכות להחזיר "undef" בשגיאה גם ב
הקשר של רשימה.

הפונקציה Win32::SetLastError(ERROR) נוספה כהשלמה ל-
Win32::GetLastError() פונקציה.

Win32::GetFullPathName(FILENAME) החדש מחזיר את שם הנתיב המוחלט המלא עבור
FILENAME בהקשר סקלרי. בהקשר של רשימה זה מחזיר רשימה של שני אלמנטים המכילה
שם הספרייה המלאה ושם הקובץ. ראה Win32.

XSLoader
תוסף XSLoader הוא חלופה פשוטה יותר ל-DynaLoader. ראה XSLoader.

מסנני DBM
תכונה חדשה בשם "מסנני DBM" נוספה לכל המודולים של DBM--DB_File,
GDBM_File, NDBM_File, ODBM_File ו-SDBM_File. מסנני DBM מוסיפים ארבע שיטות חדשות
כל מודול DBM:

מפתח_חנות_מסנן
filter_store_value
filter_fetch_key
filter_fetch_value

ניתן להשתמש בהם כדי לסנן צמדי מפתח-ערך לפני שהצמדים נכתבים ל-
מסד הנתונים או מיד לאחר קריאתם ממסד הנתונים. ראה perldbmfilter להמשך
מידע.

פרגמטה
"use attrs" מיושן כעת, והוא מסופק רק עבור תאימות לאחור. זה היה
מוחלף בתחביר "תת: תכונות". ראה "תכונות משנה" ב-perlsub ו
תכונות.

פרגמת אזהרות לקסיקליות, "השתמש באזהרות;", לשליטה באזהרות אופציונליות. ראה perllexwarn.

"השתמש ב-filtest" כדי לשלוט בהתנהגות של בדיקות קבצים ("-r" "-w" ...). כרגע רק אחד
subpragma מיושם, "השתמש ב-filtest 'access';", שמשתמש גישה(2) או שווה ערך ל
בדוק הרשאות במקום להשתמש stat(2) כרגיל. זה משנה במערכות קבצים שבהן
יש ACLs (רשימות בקרת גישה): ה stat(2) אולי משקר, אבל גישה(2) יודע טוב יותר.

ניתן להשתמש בפרגמה ה"פתוחה" כדי לציין דיסציפלינות ברירת מחדל עבור בנאי טיפול (למשל
לִפְתוֹחַ()) ועבור qx//. שתי הפסבדו-דיסציפלינות ":raw" ו-":crlf" הן כרגע
נתמך על פלטפורמות נגזרות של DOS (כלומר כאשר binmode אינו No-op). ראה גם
"binmode() ניתן להשתמש כדי להגדיר מצבים :crlf ו-:raw".

שירות שינויים

dprofpp
"dprofpp" משמש להצגת נתוני פרופיל שנוצרו באמצעות "Devel::DProf". ראה dprofpp.

find2perl
כלי השירות "find2perl" משתמש כעת בתכונות המשופרות של מודול File::Find. ה
אפשרויות עומק ומעקב נתמכות. תיעוד תרמיל כלול גם ב-
תַסרִיט.

h2xs
הכלי "h2xs" יכול כעת לעבוד בשילוב עם "C::Scan" (זמין מ-CPAN) כדי
מנתח אוטומטית קבצי כותרות מהחיים האמיתיים. האפשרויות "-M", "-a", "-k" ו-"-o" הן
חדש.

perlcc
"perlcc" תומך כעת ב-C ו-Bytecode. כברירת מחדל, הוא מייצר פלט מ
ה-C backend הפשוט ולא ה-C backend האופטימלי.

התמיכה בפלטפורמות שאינן יוניקס שופרה.

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

השמיים פרל Debugger
תיקוני באגים ושיפורים רבים נוספו perl5db.pl, מאפר הבאגים של Perl. העזרה
התיעוד סודר מחדש. פקודות חדשות כוללות "< ?", "> ?" ו-"{ ?" לרשום
פעולות נוכחיות, "גבר docpage" כדי להפעיל את מציג המסמכים שלך על מסמך perl כלשהו, ​​ותמיכה עבור
אפשרויות מצוטטות. מידע העזרה סודר מחדש, ואמור להיות ניתן לצפייה שוב אם
אתה משתמש פחות בתור הביפר שלך. נסתם חור אבטחה רציני - כדאי
הסר מיד את כל הגרסאות הישנות יותר של מאתר הבאגים של Perl כפי שהותקן בקודם
משחרר, כל הדרך חזרה ל-perl3, מהמערכת שלך כדי להימנע מנשיכה מזה.

מְשׁוּפָּר תיעוד

רבים מקבצי README הספציפיים לפלטפורמה הם כעת חלק מהתקנת perl. לִרְאוֹת
perl לרשימה המלאה.

perlapi.pod
הרשימה הרשמית של פונקציות ציבוריות של Perl API.

perlboot.pod
מדריך למתחילים על Perl מונחה עצמים.

perlcompile.pod
מבוא לשימוש בחבילת Perl Compiler.

perldbmfilter.pod
מסמך כיצד להשתמש במתקן מסנן DBM.

perldebug.pod
כל החומרים שאינם קשורים להפעלת מאתר הבאגים של Perl, בנוסף לכל החומרים דמויי הקרביים ברמה נמוכה
פרטים שהסתכנו בריסוק המשתמש המזדמן של מאתר הבאגים, הועברו מהמקום
את ה-manpage הישן לערך הבא למטה.

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

perlfork.pod
הערות על מזלג() אמולציה זמינה כעת עבור פלטפורמת Windows.

perlfilter.pod
מבוא לכתיבת מסנני מקור של Perl.

perlhack.pod
כמה הנחיות לפריצת קוד המקור של Perl.

perlintern.pod
רשימה של פונקציות פנימיות בקוד המקור של Perl. (הרשימה ריקה כרגע.)

perllexwarn.pod
מידע מבוא והתייחסות לגבי קטגוריות אזהרה בהיקף מילוני.

perlnumber.pod
מידע מפורט על מספרים כפי שהם מיוצגים בפרל.

perlopentut.pod
הדרכה לשימוש לִפְתוֹחַ() ביעילות.

perlreftut.pod
הדרכה שמציגה את עיקרי הפניות.

perltootc.pod
מדריך על ניהול נתוני מחלקה עבור מודולי אובייקט.

perltodo.pod
דיון בתכונות המבוקשות ביותר שעשויות להיות מתישהו נתמכות ב- Perl.

perlunicode.pod
מבוא לתכונות התמיכה של Unicode ב-Perl.

ביצוע שיפורים

פָּשׁוּט סוג() באמצעות { $a <=> $b } ו מה היא כמו יש לו אופטימיזציה
רבים נפוצים סוג() פעולות באמצעות בלוק מובנה פשוט מותאמות כעת למהירות יותר
ביצועים.

אופטימלי הקצאות ל לֵקסִיקָלִי משתנים
פעולות מסוימות ב-RHS של הצהרות ההקצאה עברו אופטימיזציה להגדרה ישירה
המשתנה המילוני ב-LHS, מבטל תקורה מיותרת של העתקה.

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

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

הַתקָנָה ו תְצוּרָה שיפורים

-חוטים דוסים אומר משהו אחר
הדגל -Dusethreads מאפשר כעת את תמיכת השרשור המבוסס על מתורגמן ניסיוני על ידי
בְּרִירַת מֶחדָל. כדי לקבל את הטעם של חוטים ניסויים שהיה ב-5.005 במקום זאת, אתה צריך
הפעל את ההגדרה עם "-Dusethreads -Duse5005threads".

נכון לגרסה 5.6.0, תמיכת שרשורי מתורגמן עדיין חסרה דרך ליצור שרשורים חדשים
מ-Perl (כלומר, "השתמש ב-Thread;" לא יעבוד עם שרשורי מתורגמן). "השתמש בשרשור;"
ממשיך להיות זמין כאשר אתה מציין את האפשרות -Duse5005threads להגדרה, באגים
וכל.

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

חדש גדר דגלים
הדגלים החדשים הבאים עשויים להיות מופעלים בשורת הפקודה Configure על ידי הפעלת Configure
עם "-Dflag".

להשתמש בריבוי
usethreads useithreads (שרשורי מתורגמן חדשים: עדיין אין Perl API)
usethreads use5005threads (חוטים כפי שהיו ב-5.005)

use64bitint (שווה ל'use64bits' שהוצא כעת משימוש)
השתמש ב-64bitall

uselongdouble
השתמש בעוד סיביות
uselargefiles
usesocks (נתמכים רק SOCKS v5)

חוטות ו 64 סיביות עַכשָׁיו יותר נועז
אפשרויות התצורה המאפשרות את השימוש בשרשורים ושימוש ב-64 סיביות הן כעת יותר
נועז במובן שאין להם יותר רשימה מפורשת של מערכות הפעלה ידועות
יכולות חוטים/64 סיביות. במילים אחרות: אם למערכת ההפעלה שלך יש את הדרוש
ממשקי API וסוגי נתונים, אתה אמור להיות מסוגל פשוט להמשיך ולהשתמש בהם, עבור שרשורים של
הגדר -Dusethreads, ועבור 64 סיביות או במפורש על ידי Configure -Duse64bitint או
באופן מרומז אם למערכת שלך יש סוגי נתונים ברוחב 64 סיביות. ראה גם "תמיכה ב-64 סיביות".

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

-Dusemorebits
אתה יכול להפעיל גם -Duse64bitint וגם -Duselongdouble עם -Dusemorebits. ראה גם
"תמיכה ב-64 סיביות".

-Duselargefiles
חלק מהפלטפורמות תומכות בממשקי API של מערכת המסוגלים לטפל בקבצים גדולים (בדרך כלל,
קבצים גדולים משני גיגה-בייט). Perl תנסה להשתמש בממשקי API אלה אם תבקש
-Duselargefiles.

ראה "תמיכה בקבצים גדולים" למידע נוסף.

installusrbinperl
אתה יכול להשתמש ב-"Configure -Uinstallusrbinperl" שגורם ל-installperl לדלג על ההתקנה
perl גם בתור /usr/bin/perl. זה שימושי אם אתה מעדיף לא לשנות / usr / bin עבור חלק
סיבה או סיבה אחרת אבל מזיקה מכיוון שסקריפטים רבים מניחים למצוא את Perl ב- /usr/bin/perl.

גרביים תמיכה
אתה יכול להשתמש ב-"Configure -Dusesocks" שגורם ל-Perl לחקור את פרוטוקול ה-Proxy SOCKS
ספרייה (v5, לא v4). למידע נוסף על SOCKS, ראה:

http://www.socks.nec.com/

"-א" דגל
אתה יכול "לאחר לערוך" את משתני Configure באמצעות המתג Configure "-A". העריכה
קורה מיד לאחר שקובצי רמז ספציפיים לפלטפורמה עובדו אך לפני כן
תהליך התצורה בפועל מתחיל. הפעל את "הגדר -h" כדי לגלות את ה-"-A" המלא
תחביר.

משופר הַתקָנָה מדריכים
מבנה ההתקנה הועשר כדי לשפר את התמיכה בתחזוקה
גרסאות מרובות של perl, כדי לספק מיקומים עבור מודולים, סקריפטים ו
manpages, וכדי להקל על התחזוקה של מודולים, סקריפטים ודפי man שנוספו באופן מקומי. לִרְאוֹת
הסעיף על ספריות התקנה בקובץ ה-INSTALL לפרטים מלאים. ל
רוב המשתמשים בונים ומתקינים ממקור, ברירות המחדל אמורות להיות בסדר.

אם השתמשת בעבר ב-"Configure -Dsitelib" או "-Dsitearch" כדי להגדיר ערכים מיוחדים עבור
ספריות, אולי תרצה לשקול להשתמש בהגדרה החדשה "-Dsiteprefix".
במקום זאת. כמו כן, אם ברצונך לעשות שימוש חוזר בקובץ config.sh מגרסה קודמת של perl,
אתה צריך להיות בטוח לבדוק ש-Configure עושה בחירות הגיוניות עבור הספריות החדשות.
ראה התקנה לפרטים מלאים.

פלטפורמה ספציפי שינויים

נתמך פלטפורמות
· ה-Mach CThreads (NEXTSTEP, OPENSTEP) נתמכים כעת על ידי הרחבת Thread.

· GNU/Hurd נתמך כעת.

· Rhapsody/Darwin נתמך כעת.

· EPOC נתמך כעת (ב-Psion 5).

· יציאת cygwin (לשעבר cygwin32) שופרה מאוד.

DOS
· Perl עובד כעת עם djgpp 2.02 (ו-2.03 alpha).

· שמות משתני סביבה אינם מומרים יותר לאותיות רישיות.

· קודי יציאה שגויים מ-backticks תוקנו.

· יציאה זו ממשיכה להשתמש בגלובינג מובנה משלה (לא File::Glob).

OS390 (OpenEdition MVS)
התמיכה בפלטפורמת EBCDIC זו לא חודשה במהדורה זו. יש
קשיים ליישב את הסטנדרטיזציה של פרל על UTF-8 כייצוג הפנימי שלה
עבור תווים עם ערכת התווים EBCDIC, מכיוון ששניהם אינם תואמים.

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

VMS
גרסאות והרחבות רבות לתצורה, בנייה, בדיקה והתקנה
תהליך כדי להתאים לשינויי ליבה ואפשרויות ספציפיות ל-VMS.

הרחב את קוד הטיפול ב-%ENV כדי לאפשר מיפוי זמן ריצה לשמות לוגיים, סמלי CLI ו-CRTL
מערך הסביבה.

הרחבה של קוד הפעלת תהליכי משנה כדי לקבל מפרט קבצים כפקודה "פעלים".

הוסף לעיבוד שורת הפקודה של Perl את היכולת להשתמש בסוגי קבצים המוגדרים כברירת מחדל ולזהות
"2>&1" בסגנון יוניקס.

הרחבת רוטינות File::Spec::VMS ושילוב ב-ExtUtils::MM_VMS.

הרחבה של ExtUtils::MM_VMS לטיפול בהרחבות מורכבות בצורה גמישה יותר.

ניתן להתייחס למילים חשופות בתחילת נתיב תחביר Unix כטקסט ולא רק כהגיוני
שמות.

תרגום מאובטח אופציונלי של מספר שמות לוגיים בשימוש פנימי של Perl.

תיקון באגים שונים והעברת קוד ליבה חדש ל-VMS.

תודה מורחבת בשמחה לאנשים רבים שתרמו תיקוני VMS, בדיקות,
ורעיונות.

Win32
Perl יכול כעת לחקות מזלג() באופן פנימי, תוך שימוש במספר מתורגמנים הפועלים בשונה
חוטים במקביל. תמיכה זו חייבת להיות מופעלת בזמן הבנייה. ראה perlfork עבור
מידע מפורט.

כאשר ניתן שם נתיב המורכב רק משם כונן, כגון "A:", opendir () ו
stat () השתמש כעת בספריית העבודה הנוכחית עבור הכונן במקום בשורש הכונן.

פונקציות ה-XSUB המובנות במרחב השמות של Win32:: מתועדות. ראה Win32.

$^X מכיל כעת את שם הנתיב המלא של קובץ ההפעלה הפועל.

A Win32::GetLongPathName() הפונקציה מסופקת כדי להשלים Win32::GetFullPathName() ו
Win32::GetShortPathName(). ראה Win32.

POSIX::uname() נתמך.

system(1,...) מחזיר כעת מזהי תהליכים אמיתיים במקום נקודות זיהוי לתהליכים. לַהֲרוֹג() מקבלת
כל מזהה תהליך אמיתי, במקום להחזיר ערכים מהמערכת (1,...).

לתאימות טובה יותר עם Unix, כעת ניתן להשתמש ב-"kill(0, $pid)" כדי לבדוק אם א
תהליך קיים.

מודול "Shell" נתמך.

נוספה תמיכה טובה יותר בבניית Perl תחת command.com ב-Windows 95.

סקריפטים נקראים במצב בינארי כברירת מחדל כדי לאפשר ByteLoader (ומנגנון הסינון
באופן כללי) לעבוד כמו שצריך. לצורך תאימות, ידית הקובץ DATA תוגדר לטקסט
במצב אם מזוהה החזרת עגלה בסוף השורה המכילה את ה-__END__ או
אסימון __DATA__; אם לא, ידית הקובץ DATA תישאר פתוחה במצב בינארי. מוקדם יותר
גרסאות תמיד פתחו את ידית הקובץ DATA במצב טקסט.

השמיים גלוב () המפעיל מיושם באמצעות סיומת "File::Glob", התומכת ב-glob
תחביר של מעטפת C. זה מגביר את הגמישות של גלוב () מפעיל, אבל שם
עשויות להיות בעיות תאימות לתוכניות שהסתמכו על התחביר הישן יותר. אם אתה
רוצה לשמור על תאימות עם התחביר הישן יותר, אולי תרצה להריץ עם perl
"-MFile::DosGlob". לפרטים ומידע תאימות, ראה File::Glob.

משמעותי באג תיקוני

on ריק קבצים
כאשר $/ מוגדר ל-"undef", "השחתה" של קובץ ריק מחזירה מחרוזת באורך אפס (במקום זאת
של "undef", כפי שהיה פעם) בפעם הראשונה שה-HANDLE נקרא לאחר ש-$/ מוגדר ל-"undef".
קריאה נוספת תניב "undef".

המשמעות היא שהדברים הבאים יצרפו "foo" לקובץ ריק (הוא לא עשה כלום בעבר):

perl -0777 -pi -e 's/^/foo/' empty_file

ההתנהגות של:

perl -pi -e 's/^/foo/' empty_file

ללא שינוי (הוא ממשיך להשאיר את הקובץ ריק).

"eval '...'" שיפורים
מספרי שורות (כפי שמשתקף על ידי מתקשר() ורוב האבחונים) בתוך "eval '...'" היו
לעתים קרובות שגוי כאשר כאן היו מעורבים מסמכים. זה תוקן.

חיפושים לקסיקליים למשתנים המופיעים ב-"eval '...'" בתוך פונקציות שהיו
עצמם שנקראו בגדר "..." חיפשו במקום הלא נכון אחר מילונים. ה
חיפוש מילוני מסתיים כעת בצורה נכונה בגבול הבלוק של תת-השגרה.

השימוש ב-"return" בתוך "eval {...}" גרם ל-$@ לא להתאפס כראוי כאשר לא
חריג התרחש בתוך eval. זה תוקן.

ניתוח של מסמכים כאן היה פגום כאשר הופיעו כתחליף
ביטוי ב-"eval 's/.../.../e'". זה תוקן.

הכל קומפילציה שגיאות יש לו נָכוֹן שגיאות
כמה "שגיאות" שנתקלו בזמן הקומפילציה נוצרו מכורח בעקבות אזהרות
על ידי הפסקת התוכנית בסופו של דבר. זה אפשר לדווח על עוד שגיאות כאלה ב-a
ריצה בודדת, במקום לגרום לעצירה קשה בשגיאה הראשונה שנתקלה בה.

המנגנון לדיווח על שגיאות כאלה יושם מחדש לזמן הידור בתור
שגיאות ודווח עליהן בסוף הקומפילציה כשגיאות אמיתיות ולא כ
אזהרות. זה מתקן מקרים שבהם דלפו הודעות שגיאה בצורה של אזהרות
כאשר הקוד הידור בזמן ריצה באמצעות "eval STRING", וגם מאפשר לשגיאות כאלה
לכוד באופן אמין באמצעות "eval "..."".

באופן מרומז סגור ידיות קבצים יש לו בטוח יותר
לפעמים פעולות קבצים סגורות באופן מרומז (כמו כשהן ממוקמות, ו-Perl
סוגר אותם אוטומטית ביציאה מהטווח) עלול להגדיר $ בטעות? או $!. זֶה
תוקן.

התנהגות of רשימה פרוסות is יותר עִקבִי
כאשר לוקחים חלק מתוך רשימה מילולית (בניגוד לפרוסה של מערך או hash), Perl
משמש להחזרת רשימה ריקה אם התוצאה הורכבה במקרה מכל ערכי undef.

ההתנהגות החדשה היא לייצר רשימה ריקה אם (ורק אם) הרשימה המקורית הייתה ריקה.
שקול את הדוגמה הבאה:

@a = (1,undef,undef,2)[2,1,2];

ההתנהגות הישנה הייתה מביאה לכך של-@a אין אלמנטים. ההתנהגות החדשה מבטיחה
יש לו שלושה אלמנטים לא מוגדרים.

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

@a = ()[1,2];
@a = (getpwent)[7,0];
@a = (anything_returning_empty_list())[2,1,2];
@a = @b[2,1,2];
@a = @c{'a','b','c'};

ראה perldata.

"(\$)" אב טיפוס ו $foo{a}
אב טיפוס התייחסות סקלרי מאפשר כעת כראוי hash או אלמנט מערך בחריץ זה.

"לך ל &תַת" ו טעינה אוטומטית
מבנה ה-"goto &sub" פועל כהלכה כאשר &sub נטען אוטומטית.

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

כישלונות in להרוס()
כאשר קוד ב-destructor זרק חריג, הוא נעלם מעיניו בגרסאות קודמות של
פרל, אלא אם כן מישהו חיפש במקרה ב-$@ בדיוק אחרי נקודת ההורס
במקרה רץ. כשלים כאלה גלויים כעת כאזהרות כאשר אזהרות מופעלות.

אזור באגים קבוע
printf () ו sprintf () אפס בעבר את המקום המספרי בחזרה למקום ברירת המחדל "C".
זה תוקן.

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

זכרון הדלפות
המבנה של "eval 'return sub {...}'" יכול לפעמים לדלוף זיכרון. זה תוקן.

פעולות שאינן בוני filehandle משמשות לדליפת זיכרון כאשר נעשה בהן שימוש על לא חוקי
ידיות קבצים. זה תוקן.

קונסטרוקטים ששינו את @_ עלולים להיכשל בהקצאת ערכים ב-@_ ובכך לדלוף זיכרון.
זה תוקן.

מְזוּיָף תת-נוהל תלים לאחר נכשל תת-נוהל שיחות
Perl יכלה לפעמים ליצור בדלי תת-שגרה ריקים כאשר לא נמצאה תת-שגרה ב-
חֲבִילָה. מקרים כאלה מנעו מחיפושי שיטה מאוחרים יותר להתקדם לחבילות בסיס.
זה תוקן.

לְהַכתִים כישלונות תחת "-U"
כאשר פועל במצב לא בטוח, הפרות כתמים עלולות לפעמים לגרום לכשלים שקטים. זֶה
תוקן.

הסוף אבני ו מה היא "-ג" להחליף
גרסאות קודמות ששימשו להפעלת BEGIN ו END חוסם כאשר Perl הופעל במצב קומפילציה בלבד.
מכיוון שזו בדרך כלל לא ההתנהגות הצפויה, בלוקים END אינם מבוצעים יותר
כאשר נעשה שימוש במתג "-c", או אם ההידור נכשל.

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

פוטנציאל ל לדלוף נתונים ידיות קבצים
שימוש באסימון "__DATA__" יוצר ידית קובץ מרומזת לקובץ המכיל את
אֲסִימוֹן. באחריות התוכנית לסגור אותה בסיום הקריאה ממנה.

אזהרה זו מוסברת כעת טוב יותר בתיעוד. ראה perldata.

חדש or השתנה אבחון

משתנה "%s" %s מסווה הצהרה קודמת באותו %s
(W misc) משתנה "שלי" או "שלנו" הוכרז מחדש בהיקף הנוכחי או
הצהרה, ביטול למעשה כל גישה למופע הקודם. זה
כמעט תמיד טעות דפוס. שימו לב שהמשתנה הקודם עדיין קיים
עד תום ההיקף או עד להשמדת כל רפרנט הסגירה אליו.

"המשנה שלי" עדיין לא מיושם
(ו) עדיין לא יושמו תתי-שגרות בעלות היקף לקסיקלי. אל תנסה את זה עדיין.

המשתנה "שלנו" %s הוכרז מחדש
(W misc) נראה שכבר הכרזת על אותו גלובלי פעם אחת בעבר בזרם
היקף מילוני.

'!' מותר רק לאחר הסוגים %s
(ו) ה'!' מותר להיכנס חבילה() ו לִפְרוֹק() רק אחרי סוגים מסוימים. ראה "ארוז" פנימה
perlfunc.

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

אחרי / יש להופיע A, A או Z
(ו) הייתה לך תבנית פריקה המציינת מחרוזת באורך נספר, וזו חייבת להיות
ואחריו אחת האותיות a, A או Z כדי לציין איזה סוג של מחרוזת אמורה להיות
פורק. ראה "חבילה" ב-perlfunc.

/ חייב להיות אחריו a*, A* או Z*
(ו) הייתה לך תבנית חבילה המציינת מחרוזת באורך נספר, כרגע היחידה
דברים שאפשר לספור את אורכם הם a*, A* או Z*. ראה "חבילה" ב-perlfunc.

/ חייב לעקוב אחר סוג מספרי
(ו) הייתה לך תבנית פריקה שהכילה '#', אבל זה לא פעל לפי חלק
מפרט פתיחה מספרי. ראה "חבילה" ב-perlfunc.

/%s/: בריחה לא מזוהה \\%c עברה
(W regexp) השתמשת בשילוב של תו נטוי לאחור שאינו מזוהה על ידי Perl.
שילוב זה מופיע במשתנה אינטרפולציה או רגיל מופרד "'".
ביטוי. הדמות הובנה מילולית.

/%s/: בריחה לא מזוהה \\%c במחלקת התווים עברה
(W regexp) השתמשת בשילוב של תו נטוי לאחור שאינו מזוהה על ידי Perl
בתוך שיעורי אופי. הדמות הובנה מילולית.

/%s/ כנראה צריך להיכתב בתור "%s"
(תחביר W) השתמשת בתבנית שבה פרל ציפתה למצוא מחרוזת, כמו ב-
טיעון ראשון ל"להצטרף". Perl יטפל בתוצאה האמיתית או השגויה של התאמת ה
דפוס נגד $_ בתור המחרוזת, וזה כנראה לא מה שחשבתם.

%s() נקרא מוקדם מדי כדי לבדוק אב טיפוס
(אב טיפוס W) קראת לפונקציה שיש לה אב טיפוס לפני שהמנתח ראה א
הגדרה או הצהרה עבורו, ופרל לא יכלה לבדוק שהקריאה תואמת
אב הטיפוס. אתה צריך להוסיף הצהרת אב טיפוס מוקדמת עבור
תת-השגרה המדוברת, או הזז את הגדרת תת-השגרה לפני הקריאה לקבל
בדיקת אב טיפוס נכונה. לחלופין, אם אתה בטוח שאתה מתקשר ל-
לתפקד כהלכה, תוכל לשים אמפרסנד לפני השם כדי להימנע מהאזהרה.
ראה perlsub.

ארגומנט %s אינו רכיב HASH או ARRAY
(ו) הטיעון ל קיים () חייב להיות רכיב hash או מערך, כגון:

$foo{$bar}
$ref->{"susie"}[12]

ארגומנט %s אינו רכיב או פרוסה HASH או ARRAY
(ו) הטיעון ל מחק () חייב להיות רכיב hash או מערך, כגון:

$foo{$bar}
$ref->{"susie"}[12]

או פרוסת hash או מערך, כגון:

@foo[$bar, $baz, $xyzzy]
@{$ref->[12]}{"susie", "queue"}

ארגומנט %s אינו שם של תת שגרה
(ו) הטיעון ל קיים () עבור "קיים &sub" חייב להיות שם תת-שגרה, ולא א
שיחת תת שגרתית. "קיים &sub()" ייצור שגיאה זו.

תכונת החבילה %s עשויה להתנגש עם המילה השמורה בעתיד: %s
(W שמור) נעשה שימוש בשם תכונה באותיות קטנות שהכיל מטפל ספציפי לחבילה.
לשם זה עשויה להיות משמעות לפרל עצמה יום אחד, למרות שעדיין אין לו משמעות.
אולי כדאי להשתמש בשם של תכונה מעורבת באותיות רישיות, במקום זאת. ראה תכונות.

(בניקוי) %s
(W misc) קידומת זו מציינת בדרך כלל כי א להרוס() השיטה העלתה את המצוין
יוצא מן הכלל. מאז משמידים נקראים בדרך כלל על ידי המערכת בנקודות שרירותיות
במהלך ההוצאה להורג, ולעתים קרובות מספר עצום של פעמים, האזהרה ניתנת פעם אחת בלבד
עבור כל מספר של כשלים שאחרת היו מביאים לאותה הודעה
חוזר על עצמו.

כשל בהתקשרויות חוזרות של משתמשים שנשלחו באמצעות הדגל "G_KEEPERR" עלול גם לגרום
האזהרה הזו. ראה "G_KEEPERR" ב-perlcall.

<> צריך להיות מרכאות
(ו) כתבת "לדרוש "כאשר היית צריך לכתוב "דרוש 'קובץ'".

נסה להצטרף לעצמך
(ו) ניסית להצטרף לשרשור מתוך עצמו, וזו משימה בלתי אפשרית. אתה
ייתכן שהוא מצטרף לשרשור הלא נכון, או שתצטרך להעביר את לְהִצְטַרֵף() לאחרים אחרים
פְּתִיל.

דפוס חילוף גרוע
(ו) השתמשת בבורר /e כדי להעריך את ההחלפה להחלפה, אבל perl
מצא שגיאת תחביר בקוד שיש להעריך, ככל הנראה סוגר ימין בלתי צפוי
'}'.

רע realloc () התעלם
(ס) שגרה פנימית הנקראת realloc () על משהו שמעולם לא היה malloc ()ed
במקום הראשון. חובה, אך ניתן לנטרל על ידי הגדרת משתנה סביבה
"PERL_BADFREE" ל-1.

מילה חשופה נמצאה בתנאי
(W bareword) המהדר מצא רקword היכן שהוא ציפה לתנאי, אשר
לעתים קרובות מציין כי || או && נותח כחלק מהארגומנט האחרון של ה-
מבנה קודם, למשל:

פתוח FOO || לָמוּת;

זה עשוי גם להצביע על קבוע באיות שגוי שהתפרש כמילה חשופה:

השתמש בקבוע TYPO => 1;
if (TYOP) { print "foo" }

הפרגמה ה"קפדנית" שימושית בהימנעות מטעויות כאלה.

מספר בינארי > 0b11111111111111111111111111111111 לא נייד
(W portable) המספר הבינארי שציינת גדול מ-2**32-1 (4294967295) ו
לכן אינו נייד בין מערכות. ראה perlport למידע נוסף על ניידות
חששות.

גודל וקטור סיביות > 32 לא נייד
(W portable) שימוש בגדלי וקטור סיביות גדולים מ-32 אינו נייד.

גלישת מאגר ב-prime_env_iter: %s
(W פנימי) אזהרה ייחודית ל-VMS. בזמן שפרל התכונן לחזור על זה
%ENV, הוא נתקל בשם הגיוני או בהגדרת סמל שהיו ארוכים מדי, אז זה היה
חתוך למחרוזת המוצגת.

לא ניתן לבדוק את מערכת הקבצים של הסקריפט "%s"
(P) משום מה אתה לא יכול לבדוק את מערכת הקבצים של הסקריפט עבור nosuid.

לא ניתן להכריז על מחלקה עבור %s לא סקלרי ב-"%s"
(S) נכון לעכשיו, רק משתנים סקלאריים יכולים להכריז עם מוקד מחלקה ספציפי ב-a
ההצהרה "שלי" או "שלנו". ניתן להרחיב את הסמנטיקה לסוגים אחרים של משתנים
בעתיד.

לא יכול להכריז על %s ב-"%s"
(ו) ניתן להכריז רק על משתנים סקלרים, מערך ו-hash כמשתנים "שלי" או "שלנו".
הם חייבים להיות מזהים רגילים בתור שמות.

לא ניתן להתעלם מהאות CHLD, מכריח את ברירת המחדל
(אות W) Perl זיהה שהוא מופעל עם אות SIGCHLD (לפעמים
המכונה SIGCLD) מושבת. מאז השבתת אות זה יפריע לתקין
קביעת מצב היציאה של תהליכי צאצא, פרל איפסה את האות לשלומה
ערך ברירת מחדל. מצב זה מצביע בדרך כלל על כך שתוכנית האם במסגרתה
ייתכן שפרל פועל (למשל, קרון) הוא מאוד רשלני.

לא ניתן לשנות קריאת תת-שגרת שאינה מסוג lvalue
(ו) יש להכריז על תת-שגרות המיועדות לשימוש בהקשר lvalue ככאלה, ראה
"Lvalue subroutines" ב-perlsub.

לא יכול לקרוא את סביבת CRTL
(ס) אזהרה מיוחדת ל-VMS. פרל ניסה לקרוא אלמנט של %ENV מה-CRTL
מערך הסביבה הפנימית וגילה שהמערך חסר. אתה צריך להבין
לגלות היכן ה-CRTL שלך הטעה את סביבתו או הגדר PERL_ENV_TABLES (ראה perlvms) אז
את הסביבה הזו לא מחפשים.

לא ניתן להסיר את %s: %s, דילוג על קובץ
(S) ביקשת עריכה במקום מבלי ליצור קובץ גיבוי. פרל לא הצליח
הסר את הקובץ המקורי כדי להחליף אותו בקובץ שהשתנה. הקובץ נשאר
ללא שינוי.

לא ניתן להחזיר %s משגרת המשנה lvalue
(ו) Perl זיהה ניסיון להחזיר ערכי l לא חוקיים (כגון זמניים או לקריאה בלבד
ערכים) מתת שגרה המשמשת כ-lvalue. זה אסור.

לא יכול להחליש אי התייחסות
(ו) ניסית להחליש משהו שלא היה התייחסות. רק הפניות יכולות
לִרְפּוֹת.

מחלקת תווים [:%s:] לא ידועה
(ו) המחלקה במחלקת התווים [: :] לא ידועה. ראה perlre.

תחביר מחלקות תווים [%s] שייך למחלקות תווים
(W unsafe) מחלקת התווים בונה [: :], [= =] ו-[. .] ללכת בתוך אופי
מחלקות, ה-[] הן חלק מהמבנה, לדוגמה: /[012[:alpha:]345]/. הערות
ש-[= =] ו-[. .] אינם מיושמים כעת; הם פשוט מצייני מיקום עבור
הרחבות עתידיות.

הקבוע אינו הפניה %s
(ו) ערך קבוע (אולי מוכרז באמצעות הפרגמה של "השתמש בקבוע") הוא הוויה
נמחק, אבל זה מסתכם בסוג לא נכון של התייחסות. ההודעה מציינת
סוג ההתייחסות שהיה צפוי. זה בדרך כלל מצביע על שגיאת תחביר ב
ייחוס הערך הקבוע. ראה "פונקציות קבועות" ב-perlsub ובקבוע.

קבוע(%s): %s
(ו) המנתח מצא חוסר עקביות במהלך ניסיון להגדיר עומס יתר
קבוע, או כאשר מנסים למצוא את שם התו שצוין ב-escape "\N{...}".
אולי שכחת לטעון את הפרגמה המתאימה של "עומס יתר" או "charnames"? לִרְאוֹת
שמות שמות ועומס יתר.

CORE::%s אינה מילת מפתח
(ו) מרחב השמות הליבה:: שמור למילות מפתח של Perl.

defined(@array) הוצא משימוש
(ד) מוּגדָר() בדרך כלל אינו שימושי במערכים מכיוון שהוא בודק אם לא מוגדר
סקלר ערך. אם אתה רוצה לראות אם המערך ריק, פשוט השתמש ב-"if (@array) { # not
ריק }" למשל.

defined(%hash) הוצא משימוש
(ד) מוּגדָר() בדרך כלל אינו שימושי ב-hashs מכיוון שהוא בודק אם לא מוגדר
סקלר ערך. אם אתה רוצה לראות אם ה-hash ריק, פשוט השתמש ב-"if (%hash) { # not
ריק }" למשל.

לא יצר כותרת חוקית
ראה שגיאת שרת.

(האם התכוונת ל"מקומי" במקום ל"שלנו"?)
(W misc) זכור ש"שלנו" אינו ממקם את המשתנה הגלובלי המוצהר. יש לך
הכריז על כך שוב באותו היקף מילוני, שנראה מיותר.

המסמך אינו מכיל נתונים
ראה שגיאת שרת.

הזנת %s יעילה נכשלה
(ו) תוך כדי הפרגמה של "השתמש ב-filtest", החלפת ה-uids האמיתיים והיעילים או
מדריך נכשל.

false [] טווח "%s" בביטוי רגולרי
(W regexp) טווח מחלקות תווים חייב להתחיל ולהסתיים בתו מילולי, לא
מחלקת תווים אחרת כמו "\d" או "[:alpha:]". ה-"-" בטווח השקר שלך הוא
מתפרש כ"-" מילולי. שקול לצטט את ה-"-", "\-". ראה perlre.

ידית הקובץ %s נפתחה רק עבור פלט
(W io) ניסית לקרוא מתוך ידית קובץ שנפתחה רק לכתיבה. אם התכוונת
כדי שזה יהיה נקודת אחיזה לקריאה/כתיבה, היית צריך לפתוח אותו עם "+" או "+>>"
במקום עם "<" או כלום. אם התכוונת רק לקרוא מהקובץ, השתמש ב-"<".
ראה "פתוח" ב-perlfunc.

עֵדֶר() על ידית קובץ סגורה %s
(W סגור) נקודת האחיזה של הקובץ שאתה מנסה לעשות עֵדֶר() נסגר זמן מה
לפני עכשיו. בדוק את זרימת ההיגיון שלך. עֵדֶר() פועל על ידיות קבצים. האם אתה
מנסה להתקשר עֵדֶר() על ידנית באותו שם?

הסמל הגלובלי "%s" דורש שם חבילה מפורש
(ו) אמרת "השתמש ב-varis strict", מה שמציין שכל המשתנים חייבים להיות
בהיקף מילוני (באמצעות "שלי"), הוכרז מראש באמצעות "שלנו", או במפורש
מוסמך לומר באיזו חבילה נמצא המשתנה הגלובלי (באמצעות "::").

מספר הקסדצימלי > 0xffffffff לא נייד
(W portable) המספר הקסדצימלי שציינת גדול מ-2**32-1 (4294967295)
ולכן אינו נייד בין מערכות. ראה perlport למידע נוסף על ניידות
חששות.

ערך סביבת CRTL "%s" אינו בנוסח
(W פנימי) אזהרה ייחודית ל-VMS. פרל ניסה לקרוא את ה-CRTL הפנימי
מערך environ, ונתקל ברכיב ללא המפריד "=" המשמש להפרדה
מפתחות מתוך ערכים. מתעלמים מהאלמנט.

הודעה לא מנוסחת ב-prime_env_iter: |%s|
(W פנימי) אזהרה ייחודית ל-VMS. פרל ניסה לקרוא שם הגיוני או CLI
הגדרת סמל בעת הכנה לחזור על %ENV, ולא ראיתי את הצפוי
מפריד בין מפתח לערך, כך שהשורה התעלמה.

ספרה בינארית לא חוקית %s
(ו) השתמשת בספרה שאינה 0 או 1 במספר בינארי.

ספרה בינארית לא חוקית %s התעלמה
(ספרה W) ייתכן שניסית להשתמש בספרה שאינה 0 או 1 במספר בינארי.
פירוש המספר הבינארי הופסק לפני הספרה הפוגעת.

מספר לא חוקי של ביטים ב-vec
(ו) מספר הביטים ב vec() (הארגומנט השלישי) חייב להיות חזק של שתיים מ-1 עד
32 (או 64, אם הפלטפורמה שלך תומכת בכך).

הצפת מספרים שלמים במספר %s
(W overflow) המספר ההקסדצימלי, האוקטלי או הבינארי שציינת בתור a
מילולית או כטיעון ל hex () or אוקטובר () גדול מדי עבור הארכיטקטורה שלך, ויש לו
הומר למספר נקודה צפה. בארכיטקטורת 32 סיביות הגדול ביותר
מספר הקסדצימלי, אוקטלי או בינארי שניתן לייצוג ללא הצפה הוא 0xFFFFFFFF,
037777777777, או 0b11111111111111111111111111111111 בהתאמה. שימו לב שפרל
מקדם בשקיפות את כל המספרים לייצוג נקודה צפה
פנימי - בכפוף לאובדן שגיאות דיוק בפעולות הבאות.

מאפיין %s לא חוקי: %s
התכונה המצוינת עבור תת שגרה או משתנה לא זוהה על ידי Perl או על ידי
מטפל שסופק על ידי המשתמש. ראה תכונות.

תכונות %s לא חוקיות: %s
התכונות המצוינות עבור תת שגרה או משתנה לא זוהו על ידי Perl or
על ידי מטפל שסופק על ידי המשתמש. ראה תכונות.

טווח [] לא חוקי "%s" בביטוי הרגולרי
הטווח הפוגע מוצג כעת במפורש.

תו מפריד לא חוקי %s ברשימת התכונות
(ו) משהו אחר מלבד נקודתיים או רווח לבן נראה בין האלמנטים של an
רשימת תכונות. אם לתכונה הקודמת הייתה רשימת פרמטרים בסוגריים, אולי
הרשימה הזו בוטלה מוקדם מדי. ראה תכונות.

תו מפריד לא חוקי %s ברשימת תכונות המשנה
(ו) משהו אחר מלבד נקודתיים או רווח לבן נראה בין האלמנטים של a
רשימת תכונות משנה. אם לתכונה הקודמת היה פרמטר בסוגריים
רשימה, אולי הרשימה הזו נסגרה מוקדם מדי.

השארת %s יעילה נכשלה
(ו) תוך כדי הפרגמה של "השתמש ב-filtest", החלפת ה-uids האמיתיים והיעילים או
מדריך נכשל.

Lvalue משנה שמחזירים %s עדיין לא יושמו
(ו) עקב מגבלות ביישום הנוכחי, ערכי מערך ו-hash אינם יכולים להיות
מוחזר בתתי שגרות המשמשות בהקשר lvalue. ראה "תתי שגרות Lvalue" ב-perlsub.

השיטה %s אינה מותרת
ראה שגיאת שרת.

חסר %sbrace%s ב-\N{}
(ו) תחביר שגוי של שם התו המילולי "\N{charname}" בתוך קווים כפולים
ההקשר.

חסרה פקודה ב-piped open
(W pipe) השתמשת במבנה "open(FH, "| command")" או "open(FH, "command |")",
אבל הפקודה הייתה חסרה או ריקה.

שם חסר ב"המשנה שלי"
(ו) התחביר השמור עבור תת-שגרות בהיקף מילוני מחייב שיש להן a
השם שאיתו ניתן למצוא אותם.

לא צוין %s עבור -%c
(ו) מתג שורת הפקודה המצוין צריך ארגומנט חובה, אבל אתה לא
ציין אחד.

לא מותר שם חבילה עבור משתנה %s ב"שלנו"
(ו) שמות משתנים מתאימים לחלוטין אינם מותרים בהצהרות "שלנו", כי זה
לא הגיוני במיוחד בסמנטיקה קיימת. תחביר כזה שמור לעתיד
הרחבות.

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

ללא מידע קיזוז UTC; בהנחה שהזמן המקומי הוא UTC
(ס) אזהרה מיוחדת ל-VMS. Perl לא הצליחה למצוא את היסט אזור הזמן המקומי, אז
זה בהנחה שזמן המערכת המקומית שווה ל-UTC. אם זה לא, הגדר את
שם הגיוני SYS$TIMEZONE_DIFFERENTIAL לתרגם למספר השניות אשר
יש להוסיף ל-UTC כדי לקבל זמן מקומי.

מספר אוקטלי > 037777777777 לא נייד
(W portable) המספר האוקטלי שציינת גדול מ-2**32-1 (4294967295) ו
לכן אינו נייד בין מערכות. ראה perlport למידע נוסף על ניידות
חששות.

ראה גם perlport לכתיבת קוד נייד.

פאניקה: del_backref
(P) נכשל בבדיקת עקביות פנימית בעת ניסיון לאפס הפניה חלשה.

פאניקה: ילד פופן לא קרא
(ו) ילד מזלג החזיר הודעה לא מובנת על טעותו.

פאניקה: magic_killbackrefs
(P) נכשל בבדיקת עקביות פנימית בעת ניסיון לאפס את כל ההפניות החלשות
חפץ.

חסרים סוגריים סביב רשימת "%s".
(סוגריים W) אמרת משהו כמו

שלי $foo, $bar = @_;

מתי התכוונת

my ($foo, $bar) = @_;

זכור ש"שלי", "שלנו" ו"מקומי" מתחברים יותר מהפסיק.

אינטרפולציה בלתי מכוונת אפשרית של %s במחרוזת
(W דו משמעי) פעם פרל היה מנסה לנחש אם אתה רוצה מערך
אינטרפולציה או @ מילולי. זה כבר לא עושה את זה; מערכים הם עכשיו תמיד
אינטרפולציה למחרוזות. זה אומר שאם תנסה משהו כמו:

הדפס "[מוגן בדוא"ל]";

והמערך @example לא קיים, פרל עומד להדפיס "fred.com", כלומר
כנראה לא מה שרצית. כדי לקבל סימן "@" מילולי במחרוזת, שים קו נטוי אחורי
לפניו, בדיוק כפי שהיית מקבל סימן "$" מילולי.

באג אפשרי Y2K: %s
(W y2k) אתה משרשר את המספר 19 עם מספר אחר, שיכול להיות a
בעיה פוטנציאלית של שנת 2000.

הפרגמה "attrs" הוצאה משימוש, השתמש במקום זאת ב-"sub NAME : ATTRS".
(W הוצא משימוש) כתבת משהו כזה:

sub doit
{
השתמש ב-attrs qw(נעול);
}

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

sub doit : נעול
{
...

הפרגמה של "שימוש באטרקטים" מיושנת כעת, והיא ניתנת רק לאחור-
תְאִימוּת. ראה "תכונות משנה" ב-perlsub.

סוף מוקדם של כותרות התסריט
ראה שגיאת שרת.

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

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

realloc () של זיכרון משוחרר התעלמו
(ס) שגרה פנימית הנקראת realloc () על משהו שכבר השתחרר.

ההתייחסות כבר חלשה
(W שונות) ניסית להחליש התייחסות שכבר חלשה. לעשות כן
ללא השפעה.

setpgrp לא יכול לקחת טיעונים
(ו) למערכת שלך יש את setpgrp() מ-BSD 4.2, שאינו לוקח טיעונים, בניגוד ל-POSIX
setpgid(), אשר לוקח מזהה תהליך ומזהה קבוצת תהליך.

מוזר *+?{} בביטוי באורך אפס
(W regexp) החלת מכמת ביטוי רגולרי במקום שבו הוא הופך לא
מובן, כמו טענה ברוחב אפס. נסה לשים את המכמת בתוך
קביעה במקום. לדוגמה, הדרך להתאים את "abc" בתנאי שעוקבים אחריה
לפי שלוש חזרות של "xyz" הוא "/abc(?=(?:xyz){3})/", לא "/abc(?=xyz){3}/".

החלפת %s יעילה אינה מיושמת
(ו) בעוד תחת הפרגמה של "שימוש בקובץ בדיקה", אנחנו לא יכולים להחליף את האמיתי והיעיל
uids או gids.

Perl זה לא יכול לאפס רכיבי סביבת CRTL (%s)
Perl זה לא יכול להגדיר רכיבי סביבת CRTL (%s=%s)
(W פנימי) אזהרות מיוחדות ל-VMS. ניסית לשנות או למחוק רכיב של
מערך הסביבה הפנימי של CRTL, אבל העותק שלך של Perl לא נבנה עם CRTL ש
הכיל את setenv() פוּנקצִיָה. תצטרך לבנות מחדש את Perl עם CRTL שעושה זאת,
או להגדיר מחדש PERL_ENV_TABLES (ראה perlvms) כך שמערך הסביבה אינו המטרה
של השינוי ל-%ENV שיצר את האזהרה.

מאוחר מדי להפעיל את %s block
(W void) בלוק CHECK או INIT מוגדר במהלך זמן הריצה הנכון, כאשר
ההזדמנות להפעיל אותם כבר חלפה. אולי אתה טוען קובץ עם
"דרוש" או "עשה" כאשר אתה אמור להשתמש ב"השתמש" במקום זאת. או אולי כדאי לשים
ה"דרוש" או ה"עשה" בתוך בלוק BEGIN.

לא ידוע לִפְתוֹחַ() מצב '%s'
(ו) הטיעון השני של 3-טיעון לִפְתוֹחַ() אינו ברשימת המצבים החוקיים:
"", ">>", "+", "+>>", "-|", "|-".

תהליך לא ידוע %x שלח הודעה אל prime_env_iter: %s
(P) שגיאה מיוחדת ל-VMS. Perl קראה ערכים עבור %ENV לפני איטרציה
זה, ומישהו אחר תקע הודעה בזרם הנתונים שציפה פרל. של מישהו
מאוד מבולבל, או אולי מנסה לערער את אוכלוסיית ה-%ENV של פרל לרעה
מטרות.

בריחה לא מזוהה \\%c עברה
(W שונות) השתמשת בשילוב של תו נטוי לאחור שאינו מזוהה על ידי Perl.
הדמות הובנה מילולית.

פרמטר תכונה לא נסגר ברשימת התכונות
(ו) הלקסר ראה תו סוגריים פותח (משמאל) בזמן ניתוח תכונה
רשימה, אך תו הסוגר התואם (מימין) לא נמצא. אתה יכול
צריך להוסיף (או להסיר) תו קו נטוי כדי לגרום לסוגריים שלך להתאזן. לִרְאוֹת
תכונות.

רשימת מאפיינים ללא הפסקה
(ו) הלקסר מצא משהו אחר מלבד מזהה פשוט בתחילת an
תכונה, וזה לא היה נקודה-פסיק או התחלה של בלוק. אולי הפסקת
רשימת הפרמטרים של התכונה הקודמת מוקדם מדי. ראה תכונות.

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

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

הערך של סמל CLI "%s" ארוך מדי
(W misc) אזהרה ייחודית ל-VMS. Perl ניסתה לקרוא את הערך של רכיב %ENV
מטבלת סמלים של CLI, ומצאה מחרוזת שהתקבלה ארוכה מ-1024 תווים.
ערך ההחזרה קוצץ ל-1024 תווים.

מספר הגרסה חייב להיות מספר קבוע
(P) הניסיון לתרגם משפט "השתמש ב-Module n.n LIST" למקבילה שלו
בלוק "BEGIN" מצא אי התאמה פנימית למספר הגרסה.

חדש בדיקות

lib/attrs
מבחני תאימות עבור "sub : attrs" לעומת "use attrs" הישן יותר.

lib/env
בדיקות ליכולת סקלרית חדשה של סביבה (לדוגמה, "השתמש ב-Env qw($BAR);").

lib/env-מערך
בדיקות ליכולת מערך סביבתי חדש (לדוגמה, "השתמש ב-Env qw(@PATH);").

lib/io_const
קבועי IO (SEEK_*, _IO*).

lib/io_dir
שיטות IO הקשורות למדריך (חדש, קריאה, סגירה, הרצה אחורה, מחיקה קשורה).

lib/io_multihomed
שקעי INET עם מארחים מרובי בית.

lib/io_poll
IO מִשׁאָל().

lib/io_unix
שקעי UNIX.

op/attrs
מבחני רגרסיה עבור "my ($x,@y,%z) : attrs" ו-.

op/filetest
מפעילי בדיקת קבצים.

op/lex_assign
ודא פעולות הניגשות לאובייקטי משטח (לקסיקליים וזמניים).

op/exists_sub
ודא פעולות "קיים &sub".

שאינו עולה בקנה אחד שינויים

פרל מָקוֹר אי תאימות
היזהר שכל אזהרות חדשות שנוספו או ישנות ששופרו
לֹא נחשב לשינויים בלתי תואמים.

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

CHECK היא מילת מפתח חדשה
כל הגדרות תת-השגרה בשם CHECK הן כעת מיוחדות. ראה "/"תמיכה בבדיקה
בלוקים"" למידע נוסף.

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

הפורמט של $English::PERL_VERSION שונה
מודול האנגלית מגדיר כעת את $PERL_VERSION ל-$^V (ערך מחרוזת) במקום ל-$] (a
ערך מספרי). זוהי אי התאמה פוטנציאלית. שלח לנו דיווח באמצעות perlbug if
אתה מושפע מזה.

ראה "מערכת מספור גרסאות משופרת של Perl" לסיבות לשינוי זה.

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

לדוגמה, "הדפס 97.98.99" היה פעם פלט 97.9899 בגרסאות קודמות, אך כעת
מדפיס "abc".

ראה "תמיכה במחרוזות המיוצגות כווקטור של סידורים".

אולי שונה מחולל מספרים פסאודו-אקראיים
תוכניות Perl התלויות בשחזור קבוצה מסוימת של מספרים פסאודו-אקראיים עשויות
מייצרים כעת תפוקה שונה עקב שיפורים שבוצעו ב ראנד () מובנה. אתה יכול
השתמש ב-"sh Configure -Drandfunc=rand" כדי להשיג את ההתנהגות הישנה.

ראה "מחולל מספרים פסאודו-אקראיים טוב יותר".

פונקציית ה-Hash עבור מפתחות Hash השתנתה
למרות ש-Hashs של Perl אינם שומרי סדר, הסדר האקראי לכאורה
נתקל בעת איטרציה על התוכן של hash נקבע למעשה על ידי
נעשה שימוש באלגוריתם hashing. שיפורים באלגוריתם עשויים להניב סדר אקראי ש
is אחר מזה של גרסאות קודמות, במיוחד כאשר חוזרים על hashes.

ראה "התנהגות טובה יותר במקרה הגרוע של hashes" למידע נוסף.

"undef" נכשל בערכי קריאה בלבד
לשימוש באופרטור "undef" על ערך לקריאה בלבד (כגון $1) יש את אותה השפעה כמו
הקצאת "undef" לערך לקריאה בלבד--זה זורק חריג.

ניתן להגדיר ביט קרוב על ביצוע על ידיות הצינור והשקעים
גם ידיות הצינור והשקעים כפופות כעת להתנהגות קרוב למנהל שנקבע
על ידי המשתנה המיוחד $^F.

ראה "התנהגות עקבית יותר של קרוב למנהל".

כתיבת "$$1" בפירוש "${$}1" אינה נתמכת
Perl 5.004 הוציא משימוש את הפרשנות של $$1 ודומות בתוך אינטרפולציה
מחרוזות פירושן "$$ . "1"", אך עדיין אפשרו זאת.

ב-Perl 5.6.0 ואילך, "$$1" פירושו תמיד "${$1}".

מחק (), כל אחד(), ערכים () ו-"\(%h)"
פועלים על כינויים לערכים, לא העתקים

מחק (), כל אחד(), ערכים () ו-hashes (למשל "\(%h)") בהקשר של רשימה מחזירים את
ערכים בפועל ב-hash, במקום עותקים (כפי שהיו בעבר בגרסאות קודמות).
ניבים אופייניים לשימוש במבנים אלה מעתיקים את הערכים המוחזרים, אבל זה יכול לעשות
הבדל משמעותי בעת יצירת הפניות לערכים המוחזרים. מפתחות ב
hash עדיין מוחזרים כעותקים בעת איטרציה על hash.

ראה גם "מחק (), כל אחד(), ערכים () ואיטרציית ה-hash מהירה יותר".

vec(EXPR,OFFSET,BITS) אוכף סמכויות של שני BITS
vec() יוצר שגיאת זמן ריצה אם הארגומנט BITS אינו כוח-של שניים חוקי
מספר שלם.

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

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

בסוגריים לֹא() מתנהג כמו אופרטור רשימה
האופרטור "לא" נופל כעת תחת "אם זה נראה כמו פונקציה, זה מתנהג כמו a
כלל הפונקציה.

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

grep not($_), @things;

מצד שני, ייתכן שהשימוש ב"לא" עם פרוסת רשימה מילולית לא יעבוד. הבאים
מבנה שהותר בעבר:

הדפס לא (1,2,3)[0];

צריך לכתוב בסוגריים נוספים עכשיו:

print not((1,2,3)[0]);

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

הסמנטיקה של אב הטיפוס החשוף "(*)" השתנתה
הסמנטיקה של אב הטיפוס החשוף "*" השתנתה. פרל 5.005 תמיד נכפה
טיעונים סקלרים פשוטים ל-typeglob, שלא היה שימושי במצבים שבהם ה
תת-השגרה חייבת להבחין בין סקלר פשוט לטייפגלוב. ההתנהגות החדשה
זה לא לכפות טיעונים חשופים לטייפגלוב. הערך תמיד יהיה גלוי
כסקלר פשוט או כהתייחסות לטייפגלוב.

ראה "אב-טיפוס חשוף פונקציונלי יותר (*)".

ייתכן שהסמנטיקה של אופרטורי סיביות השתנתה בפלטפורמות של 64 סיביות
אם הפלטפורמה שלך היא 64 סיביות מקורית או אם Perl הוגדרה לשימוש
מספרים שלמים של 64 סיביות, כלומר, $Config{ivsize} הוא 8, ייתכן שיש אי התאמה פוטנציאלית
בהתנהגות של אופרטורים מספריים סיביים (& | ^ ~ >). מפעילים אלה נהגו
פועלים בקפדנות על 32 הסיביות התחתונות של מספרים שלמים בגרסאות קודמות, אבל עכשיו
לפעול על פני כל הרוחב האינטגרלי המקורי. בפרט, שים לב ש"~" לא רגיל
יפיק תוצאות שונות בפלטפורמות שיש להן $Config{ivsize} שונה. ל
ניידות, הקפד להסוות את הסיביות העודפות בתוצאה של "~", למשל,
"~$x & 0xffffffff".

ראה "אופרטורי סיביות תומכים ברוחב מלא של מספר שלם".

מבנים נוספים פוגעים בתוצאות שלהם
כפי שמתואר ב"תכונות אבטחה משופרות", עשויים להיות מקורות נוספים לכתמים ב-a
תוכנית פרל.

כדי להימנע מהתנהגויות כתמים חדשות אלה, אתה יכול לבנות את Perl עם אפשרות ההגדרה
"-Accflags=-DINCOMPLETE_TAINTS". היזהר שהקובץ הבינארי של perl שלאחר מכן עלול להיות לא מאובטח.

C מָקוֹר אי תאימות
"PERL_POLLUTE"
שחרר 5.005 שמות סמלים גלובליים ישנים על ידי אספקת פקודות מאקרו קדם-מעבד
עבור תאימות מקור הרחבה. נכון לגרסה 5.6.0, מעבד קדם אלה
הגדרות אינן זמינות כברירת מחדל. אתה צריך להדר במפורש עם perl
"-DPERL_POLLUTE" כדי לקבל הגדרות אלה. עבור הרחבות שעדיין משתמשות בישן
סמלים, ניתן לציין אפשרות זו דרך MakeMaker:

perl Makefile.PL POLLUTE=1

"PERL_IMPLICIT_CONTEXT"
אפשרות בנייה חדשה זו מספקת קבוצה של פקודות מאקרו עבור כל פונקציות ה-API כך ש-
ארגומנט מפרש/שרשור מרומז מועבר לכל פונקציית API. כ
כתוצאה מכך, משהו כמו "sv_setsv(foo,bar)" מסתכם בקריאת מאקרו ש
למעשה מתורגם למשהו כמו "Perl_sv_setsv(my_perl,foo,bar)". בזמן שזה כן
בדרך כלל לא יהיו בעיות משמעותיות של תאימות מקור, ה
יש לקחת בחשבון את ההבדל בין מאקרו לקריאת פונקציה אמיתית.

זה אומר ששם is בעיית תאימות מקור כתוצאה מכך אם שלך
הרחבות מנסות להשתמש במצביעים לכל אחת מהפונקציות של Perl API.

שים לב שהנושא לעיל אינו רלוונטי ל-build ברירת המחדל של Perl, שלו
ממשקים ממשיכים להתאים לאלה של גרסאות קודמות (אך בכפוף לאפשרויות האחרות
המתואר כאן).

למידע מפורט על
השלכות של בניית Perl עם אפשרות זו.

הערה: PERL_IMPLICIT_CONTEXT מופעל אוטומטית בכל פעם ש-Perl נבנית
עם אחד מ-Dusethreads, -Dusemultiplicity, או שניהם. זה לא
מיועד להיות מופעל על ידי המשתמשים בשלב זה.

"PERL_POLLUTE_MALLOC"
הפעלת ה-malloc של Perl במהדורה 5.005 ואילך גרמה למרחב השמות של ה-
משפחת הפונקציות malloc של מערכת שיש לגזול על ידי גרסאות Perl, מאז על ידי
ברירת מחדל הם השתמשו באותם שמות. חוץ מזה לגרום לבעיות בפלטפורמות שלא
לאפשר החלפה נקייה של פונקציות אלה, פירוש הדבר גם שגרסאות המערכת
לא ניתן היה לקרוא בתוכניות שהשתמשו ב-malloc של Perl. גרסאות קודמות של Perl
אפשרו לדכא את ההתנהגות הזו עם ה-HIDEMYMALLOC ו-EMBEDMYMALLOC
הגדרות קדם-מעבד.

נכון לגרסה 5.6.0, למשפחת הפונקציות malloc של Perl יש שמות ברירת מחדל ברורים
מגרסאות המערכת. אתה צריך להדר במפורש עם perl
"-DPERL_POLLUTE_MALLOC" כדי לקבל את ההתנהגות הישנה יותר. HIDEMYMALLOC ו- EMBEDMYMALLOC
אין השפעה, מכיוון שההתנהגות שהם אפשרו היא כעת ברירת המחדל.

שים לב שהפונקציות האלה כן לֹא מהווים את API להקצאת זיכרון של Perl. ראה "זיכרון
הקצאה" ב-perlguts למידע נוסף על כך.

תוֹאֵם C מָקוֹר API שינויים
"PATCHLEVEL" הוא כעת "PERL_VERSION"
פקודות המאקרו "PERL_REVISION", "PERL_VERSION" ו-"PERL_SUBVERSION" הן כעת
זמין כברירת מחדל מ-perl.h, ומשקף את גרסת הבסיס, patchlevel ו-
חתרנות בהתאמה. ל-"PERL_REVISION" לא הייתה מקבילה קודמת, בעוד
"PERL_VERSION" ו-"PERL_SUBVERSION" היו זמינים בעבר בתור "PATCHLEVEL" ו
"חַתרָנוּת".

השמות החדשים גורמים פחות זיהום של cpp מרחב שמות ומשקף מה המספרים
באים לעמוד על הפרקטיקה המקובלת. למען תאימות, השמות הישנים עדיין
נתמך מתי patchlevel.h נכלל במפורש (כפי שנדרש קודם לכן), אז יש
אין אי תאימות מקור מהשינוי.

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

ה-usethreads או usemultiplicity builds הם לֹא בינארי תואם את המקביל
בונה ב-5.005.

בפלטפורמות הדורשות רשימה מפורשת של יצוא (AIX, OS/2 ו-Windows, בין
אחרים), סמלים פנימיים גרידא, כגון פונקציות מנתח וקודי זמן הריצה אינם
מיוצא כברירת מחדל. Perl 5.005 נהג לייצא את כל הפונקציות ללא קשר אם הן
נחשבו חלק מהממשק ה-API הציבורי או לא.

לרשימה המלאה של פונקציות API ציבוריות, ראה perlapi.

ידוע בעיות

Thread מבחן כישלונות
ידוע כי תתי-הבדיקות 19 ו-20 של מבחן lib/thr5005.t נכשלות עקב בעיות יסודיות.
במימוש 5.005 של שרשור. אלו לא כשלים חדשים -- ל-Perl 5.005_0x יש את
אותם באגים, אבל לא היו לי את הבדיקות האלה.

EBCDIC פלטפורמות לֹא נתמך
במהדורות קודמות של Perl, סביבות EBCDIC כמו OS390 (הידוע גם בשם Open Edition
MVS) ו-VM-ESA נתמכו. עקב שינויים הנדרשים על ידי תמיכת UTF-8 (Unicode),
פלטפורמות EBCDIC אינן נתמכות ב-Perl 5.6.0.

In 64 סיבית HP-UX מה היא lib/io_multihomed מבחן אולי לתלות
בדיקת lib/io_multihomed עשויה להיתקע ב-HP-UX אם Perl הוגדרה להיות 64 סיביות.
מכיוון שפלטפורמות אחרות של 64 סיביות אינן נתלות בבדיקה זו, HP-UX חשוד. כל שאר
הבדיקות עוברות ב-64 סיביות HP-UX. הבדיקה מנסה ליצור ולהתחבר ל-"multihomed"
שקעים (שקעים בעלי מספר כתובות IP).

השלב הבא 3.3 POSIX מבחן כישלון
ב-NEXTSTEP 3.3p2 היישום של זמן אחסון(3) בספריות מערכת ההפעלה
באגי: הפורמט %j ממספר את ימי החודש החל מאפס, אשר, למרות היותו
הגיוני למתכנתים, יגרום לתת-הבדיקות 19 עד 27 של בדיקת lib/posix להיכשל.

Tru64 (aka דִיגִיטָלי יוניקס, aka דצמבר OSF/1) lib/sdbm מבחן כישלון עם gcc
אם קומפילציה עם gcc 2.95 תתבצע, בדיקת lib/sdbm תיכשל (dump core). הפתרון הוא להשתמש ב-
ספק cc, הוא מגיע עם מערכת ההפעלה ומייצר קוד טוב.

UNICOS/mk CC כישלונות בְּמַהֲלָך גדר לָרוּץ
ב-UNICOS/mk השגיאות הבאות עשויות להופיע במהלך הפעלת ה-Configure:

מנחש אילו סמלים מגדירים מהדר C והקדם-מעבד שלך...
CC-20 cc: ERROR File = try.c, Line = 3
...
מתג גרוע yylook 79bad switch yylook 79bad switch yylook 79bad switch yylook 79#ifdef A29K
...
4 שגיאות זוהו בהידור של "try.c".

האשם הוא ה-awk השבור של UNICOS/mk. למרבה המזל ההשפעה מתונה למדי: פרל
עצמו אינו מושפע לרעה מהשגיאה, רק כלי השירות h2ph שמגיע עם Perl, ו
זה די נחוץ בימים אלה.

חץ מפעיל ו מערכים
כאשר הארגומנט השמאלי לאופרטור החץ "->" הוא מערך, או האופרטור "סקלרי".
הפעלה על מערך, תוצאת הפעולה חייבת להיחשב כשגויה. ל
דוּגמָה:

@x->[2]
scalar(@x)->[2]

ביטויים אלה יקבלו שגיאות זמן ריצה במהדורה עתידית כלשהי של Perl.

ניסויי מאפיינים
כפי שנדון לעיל, תכונות רבות עדיין ניסיוניות. ממשקים ויישום
מתכונות אלו כפופות לשינויים, ובמקרים קיצוניים, אף כפופים להסרה
מהדורה עתידית כלשהי של Perl. תכונות אלה כוללות את הדברים הבאים:

האשכולות
Unicode
תמיכה של 64 סיביות
Lvalue תת שגרות
הפניות חלשות
סוג הנתונים פסאודו-hash
חבילת הקומפיילר
הטמעה פנימית של גלוב קבצים
מודול DB
קוד הביטוי הרגולרי בונה:
"(?{ קוד })" ו-"(??{ קוד })"

מְיוּשָׁן אבחון

תחביר מחלקות התווים [: :] שמור להרחבות עתידיות
(W) בתוך מחלקות תווים של ביטוי רגולרי ([]) התחביר שמתחיל ב-"[:"
ומסתיים ב-":]" שמורה להרחבות עתידיות. אם אתה צריך לייצג
רצפי התווים האלה בתוך מחלקת תווים של ביטוי רגולרי, פשוט צטט את ה
סוגריים מרובעים עם הנטוי האחורי: "\[:" ו-":\]".

שם לוגי שגוי |%s| ב-prime_env_iter
(W) אזהרה ייחודית ל-VMS. שם הגיוני נתקל בעת הכנה
לחזור על %ENV אשר מפר את הכללים התחביריים השולטים בשמות לוגיים. כי
לא ניתן לתרגם אותו כרגיל, הוא נדלג ולא יופיע ב-%ENV. זֶה
עשוי להיות אירוע שפיר, שכן חבילות תוכנה מסוימות עשויות להשתנות באופן ישיר לוגית
שמות טבלאות ולהציג שמות לא סטנדרטיים, או שזה עשוי להצביע על שם הגיוני
הטבלה פגומה.

במחרוזת, @%s עכשיו חייב להיכתב כ-\@%s
התיאור של שגיאה זו היה אומר:

(יום אחד זה פשוט יניח ש-@ ללא חתך לאחור
אינטרפולציה של מערך.)

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

בעיית קדימות כנראה ב-%s
(W) המהדר מצא מילה חשופה שבה הוא ציפה לתנאי, אשר לעתים קרובות
מציין ש-|| או && נותח כחלק מהארגומנט האחרון של הקודם
לבנות, למשל:

פתוח FOO || לָמוּת;

ביטוי רגיל גדול מדי
(ו) היישום הנוכחי של ביטויים רגולריים משתמש בשורטים כקיזוז כתובות
בתוך מחרוזת. למרבה הצער זה אומר שאם הביטוי הרגולרי קומפילציה ל
יותר מ-32767, זה יתפוצץ. בדרך כלל כאשר אתה רוצה ביטוי רגולרי זה
גדול, יש דרך טובה יותר לעשות את זה עם מספר הצהרות. ראה perlre.

שימוש ב-"$$ " כלומר "${$} " הוצא משימוש
(ד) גרסאות Perl לפני 5.004 פירשו לא נכון כל סמן סוג ואחריו "$" ו-
סִפְרָה. לדוגמה, "$$0" פירושו בטעות "${$}0" במקום "${$0}".
באג זה תוקן (בעיקר) ב-Perl 5.004.

עם זאת, המפתחים של Perl 5.004 לא יכלו לתקן את הבאג הזה לחלוטין, כי ב-
לפחות שני מודולים בשימוש נרחב תלויים במשמעות הישנה של "$$0" במחרוזת. אז פרל
5.004 עדיין מפרש את "$$ "בדרך הישנה (השבורה) בתוך מיתרים; אבל זה
יוצר הודעה זו כאזהרה. ובפרל 5.005, הטיפול המיוחד הזה יהיה
לחדול.

דווח באגס

אם אתה מוצא את מה שאתה חושב שהוא באג, תוכל לבדוק את המאמרים שפורסמו לאחרונה ב-
קבוצת דיון comp.lang.perl.misc. ייתכן שיהיה מידע גם ב http://www.perl.com/perl/
, דף הבית של פרל.

אם אתה מאמין שיש לך באג שלא דווח, אנא הפעל את פרלבאג תוכנית הכלולה עם
השחרור שלך. הקפד לקצץ את הבאג שלך למקרה מבחן זעיר אך מספיק. הבאג שלך
דוח, יחד עם הפלט של "perl -V", יישלח אל [מוגן בדוא"ל] להיות
נותח על ידי צוות העברת פרל.

השתמש ב-perl56delta באופן מקוון באמצעות שירותי onworks.net