זוהי הפקודה perlfaq8 שניתן להפעיל בספק האירוח החינמי של OnWorks באמצעות אחת מתחנות העבודה המקוונות המרובות שלנו, כגון Ubuntu Online, Fedora Online, אמולטור מקוון של Windows או אמולטור מקוון של MAC OS
תָכְנִית:
שֵׁם
perlfaq8 - מערכת אינטראקציה
גִרְסָה
גרסה 5.021009
תיאור
חלק זה של השאלות הנפוצות של Perl מכסה שאלות הקשורות לאינטראקציה עם מערכת ההפעלה.
הנושאים כוללים תקשורת בין תהליכים (IPC), שליטה על ממשק המשתמש
(מקלדת, מסך והתקני הצבעה), ובעיקר כל דבר אחר שאינו קשור לנתונים
מניפולציה.
קרא את השאלות הנפוצות והתיעוד הספציפיים ליציאה של perl למערכת ההפעלה שלך (למשל,
perlvms, perlplan9, ...). אלה צריכים להכיל מידע מפורט יותר על הגחמות
של הפרל שלך.
איך do I למצוא הַחוּצָה אשר פועל מערכת אני ריצה תַחַת?
המשתנה $^O ($OSNAME אם אתה משתמש ב-"אנגלית") מכיל אינדיקציה של השם של
מערכת הפעלה (לא מספר השחרור שלה) שעבורה נבנה ה-perl הבינארי שלך.
איך איך exec () לא לַחֲזוֹר?
(תרומה מאת brian d foy)
תפקיד הפונקציה "exec" הוא להפוך את התהליך שלך לפקודה אחרת ולעולם לא לעשות זאת
לַחֲזוֹר. אם זה לא מה שאתה רוצה לעשות, אל תשתמש ב-exec. :)
אם אתה רוצה להפעיל פקודה חיצונית ועדיין להמשיך את תהליך ה-Perl שלך, עיין ב-a
צינור "פתוח", "מזלג" או "מערכת".
איך do I do אשליה דברים עם מה היא מקלדת/מסך/עכבר?
האופן שבו אתה ניגש/שולט במקלדות, במסכים ובמכשירי הצבעה ("עכברים") הוא מערכת-
תלוי. נסה את המודולים הבאים:
מקלדת
מונח:: התפלגות פרל סטנדרטית
מונח::ReadKey CPAN
Term::ReadLine::Gnu CPAN
Term::ReadLine::Perl CPAN
טווח:: CPAN למסך
מסך
מונח:: התפלגות פרל סטנדרטית
מקלל את CPAN
טווח::ANSIColor CPAN
עכבר
Tk CPAN
Wx CPAN
Gtk2 CPAN
חבילת Qt4 kdebindings4
חלק מהמקרים הספציפיים הללו מוצגים כדוגמאות בתשובות אחרות בחלק זה של ה
perlfaq.
איך do I הדפסה משהו הַחוּצָה in צֶבַע?
באופן כללי, אתה לא, כי אתה לא יודע אם לנמען יש מודע לצבע
מכשיר תצוגה. אם אתה יודע שיש להם מסוף ANSI שמבין צבע, אתה
יכול להשתמש במודול Term::ANSIColor מ-CPAN:
השתמש במונח::ANSIColor;
print color("אדום"), "עצור!\n", color("reset");
print color("ירוק"), "לך!\n", color("reset");
או ככה:
השתמש במונח::ANSIColor qw(:constants);
הדפס אדום, "עצור!\n", איפוס;
הדפס ירוק, "לך!\n", RESET;
איך do I לקרוא רק אחד מפתח לְלֹא המתנה ל a לַחֲזוֹר מַפְתֵחַ?
שליטה באגירת קלט היא עניין תלוי מערכת להפליא. במערכות רבות, אתה
פשוט יכול להשתמש ב- stty הפקודה כפי שמוצג ב-"getc" ב-perlfunc, אבל כפי שאתה רואה, זהו
כבר מכניס אותך לבעיות ניידות.
open(TTY, "+
מערכת "stty cbreak /dev/tty 2>&1";
$key = getc(TTY); # אולי זה עובד
# אחרת
sysread(TTY, $key, 1); # כנראה שכן
מערכת "stty -cbreak /dev/tty 2>&1";
מודול Term::ReadKey מ-CPAN מציע ממשק קל לשימוש שאמור להיות יותר
יעיל מאשר להפגיז stty עבור כל מפתח. זה אפילו כולל תמיכה מוגבלת עבור
של Windows.
השתמש במונח::ReadKey;
ReadMode('cbreak');
$key = קריאה(0);
ReadMode('normal');
עם זאת, השימוש בקוד מחייב שיהיה לך מהדר C עובד ותוכל להשתמש בו
לבנות ולהתקין מודול CPAN. הנה פתרון באמצעות מודול POSIX הסטנדרטי, אשר
כבר במערכת שלך (בהנחה שהמערכת שלך תומכת ב-POSIX).
השתמש במקש קיצור;
$key = readkey();
והנה מודול "המפתח החם", שמסתיר את הקריאות המסומנות במקצת למניפולציה
מבני ה-POSIX termios.
# מקש חם.pm
חבילה HotKey;
השתמש מחמירים;
להשתמש באזהרות;
השתמש בהורה 'יצואן';
@EXPORT שלנו = qw(cbreak cooked readkey);
השתמש ב-POSIX qw(:termios_h);
my ($term, $oterm, $echo, $noecho, $fd_stdin);
$fd_stdin = fileno(STDIN);
$term = POSIX::Termios->new();
$term->getattr($fd_stdin);
$oterm = $term->getlflag();
$echo = ECHO | ECHOK | ICANON;
$noecho = $oterm & ~$echo;
sub cbreak {
$term->setlflag($noecho); # בסדר, אז גם אני לא רוצה הד
$term->setcc(VTIME, 1);
$term->setattr($fd_stdin, TCSANOW);
}
תת מבושל {
$term->setlflag($oterm);
$term->setcc(VTIME, 0);
$term->setattr($fd_stdin, TCSANOW);
}
מפתח קריאה משנה {
ה-$key שלי = '';
cbreak();
sysread(STDIN, $key, 1);
מְבוּשָׁל();
החזר מפתח $;
}
END { cooked() }
1;
איך do I לבדוק אם קלט is מוכן on מה היא מקלדת?
הדרך הקלה ביותר לעשות זאת היא לקרוא מפתח במצב לא חסימה עם Term::ReadKey
מודול מ-CPAN, מעביר לו ארגומנט של -1 כדי לציין לא לחסום:
השתמש במונח::ReadKey;
ReadMode('cbreak');
if ( מוגדר (my $char = ReadKey(-1)) ) {
# קלט חיכה וזה היה $char
אחר} {
# שום קלט לא חיכה
}
ReadMode('normal'); # שחזר הגדרות tty רגילות
איך do I ברור מה היא מָסָך?
(תרומה מאת brian d foy)
כדי לנקות את המסך, אתה רק צריך להדפיס את הרצף המיוחד שמספר למסוף
כדי לנקות את המסך. ברגע שיש לך את הרצף הזה, פלט אותו כאשר אתה רוצה לנקות את
מסך.
אתה יכול להשתמש במודול Term::ANSIScreen כדי לקבל את הרצף המיוחד. ייבא את ה"cls"
פונקציה (או תג ":screen"):
השתמש במונח::ANSIScreen qw(cls);
my $clear_screen = cls();
הדפס $clear_screen;
מודול Term::Cap יכול גם לקבל את הרצף המיוחד אם אתה רוצה להתמודד עם הנמוך-
פרטים ברמה של בקרת מסוף. שיטת "Tputs" מחזירה את המחרוזת עבור הנתון
יכולת:
השתמש במונח::Cap;
my $terminal = Term::Cap->Tgetent( { OSPEED => 9600 } );
my $clear_string = $terminal->Tputs('cl');
הדפס $clear_screen;
ב-Windows, אתה יכול להשתמש במודול Win32::Console. לאחר יצירת אובייקט עבור הפלט
filehandle שאתה רוצה להשפיע, קרא לשיטת "Cls":
Win32::Console;
my $OUT = Win32::Console->new(STD_OUTPUT_HANDLE);
my $clear_string = $OUT->Cls;
הדפס $clear_screen;
אם יש לך תוכנית שורת פקודה שעושה את העבודה, אתה יכול לקרוא לה ב-backticks אל
ללכוד את כל מה שהוא מוציא כדי שתוכל להשתמש בו מאוחר יותר:
my $clear_string = `נקה`;
הדפס $clear_string;
איך do I לקבל מה היא מסך גודל?
אם מותקן Term::ReadKey מודול מ-CPAN, אתה יכול להשתמש בו כדי להביא את הרוחב
וגובה בתווים ובפיקסלים:
השתמש במונח::ReadKey;
my ($wchar, $hchar, $wpixels, $hpixels) = GetTerminalSize();
זה יותר נייד מה-"ioctl" הגולמי, אבל לא להמחשה:
דורש 'sys/ioctl.ph';
למות "ללא TIOCGWINSZ " אלא אם הוגדר &TIOCGWINSZ;
open(my $tty_fh, "+
אלא אם כן (ioctl($tty_fh, &TIOCGWINSZ, $winsize='')) {
die sprintf "$0: ioctl TIOCGWINSZ (%08x: $!)\n", &TIOCGWINSZ;
}
my ($row, $col, $xpixel, $ypixel) = unpack('S4', $winsize);
print "(row,col) = ($row,$col)";
הדפס "(xpixel,ypixel) = ($xpixel,$ypixel)" אם $xpixel || $ypixel;
הדפס "\n";
איך do I לשאול מה היא המשתמש ל a סיסמה?
(לשאלה זו אין שום קשר לאינטרנט. עיין בשאלות נפוצות אחרות עבור זה.)
יש דוגמה לכך ב"קריפטה" ב-perlfunc). ראשית, אתה מכניס את המסוף ל"לא
echo", ואז פשוט קרא את הסיסמה כרגיל. אתה יכול לעשות זאת בסגנון ישן
פונקציית "ioctl()", בקרת מסוף POSIX (ראה POSIX או התיעוד שלו ה-Camel
ספר), או שיחה אל stty תוכנית, עם דרגות שונות של ניידות.
אתה יכול גם לעשות זאת עבור רוב המערכות באמצעות מודול Term::ReadKey מ-CPAN, כלומר
קל יותר לשימוש ובתיאוריה נייד יותר.
השתמש במונח::ReadKey;
ReadMode('noecho');
ה-$password שלי = קריאת שורה(0);
איך do I לקרוא ו לכתוב מה היא סידורי נמל?
זה תלוי באיזו מערכת הפעלה התוכנית שלך פועלת. במקרה של יוניקס,
היציאות הטוריות יהיו נגישות דרך קבצים ב"/ dev"; במערכות אחרות, התקן
אין ספק שהשמות יהיו שונים. ישנם מספר אזורים בעייתיים המשותפים לכל האינטראקציה עם המכשיר
הבא:
קבצי נעילה
המערכת שלך עשויה להשתמש בקבצי נעילה כדי לשלוט בגישה מרובה. הקפד לעקוב אחר ה
פרוטוקול נכון. התנהגות בלתי צפויה יכולה לנבוע מקריאת תהליכים מרובים
ממכשיר אחד.
מצב פתוח
אם אתה מצפה להשתמש בפעולות קריאה וכתיבה במכשיר, תצטרך לפתוח
זה לעדכון (ראה "פתוח" ב-perlfunc לפרטים). אולי תרצה לפתוח אותו בלי
מסתכן בחסימה באמצעות "sysopen()" ו-"O_RDWR|O_NDELAY|O_NOCTTY" מ-
מודול Fcntl (חלק מהפצת perl הסטנדרטית). ראה "sysopen" ב-perlfunc
למידע נוסף על גישה זו.
סוף השורה
חלק מהמכשירים יצפו ל-"\r" בסוף כל שורה ולא "\n". ב
חלק מהיציאות של perl, "\r" ו-"\n" שונות מערכי ה-ASCII הרגילים שלהם (Unix)
של "\015" ו-"\012". ייתכן שיהיה עליך לתת את הערכים המספריים הרצויים ישירות, באמצעות
אוקטלי ("\015"), hex ("0x0D"), או כמפרט תו בקרה ("\cM").
הדפס DEV "atv1\012"; # שגוי, עבור מכשירים מסוימים
הדפס DEV "atv1\015"; # נכון, עבור מכשירים מסוימים
למרות שבקובצי טקסט רגילים, "\n" יעשה את העבודה, עדיין אין מאוחד
ערכת סיום קו הנייד בין Unix, DOS/Win ומקינטוש,
למעט לסיום הכל השורה מסתיימת ב-"\015\012", והסר את מה שאינך צריך ממנו
הפלט. זה חל במיוחד על שקע קלט/פלט ושטיפה אוטומטית, שנדון בהמשך.
פלט שטיפה
אם אתה מצפה שתווים יגיעו למכשיר שלך כשאתה "מדפיס()" אותם, תרצה
שטוף אוטומטי את ידית הקובץ. אתה יכול להשתמש ב-"select()" וב-$| משתנה לשליטה
שטיפה אוטומטית (ראה "$|" ב-perlvar ו-"select" ב-perlfunc, או perlfaq5, "How do I
לשטוף/להתחזק ידית קובץ פלט? למה אני חייב לעשות את זה?"):
my $old_handle = select($dev_fh);
$| = 1;
select($old_handle);
תראה גם קוד שעושה זאת ללא משתנה זמני, כמו ב
select((select($deb_handle), $| = 1)[0]);
או אם לא אכפת לך למשוך כמה אלפי שורות קוד רק בגלל שאתה
מפחד מקצת $| מִשְׁתַנֶה:
השתמש ב-IO::Handle;
$dev_fh->שטיפה אוטומטית(1);
כפי שהוזכר בפריט הקודם, זה עדיין לא עובד בעת שימוש ב-Socket I/O
בין יוניקס למקינטוש. תצטרך לקוד קשיח את מסימי הקו שלך, בזה
מקרה.
קלט לא חוסם
אם אתה מבצע חסימת "read()" או "sysread()", תצטרך לארגן
מטפל באזעקה כדי לספק פסק זמן (ראה "אזעקה" ב-perlfunc). אם יש לך לא-
חסימת פתיחה, סביר להניח שתהיה לך קריאה לא חוסמת, מה שאומר שאולי תצטרך להשתמש
4-arg "select()" כדי לקבוע אם I/O מוכן במכשיר זה (ראה "בחר" ב
perlfunc.
בעודו מנסה לקרוא מתיבת המתקשר שלו, את ג'יימי זווינסקי הידוע לשמצה
"<[מוגן בדוא"ל]>", אחרי הרבה חריקות שיניים ולחימה עם "sysread", "sysopen",
עסקי ה-"tcgetattr" של POSIX, ועוד פונקציות שונות שמתפרצות בלילה,
סוף סוף עלה על זה:
sub open_modem {
השתמש ב-IPC::Open2;
$stty שלי = `/ bin / stty -g`;
open2( \*MODEM_IN, \*MODEM_OUT, "cu -l$modem_device -s2400 2>&1");
# מתחילים את הגדרות stty של /dev/tty של cu, גם כאשר יש
# נפתח על צינור...
מערכת("/ bin / stty $stty");
$_ = ;
chomp;
if ( !m/^Connected/ ) {
print STDERR "$0: cu הודפס `$_' במקום `מחוברים'\n";
}
}
איך do I לְפַעֲנֵחַ מוצפן סיסמא קבצים?
אתה מוציא המון המון כסף על חומרה ייעודית, אבל זה בטוח יביא אותך
דיברו על.
ברצינות, אתה לא יכול אם הם קבצי סיסמאות יוניקס - מערכת הסיסמאות של יוניקס משתמשת
הצפנה חד כיוונית. זה יותר כמו hashing מאשר הצפנה. הכי טוב שאתה יכול לעשות זה לבדוק
האם משהו אחר מתחזק לאותה מחרוזת. אתה לא יכול להפוך גיבוב חזרה ל-
מחרוזת מקורית. תוכניות כמו קראק יכולות בכוח (ותבונה) לנסות לנחש
סיסמאות, אך אינן (לא יכולות) להבטיח הצלחה מהירה.
אם אתה חושש שמשתמשים יבחרו סיסמאות גרועות, עליך לבדוק באופן יזום מתי
הם מנסים לשנות את הסיסמה שלהם (על ידי שינוי פסח(1), למשל).
איך do I התחלה a תהליך in מה היא רקע כללי?
(תרומה מאת brian d foy)
אין דרך אחת להריץ קוד ברקע כך שלא תצטרך לחכות שזה יצליח
סיים לפני שהתוכנית שלך עוברת למשימות אחרות. ניהול תהליכים תלוי בכם
מערכת הפעלה מסוימת, ורבות מהטכניקות מכוסות ב-perlipc.
מספר מודולי CPAN עשויים לעזור, כולל IPC::Open2 או IPC::Open3, IPC::Run,
Parallel::Jobs, Parallel::ForkManager, POE, Proc::Background ו-Win32::Process. שם
ישנם מודולים רבים אחרים שאתה עשוי להשתמש בהם, אז בדוק גם את מרחבי השמות האלה עבור אפשרויות אחרות.
אם אתה משתמש במערכת דמוית יוניקס, ייתכן שתוכל להתחמק בשיחת מערכת לאן
אתה שם "&" בסוף הפקודה:
system("cmd &")
אתה יכול גם לנסות להשתמש ב"מזלג", כפי שמתואר ב-perlfunc (למרות שזה אותו דבר
שרבים מהמודולים יעשו עבורך).
STDIN, STDOUT ו-STDERR משותפים
גם התהליך המרכזי וגם התהליך הרקע (תהליך ה"ילד") חולקים אותו הדבר
ידיות קבצים מסוג STDIN, STDOUT ו-STDERR. אם שניהם מנסים לגשת אליהם בבת אחת, מוזר
דברים יכולים לקרות. ייתכן שתרצה לסגור או לפתוח אותם מחדש עבור הילד. אתה יכול לקבל
סביב זה עם "פתיחת" צינור (ראה "פתוח" ב-perlfunc) אבל במערכות מסוימות זה
פירושו שתהליך הילד אינו יכול להאריך ימים יותר מההורה.
אותות
תצטרך לתפוס את האות SIGCHLD, ואולי גם SIGPIPE. SIGCHLD נשלח
כאשר התהליך ברקע מסתיים. SIGPIPE נשלח כאשר אתה כותב ל- filehandle
שתהליך הצאצא שלו נסגר (SIGPIPE לא נלכד יכול לגרום לתוכנית שלך
למות בשקט). זו לא בעיה עם "system("cmd&").
זומבים
אתה צריך להיות מוכן "לקצור" את תהליך הילד כשהוא מסתיים.
$SIG{CHLD} = sub { wait };
$SIG{CHLD} = 'התעלם';
אפשר גם להשתמש במזלג כפול. אתה מיד "מחכה()" לילד הראשון שלך, וה-
init daemon "יחכה()" לנכדך ברגע שהוא ייצא.
אלא אם כן ($pid = מזלג) {
אלא אם כן (מזלג) {
exec "מה אתה באמת רוצה לעשות";
למות "המנהל נכשל!";
}
יציאה 0;
}
waitpid($pid, 0);
ראה "אותות" ב-perlipc לדוגמאות אחרות של קוד לעשות זאת. זומבים הם לא
בעיה עם "system("prog &").
איך do I מלכודת לִשְׁלוֹט תווים/אותות?
אתה בעצם לא "לוכד" דמות בקרה. במקום זאת, הדמות הזו מייצרת אות
אשר נשלחת לקבוצת התהליכים המופיעה כעת בחזית הטרמינל שלך, שאותה אתה מלכוד
בתהליך שלך. האותות מתועדים ב"אותות" ב-perlipc ובסעיף על
"אותות" בגמל.
אתה יכול להגדיר את הערכים של ה-%SIG hash להיות הפונקציות שברצונך לטפל באות.
לאחר ש-perl קולט את האות, הוא מחפש ב-%SIG מפתח בעל שם זהה לזה
אות, ואז קורא לערך המשנה של המפתח הזה.
# כתת-שגרה אנונימית
$SIG{INT} = sub { syswrite(STDERR, "ouch\n", 5 ) };
# או הפניה לפונקציה
$SIG{INT} = \&ouch;
# או שם הפונקציה כמחרוזת
$SIG{INT} = "אאוץ'";
גרסאות Perl לפני 5.8 היו בקוד המקור C שלה מטפלי אותות שיתפסו את
לאות ואולי להפעיל פונקציית Perl שהגדרת ב-%SIG. זה הפר את הכללים
של טיפול באותות באותה רמה שגורם ל-perl לזרוק ליבה. מאז גרסה 5.8.0, perl
מסתכל על %SIG לאחר האות נתפס, ולא בזמן שהוא נתפס.
גרסאות קודמות של תשובה זו היו שגויות.
איך do I לשנות מה היא צל סיסמא פילה on a יוניקס מערכת?
אם perl הותקן כהלכה וספריית הצללים שלך נכתבה כהלכה, ה-
פונקציות "getpw*()" המתוארות ב-perlfunc אמורות לספק גישה (לקריאה בלבד) ל
ערכים בקובץ סיסמת הצל. כדי לשנות את הקובץ, צור קובץ סיסמת צל חדש
(הפורמט משתנה ממערכת למערכת - ראה פסח(1) לפרטים) ולשימוש pwd_mkdb(8)
להתקין אותו (ראה pwd_mkdb(8) לפרטים נוספים).
איך do I סט מה היא זמן ו תַאֲרִיך?
בהנחה שאתה פועל תחת הרשאות מספיקות, אתה אמור להיות מסוגל להגדיר את
תאריך ושעה כלל המערכת על ידי הפעלת ה נתונים(1) תוכנית. (אין דרך להגדיר את השעה
ותאריך על בסיס לכל תהליך.) מנגנון זה יעבוד עבור Unix, MS-DOS, Windows ו-
נ"ט; המקבילה ל-VMS היא "זמן מוגדר".
עם זאת, אם כל מה שאתה רוצה לעשות הוא לשנות את אזור הזמן שלך, אתה כנראה יכול לברוח
הגדרת משתנה סביבה:
$ENV{TZ} = "MST7MDT"; # יוניקסיש
$ENV{'SYS$TIMEZONE_DIFFERENTIAL'}="-5" # vms
system('trn', 'comp.lang.perl.misc');
איך יכול I שינה () or אזעקה() ל תחת a שְׁנִיָה?
אם אתה רוצה גרעיניות עדינה יותר מהשנייה שהפונקציה "sleep()" מספקת, ה-
הדרך הקלה ביותר היא להשתמש בפונקציה "select()" כפי שמתועדת ב-"select" ב-perlfunc. לְנַסוֹת
מודולי Time::HiRes וה-BSD::Itimer (זמינים מ-CPAN, ומתחילים מ-Perl
5.8 Time::HiRes הוא חלק מההפצה הסטנדרטית).
איך יכול I למדוד זמן תחת a שְׁנִיָה?
(תרומה מאת brian d foy)
מודול Time::HiRes (חלק מההפצה הסטנדרטית נכון ל-Perl 5.8) מודד זמן
עם קריאת המערכת "gettimeofday()", המחזירה את הזמן במיקרו-שניות מאז ה-
תְקוּפָה. אם אינך יכול להתקין את Time::HiRes עבור Perls ישנים יותר ואתה על מערכת Unixish,
אולי תוכל להתקשר השעות היום(2) ישירות. ראה "syscall" ב-perlfunc.
איך יכול I do an Atexit () or setjmp()/longjmp()? (יוצא מן הכלל טיפול)
אתה יכול להשתמש בבלוק "END" כדי לדמות "ateexit()". בלוק "END" של כל חבילה נקרא
כאשר התוכנית או השרשור מסתיימים. ראה את דף היד של perlmod לפרטים נוספים על "END"
בלוקים.
לדוגמה, אתה יכול להשתמש בזה כדי לוודא שתוכנית הסינון שלך הצליחה לסיים אותה
פלט מבלי למלא את הדיסק:
END {
close(STDOUT) || die "stdout close נכשל: $!";
}
הבלוק "END" לא נקרא כאשר אותות לא נלכדים הורגים את התוכנית, אז אם אתה
השתמש בלוקים "END" שאתה צריך גם להשתמש
השתמש ב-sigtrap qw(die normal-signals);
מנגנון הטיפול בחריגים של Perl הוא האופרטור "eval()" שלו. אתה יכול להשתמש ב-"eval()" בתור
"setjmp" ו-"die()" בתור "longjmp". לפרטים על כך, עיין בסעיף האותות,
במיוחד המטפל פסק זמן עבור "flock()" חוסם ב-"Signals" ב-perlipc או ב-
סעיף על "אותות" ב תכנות פרל.
אם הטיפול בחריגים הוא כל מה שאתה מעוניין בו, השתמש באחד ממודולי ה-CPAN הרבים
לטפל בחריגים, כגון Try::Tiny.
אם אתה רוצה את התחביר "atexit()" (וגם "rmexit()", נסה את המודול "AtExit"
זמין מ-CPAN.
למה לא my ארובות התוכנית לעבוד תחת מערכת V (סולאריס)? מה עושה מה היא שגיאה הודעה
"נוהל לֹא נתמך" אומר?
כמה מערכות מבוססות Sys-V, במיוחד Solaris 2.X, הגדירו מחדש חלק מהשקע הסטנדרטי
קבועים. מכיוון שהן היו קבועות בכל הארכיטקטורות, הן היו מקובלות לרוב
לתוך קוד perl. הדרך הנכונה להתמודד עם זה היא "להשתמש ב-Socket" כדי לקבל את הנכון
ערכים.
שימו לב שלמרות ש-SunOS ו-Solaris תואמות בינאריות, ערכים אלו שונים.
לך תבין.
איך יכול I שיחה my המערכת של ייחודי C פונקציות החל מ- פרל?
ברוב המקרים, אתה כותב מודול חיצוני כדי לעשות זאת - ראה את התשובה ל"איפה אני יכול ללמוד
לגבי קישור C עם Perl? [h2xs, xsubpp]". עם זאת, אם הפונקציה היא קריאת מערכת,
והמערכת שלך תומכת ב-"syscall()", אתה יכול להשתמש בפונקציה "syscall" (מתועדת ב
perlfunc).
זכור לבדוק את המודולים שהגיעו עם ההפצה שלך, וגם את CPAN - מישהו
יכול להיות שכבר כתב מודול לעשות את זה. ב-Windows, נסה את Win32::API. במחשבי Mac, נסה
Mac::פחמן. אם לאף מודול אין ממשק לפונקציית C, אתה יכול להכניס מעט מ-C פנימה
מקור Perl שלך עם Inline::C.
איפה do I לקבל מה היא לכלול קבצים ל do ioctl() or syscall()?
מבחינה היסטורית, אלה יופקו על ידי הכלי h2ph, חלק מה-perl הסטנדרטי
הפצה. תוכנית זו ממירה cpp(1) הנחיות בקבצי כותרות C לקבצים
המכיל הגדרות של תת-שגרה, כמו "SYS_getitimer()", שבהן אתה יכול להשתמש כארגומנטים
לפונקציות שלך. זה לא עובד בצורה מושלמת, אבל זה בדרך כלל עושה את רוב העבודה.
קבצים פשוטים כמו errno.h, syscall.h, ו socket.h היו בסדר, אבל הקשים אוהבים
ioctl.h כמעט תמיד צריך לערוך ביד. הנה איך להתקין את קבצי *.ph:
1. הפוך למשתמש-על
2. תקליטור / usr / include
3. h2ph *.h */*.h
אם המערכת שלך תומכת בטעינה דינמית, מסיבות של ניידות ושפיות אתה
כנראה צריך להשתמש ב-h2xs (גם חלק מהתפלגות ה-perl הסטנדרטית). הכלי הזה
ממיר קבצי כותרות C להרחבות Perl. ראה perlxstut כיצד להתחיל עם
h2xs.
אם המערכת שלך לא תומכת בטעינה דינמית, אתה עדיין כנראה צריך להשתמש ב-h2xs. לִרְאוֹת
perlxstut ו-ExtUtils::MakeMaker למידע נוסף (בקיצור, פשוט השתמש לעשות פרל
במקום מישור לעשות כדי לבנות מחדש את perl עם הרחבה סטטית חדשה).
למה do זמן מוגדר פרל סקריפטים להתלונן על גרעין בעיות?
לחלק ממערכות ההפעלה יש באגים בקרנל שיוצרים סקריפטים של setuid מטבעם
לֹא בָּטוּחַ. Perl נותן לך מספר אפשרויות (מתוארות ב-perlsec) כדי לעקוף כאלה
מערכות.
איך יכול I לפתוח a מקטרת שניהם ל ו החל מ- a פקודה?
מודול IPC::Open2 (חלק מהפצת perl הסטנדרטית) הוא גישה קלה לשימוש
שמשתמש באופן פנימי ב-"pipe()", "fork()" ו-"exec()" כדי לבצע את העבודה. הקפד לקרוא
עם זאת, אזהרות הקיפאון בתיעוד שלה (ראה IPC::Open2). ראה "דו-כיווני
תקשורת עם תהליך אחר" ב-perlipc ו"תקשורת דו-כיוונית עם
את עצמך" ב-perlipc
אתה יכול גם להשתמש במודול IPC::Open3 (חלק מהפצת perl הסטנדרטית), אבל תהיה
הזהיר שיש לו סדר טיעונים שונה מ-IPC::Open2 (ראה IPC::Open3).
למה לא יכול I לקבל מה היא תפוקה of a הפקודה עם מערכת()?
אתה מבלבל בין המטרה של "system()" ו-backticks (``). "system()" מריץ פקודה
ומחזיר מידע על מצב יציאה (כערך של 16 סיביות: 7 הסיביות הנמוכות הן האות
התהליך מת, אם בכלל, ו-8 הביטים הגבוהים הם ערך היציאה בפועל). תווים אחוריים (``)
הרץ פקודה והחזר את מה שהיא שלחה אל STDOUT.
my $exit_status = system("משתמשי דואר");
my $output_string = `ls`;
איך יכול I ללכוד STDERR החל מ- an חיצוני פקודה?
ישנן שלוש דרכים בסיסיות להפעלת פקודות חיצוניות:
מערכת $cmd; # באמצעות system()
שלי $output = `$cmd`; # משתמש ב-backticks (``)
פתוח (my $pipe_fh, "$cmd |"); # באמצעות open()
עם "system()", גם STDOUT וגם STDERR יעברו לאותו מקום כמו STDOUT של הסקריפט ו-
STDERR, אלא אם הפקודה "system()" מפנה אותם מחדש. התקפות אחוריות ו-"open()" קוראים רק
STDOUT של הפקודה שלך.
אתה יכול גם להשתמש בפונקציה "open3()" מ-IPC::Open3. בנימין גולדברג מספק כמה
קוד לדוגמא:
כדי ללכוד את STDOUT של תוכנית, אך למחוק את STDERR שלה:
השתמש ב-IPC::Open3;
השתמש בקובץ::Spec;
שלי $in = '';
open(NULL, ">", File::Spec->devnull);
my $pid = open3($in, \*PH, ">&NULL", "cmd");
בזמן( ) { }
waitpid($pid, 0);
כדי ללכוד את STDERR של תוכנית, אך להשליך את STDOUT שלה:
השתמש ב-IPC::Open3;
השתמש בקובץ::Spec;
שלי $in = '';
open(NULL, ">", File::Spec->devnull);
my $pid = open3($in, ">&NULL", \*PH, "cmd");
בזמן( ) { }
waitpid($pid, 0);
כדי ללכוד את STDERR של תוכנית, ולתת ל-STDOUT שלה לעבור ל-STDERR שלנו:
השתמש ב-IPC::Open3;
שלי $in = '';
my $pid = open3($in, ">&STDERR", \*PH, "cmd");
בזמן( ) { }
waitpid($pid, 0);
כדי לקרוא גם את STDOUT של פקודה וגם את STDERR שלה בנפרד, אתה יכול להפנות אותם ל-temp
קבצים, תן לפקודה לרוץ, ואז קרא את הקבצים הזמניים:
השתמש ב-IPC::Open3;
השתמש ב-IO::File;
שלי $in = '';
local *CATCHOUT = IO::File->new_tmpfile;
local *CATCHERR = IO::File->new_tmpfile;
my $pid = open3($in, ">&CATCHOUT", ">&CATCHERR", "cmd");
waitpid($pid, 0);
חפש $_, 0, 0 עבור \*CATCHOUT, \*CATCHERR;
בזמן( ) {}
בזמן( ) {}
אבל אין צורך אמיתי בזה שניהם להיות tempfiles... הדברים הבאים צריכים לעבוד בדיוק כמו
ובכן, בלי מבוי סתום:
השתמש ב-IPC::Open3;
שלי $in = '';
השתמש ב-IO::File;
local *CATCHERR = IO::File->new_tmpfile;
my $pid = open3($in, \*CATCHOUT, ">&CATCHERR", "cmd");
בזמן( ) {}
waitpid($pid, 0);
חפש CATCHERR, 0, 0;
בזמן( ) {}
וזה גם יהיה מהיר יותר, מכיוון שנוכל להתחיל לעבד את הסטדout של התוכנית באופן מיידי,
במקום לחכות לסיום התוכנית.
עם כל אחד מאלה, אתה יכול לשנות את מתארי הקבצים לפני השיחה:
open(STDOUT, ">logfile");
system("ls");
או שאתה יכול להשתמש בהפניה מחדש של תיאור הקובץ של Bourne:
$output = `$cmd 2>קובץ_כמה`;
open (PIPE, "cmd 2>some_file |");
אתה יכול גם להשתמש בהפניה מחדש של מתאר קבצים כדי להפוך את STDERR לשכפול של STDOUT:
$output = `$cmd 2>&1`;
פתוח (PIPE, "cmd 2>&1 |");
שים לב שאתה לא יכול פשוט פתח את STDERR כדי להיות דופ של STDOUT בתוכנית Perl שלך ו
הימנע מקריאת המעטפת כדי לבצע את ההפניה מחדש. זה לא עובד:
open(STDERR, ">&STDOUT");
$alloutput = `cmd args`; # stderr עדיין בורח
זה נכשל מכיוון שה-"open()" גורם ל-STDERR ללכת למקום שבו STDOUT נסע בזמן של
הפתוח()". ההקפות האחוריות גורמות ל-STDOUT לעבור למחרוזת, אבל אל תשנה את STDERR
(שעדיין הולך ל-STDOUT הישן).
שים לב שאתה צריך השתמש במעטפת בורן (sh(1)) תחביר ניתוב מחדש ב-backticks, לא CSH(1)!
פרטים על הסיבה שה-"system()" של Perl וה-backtick and pipe נפתחים כולם משתמשים במעטפת Bourne
ב לעומת/csh.whynot מאמר באוסף "הרבה יותר ממה שאי פעם רצית לדעת".
בhttp://www.cpan.org/misc/olddoc/FMTEYEWTK.tgz> . כדי ללכוד את STDERR ו- של פקודה
STDOUT ביחד:
$output = `cmd 2>&1`; # או עם סימנים אחוריים
$pid = open(PH, "cmd 2>&1 |"); # או עם צינור פתוח
בזמן ( ) { } # פלוס קריאה
כדי ללכוד את STDOUT של פקודה אך למחוק את STDERR שלה:
$output = `cmd 2>/dev/null`; # או עם סימנים אחוריים
$pid = open(PH, "cmd 2>/dev/null |"); # או עם צינור פתוח
בזמן ( ) { } # פלוס קריאה
כדי ללכוד את STDERR של פקודה אך למחוק את STDOUT שלה:
$output = `cmd 2>&1 1>/dev/null`; # או עם סימנים אחוריים
$pid = open(PH, "cmd 2>&1 1>/dev/null |"); # או עם צינור פתוח
בזמן ( ) { } # פלוס קריאה
להחליף את STDOUT ו-STDERR של פקודה כדי ללכוד את ה-STDERR אבל לעזוב את הפקודה שלו
STDOUT לצאת STDERR הישן שלנו:
$output = `cmd 3>&1 1>&2 2>&3 3>&-`; # או עם סימנים אחוריים
$pid = open(PH, "cmd 3>&1 1>&2 2>&3 3>&-|");# או עם צינור פתוח
בזמן ( ) { } # פלוס קריאה
כדי לקרוא גם את STDOUT של פקודה וגם את STDERR שלה בנפרד, הכי קל לנתב אותם מחדש
בנפרד לקבצים, ולאחר מכן קרא מהקבצים האלה כשהתוכנית מסתיימת:
system("program args 1>program.stdout 2>program.stderr");
ההזמנה חשובה בכל הדוגמאות הללו. זה בגלל שהמעטפת מעבדת את הקובץ
הפניות מחדש של מתאר בסדר משמאל לימין.
system("prog args 1>tmpfile 2>&1");
system("prog args 2>&1 1>tmpfile");
הפקודה הראשונה שולחת גם שגיאה רגילה החוצה וגם שגיאה רגילה לקובץ הזמני. ה
הפקודה השנייה שולחת לשם רק את הפלט הסטנדרטי הישן, ושגיאת התקן הישנה מופיעה
על התקן הישן החוצה.
למה לא לִפְתוֹחַ() לַחֲזוֹר an שגיאה מתי a מקטרת לפתוח נכשל?
אם הארגומנט השני ל-"open()" בצינור מכיל תווי מעטפת, perl "fork()"s,
ואז "exec()"sa shell כדי לפענח את המטא-תווים ובסופו של דבר להפעיל את הרצוי
תכנית. אם לא ניתן היה להפעיל את התוכנית, המעטפת היא זו שמקבלת את ההודעה, לא Perl.
כל מה שתוכנית Perl שלך יכולה לגלות הוא אם המעטפת עצמה יכולה להצליח
התחיל. אתה עדיין יכול ללכוד את STDERR של המעטפת ולבדוק אם יש הודעות שגיאה. לִרְאוֹת
"איך אני יכול ללכוד STDERR מפקודה חיצונית?" במקום אחר במסמך זה, או להשתמש
מודול IPC::Open3.
אם אין תווי מעטפת בארגומנט של "open()", Perl מפעיל את הפקודה
ישירות, מבלי להשתמש במעטפת, ויכול לדווח נכון אם הפקודה התחילה.
מה זה לא נכון עם באמצעות תיקונים אחוריים in a לבטל את הֶקשֵׁר?
למהדרין, כלום. מבחינה סגנונית, זו לא דרך טובה לכתוב
קוד שניתן לתחזוקה. לפרל יש מספר אופרטורים להפעלת פקודות חיצוניות. אחוריים הם
אחד; הם אוספים את הפלט מהפקודה לשימוש בתוכנית שלך. המערכת"
פונקציה היא אחרת; זה לא עושה את זה.
כתיבת סימנים לאחור בתוכנית שלך שולחת מסר ברור לקוראי הקוד שלך
רצית לאסוף את הפלט של הפקודה. למה לשלוח מסר ברור שלא
נָכוֹן?
שקול את השורה הזו:
`cat /etc/termcap`;
שכחת לבדוק $? כדי לראות אם התוכנית בכלל רצה כהלכה. גם אם כתבת
הדפס `cat /etc/termcap`;
קוד זה יכול וכנראה צריך להיכתב בתור
system("cat /etc/termcap") == 0
או למות "תוכנית החתול נכשלה!";
אשר יהדהד את הפלט של פקודת החתול כפי שהיא נוצרת, במקום לחכות עד ל-
התוכנית השלימה כדי להדפיס אותו. זה גם בודק את ערך ההחזרה.
"מערכת" מספקת גם שליטה ישירה על האם עיבוד תווים כלליים למעטפת עשוי להימשך
מקום, בעוד ש-backticks לא.
איך יכול I שיחה תיקונים אחוריים לְלֹא פָּגָז מעבד?
זה קצת מסובך. אתה לא יכול פשוט לכתוב את הפקודה כך:
@ok = `grep @opts '$search_string' @filenames`;
החל מ-Perl 5.8.0, אתה יכול להשתמש ב-"open()" עם מספר ארגומנטים. בדיוק כמו טפסי הרשימה
של "system()" ו-"exec()", לא מתרחשות בריחת מעטפת.
open( GREP, "-|", 'grep', @opts, $search_string, @filenames );
chomp(@ ok = );
סגור GREP;
אתה יכול גם:
שלי @ אוקיי = ();
if (open(GREP, "-|")) {
בזמן ( ) {
chomp;
push(@ok, $_);
}
סגור GREP;
אחר} {
exec 'grep', @opts, $search_string, @filenames;
}
בדיוק כמו ב-"system()", שום בריחה של מעטפת לא מתרחשת כאשר אתה "exec()" רשימה. נוסף
דוגמאות לכך ניתן למצוא ב-"Safe Pipe Opens" ב-perlipc.
שים לב שאם אתה משתמש ב-Windows, אין אפילו פתרון לבעיה המטרידה הזו אפשרי. אֲפִילוּ
למרות ש-Perl מחקה "fork()", אתה עדיין תהיה תקוע, כי ל-Windows אין an
API בסגנון argc/argv.
למה לא יכול my תסריט לקרוא החל מ- STDIN לאחר I נתן it EOF (^D on יוניקס, ^Z on MS-DOS)?
זה קורה רק אם ה-perl שלך מורכב לשימוש ב-stdio במקום ב-perlio, שהוא ה-
בְּרִירַת מֶחדָל. חלק מהסטדיו (אולי כולם?) מגדירים שגיאה ודגלי eof שאולי תצטרך לנקות. ה
מודול POSIX מגדיר "clearerr()" שבו אתה יכול להשתמש. זו הדרך הנכונה מבחינה טכנית
תעשה את זה. הנה כמה דרכים לעקיפת הבעיה פחות אמינים:
1. נסה לשמור על ה-seekpointer ולעבור לשם, כך:
my $where = tell($log_fh);
seek($log_fh, $where, 0);
2. אם זה לא עובד, נסה לחפש לחלק אחר של הקובץ ואז חזרה.
3. אם זה לא עובד, נסה לחפש לחלק אחר של הקובץ, לקרוא משהו,
ואז לחפש בחזרה.
4. אם זה לא עובד, תוותר על חבילת ה-stdio שלך והשתמש ב-sysread.
איך יכול I להמיר my פָּגָז תסריט ל פרל?
למד את Perl ושכתב אותה. ברצינות, אין ממיר פשוט. דברים שהם
מסורבל לעשות במעטפת קל לעשות בפרל, ועצם הסרבול הזה הוא מה שהיה
הפוך ממיר shell->perl כמעט בלתי אפשרי לכתוב. על ידי כתיבה מחדש, אתה תחשוב
על מה שאתה באמת מנסה לעשות, ובתקווה שתברח מהצינור של הפגז
פרדיגמת זרם הנתונים, שאמנם נוחה לכמה עניינים, אך גורמת לחוסר יעילות רבות.
פחית I להשתמש פרל ל לָרוּץ a Telnet or FTP מוֹשָׁב?
נסה את המודולים Net::FTP, TCP::Client ו-Net::Telnet (זמינים מ-CPAN).
<http://www.cpan.org/scripts/netstuff/telnet.emul.shar> יעזור גם לחיקוי של
פרוטוקול telnet, אבל Net::Telnet הוא כנראה קל יותר לשימוש.
אם כל מה שאתה רוצה לעשות הוא להעמיד פנים שאתה telnet אבל לא צריך את ה-telnet הראשוני
לחיצת ידיים, אז הגישה הסטנדרטית של תהליך כפול תספיק:
השתמש ב-IO::Socket; # חדש ב-5.004
my $handle = IO::Socket::INET->new('www.perl.com:80')
או למות "לא יכול להתחבר ליציאה 80 ב-www.perl.com $!";
$handle->שטיפה אוטומטית(1);
if (fork()) { # XXX: undef פירושו כישלון
select($handle);
להדפיס תוך כדי ; # הכל מהסטדין ועד לשקע
אחר} {
הדפס תוך כדי <$handle>; # הכל משקע ל-stdout
}
סגור את $handle;
יציאה;
איך יכול I לכתוב לצפות in פרל?
פעם הייתה ספרייה בשם chat2.pl (חלק מה-perl
הפצה), שמעולם לא הסתיימה באמת. אם תמצא את זה איפשהו, לא להשתמש it.
בימים אלה, ההימור הטוב ביותר שלך הוא להסתכל על מודול Expect הזמין מ-CPAN, שגם הוא
דורש שני מודולים אחרים מ-CPAN, IO::Pty ו-IO::Stty.
Is שם a דרך ל להסתיר פרל'ס הפקודה קו החל מ- תוכניות כזה as "נ.ב"?
קודם כל שים לב שאם אתה עושה זאת מסיבות אבטחה (כדי למנוע מאנשים לראות
סיסמאות, למשל), אז אתה צריך לשכתב את התוכנית שלך כך מידע קריטי
אף פעם לא ניתן כטיעון. הסתרת הטיעונים לא תהפוך את התוכנית שלך לחלוטין
לבטח.
כדי לשנות בפועל את שורת הפקודה הגלויה, אתה יכול להקצות למשתנה $0 as
מתועד ב-perlvar. עם זאת, זה לא יעבוד בכל מערכות ההפעלה. תוכניות Daemon
כמו sendmail מציבים את המדינה שלהם שם, כמו ב:
$0 = "orcus [מקבל חיבורים]";
I {השתנה מַדרִיך, שונים my סביבה} in a פרל תַסרִיט. איך איך מה היא שינוי
נעלם מתי I יצא מה היא תַסרִיט? איך do I לקבל my שינויים ל be גלוי?
יוניקס
במובן המחמיר, זה לא יכול להיעשות - התסריט מבוצע כתהליך שונה
מהקליפה שממנה התחילו. שינויים בתהליך אינם משתקפים בו
הורה--רק בכל הילדים שנוצרו לאחר השינוי. יש קסם קליפה שאולי
לאפשר לך לזייף את זה על ידי "eval()"ליצור הפלט של הסקריפט במעטפת שלך; בדוק את
comp.unix.questions שאלות נפוצות לפרטים.
איך do I close a של התהליך ידית קבצים לְלֹא המתנה ל it ל לְהַשְׁלִים?
בהנחה שהמערכת שלך תומכת בדברים כאלה, פשוט שלח אות מתאים לתהליך
(ראה "להרוג" ב-perlfunc). מקובל לשלוח תחילה אות TERM, לחכות מעט, ו
ואז שלח אות KILL כדי לסיים את זה.
איך do I מזלג a דמון תהליך?
אם בתהליך הדמון אתה מתכוון לאחד שמנותק (מנותק מה-tty שלו), אז
דווח כי התהליך הבא עובד ברוב מערכות ה-Unixish. משתמשים שאינם יוניקס צריכים לבדוק
Your_OS:: מודול התהליכים שלהם עבור פתרונות אחרים.
· פתח את /dev/tty והשתמש בו ב-TIOCNOTTY ioctl. לִרְאוֹת tty(1) לפרטים. או יותר טוב
עם זאת, אתה יכול פשוט להשתמש בפונקציה "POSIX::setsid()", כך שלא תצטרך לדאוג לגבי
קבוצות תהליך.
· שנה ספרייה ל-/
· פתחו מחדש את STDIN, STDOUT ו-STDERR כדי שהם לא יהיו מחוברים ל-tty הישן.
· רקע את עצמך כך:
מזלג && יציאה;
מודול Proc::Daemon, הזמין מ-CPAN, מספק פונקציה לביצוע פעולות אלו
בשבילך.
איך do I למצוא הַחוּצָה if אני ריצה באופן אינטראקטיבי or לֹא?
(תרומה מאת brian d foy)
זו שאלה שקשה לענות עליה, והתשובה הטובה ביותר היא רק ניחוש.
מה אתה באמת רוצה לדעת? אם אתה רק רוצה לדעת אם אחת מהטיפולים בקבצים שלך היא
מחובר למסוף, אתה יכול לנסות את בדיקת הקובץ "-t":
if( -t STDOUT ) {
print "אני מחובר למסוף!\n";
}
עם זאת, ייתכן שיהיה לך מזל אם אתה מצפה שזה אומר שיש אדם אמיתי על
צד שני. עם מודול Expect, תוכנית אחרת יכולה להעמיד פנים שהיא אדם. ה
התוכנית עשויה אפילו להתקרב לעמידה במבחן טיורינג.
המודול IO::Interactive עושה כמיטב יכולתו כדי לתת לך תשובה. שֶׁלָה
הפונקציה "is_interactive" מחזירה ידית קובץ פלט; כי filehandle מצביע על תקן
פלט אם המודול חושב שההפעלה היא אינטראקטיבית. אחרת, ידית הקובץ היא a
ידית null שפשוט משליך את הפלט:
השתמש ב-IO::Interactive;
print { is_interactive } "אולי אני אעבור לפלט סטנדרטי!\n";
זה עדיין לא מבטיח שאדם אמיתי עונה להנחיות שלך או קורא את שלך
פלט.
אם אתה רוצה לדעת איך לטפל בבדיקות אוטומטיות עבור ההפצה שלך, אתה יכול לבדוק
הסביבה. בודקי ה-CPAN, למשל, מגדירים את הערך של "AUTOMATED_TESTING":
אלא אם( $ENV{AUTOMATED_TESTING} ) {
הדפס "שלום בודק אינטראקטיבי!\n";
}
איך do I פסק זמן a להאט אירוע?
השתמש בפונקציה "alarm()", כנראה בשילוב עם מטפל באותות, כפי שתועד
ב"אותות" ב-perlipc ובקטע של "אותות" בגמל. אתה יכול במקום זאת להשתמש ב-
מודול Sys::AlarmCall גמיש יותר זמין מ-CPAN.
הפונקציה "alarm()" אינה מיושמת בכל הגירסאות של Windows. בדוק את ה
תיעוד עבור הגרסה הספציפית שלך של Perl.
איך do I סט CPU גבולות?
(תרם על ידי Xho)
השתמש במודול BSD::Resource מ-CPAN. לדוגמא:
השתמש ב-BSD::Resource;
setrlimit(RLIMIT_CPU,10,20) או למות $!;
זה מגדיר את הגבולות הרכים והקשים ל-10 ו-20 שניות, בהתאמה. לאחר 10 שניות
של זמן ריצה על המעבד (לא זמן "קיר"), התהליך יישלח אות
(XCPU במערכות מסוימות) שאם לא נלכד, יגרום להפסקת התהליך. אם זה
האות נלכד, ואז לאחר 10 שניות נוספות (20 שניות בסך הכל) התהליך יהיה
נהרג עם אות שלא ניתן ללכוד.
ראה את BSD::Resource ותיעוד המערכות שלך לפרטים העגומים.
איך do I לְהִמָנַע זומבים on a יוניקס מערכת?
השתמש בקוד הקוצר מ-"Signals" ב-perlipc כדי לקרוא ל-"wait()" כאשר מתקבל SIGCHLD,
או להשתמש בטכניקת המזלג הכפול המתוארת ב"כיצד אני מתחיל תהליך ב-
רקע?" בפרלפאק8.
איך do I להשתמש an SQL מאגר מידע?
מודול DBI מספק ממשק מופשט לרוב שרתי וסוגי מסד הנתונים,
כולל Oracle, DB2, Sybase, mysql, Postgresql, ODBC וקבצים שטוחים. מודול DBI
ניגש לכל סוג מסד נתונים דרך מנהל התקן מסד נתונים, או DBD. אתה יכול לראות רשימה מלאה
של מנהלי התקנים זמינים ב-CPAN:http://www.cpan.org/modules/by-module/DBD/> . אתה יכול לקרוא
עוד על DBI עלhttp://dbi.perl.org/>.
מודולים אחרים מספקים גישה ספציפית יותר: Win32 :: ODBC, Alzabo, "iodbc", ואחרים שנמצאו
בחיפוש CPAN:http://search.cpan.org/>.
איך do I לעשות a מערכת() יציאה on שליטה-C?
אתה לא יכול. אתה צריך לחקות את הקריאה "system()" (ראה perlipc לקוד לדוגמה) ולאחר מכן
יש מטפל באותות לאות INT שמעביר את האות לתהליך המשנה. אוֹ
אתה יכול לבדוק את זה:
$rc = system($cmd);
if ($rc & 127) { die "signal death" }
איך do I לפתוח a פילה לְלֹא חסימה?
אם התמזל מזלך להשתמש במערכת שתומכת בקריאה שאינה חוסמת (רוב Unixish
מערכות עושות), אתה רק צריך להשתמש בדגל "O_NDELAY" או "O_NONBLOCK" מה-"Fcntl"
מודול בשילוב עם "sysopen()":
השתמש ב-Fcntl;
sysopen(my $fh, "/foo/somefile", O_WRONLY|O_NDELAY|O_CREAT, 0644)
או למות "לא יכול לפתוח /foo/somefile: $!":
איך do I לספר מה היא הבדל בֵּין שגיאות החל מ- מה היא פָּגָז ו פרל?
(התשובה תרם על ידי Brian D Foy)
כאשר אתה מפעיל סקריפט של Perl, משהו אחר מריץ את הסקריפט עבורך, וזה
משהו אחר עלול להוציא הודעות שגיאה. התסריט עשוי להפיץ אזהרות ושגיאות משלו
הודעות. רוב הזמן אתה לא יכול לדעת מי אמר מה.
אתה כנראה לא יכול לתקן את הדבר שמפעיל את perl, אבל אתה יכול לשנות את האופן שבו perl מוציא את זה
אזהרות על ידי הגדרת אזהרה מותאמת אישית ופונקציות קוביות.
שקול את הסקריפט הזה, שיש בו שגיאה שאולי לא תבחין בה מיד.
#!/usr/locl/bin/perl
הדפס "שלום עולם\n";
אני מקבל שגיאה כשאני מריץ את זה מהקליפה שלי (שזה במקרה bash). זה עשוי להיראות
כמו perl שכחתי שיש לו פונקציה "print()", אבל קו ה-shbang שלי הוא לא הנתיב לפרל,
אז המעטפת מריץ את הסקריפט, ואני מקבל את השגיאה.
$ ./ מבחן
./test: שורה 3: print: הפקודה לא נמצאה
תיקון מהיר ומלוכלך כרוך במעט קוד, אבל זה עשוי להיות כל מה שאתה צריך
להבין את הבעיה.
#!/usr/bin/perl -w
התחל {
$SIG{__WARN__} = sub{ print STDERR "Perl: ", @_; };
$SIG{__DIE__} = sub{ print STDERR "Perl: ", @_; יציאה 1};
}
$a = 1 + undef;
$x / 0;
__סוֹף__
הודעת הפרל יוצאת עם "פרל" מלפנים. בלוק "BEGIN" עובד בזמן ההידור
כך שכל שגיאות ההידור והאזהרות מקבלים גם את הקידומת "Perl:".
Perl: שימוש חסר תועלת בחלוקה (/) בהקשר ריק ב-./שורת בדיקה 9.
Perl: השם "main::a" בשימוש פעם אחת בלבד: שגיאת הקלדה אפשרית ב-./test שורה 8.
Perl: השם "main::x" בשימוש פעם אחת בלבד: שגיאת הקלדה אפשרית ב-./test שורה 9.
Perl: שימוש בערך לא מאותחל בנוסף (+) ב-./שורת בדיקה 8.
Perl: שימוש בערך לא מאותחל בחלוקה (/) ב-./שורת בדיקה 9.
פרל: חלוקה לא חוקית באפס ב-./שורת בדיקה 9.
פרל: חלוקה לא חוקית באפס ב-e שורה 3.
אם אני לא רואה את ה-"Perl:", זה לא מ-perl.
אתה יכול גם פשוט לדעת את כל שגיאות ה-perl, ולמרות שיש כמה אנשים שאולי
מכיר את כולם, כנראה שלא. עם זאת, כולם צריכים להיות ב-manpage perldiag.
אם אתה לא מוצא את השגיאה שם, כנראה שזו לא שגיאת perl.
חיפוש כל הודעה היא לא הדרך הקלה ביותר, אז תן ל-perl לעשות זאת עבורך. להשתמש ב
פרגמת אבחון עם הופכת את ההודעות הרגילות של פרל לדיונים ארוכים יותר בנושא.
להשתמש באבחון;
אם לא תקבלו פסקה או שתיים של דיון מורחב, ייתכן שהיא לא של פרל
הוֹדָעָה.
איך do I להתקין a מודול החל מ- CPAN?
(תרומה מאת brian d foy)
הדרך הקלה ביותר היא לגרום למודול בשם CPAN לעשות זאת עבורך על ידי שימוש ב-"cpan"
פקודה שמגיעה עם Perl. אתה יכול לתת לו רשימה של מודולים להתקנה:
$ cpan IO::Interactive Getopt::Whatever
אם אתה מעדיף "CPANPLUS", זה קל באותה מידה:
$ cpanp i IO::Interactive Getopt::Whatever
אם אתה רוצה להתקין הפצה מהספרייה הנוכחית, אתה יכול להגיד "CPAN.pm"
להתקין "." (הנקודה):
$ cpan .
עיין בתיעוד של אחת מהפקודות הללו כדי לראות מה עוד אתה יכול לעשות.
אם אתה רוצה לנסות להתקין הפצה בעצמך, לפתור את כל התלות ב
משלך, אתה הולך אחד משני נתיבים אפשריים לבנייה.
להפצות שמשתמשות Makefile.PL:
$ perl Makefile.PL
$ בצע התקנת בדיקה
להפצות שמשתמשות Build.PL:
$ perl Build.PL
$ ./מבחן בנייה
$ ./Build התקנת
ייתכן שהפצות מסוימות יצטרכו לקשר לספריות או לקוד אחר של צד שלישי ולבנייתן
ורצפי ההתקנה עשויים להיות מסובכים יותר. בדוק כל README or תתקין קבצים
שתוכל למצוא.
מה זה מה היא הבדל בֵּין לדרוש ו להשתמש?
(תרומה מאת brian d foy)
Perl מריץ הצהרת "דרוש" בזמן הריצה. ברגע ש-Perl טוען, מקמפל ומפעיל את הקובץ,
זה לא עושה שום דבר אחר. ההצהרה "השתמש" זהה להרצת "דרוש" ב
זמן קומפילציה, אבל Perl קורא גם לשיטת "ייבוא" עבור החבילה הנטענת. שני אלו
אותו הדבר:
השתמש ב- MODULE qw(רשימת ייבוא);
התחל {
דורש MODULE;
MODULE->ייבוא(רשימת ייבוא);
}
עם זאת, אתה יכול לדכא את ה"יבוא" באמצעות רשימת ייבוא מפורשת וריקה. שניהם
אלה עדיין קורים בזמן ההידור:
השתמש ב- MODULE ();
התחל {
דורש MODULE;
}
מכיוון ש"שימוש" יקרא גם לשיטת "ייבוא", הערך בפועל עבור "מודול" חייב להיות a
מילה חשופה. כלומר, "שימוש" אינו יכול לטעון קבצים לפי שם, למרות ש"דרוש" יכול:
דורש "$ENV{HOME}/lib/Foo.pm"; # אין חיפוש @INC!
ראה את הערך עבור "שימוש" ב-perlfunc לפרטים נוספים.
איך do I לשמור my שֶׁלוֹ מודול/ספרייה מַדרִיך?
כשאתה בונה מודולים, אמור לפרל היכן להתקין את המודולים.
אם אתה רוצה להתקין מודולים לשימוש עצמי, הדרך הקלה ביותר עשויה להיות מקומית::lib,
שתוכל להוריד מ-CPAN. הוא מגדיר עבורך הגדרות התקנה שונות ושימושים
אותן הגדרות בתוך התוכניות שלך.
אם אתה רוצה יותר גמישות, עליך להגדיר את לקוח ה-CPAN שלך עבורך
מצב.
עבור הפצות מבוססות "Makefile.PL", השתמש באפשרות INSTALL_BASE בעת היצירה
Makefiles:
perl Makefile.PL INSTALL_BASE=/mydir/perl
אתה יכול להגדיר זאת בתצורת ה-"CPAN.pm" שלך כך שהמודולים יותקנו אוטומטית ב-
ספריית ספרייה פרטית כאשר אתה משתמש במעטפת CPAN.pm:
% cpan
cpan> o conf makepl_arg INSTALL_BASE=/mydir/perl
cpan> o conf commit
עבור הפצות מבוססות "Build.PL", השתמש באפשרות --install_base:
perl Build.PL --install_base /mydir/perl
אתה יכול להגדיר את "CPAN.pm" לשימוש אוטומטי גם באפשרות זו:
% cpan
cpan> o conf mbuild_arg "--install_base /mydir/perl"
cpan> o conf commit
INSTALL_BASE אומר לכלים האלה להכניס את המודולים שלך /mydir/perl/lib/perl5. ראה "איך עושים
אני מוסיף ספרייה לנתיב ה-include שלי (@INC) בזמן ריצה?" לפרטים כיצד להפעיל את
מודולים שהותקנו לאחרונה.
עם זאת, יש אזהרה אחת עם INSTALL_BASE, מכיוון שהוא פועל בצורה שונה מה-PREFIX
והגדרות LIB שגרסאות ישנות יותר של ExtUtils::MakeMaker דגלו בהן. INSTALL_BASE כן
לא תומך בהתקנת מודולים עבור גרסאות מרובות של Perl או ארכיטקטורות שונות
תחת אותה ספרייה. אתה צריך לשקול אם אתה באמת רוצה את זה, ואם כן,
השתמש בהגדרות הישנות יותר של PREFIX ו-LIB. עיין בתיעוד של ExtUtils::Makemaker למידע נוסף
פרטים.
איך do I להוסיף מה היא בספרייה my התוכנית חיים in ל מה היא מודול/ספרייה search נָתִיב?
(תרומה מאת brian d foy)
אם אתה מכיר את הספרייה כבר, אתה יכול להוסיף אותה ל-@INC כפי שהיית עושה עבור כל ספר אחר
מַדרִיך. אתה עלול אם אתה מכיר את הספרייה בזמן הקומפילציה:
השתמש ב-lib $directory;
החוכמה במשימה זו היא למצוא את הספרייה. לפני שהתסריט שלך יעשה משהו אחר
(כגון "chdir"), אתה יכול לקבל את ספריית העבודה הנוכחית עם מודול "Cwd",
שמגיע עם Perl:
התחל {
השתמש ב-Cwd;
מדריך ה$ שלנו = cwd;
}
השתמש ב-lib $directory;
אתה יכול לעשות דבר דומה עם הערך של $0, שמכיל את שם הסקריפט. זה עשוי
להחזיק נתיב יחסי, אבל "rel2abs" יכול להפוך אותו לנתיב מוחלט. ברגע שיש לך את
התחל {
השתמש בקובץ::Spec::Functions qw(rel2abs);
השתמש בקובץ::Basename qw(שם שם);
my $path = rel2abs( $0 );
מדריך ה$ שלנו = שם שם( $path );
}
השתמש ב-lib $directory;
מודול FindBin, שמגיע עם Perl, עשוי לעבוד. זה מוצא את הספרייה של
כרגע פועל סקריפט ומכניס אותו ל-$Bin, שבו תוכל להשתמש כדי לבנות את
נתיב ספרייה ימני:
השתמש ב-FindBin qw($Bin);
אתה יכול גם להשתמש ב-local::lib כדי לעשות הרבה מאותו הדבר. התקן מודולים באמצעות
ההגדרות של local::lib ולאחר מכן השתמש במודול בתוכנית שלך:
השתמש ב-local::lib; # מגדיר lib מקומי ב ~/perl5
עיין בתיעוד המקומי::lib לפרטים נוספים.
איך do I להוסיף a בספרייה ל my לכלול נתיב (@INC) at זמן ריצה?
להלן הדרכים המוצעות לשנות את נתיב הכלולים שלך, כולל סביבה
משתנים, מתגי זמן ריצה והצהרות בקוד:
משתנה הסביבה "PERLLIB".
$ export PERLLIB=/path/to/my/dir
$ perl program.pl
משתנה הסביבה "PERL5LIB".
$ export PERL5LIB=/path/to/my/dir
$ perl program.pl
דגל שורת הפקודה "perl -Idir".
$ perl -I/path/to/my/dir program.pl
פרגמת ה"ליב":
השתמש ב-lib "$ENV{HOME}/myown_perllib";
המודול המקומי::lib:
השתמש ב-local::lib;
השתמש ב-local::lib"~/myown_perllib";
האחרון שימושי במיוחד מכיוון שהוא יודע על ארכיטקטורות תלויות מכונה.
המודול הפרגמטי "lib.pm" נכלל לראשונה במהדורת 5.002 של Perl.
איפה יש לו מודולים מוּתקָן?
מודולים מותקנים על בסיס כל מקרה לגופו (כפי שמסופקים בשיטות המתוארות ב-
הסעיף הקודם), ובמערכת ההפעלה. כל הנתיבים האלה מאוחסנים ב-@INC,
שתוכל להציג עם ה-one-liner
perl -e 'print join("\n",@INC,"")'
אותו מידע מוצג בסוף הפלט מהפקודה
perl -V
כדי לגלות היכן נמצא קוד המקור של מודול, השתמש
perldoc -l Encode
כדי להציג את הנתיב למודול. במקרים מסוימים (לדוגמה, מודול "טוען אוטומטי"),
פקודה זו תציג את הנתיב לקובץ "פוד" נפרד; המודול עצמו צריך להיות ב
אותה ספרייה, עם סיומת קובץ 'pm'.
מה is socket.ph ו איפה do I לקבל את זה?
זהו קובץ בסגנון Perl 4 המגדיר ערכים עבור קבועי רשת מערכת. לפעמים זה
נבנה באמצעות h2ph כאשר Perl מותקן, אך במקרים אחרים הוא לא. תוכניות מודרניות צריכות
השתמש ב-"השתמש ב-Socket;" במקום זאת.
AUTHOR ו זכויות יוצרים
זכויות יוצרים (ג) 1997-2010 טום כריסטיאנסן, נתן טורקינגטון ומחברים אחרים כאמור.
כל הזכויות שמורות.
תיעוד זה הוא בחינם; אתה יכול להפיץ אותו מחדש ו/או לשנות אותו באותם תנאים
בתור פרל עצמה.
ללא קשר להפצתו, כל דוגמאות הקוד בקובץ זה מוכנסות בזאת לתוך
נחלת הכלל. מותר ומעודדים אותך להשתמש בקוד זה בתוכניות שלך
בשביל הכיף או למטרות רווח לפי ראות עיניכם. הערה פשוטה בקוד נותנת קרדיט תהיה
אדיב אבל לא חובה.
השתמש ב-perlfaq8 באופן מקוון באמצעות שירותי onworks.net
