print#

כותב רשימת ערכים למטפל קובץ.

print הוא פרימיטיב הפלט היומיומי. הוא ממיר למחרוזת כל פריט ב־LIST, מצרף אותם עם הערך הנוכחי של $, (מפריד שדות הפלט, לרוב ריק), כותב אותם ל־FILEHANDLE, ולבסוף מצרף את $\ (מפריד רשומות הפלט, לרוב ריק). אם FILEHANDLE מושמט, הפלט הולך למטפל הנבחר כעת (ראו select), שברירת המחדל שלו היא STDOUT. אם LIST מושמט, $_ מודפס.

תקציר#

print LIST
print FILEHANDLE LIST
print {EXPR} LIST
print

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

1 בהצלחה, undef בכשל (כאשר $! נקבע). ערך ההחזרה נבדק לעיתים נדירות - רוב הקריאות ל־print מכוונות ל־STDOUT או ל־STDERR וכשל כתיבה לאחד מהם הוא כבר תנאי שמסיים את התוכנית. בדקו את ערך ההחזרה כאשר כותבים לקובץ, pipe, או סוקט שבהם כתיבות חלקיות ו־pipes שבורים חשובים.

print $fh @records
    or die "write to $path failed: $!";

מטפל קובץ ברירת־מחדל, מפרידים ברירת־מחדל#

שלושה פיסות מצב גלובלי מעצבות כל קריאה ל־print:

מטפל הקובץ הנבחר כעת, ניתן לשינוי באמצעות select. print LIST (ללא מטפל קובץ מפורש) כותב לשם. בתחילת התוכנית זהו STDOUT.
$, - מפריד שדות הפלט, מוכנס בין פריטי הרשימה. ברירת המחדל היא המחרוזת הריקה, כך ש־print 1, 2, 3 מפיק 123, לא 1 2 3. ידוע גם בשם $OFS תחת use English.
$\ - מפריד רשומות הפלט, מצורף לאחר הרשימה כולה. ברירת המחדל היא המחרוזת הריקה, כך ש־print אינו מוסיף שורה חדשה. ידוע גם בשם $ORS תחת use English.

קביעת שניהם נותנת סמנטיקת print דמוית־Python:

local $, = " ";
local $\ = "\n";
print 1, 2, 3;          # "1 2 3\n"

השתמשו ב־local כשמשנים אותם בתוך תת־שגרה כך שהשינוי לא ידלוף לקורא.

say הוא בדיוק print עם $\ המאולץ ל־"\n" עבור אותה קריאה אחת - בחרו בו כשרוצים שורה חדשה בכל פעם ולא רוצים לגעת ב־$\.

דוגמאות#

כתיבה בסיסית ל־STDOUT:

print "hello, world\n";

כתיבה למטפל קובץ באמצעות צורת האובייקט העקיף. שימו לב: ללא פסיק בין מטפל הקובץ לרשימה:

open my $fh, ">", "out.txt" or die $!;
print $fh "line 1\n", "line 2\n";
close $fh;

כתיבה למטפל קובץ המוחזק בביטוי. כל מטפל קובץ מורכב יותר מ־bareword או סקלר פשוט זקוק לצורת בלוק {EXPR}:

my @logs = (\*STDOUT, \*STDERR);
print { $logs[$level] } "message\n";

צירוף פריטי רשימה עם $, וסיום הרשומה עם $\:

local $, = ", ";
local $\ = ".\n";
print "apples", "pears", "plums";   # "apples, pears, plums.\n"

רשימה המכילה undef - כל undef מומר למחרוזת הריקה ומפעיל אזהרת uninitialized תחת use warnings:

use warnings;
my $x;
print "value=", $x, "\n";           # "value=\n" plus a warning

הקשר רשימה לעומת הקשר סקלר. @arr במיקום LIST מתפרש לאלמנטים שלו; עטפו ב־scalar כדי להדפיס את המונה במקום:

my @arr = (10, 20, 30);
print @arr, "\n";                   # "102030\n"
print scalar @arr, "\n";            # "3\n"

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

no warnings 'uninitialized';
print join(",", @row), "\n";        # empty fields render as ""

מקרי קצה#

ללא ארגומנטים: print; מדפיס את $_ למטפל הנבחר. בשימוש אידיומטי בתוך while (<>) { print; }.
העמימות בין מטפל־קובץ לארגומנט־ראשון: Perl מחליט האם הטוקן הראשון הוא מטפל קובץ לפי הפרסור, לא לפי טיפוס זמן־הריצה. bareword או משתנה סקלרי פשוט שמיד אחריו בא איבר (ללא פסיק) נתפס כמטפל קובץ:
```
print STDERR "oops\n";            # STDERR is the filehandle
print $fh "oops\n";               # $fh is the filehandle
```
ביטוי שמחזיר מטפל קובץ אינו עובד באותו מיקום - print $handles[0] "x" הוא שגיאת תחביר. השתמשו בצורת הבלוק: print { $handles[0] } "x".

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

print localtime(), "\n";          # prints nine numbers, no spaces
print scalar localtime(), "\n";   # prints the familiar date string

print (…) מתפרסר כקריאת פונקציה. print (2+3)*4 מדפיס 5, ואז משליך את *4. עטפו את כל רשימת הארגומנטים בסוגריים, או הקדימו ב־+:
```
print((2+3)*4);                   # prints 20
print +(2+3)*4;                   # prints 20
```
מטפל קובץ סגור: מחזיר undef וקובע את $! ל־"Bad file descriptor". תחת use warnings נפלטת אזהרת print() on closed filehandle.
שכבות קידוד: print כותב את מה שמחסנית PerlIO של המטפל אומרת לכתוב. אם למטפל יש שכבת :utf8 או :encoding(...), מחרוזות מקודדות בדרכן החוצה. מטפלים במצב־בתים מצפים למחרוזות בתים; העברת מחרוזת תווים רחבים כותבת נקודות קוד גולמיות ופולטת אזהרת Wide character in print.
Autoflush: print משתמש ב־buffering דרך PerlIO. קבעו את $| על המטפל הנבחר כדי לעשות flush לאחר כל כתיבה - צורך נפוץ עבור פלט התקדמות על pipes או כשמתאמים עם תהליך אחר:
```
$| = 1;                           # autoflush current handle
```
הדפסה ל־pipe או לסוקט סגורים מעלה SIGPIPE. פעולת ברירת המחדל היא לסיים את התהליך; התקינו מטפל ($SIG{PIPE} = 'IGNORE' או sub) כדי להפוך זאת לכשל כתיבה רגיל שניתן לבדוק.

הבדלים מ־upstream#

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

ראו גם#

say - print עם $\ המאולץ ל־"\n" עבור הקריאה; השתמשו בו כאשר כל רשומה מסתיימת בשורה חדשה
printf - אותם כללי יעד כמו print, אך הארגומנט הראשון הוא מחרוזת פורמט של sprintf ו־$\ אינו מצורף
sprintf - בנו את המחרוזת המפורמטת מבלי לכתוב אותה; שלבו עם print כשרוצים לרשום אותה למקום אחר תחילה
select - שנו לאיזה מטפל קובץ הצורה ללא־ארגומנטים של print כותבת
$, - מפריד שדות הפלט המוכנס בין פריטי הרשימה
$\ - מפריד רשומות הפלט המצורף לאחר הרשימה
$| - דגל autoflush עבור המטפל הנבחר כעת