דערוואַרטן אַ פּראָגראַם וואָס רעדט צו אנדערע ינטעראַקטיוו מגילה לויט צו אַ שריפט. ווייַטערדיק דעם שריפט, דערוואַרטן וואָס איר קענען דערוואַרטן פון אַ פּראָגראַם און וואָס די ריכטיק ענטפער זאָל זיין. אַ ינטערפּראַטעסטיד שפּראַך גיט בראַנטשינג און הויך-מדרגה קאָנטראָל סטראַקטשערז צו ווייַזן דעם דיאַלאָג. אין דערצו, דער באַניצער קענען נעמען קאָנטראָל און ינטעראַקט גלייַך ווען געוואלט, דערנאָך אומגעקערט קאָנטראָל צו די שריפט.
עקספּעקטק איז אַ געמיש פון דערוואַרט און טק. עס ביכייווז פּונקט ווי דערוואַרט און טק ס 'ווינטשן. דערוואַרטן קענען אויך זיין גלייַך אין C אָדער C + + אָן טקל.
דער נאָמען "עקספּעקט" קומט פון דער געדאַנק פון שיקן / דערוואַרטן סיקוואַנסיז פאָוקאַלייזד דורך uucp, kermit און אנדערע מאָדעם קאָנטראָל מגילה. אָבער ניט ענלעך ווקפּ, עקספּעקט איז גענעראַליזעד אַזוי אַז עס קענען זיין לויפן ווי אַ באַניצער-מדרגה באַפֿעל מיט קיין פּראָגראַם און אַרבעט אין גייַסט. דערוואַרטן קענען רעדן צו עטלעכע מגילה אין די זעלבע צייַט.
וואָס דערוואַרטן קענען טאָן
למשל, דאָ זענען עטלעכע זאכן די דערוואַרטן באַפֿעל קענען טאָן:
- קלעם דיין קאָמפּיוטער צו רעדל איר צוריק, אַזוי אַז איר קענען קלאָץ אין אָן פּייינג פֿאַר די רופן.
- אָנהייב אַ שפּיל און אויב די אָפּטימאַל קאַנפיגיעריישאַן טוט נישט דערשייַנען, ריסטאַרט עס ווידער און ווידער) ביז עס טוט, און דאַן האַנט קאָנטראָל איבער איר.
- לויף פסק , און אין ענטפער צו זייַן פראגעס, ענטפֿערן "יאָ" אָדער "קיין" אָדער געבן קאָנטראָל צוריק צו איר, באזירט אויף פּרידיטערטערד קרייטיריאַ.
- פאַרבינדן צו אן אנדער נעץ און אויטאָמאַטיש באַקומען דיין פּאָסט אַזוי אַז עס איז ווי אויב עס איז געווען ערידזשאַנאַלי געשיקט צו דיין היגע סיסטעם.
- פירן סוויווע וועריאַבאַלז, קראַנט וועגווייַזער, אָדער קיין אינפֿאָרמאַציע וועגן ראָגגין, טעלנעט, שפּיץ, סו , אָדער טשגרפּ
עס זענען אַ פאַרשיידנקייַט פון סיבות וואָס די שאָל קענען נישט דורכפירן די טאַסקס. אַלע זענען מעגלעך מיט עקספּעקט.
אין אַלגעמיין, עקספּעקט איז נוצלעך פֿאַר פליסנדיק קיין פּראָגראַם וואָס ריקווייערז ינטעראַקשאַן צווישן די פּראָגראַם און די באַניצער. אַלע וואָס איז נייטיק איז אַז די ינטעראַקשאַן קענען זיין קעראַקטערייזד פּראָגראַממאַטיקאַללי. דערוואַרטן קענען אויך געבן צוריק קאָנטראָל צו דער באַניצער אָן האַלטן די פּראָגראַם קאַנטראָולד. סימילאַרלי, דער באַניצער קענען צוריקקריגן קאָנטראָל צו די שריפט אין קיין צייַט.
באַניץ
דערוואַרטן לייענען קמדפילע פֿאַר אַ רשימה פון קאַמאַנדז צו ויספירן. דערוואַרטן קען זיין ינוווקטיד אויף סיסטעמס וואָס שטיצן די #! נאָטיץ דורך מאַרקינג דעם שריפט ווי עקסעקוטאַבלע און מאכן די ערשטער שורה אין דעם שריפט:
#! / וסר / היגע / בין / דערוואַרטן-ףפון קורס, דער דרך מוזן אַקיעראַטלי באַשרייַבן ווו עקספּעקט לעבן. / וסר / היגע / בין איז נאָר אַ בייַשפּיל.
די -c פאָן פּרעפעראַסיז אַ באַפֿעל צו זיין עקסאַקיוטאַד איידער קיין אין דעם שריפט. דער באַפֿעל זאָל זיין ציטירטן צו פאַרמייַדן זייַענדיק צעבראכן דורך די שאָל. דעם אָפּציע קען זיין געניצט קייפל מאל. קייפל קאַמאַנדז קענען זיין עקסאַקיוטיד מיט אַ איין-ק דורך סעפּערייטינג זיי מיט סעמיקאָלאָנס. קאַמאַנדז זענען עקסאַקיוטאַד אין די סדר זיי דערשייַנען. ווען ניצן Expectk, דעם אָפּציע איז ספּעסאַפייד ווי -command.
דער-ד פאָן ינייבאַלז עטלעכע דיאַגנאָסטיק רעזולטאַט, וואָס בפֿרט ינסטאָלז ינערלעך אַקטיוויטעטן פון קאַמאַנדז אַזאַ ווי דערוואַרטן און ינטעראַקט. דעם פאָן האט די זעלבע ווירקונג ווי "עקספּ_ינטערנאַל 1" אין די אָנהייב פון אַ עקספּעקט שריפט, plus the version of Expect is printed.
דער-ד פאָן ינייבאַלז אַ ינטעראַקטיוו דעבוגגער. אַ ינטאַדזשער ווערט זאָל נאָכפאָלגן. די דעבוגגער וועט נעמען קאָנטראָל איידער די ווייַטער טקל פּראָצעדור אויב די ווערט איז ניט-נול אָדער אויב אַ * C איז געדריקט אָדער אַ ברעאַקפּאָינט איז שלאָגן, אָדער אנדערע צונעמען דעבוגגער באַפֿעלן אויס אין דעם שריפט. ווען ניצן Expectk, דעם אָפּציע איז ספּעסאַפייד ווי - דעבוג.
דער -f פאָן פּרעפערייזיז אַ טעקע פון וואָס צו לייענען קאַמאַנדז. די פאָן זיך איז אַפּשאַנאַל ווי עס איז נאָר נוצלעך ווען ניצן די #! נאָטאַטיאָן, אַזוי אַז אנדערע אַרגומענטן קען זיין סאַפּלייד אויף די באַפֿעל שורה. ווען ניצן Expectk, דעם אָפּציע איז ספּעסאַפייד ווי-טעקע.
דורך פעליקייַט, די באַפֿעל טעקע איז לייענען אין זיקאָרן און עקסאַקיוטאַד אין זייַן ינטייערטי. עס איז טייל מאָל דיזייראַבאַל צו לייענען טעקעס איין שורה אין אַ צייַט. אין סדר צו צווינגען אַרביטראַריש טעקעס צו זיין כאַנדאַלד דעם וועג, נוצן די -ב פאָן. ווען ניצן Expectk, דעם אָפּציע איז ספּעסאַפייד ווי-באַפער.
אויב די שטריקל "-" איז סאַפּלייד ווי אַ פילענאַמע, די סטאַנדאַרט אַרייַנשרייַב איז אַנשטאָט. ניצן "./-" צו לייענען פון אַ טעקע פאקטיש געהייסן "-".
דער -י פאָן ז ץ גערעדט צו ינטעראַקטיוולי פּינטלעך פֿאַר קאַמאַנדז אַנשטאָט פון לייענען זיי פון אַ טעקע. פּראָמפּטינג איז טערמאַנייטיד דורך די אַרויסגאַנג באַפֿעל אָדער אויף עאָף. דער -י פאָן איז אנגענומען אויב ניט אַ באַפֿעל טעקע אדער -c איז געניצט. ווען ניצן Expectk, דעם אָפּציע איז ספּעסאַפייד as -interactive.
- קען זיין געניצט צו דעלימיט די סוף פון די אָפּציעס. דעם איז נוציק אויב איר ווילן צו פאָרן אַ אָפּציע-ווי אַרגומענט צו דיין שריפט אָן עס איז ינטערפּראַטאַד דורך עקספּעקט. דעם קענען נוצלעך זיין געשטעלט אין די #! שורה צו פאַרמייַדן קיין פלאַגאַקיש ינטערפּריטיישאַן דורך עקספּעקט. פֿאַר בייַשפּיל, די פאלגענדע וועט לאָזן די אָריגינעל אַרמאַמענץ אַרייַנגערעכנט די שריפט נאָמען אין די בייַטעוודיק אַרגוו .
#! / וסר / היגע / בין / דערוואַרטן -באַמערקונג אַז די געוויינטלעך getopt (3) און עקסעקווע (2) קאַנווענשאַנז מוזן זיין באמערקט ווען לייגן אַרגומענטן צו די #! ליניע.
דער טעקע $ exp_library / expect.rc איז סאָורסירט אויטאָמאַטיש אויב איר פאָרשטעלן, סייַדן די -ן פאָן איז געניצט. (ווען ניצן Expectk, דעם אָפּציע איז ספּעסאַפייד ווי -NORC.) תיכף נאָך דעם, די טעקע ~ / .expect.rc איז אויטאָמאַטיש אויטאָמאַטיש, סייַדן דער -ן פאָן איז געניצט. אויב דער סוויווע בייַטעוודיק DOTDIR איז דיפיינד, עס איז באהאנדלט ווי אַ וועגווייַזער און .expect.rc איז לייענען פון דאָרט. ווען ניצן Expectk, דעם אָפּציע איז ספּעסאַפייד ווי -נאָרק. דעם סאָרסינג אַקערז נאָר נאָך עקסאַקיוטינג קיין -ק פלאַגס.
-וו סיבות דערוואַרטן צו דרוקן זייַן ווערסיע נומער און אַרויסגאַנג. די קאָראַספּאַנדינג פאָן אין עקספּעקטק, וואָס ניצט לאַנג פאָן נעמען, איז -וויווערסיאָן.
אָפּטיאָנאַל אַרגס זענען קאַנסטראַקטאַד אין אַ רשימה און סטאָרד אין די בייַטעוודיק גערופן אַגוווו און. אַרגק איז ינישאַלייזד צו די לענג פון אַרגוו.
אַרגוו 0 איז דיפיינד צו זיין די נאָמען פון די שריפט אָדער ביינערי אויב קיין שריפט איז געניצט. פֿאַר בייַשפּיל, די ווייַטערדיק פּרינץ אויס די נאָמען פון די שריפט און די ערשטער דרייַ אַרמאַמאַנץ:
send_user "$ argv0 [lrange $ argv 0 2] \ n"קאַמאַנדז
דערוואַרטן ניצן Tool Command Language. טקל גיט קאָנטראָל לויפן (אויב, פֿאַר, ברעכן), אויסדרוק עוואַלושאַן און עטלעכע אנדערע פֿעיִקייטן אַזאַ ווי רעקורסיאָנאַנד פּראָצעדור דעפֿיניציע. קאָממאַנדז געניצט דאָ אָבער ניט דיפיינד (שטעלן, אויב, עקסאַק) זענען טקל קאַמאַנדז. דערוואַרטן שטיצט נאָך קאַמאַנדז. אויב אַנדערש ספּעסאַפייד, קאַמאַנדז צוריקקומען די ליידיק שטריקל.
קאַמאַנדז זענען ליסטעד אַלפאַבעטיקלי אַזוי אַז זיי קענען זיין געשווינד ליגן. אָבער, נייַע ניצערס קענען געפֿינען עס גרינגער צו אָנהייבן דורך לייענען די דיסקריפּשאַנז פון רויג, שיקן, דערוואַרטן, און ינטעראַקט אין דעם סדר.
close [-slave] [-onexec 0 | 1] [-i spawn_id]קלאָוזיז די קשר צו די קראַנט פּראָצעס . רובֿ ינטעראַקטיוו מגילה וועט דעטעקט EOF אויף זייער סטדין און אַרויסגאַנג; אַזוי נאָענט יוזשאַוואַלי גענוג צו טייטן די פּראָצעס ווי געזונט. די-איך פאָן דערקלערט דעם פּראָצעס צו נאָענט קאָראַספּאַנדינג צו די געהייסן spawn_id.
ביידע דערוואַרטן און ינטעראַקט וועט דעטעקט ווען די קראַנט פּראָצעס יקסידז און ימפּליסאַטלי טאָן אַ נאָענט, אָבער אויב איר טייטן דעם פּראָצעס דורך, זאָגן, "ויספירן טייטן $ פּיד", איר דאַרפֿן צו בישליימעס רופן נאָענט .
די -אָנעקסעק פאָן באשלאסן אויב דער רוימס שייַן איז פארשלאסן אין קיין נייַ ספּאַנדזשד פּראַסעסאַז אָדער אויב די פּראָצעס איז אָוווערלייד. צו לאָזן אַן רויג שייַן אָף עפענען, נוצן די ווערט 0. א ניט-נול ינטעגער ווערט פאָרסעס די רויג פֿאַרמאַכט אין קיין נייַ פּראַסעסאַז.
די-סלאַווע פאָן קלאָוזיז די שקלאַף פארבונדן מיט דער רויג שייַן. ווען די קשר איז פארשלאסן, די שקלאַף איז אויטאָמאַטיש פארמאכט ווי געזונט אויב עס איז נאָך עפענען.
ניט קיין ענין צי די קשר איז ימפּליטיד אָדער בישליימעס קלאָוזד, איר זאָל רופן וואַרטן צו קלאָר די קאָראַספּאַנדינג קערן פּראָצעס שפּעלטל. דער נאָענט באַפֿעל טוט נישט רופן וואַרטן זינט עס איז קיין גאַראַנטירן אַז קלאָוזינג אַ פּראָצעס קשר וועט פאַרשאַפן עס צו אַרויסגאַנג.
debug [[-now] 0 | 1]קאָנטראָלס אַ טקל דעבוגגער אַלאַוינג איר צו שריט דורך סטייטמאַנץ און שטעלן ברעאַקפּאָינץ.
מיט קיין אַרגומענטן, אַ 1 איז אומגעקערט אויב די דעבוגגער איז נישט פליסנדיק, אַנדערש 0 איז אומגעקערט.
מיט אַ 1 אַרגומענט, די דעבוגגער איז סטאַרטעד. מיט אַ 0 אַרגומענט, די דעבוגגער איז פארשטאפט. אויב אַ 1 אַרגומענט איז פּריסטיד דורך די -נאָוו פאָן, די דעבוגגער איז סטאַרטעד מיד. אַנדערש, די דעבוגגער איז סטאַרטעד מיט דער ווייַטער טקל דערקלערונג.
די דיבאַג באַפֿעל טוט נישט טוישן קיין טראַפּס. פאַרגלייַכן דעם צו סטאַרטינג דערוואַרטן מיט די -ד פאָן.
די דיסקאַנעקט באַפֿעל דיסקלאָוזד אַ פאָרקעד פּראָצעס פון די וואָקזאַל . עס האלט פליסנדיק אין דער הינטערגרונט. דער פּראָצעס איז געגעבן זייַן אייגן פּראָצעס גרופּע. נאָרמאַל איך / אָ איז רידערעקטיד צו / dev / null .
די ווייַטערדיק פראַגמענט ניצט דיסקאַנעקט צו פאָרזעצן פליסנדיק די שריפט אין די הינטערגרונט.
אויב {[פאָרק]! = 0} אַרויסגאַנג דיסקאַנעקט. . .דער ווייַטער שריפט לייענט אַ פּאַראָל און דעמאָלט לויפט אַ פּראָגראַם יעדער שעה וואָס דאַרף אַ פּאַראָל יעדער מאָל עס איז פליסנדיק. דער שריפט סאַפּלייז די פּאַראָל אַזוי אַז איר נאָר האָבן צו דרוקן עס אַמאָל.
({{פיטש!] {0} {שלאָפן 3600, פאָרזעצן} דיסקאַנעקט דערקלערן priv_prog דערוואַרטן שפּריכוואָרט: שיקן "$ expect_user" 1, שטריקל) \ r ". . . exit}אַ מייַלע צו נוצן דיסקאַנעקט איבער די שאָל ייסינגקראַנאַס פּראָצעס שטריך (&) איז אַז דערוואַרטן קענען ראַטעווען די וואָקזאַל פּאַראַמעטערס איידער דיסקאַנעקשאַן און דעמאָלט שפּעטער זיי צולייגן צו נייַ פּטי. מיט &, עקספּעקט טוט נישט האָבן אַ געלעגנהייַט צו לייענען די וואָקזאַל ס פּאַראַמעטערס זינט די וואָקזאַל איז שוין דיסקאַנעקטיד דורך די צייַט דערוואַרטן באקומט קאָנטראָל.
אַרויסגאַנג [-אָפּט] [סטאַטוס]סיבה דערוואַרטן צו אַרויסגאַנג אָדער אַנדערש צוגרייטן צו טאָן אַזוי.
די -אָנעקסיט פאָן זייַנען דער ווייַטער אַרגומענט צו זיין געניצט ווי אַ אַרויסגאַנג האַנדלער. אָן אַ אַרגומענט, די קראַנט אַרויסגאַנג האַנדלער איז אומגעקערט.
די- נעאָיט פאָן ז ץ דערוואַרטן צו צוגרייטן צו אַרויסגאַנג אָבער האַלטן קורץ פון פאקטיש צוריקקומען קאָנטראָל צו די אָפּערייטינג סיסטעם. דער באַניצער-דיפיינד אַרויסגאַנג האַנדלער איז לויף ווי געזונט ווי עקספּעקט ס אייגן ינערלעך האַנדלערס. ניט ווייַטער דערוואַרטן קאַמאַנדז זאָל זיין עקסאַקיוטיד. דעם איז נוציק אויב איר זענען פליסנדיק עקספּעקט מיט אנדערע טקל יקסטענשאַנז. די קראַנט יבערזעצער (און הויפּט פֿענצטער אויב אין די טק סוויווע) בלייַבן אַזוי אַז אנדערע טקל יקסטענשאַנז קענען ריין אַרויף. אויב דער אַרויסגאַנג פון דער אַרויסגאַנג איז גערופן ווידער (אָבער דאָס קען פאַלן), די האַנדלערס זענען נישט רערון.
נאָך אַרויסגאַנג, אַלע קאַנעקשאַנז צו ספּאַנדזשד פּראַסעסאַז זענען פארשלאסן. קלאָוזער וועט זיין דיטעקטאַד ווי אַ עאָף דורך ספּאַנדזשד פּראַסעסאַז. אַרויסגאַנג נעמט קיין אנדערע אַקשאַנז ווייַטער פון וואָס דער נאָרמאַל _עקסיט (2) פּראָצעדור טוט. אזוי, פּראָונדעס פּראָצעס וואָס טאָן נישט קאָנטראָלירן פֿאַר EOF קען פאָרזעצן צו לויפן. (א פאַרשיידנקייַט פון באדינגונגען זענען וויכטיק צו דיטערמאַנינג, פֿאַר בייַשפּיל, וואָס סיגנאַלז אַ געשאפן פּראַסעס וועט ווערן געשיקט, אָבער די זענען סיסטעם-אָפענגיק, טיפּיקלי דאַקיומענטאַד אונטער אַרויסגאַנג (3).) ספּאָאָנעד פּראַסעסאַז וואָס פאָרזעצן צו לויפן וועט זיין ינכעראַטיד דורך יניט.
סטאַטוס (אָדער 0 אויב ניט ספּעסאַפייד) איז אומגעקערט ווי דער אַרויסגאַנג סטאַטוס פון עקספּעקט . אַרויסגאַנג איז ימפּליסאַטלי עקסאַקיוטיד אויב די סוף פון די שריפט איז ריטשט.
exp_continue [-kontinue_timer]
דער באַפֿעל עקספּ_קאָנטינוע אַלאַוז דערוואַרטן זיך צו פאָרזעצן עקסאַקיוטינג אלא ווי אומגעקערט ווי עס נאָרמאַלי וואָלט. דורך פעליקייַט עקספּ_קאָנטינוע באַשטעטיק די טיימאַוט טייַמער. די -קאָנטינוע_טימער פאָן פּריווענץ טייַמער פון זייַענדיק ריסטאַרטיד. (זען דערוואַרטן פֿאַר מער אינפֿאָרמאַציע.)
exp_internal [-f file] ווערט
זע ווייַטער קאַמאַנדז צו שיקן די דיאַגנאָסטיק אינפֿאָרמאַציע ינערלעך צו דערוואַרטן צו סטדערר אויב ווערט איז ניט-נול. דעם רעזולטאַט איז פאַרקריפּלט אויב ווערט איז 0. די דיאַגנאָסטיק אינפֿאָרמאַציע כולל יעדער כאַראַקטער באקומען, און יעדער פּרווון געמאכט צו גלייַכן די קראַנט רעזולטאַט קעגן די פּאַטערנז.
אויב די אָפּטיאָנאַל טעקע איז סאַפּלייד, אַלע נאָרמאַל און דיבאַגינג רעזולטאַט איז געשריבן צו אַז טעקע (ראַגאַרדלאַס פון די ווערט פון ווערט ). קיין פרייַערדיק דיאַגנאָסטיק רעזולטאַט טעקע איז פארשלאסן.
די- אינפֿאָרמאַציע פאָן זיר אַרויסדרוקן צו צוריקקריגן אַ באַשרייַבונג פון די מערסט פריש ניט-אינפֿאָרמאַציע טענות געגעבן.
exp_open [args] [-i spawn_id]
קערט אַ טקל טעקע יידענטאַפייער וואָס קאָראַספּאַנדז צו דער אָריגינעל רויטער שייַן. דער טעקע יידענטאַפייער קענען זיין געניצט ווי אויב עס איז געעפנט געווארן דורך טקל ס עפענען באַפֿעל. (די רויטן שייַן זאָל ניט זיין געניצט. א וואַרטן זאָל נישט זיין עקסאַקיוטאַד.
די -לעאַוועאָפּען פאָן בלעטער דער רויג שייַן אָף פֿאַר אַקסעס דורכקוק קאַמאַנדז. א וואַרטן מוזן זיין עקסאַקיוטאַד אויף די רויג שייַן.
exp_pid [-i spawn_id]
קערט דער פּראָצעס שייַן קאָראַספּאַנדינג צו די דערווייַל ספּאָאָנעד פּראָצעס. אויב דער -י פאָן איז געניצט, די פּיד אומגעקערט קאָראַספּאַנדז צו אַז פון די געגעבן רויטער שייַן.
exp_send
איז אַ אַליאַס פֿאַר שיקן .
exp_send_error
איז אַ אַליאַס פֿאַר סענד_עראָר .
exp_send_log
איז אַ אַליאַס פֿאַר send_log .
exp_send_tty
איז אַ אַליאַס פֿאַר סענד_טטי .
exp_send_user
איז אַ אַליאַס פֿאַר סענד_וסער .
exp_version [[-exit] ווערסיע]
איז נוציק פֿאַר אַשורד אַז די שריפט איז קאַמפּאַטאַבאַל מיט די קראַנט ווערסיע פון דערוואַרט.
מיט קיין אַרגומענטן, די קראַנט ווערסיע פון עקספּעקט איז אומגעקערט. דעם ווערסיע קען זיין ענדייטיד אין דיין שריפט. אויב איר טאַקע וויסן אַז איר זענט נישט ניצן פֿעיִקייטן פון פריש ווערסיעס, איר קענען ספּעציפיצירן אַן פריער ווערסיע.
ווערסיעס צונויפשטעלנ זיך פון דרייַ נומערן אפגעשיידט דורך דאַץ. ערשטער איז די הויפּט נומער. סקריפּץ געשריבן פֿאַר ווערסיעס פון דערוואַרטן מיט אַ אַנדערש הויפּט נומער וועט כּמעט זיכער נישט אַרבעטן. exp_version קערט אַ טעות אויב די הויפּט נומערן טאָן ניט גלייַכן.
צווייטע איז די מינימום נומער. סקריפּץ געשריבן פֿאַר אַ ווערסיע מיט אַ גרעסערער מינימום נומער ווי די קראַנט ווערסיע קען אָפענגען אויף עטלעכע נייַ פֿעיִקייטן און קען נישט לויפן. exp_version קערט אַ טעות אויב די הויפּט נומערן גלייַכן, אָבער די שריפט מינימום נומער איז גרעסער ווי אַז פון די פליסנדיק עקספּעקט .
דריט איז אַ נומער וואָס איז ניט אַ טייל אין דער ווערסיע פאַרגלייַך. אָבער, עס איז ינקראַמענטיד ווען דער עקספּעקט סאָפטווער פאַרשפּרייטונג איז געביטן אין קיין וועג, אַזאַ ווי דורך נאָך דאַקיומענטיישאַן אָדער אָפּטימיזאַטיאָן. עס איז באַשטעטיק צו 0 אויף יעדער נייַ מינערווערטיק ווערסיע.
מיט דער- אַרויסלאָזן פאָן, דערוואַרטן דרוקן אַ טעות און יקסייץ אויב די ווערסיע איז אויס פון טאָג.
דערוואַרטן [[-אָפּץ] פּאַט 1 באָדי 1] ... [-אָפּץ] פּאַטן [באָדין]
ווייזט ביז איינער פון די פּאַטערנז שוועבעלעך די רעזולטאַט פון אַ ספּאָאָנעד פּראָצעס, אַ ספּעסאַפייד צייט צייַט האט דורכגעגאנגען, אָדער אַ סוף-פון-טעקע איז געזען. אויב די לעצט גוף איז ליידיק, עס קען זיין איבערגעהיפּערט.
פּאַטטערנס פון די מערסט פראַסטיק דערוואַרטונג איידער דער באַפֿעלן זענען ימפּליסאַטלי געניצט איידער קיין אנדערע פּאַטערנז. פּאַטטערנס פון די מערסט פראַסטיש דערוואַרטן יבעררוק באַפֿעלן זענען ימפּליסאַטלי געניצט נאָך קיין אנדערע פּאַטערנז.
אויב די אַרגומענטן צו די גאנצע דערוואַרטן דערקלערונג דאַרף מער ווי איין שורה, אַלע די אַרגומענטן קען זיין "בראַסעד" אין איין אַזוי ווי צו ויסמייַדן טערמאַנייטינג יעדער שורה מיט אַ באַקקלאַש. אין דעם איין פאַל, די געוויינטלעך טקל סאַבסטיטיושאַנז וועט פאַלן טראָץ די ברייסאַז.
אויב אַ מוסטער איז די קיווערד eof , די קאָראַספּאַנדינג גוף איז עקסאַקיוטאַד אויף סוף-פון-טעקע. אויב אַ מוסטער איז די קיווערד טיימאַוט , די קאָראַספּאַנדינג גוף איז עקסאַקיוטאַד אויף טיימאַוט. אויב קיין טיימאַוט קיווערד איז געניצט, אַ ימפּליסאַט נאַל קאַמף איז עקסאַקיוטאַד אויף טיימאַוט. די פעליקייַט טיימאַוט צייַט איז 10 סעקונדעס אָבער קען זיין באַשטימט, פֿאַר בייַשפּיל צו 30, דורך די באַפֿעל "שטעלן טיימאַאָוט 30". אַ ינפאַנאַט טיימאַוט קען זיין דעזיגנייטיד דורך די ווערט -1. אויב אַ מוסטער איז דער קיווערד פעליקייַט , די קאָראַספּאַנדינג גוף איז עקסאַקיוטאַד אויף די טיימאָוט אָדער סוף-פון-טעקע.
אויב אַ מוסטער שוועבעלעך, דער קאָראַספּאַנדינג גוף איז עקסאַקיוטאַד. דערוואַרטן קערט דער רעזולטאַט פון דעם גוף (אָדער די ליידיק שטריקל אויב קיין מוסטער מאַטשט). אין דער געשעעניש אַז קייפל פּאַטערנז גלייַכן, דער איינער דערשייַנען ערשטער איז געניצט צו אויסקלייַבן אַ גוף.
יעדער מאָל די נייַ רעזולטאַט קומט, עס איז קאַמפּערד מיט יעדער מוסטער אין די סדר זיי זענען ליסטעד. אזוי, איר קענען פּרובירן פֿאַר אַוועק פון אַ גלייַכן דורך מאַכן די לעצט מוסטער עפּעס געראַנטיד צו דערשייַנען, אַזאַ ווי אַ פּינטלעך. אין סיטואַטיאָנס ווו עס איז קיין פּינטלעך, איר מוזן נוצן טיימאַוט (פּונקט ווי איר וואָלט אויב איר געווען ינטעראַקטינג מאַניואַלי).
פּאַטטערנס זענען ספּעסאַפייד אין דרייַ וועגן. דורך פעליקייַט, פּאַטערנז זענען ספּעסאַפייד ווי טקל ס שטריקל גלייַכן באַפֿעל. (אַזאַ מאָדעלס זענען אויך ענלעך צו C-שאָל רעגולער אויסדרוקן יוזשאַוואַלי ריפערד צו ווי "גלאָב" פּאַטערנז). דער- הל פאָן קען זיין געניצט צו באַשיצן די מוסטער אַז קען אַנדערש גלייַכן דערוואַרטן פלאַגס פון טאן אַזוי. קיין מוסטער אָנפאַנגען מיט אַ "-" זאָל זיין פּראָטעקטעד דעם וועג. (כל סטרינגס סטאַרטינג מיט "-" זענען רעזערווירט פֿאַר צוקונפֿט אָפּציעס.)
פֿאַר בייַשפּיל, די פאלגענדע פראַגמענט קוקט פֿאַר אַ מצליח לאָגין. (באַמערקונג אַז אַבאָרט איז פּרעסומעד צו זיין אַ פּראָצעדור דיפיינד אנדערש אין דעם שריפט.)
דערוואַרטן {פאַרנומען {שטעלן פאַרנומען \ n; exp_continue} פאַרפעלן "אַנאָטערייזד שפּריכוואָרט" אַבאָרט טיימאָוט אַבאָרט פאַרבינדן}קוואָטעס זענען נייטיק אויף די פערט מוסטער זינט עס כּולל אַ פּלאַץ, וואָס וואָלט אַנדערש באַזונדער די מוסטער פון די אַקציע. פּאַטטערנס מיט דער זעלביקער קאַמף (אַזאַ ווי די 3 און 4) דאַרפן ליסטינג די אַקשאַנז ווידער. דעם קענען זיין ויסגעמאַטערט דורך ניצן רעקסעקס-סטייל פּאַטערנז (זען ווייטער). מער אינפֿאָרמאַציע אויף פאָרמינג גלאָב-נוסח מוסטער קענען זיין געפונען אין די טקל מאַנואַל.
רעגעקספּ-נוסח מוסטער נאָכפאָלגן די סינטאַקס דיפיינד דורך טקל ס רעקסעקספּ (קורץ פֿאַר "רעגולער אויסדרוק") באַפֿעל. רעקסעקספּ פּאַטערנז זענען באַקענענ מיט די פאָן -רע . די פריערדיקע בייַשפּיל קענען זיין ריריטיד ניצן אַ רעגעקספּ ווי:
דערוואַרטן {פאַרנומען {שטעלן פאַרנומען \ n; exp_continue} -re "דורכפאַל | פאַרקריפּלט פּאַראָל" abort timeout abort connected}ביידע טייפּס פון פּאַטערנז זענען "ונאַנטשאַנד". דעם מיטל אַז פּאַטערנז טאָן ניט האָבן צו ריכטן די גאנצע שטריקל, אָבער קענען אָנהייבן און סוף די גלייַכן ערגעץ אין די שטריקל (ווי לאַנג ווי אַלץ אַנדערש שוועבעלעך). ניצן * צו גלייַכן דעם אָנהייב פון אַ שטריקל, און $ צו גלייַכן די סוף. באַמערקונג אַז אויב איר טאָן ניט וואַרטן פֿאַר די סוף פון אַ שטריקל, דיין רעספּאָנסעס קענען לייכט סוף אַרויף אין די מיטן פון די שטריקל ווי זיי זענען עקאָוד פון די ספּאָאָנעד פּראָצעס. בשעת נאָך פּראָדוצירן ריכטיק רעזולטאטן, די רעזולטאַט קען נישט ומנאַטירלעך. אזוי, נוצן פון $ איז ינקעראַדזשד אויב איר קענען פּונקט באַשליסן די אותיות אין די סוף פון אַ שטריקל.
באַמערקונג אַז אין פילע רעדאקציע, די * און $ גלייַכן די אָנהייב און סוף פון שורות ריספּעקטיוולי. אָבער, ווייַל דערוואַרטן איז ניט שורה אָריענטיד, די אותיות גלייַכן די אָנהייב און סוף פון די דאַטן (ווי קעגן צו שורות) דערווייַל אין די דערוואַרטן ריכטן באַפער. (אויך זען די טאָן ונטער אויף "סיסטעם ינדיידזשעסטשאַן.")
די -עקס פאָן זייַנען די מוסטער צו זיין מאַטשט ווי אַ "פּינטלעך" שטריקל. קיין ינטערפּריטיישאַן פון *, *, עטק איז געמאכט (כאָטש די געוויינטלעך טקל קאַנווענשאַנז מוזן נאָך זיין באמערקט). פּונקט פּאַטערנז זענען שטענדיק אַנאַנטשאַנד.
די -נאָסאַסע פאָן זיינען די ופּפּערקאַסע אותיות פון דער רעזולטאַט צו פאַרגלייַכן ווי אויב זיי זענען לאָווערקאַסע אותיות. דער מוסטער איז נישט אַפעקטאַד.
בשעת לייענען רעזולטאַט, מער ווי 2000 ביטעס קענען קראַפט פריער ביטעס צו זיין "פארגעסן". דעם קען זיין געביטן מיט די פונקציע match_max . (באַמערקונג אַז יבעריק גרויס וואַלועס קענען פּאַמעלעך די מוסטער מאַטטשער.) אויב פּאַטליס איז פול_בuffer , די קאָראַספּאַנדינג גוף איז עקסאַקיוטאַד אויב match_max ביטעס האָבן שוין באקומען און קיין אנדערע פּאַטערנז האָבן מאַטשט. אויב די full_buffer קיווערד איז ניט געניצט, די פארגעסן אותיות זענען געשריבן צו דערוואַרטונג_אָוט (באַפער).
אויב פּאַטליסט איז די קיווערד נאַל , און נולז זענען ערלויבט (דורך די באַפֿעל באַזייַטיקונג_נולס ), די קאָראַספּאַנדינג גוף איז עקסאַקיוטאַד אויב אַ איין ASCII 0 איז מאַטשט. עס איז ניט מעגלעך צו גלייַכן 0 ביטעס דורך גלאָב אָדער רעקסעקספּ פּאַטערנז.
אויף וואָס ריכטן אַ מוסטער (אָדער עף אָדער פול_בuffer), קיין ריכטיק און ביז אַהער גלייַכן פּראָדוקציע איז געראטעוועט אין די בייַטעוודיק ווייט_קאָוט (באַפער) . אַרויף צו 9 רעקסעקספּ סאַבסטרייץ שוועבעלעך זענען געראטעוועט אין די וועריאַבאַלז ייטאַמז (1, שטריקל) דורך דערוואַרטונג_אָוט (9, שטריקל) . אויב דער- ינדיקייץ פאָן איז געניצט איידער אַ מוסטער, די סטאַרטינג און סאָף ינדאַסיז (אין אַ פאָרעם פֿאַר לראַנגע ) פון די 10 שטריקל זענען סטאָרד אין די וועריאַבאַלז אָוקייאַוט (X, אָנהייב) און דערוואַרטן אָוט (X, סוף) ווו רענטגענ איז ציפער, קאָראַספּאַנדז צו די סאַבסטרייט שטעלע אין דער באַפער. 0 רעפערס צו סטרינגס וואָס גלייַכן די גאנצע מוסטער און איז דזשענערייטאַד פֿאַר גלאָב מוסטער און ראַגעקספּ פּאַטערנז. פֿאַר בייַשפּיל, אויב אַ פּראָצעס האט געשאפן רעזולטאַט פון "אַבקדעפגה \ n", דער רעזולטאַט פון:
דערוואַרטן "סי"איז ווי אויב די פאלגענדע סטייטמאַנץ זענען עקסאַקיוטאַד:
שטעלן דערוואַרטונג (0, שטריקל) קד שטעלן דערוואַרטונג (באַפער) אַבקדאון "עפגה \ n" איז לינקס אין די רעזולטאַט באַפער. אויב אַ פּראָצעס געשאפן די פּראָדוקציע "אַבבבקאַבקקקקאַ \ n", דער רעזולטאַט פון:
דערוואַרטן-ינדיסעס -רע "ב (ב *). * (ק +)"איז ווי אויב די פאלגענדע סטייטמאַנץ זענען עקסאַקיוטאַד:
set 0 (end, wait) 1 set expect_out (0, end) 10 set expect_out (0, string) bbbcabkkkk set wait_out (1, start) 2 set expect_out (2, אָנהייב) 10 set expect_out (2, end) 10 set expect_out (2, string) k set expect_out (buffer) אַבבבקאַבקקקקאון "אַ \ n" איז לינקס אין דער רעזולטאַט באַפער. דער מוסטער "*" (און -רע ". *") וועט גלייַך דער רעזולטאַט באַפער אָן לייענען מער רעזולטאַט פון דעם פּראָצעס.
נאָרמאַללי, די מאַטשט רעזולטאַט איז אַוועקגענומען פון עקספּוט ס ינערלעך באַפערז. דעם קען זיין פּריווענטיד דורך פּרעפיקסינג אַ מוסטער מיט די -נאָטראַנספער פאָן. דעם פאָן איז ספּעציעל נוציק אין עקספּעראַמענטינג (און קענען זיין אַבריוויייטיד צו "-ניט" פֿאַר קאַנוויניאַנס בשעת עקספּערימענטינג).
די רויג שייַן איז פארבונדן מיט די ריכטן רעזולטאַט (אָדער עף אָדער פול_בuffer) איז סטאָרד אין דערוואַרטונג (ספּאַוונ_יד) .
די- צייטאַוט פאָן ז אַז די קראַנט דערוואַרטן באַפֿעל צו נוצן די פאלגענדע ווערט ווי אַ טיימאַוט אַנשטאָט פון ניצן די ווערט פון די טיימאַוט בייַטעוודיק.
דורך פעליקייַט, פּאַטערנז זענען מאַטשט קעגן רעזולטאַט פון דעם קראַנט פּראָצעס, אָבער די -י פאָן דערקלערט די רעזולטאַט פון די געהייסן spawn_id רשימה זיין מאַטשט קעגן קיין ווייַטערדיק פּאַטערנז (אַרויף צו דער ווייַטער- איך ). די spawn_id רשימה זאָל זיין אַ באַזונדער אפשאצונג רשימה פון spawn_ids אָדער אַ בייַטעוודיק ריפערינג צו אַ רשימה פון spawn_ids.
למשל, דער ווייַטערדיק בייַשפּיל ווייזט פֿאַר "פארבונדן" פון דעם קראַנט פּראָצעס, אָדער "פאַרנומען", "אַנדערש" אָדער "פאַרקריפּלט פּאַראָל" פון די ספּאַוונ_יד געהייסן דורך $ proc2.
דערוואַרטן {-א $ פּראָק 2 פאַרנומען {שטעלט פאַרנומען \ n; exp_continue} -re "דורכפאַל | פאַרקריפּלט פּאַראָל" abort timeout abort connected}די ווערט פון די גלאבאלע ווערייישאַן any_spawn_id קען זיין געניצט צו גלייַכן מוסטער צו קיין spawn_ids וואָס זענען גערופן מיט אַלע אנדערע -י פלאַגס אין דעם קראַנט דערוואַרטן באַפֿעל. די ספּאַוונ_יד פון אַ -י פאָן מיט קיין פארבונדן מוסטער (ד"ה, נאכגעגאנגען מיד דורך אנדערן -י ) איז געמאכט פאַראַנען צו קיין אנדערע פּאַטערנז אין דער זעלביקער דערוואַרטן באַפֿעלן פארבונדן מיט אַנע_ספּאַוונ_יד.
דער -יי פאָן קען אויך נאָמען אַ גלאבאלע בייַטעוודיק אין וועלכע פאַל די בייַטעוודיק איז לייענען פֿאַר אַ רשימה פון רויטן יידז. די בייַטעוודיק איז רידערד ווען עס ענדערונגען. דעם גיט אַ וועג פון טשאַנגינג די איך / אָ מקור בשעת דער באַפֿעל איז אין דורכפירונג. ספּון יידז ביטנייַ דעם וועג זענען גערופן "ומדירעקט" רויטן יידז.
אַקטיאָנס אַזאַ ווי ברעכן און פאָרזעצן גרונט קאָנטראָל סטראַקטשערז (ד"ה, פֿאַר , פּראָק ) צו ביכייוו אין די געוויינטלעך וועג. דער באַפֿעל עקספּ_קאָנטינוע אַלאַוז דערוואַרטן זיך צו פאָרזעצן עקסאַקיוטינג אלא ווי אומגעקערט ווי עס נאָרמאַלי וואָלט.
דעם איז נוצלעך פֿאַר אַוווידינג יקספּליסאַט שלייקס אָדער ריפּיטיד דערוואַרטן סטייטמאַנץ. די ווייַטערדיק בייַשפּיל איז טייל פון אַ פראַגמענט צו אָטאַמייט ראָגלין. די עקספּ_קאָנטינוע אַוווידז האט צו שרייַבן אַ רגע דערוואַרטן דערקלערונג (צו קוקן פֿאַר די פּינטלעך ווידער) אויב די רללינן פּראַמפּס פֿאַר אַ פּאַראָל.
דערוואַרטן {שפּריכוואָרט: {stty -echo send_user} "פּאַראָל (פֿאַר $ באַניצער) אויף $ באַלעבאָס:" expect_user -re "(. *) \ n" send_user "\ n" שיקן "$ expect_out (1, string) \ r" stty echo exp_continue} ניט ריכטיק {send_user "פאַרקריפּלט פּאַראָל אָדער חשבון \ n" אַרויסגאַנג} timeout {send_user "קשר צו $ האָסט טיימד אויס \ n" עקסיט} עאָף {send_user \ "קשר צו באַלעבאָס ניט אַנדערש: $ expect_out (באַפער)" אַרויסגאַנג} שרייַבט אַרייַן $)פֿאַר בייַשפּיל, די פאלגענדע פראַגמענט זאל העלפן אַ באַניצער פירן אַן ינטעראַקטיאָן וואָס איז שוין גאָר אָטאַמייטיד. אין דעם פאַל, די וואָקזאַל איז שטעלן אין רוי מאָדע. אויב דער באַניצער גיט "+", אַ בייַטעוודיק איז ינקראַמענטיד. אויב "פּ" איז געדריקט, עטלעכע רעטורנס זענען געשיקט צו דעם פּראָצעס, טאָמער צו שטופּן עס אין עטלעכע וועגן, און "איך" לעץ דער באַניצער ינטעראַקט מיט דעם פּראָצעס, יפעקטיוולי סטילינג קאָנטראָל פון די שריפט. אין יעדער פאַל, די עקספּ_קאָנטינוע אַלאַוז די קראַנט דערוואַרטן צו פאָרזעצן מוסטער וואָס ריכטן נאָך עקסאַקיוטינג די קראַנט קאַמף.
stty raw -echo expect_after {-i $ user_spawn_id "פּ" {שיקן "\ r \ r \ r"; exp_continue} "+" {incr foo; exp_continue} "איך" {interact; exp_continue} "פאַרלאָזן" אַרויסגאַנג}דורך פעליקייַט, עקספּ_קאָנטינוע רעסעץ די טיימאַוט טייַמער. דער טייַמער איז נישט ריסטאַרטיד, אויב עקספּ_קאָנטינוע איז גערופן מיט די -קאָנטינוע_טימער פאָן.
expected_after [דערוואַרטן_אַרגס]
אַרבעט יידעניקאַללי צו די דערוואַרטונג איידער, כאָטש אויב די מוסטער פון ביידע דערוואַרטן און דערוואַרטן יבערקוקן, קענען דערוואַרטן די דערוואַרטן מוסטער. זע די expected_before באַפֿעל פֿאַר מער אינפֿאָרמאַציע.
expect_background [דערוואַרטן_אַרגס]
נעמט די זעלבע אַרגומענטן ווי דערוואַרטן , אָבער עס קערט מיד. פּאַטטערנס זענען טעסטעד ווען נייַ אַרייַנשרייַב קומט. דער מוסטער טיימאַוט און פעליקייַט זענען סאַנקט צו דערוואַרטן_באַקקגראָונד און זענען בישטיקע דיסקאַרדיד. אַנדערש, די דערוואַרטונג_באַקקסטראַקט באַפֿעל ניצט expect_before and expect._after patterns just as expected .
ווען דערוואַרטונג_באַקקגראָונד אַקשאַנז זענען עוואַלואַטעד, הינטערגרונט פּראַסעסינג פֿאַר די זעלבע רויטער שייַן איז אפגעשטעלט. הינטערגרונט פּראַסעסינג איז ונבלאָקקעד ווען דער קאַמף קאַמפּליץ. בשעת הינטערגרונט פּראַסעסינג איז אפגעשטעלט, עס איז מעגלעך צו טאָן אַ (פאָרגראַונד) דערוואַרטן אויף דער זעלביקער רויטער שייַן.
עס איז ניט מעגלעך צו ויספירן אַ דערוואַרטונג ווען אַ וואַוטש_באַקקראָד איז ונבלאָקקעד. דערוואַרטונגקבאַקקגראָונד פֿאַר אַ באַזונדער רוימישע שייעך איז אויסגעמעקט דורך דערקלערונג פון אַ נייַ וואַוטשינג_באַקקראָד מיט די זעלבע רויטער שייַן. דעקלאַרינג expect_background מיט קיין מוסטער רימוווז דער געגעבן רויטער שייַן פון די פיייקייַט צו גלייַכן פּאַטערנז אין דער הינטערגרונט.
expected_before [expected_args]
נעמט די זעלבע אַרגומענטן ווי דערוואַרטן , אָבער עס קערט מיד. מוסטער-קאַמף פּערז פון די מערסט פריש דערוואַרטונג_טאָרף מיט די זעלבע רוימישע שייַן זענען ימפּליסאַטלי צוגעגעבן צו קיין פאלגענדע דערוואַרטן קאַמאַנדז. אויב אַ מוסטער שוועבעלעך, עס איז באהאנדלט ווי אויב עס איז געווען ספּעסאַפייד אין די דערוואַרטן באַפֿעל זיך, און די פארבונדן גוף איז עקסאַקיוטיד אין די קאָנטעקסט פון די דערוואַרטן באַפֿעל. אויב די מוסטער פון ביידע דערוואַרטונג & אַמפּ; איידער און דערוואַרטן קען גלייַכן, די דערוואַרטונג פון דער ווייַטער מוסטער איז געניצט.
אויב קיין מוסטער איז ניט ספּעסאַפייד, די רויאַל שייַן איז ניט אָפּגעשטעלט פֿאַר קיין מוסטער.
סיידן אָווועררייטיד דורך אַ -י פאָן, expect_before patterns match against the spawn id defined at the time that the expecting_before command was executed (not when its pattern is matched).
די-אינפֿאָרמאַציע פאָן causes expect_before to return the current specifications of what patterns it will match. דורך פעליקייַט, עס ריפּאָרץ אויף די קראַנט רויאַל שייַן. אַ אַפּשאַנאַל ספּון שייַן באַשרייַבונג קען זיין געגעבן פֿאַר אינפֿאָרמאַציע אויף אַז רויטער שייַן. פֿאַר בייַשפּיל
expected_before -info-$ $אין רובֿ איין שפּאַן שייַן באַשרייַבונג קען זיין געגעבן. די פאָן-ינייטירד סאַפּרעסיז דירעקט רויג ידס אַז קומען בלויז פון ומדירעקט ספּעסאַפאַקיישאַנז.
אַנשטאָט אַ רויטן שייַן באַשרייַבונג, די פאָן "-אַל" וועט פאַרשאַפן "-פונקט" צו באַריכט אויף אַלע רויזן ידידס.
דער רעזולטאַט פון די-אינפֿאָרמאַציע פאָן קענען זיין ריוזד ווי דער אַרגומענט צו expect_before.
expected_tty [דערוואַרטן_אַרגס]
איז ווי דערוואַרט אָבער עס לייקס אותיות פון / דעוו / טטי (ד"ה קיסטראָוקס פון די באַניצער). דורך פעליקייַט, לייענען איז געטאן אין האַלב מאָדע. אזוי, שורות מוזן סוף מיט אַ צוריקקומען אין סדר צו דערוואַרטן צו זען זיי. דעם קען זיין געביטן דורך סטטי (זען די סטטי באַפֿעל ונטער).
expected_user [דערוואַרטן_אַרגס]
איז ווי דערוואַרטן אָבער עס לייענט אותיות פון סטדין (ד"ה קיסטראָוקס פון די באַניצער). דורך פעליקייַט, לייענען איז געטאן אין האַלב מאָדע. אזוי, שורות מוזן סוף מיט אַ צוריקקומען אין סדר צו דערוואַרטן צו זען זיי. דעם קען זיין געביטן דורך סטטי (זען די סטטי באַפֿעל ונטער).
גאָפּל
קריייץ אַ נייַע פּראָצעס . דער נייַ פּראָצעס איז אַ פּינטלעך קאָפּיע פון דעם קראַנט דערוואַרטן פּראָצעס . אויף הצלחה, גאָפּל קערט 0 צו די נייַ (קינד) פּראָצעס און קערט דער פּראָצעס שייַן פון דעם קינד פּראָצעס צו דעם פאָטער פּראָצעס . אויף דורכפאַל (טאָמיד רעכט צו פעלן פון רעסורסן, למשל, ויסבייַטן פּלאַץ, זכּרון), גאָפּל קערט -1 צו די פאָטער פּראָס , און קיין קינד פּראָצעס איז באשאפן.
פראָקעד פּראַסעסאַז אַרויסגאַנג דורך די עקסיט באַפֿעל, פּונקט ווי דער אָריגינעל פּראָצעס . פאַרדאָרבן פּראַסעסאַז זענען דערלויבט צו שרייַבן צו די לאָג טעקעס. אויב איר טאָן ניט דיסייבאַל דיבאַגינג אָדער לאָגינג אין רובֿ פון די פּראַסעסאַז, די רעזולטאַט קענען זיין קאַנפיוזינג.
עטלעכע פּטי ימפּלאַמענטיישאַן קען זיין צעמישט דורך קייפל לייענער און שרייבערס, אַפֿילו בשעת. אזוי, עס איז זיכער צו גאָפּל איידער ספּאַנינג פּראַסעסאַז.
ינטעראַקט [סטרינג 1 גוף1] ... [סטרינגן [באָדין]]
גיט קאָנטראָל פון דעם קראַנט פּראָצעס צו דער באַניצער, אַזוי אַז די קיסטראָוקס זענען געשיקט צו דעם קראַנט פּראָצעס , און די סטדאַו און סטדערר פון די קראַנט פּראָצעס זענען אומגעקערט.
שטריקל-גוף פּערז קענען זיין ספּעסאַפייד ווי אַרגומענטן, אין וועלכע פאַל די גוף איז עקסאַקיוטאַד ווען די קאָראַספּאַנדינג שטריקל איז אריין. (דורך פעליקייַט, די שטריקל איז נישט געשיקט צו דעם קראַנט פּראָצעס .) די ינטערפּרעטער באַפֿעל איז אנגענומען, אויב די לעצט גוף איז פעלנדיק.
אויב די אַרגומענטן צו די גאנצע ינטעראַקט ויסזאָגונג דאַרפן מער ווי איין שורה, אַלע די אַרגומענטן קען זיין "בראַסעד" אין איין אַזוי ווי צו ויסמייַדן טערמאַנייטינג יעדער שורה מיט אַ באַקקלאַש. אין דעם איין פאַל, די געוויינטלעך טקל סאַבסטיטיושאַנז וועט פאַלן טראָץ די ברייסאַז.
פֿאַר בייַשפּיל, די ווייַטערדיק באַפֿעל לויפט ינטעראַקט מיט די פאלגענדע שטריקל-גוף פּערז דיפיינד: ווען * ז איז געדריקט, עקספּעקט איז סוספּענדעד. (די -רעסעט פאָן ריסטאָרז די וואָקזאַל מאָדעס.) ווען ^ A איז געדריקט, דער באַניצער זעט "איר טייפּט אַ קאָנטראָל-א" און דער פּראָצעס איז געשיקט אַ * א. ווען $ איז געדריקט, דער באַניצער זעט די דאַטע. ווען ^ C איז געדריקט, דערוואַרטן עגזיץ. אויב "פאָו" איז אריין, דער באַניצער זעט "באַר". ווען ~~ איז געדריקט, די עקספּעקט יבערזעצער לויפט ינטעראַקטיוולי.
set CTRLZ \ 032 interact {-reset $ CTRLZ {execute kill -STOP [pid]} \ 001 {send_user "איר טייפּט אַ קאָנטראָל-א \ n"; שיקט "\ 001"} $ {send_user "די טאָג איז [זייגער פֿאָרמאַט [זייגער סעקונדן]]."} \ 003 אַרויסגאַנג פאָו {סעאַס_וסער "באַר"} ~~}אין שטריקל-גוף פּערז, סטרינגס זענען מאַטשט אין די סדר זיי זענען ליסטעד ווי אַרגומענטן. סטרינגס אַז טייל גלייַכן זענען נישט געשיקט צו דעם קראַנט פּראָצעס אין אַנטיסאַפּיישאַן פון די רעשט קומען. אויב אותיות זענען דעמאָלט אַרייַנגערעכנט אַזוי אַז עס קען ניט מער זיין אַ גלייַכן, נאָר דער טייל פון די שטריקל וועט ווערן געשיקט צו דעם פּראָצעס וואָס קען נישט עפשער אָנהייבן אן אנדער גלייַכן. אזוי, די סטרינגס וואָס זענען סובסטרינגס פון פּאַרטיייש שוועבעלעך קענען צופּאַסן שפּעטער, אויב דער אָריגינעל סטרינגס וואָס איז געווען אַטשיווד צו זיין גלייַכן לעסאָף פיילז.
דורך פעליקייַט, שטריקל וואָס ריכטן זיך איז פּינטלעך מיט קיין ווילד קאַרדס . (אין קאַנטראַסט, די דערוואַרטן באַפֿעל ניצט גלאָב-נוסח מוסטער דורך פעליקייַט.) די -עקס פאָן קען זיין געניצט צו באַשיצן די מוסטער וואָס קען אַנדערש גלייַכן ינטעראַקט פלאַגס פון טאן אַזוי. קיין מוסטער אָנפאַנגען מיט אַ "-" זאָל זיין פּראָטעקטעד דעם וועג. (כל סטרינגס סטאַרטינג מיט "-" זענען רעזערווירט פֿאַר צוקונפֿט אָפּציעס.)
די -רע פאָן פאָרסעס די שטריקל צו זיין ינטערפּראַטאַד ווי אַ רעגעקספּ-נוסח מוסטער. אין דעם פאַל, וואָס ריכטן סובסטרינגס זענען סטאָרד אין די בייַטעוודיק ינטעראַקט_אָוט גלייַך צו דערוואַרטן דערוואַרטן סטאָרז זייַן רעזולטאַט אין די בייַטעוודיק ווייטשונג . די- ינדיסעס פאָן איז סימפּלי שטיצט.
דער מוסטער עף ינטראַדוסיז אַ קאַמף אַז איז עקסאַקיוטאַד אויף די סוף-פון-טעקע. א באַזונדער עופ מוסטער קען אויך נאָכפאָלגן די -אָוטפּוט פאָן אין וואָס פאַל עס איז מאַטשט אויב אַ עף איז דיטעקטאַד בשעת שרייבן פּראָדוקציע. די default EOF קאַמף איז "צוריקקומען", אַזוי אַז ינטעראַקט פשוט קערט אויף קיין עאָף.
דער מוסטער טיימאַוט ינטראַדוסיז אַ טיימאַוט (אין סעקונדן) און קאַמף וואָס איז עקסאַקיוטיד נאָך קיין אותיות האָבן שוין לייענען פֿאַר אַ געגעבן צייַט. די טיימאַוט מוסטער אַפּלייז צו די לעצטנס ספּעסאַפייד פּראָצעס . עס איז קיין פעליקייַט טיימאַוט. דער ספּעציעל בייַטעוודיק "טיימאַוט" (געניצט דורך די דערוואַרטן באַפֿעל) האט קיין ווירקונג אויף דעם טיימאַוט.
פֿאַר בייַשפּיל, די פאלגענדע סטאַטעמענט קען זיין געניצט צו אַוטאָלאָגאָוט ניצערס וואס האָבן נישט טייפּט עפּעס פֿאַר אַ שעה אָבער וואס נאָך באַקומען אָפט סיסטעם אַרטיקלען:
ינטעראַקט-ינפּוט $ user_spawn_id טיימאַוט 3600 צוריקקומען -אָוטפּוט \ $ ספּאַוונ_ידאויב די מוסטער איז די קיווערד נאַל , און נולז זענען ערלויבט (דורך די באַפֿעל באַזייַטיקונג_נוללס ), די קאָראַספּאַנדינג גוף איז עקסאַקיוטאַד אויב אַ איין ASCII 0 איז מאַטשט. עס איז ניט מעגלעך צו גלייַכן 0 ביטעס דורך גלאָב אָדער רעקסעקספּ פּאַטערנז.
פּרעפאַסינג אַ מוסטער מיט די פאָן -וויסייט זייַנען די בייַטעוודיק ינטעראַקט_אָוט (ספּאַוונ_יד) צו שטעלן צו די ספּאַוונ_יד וואָס גלייַכן די מוסטער (אָדער עאָף).
אַקטיאָנס אַזאַ ווי ברעכן און פאָרזעצן גרונט קאָנטראָל סטראַקטשערז (ד"ה, פֿאַר , פּראָק ) צו ביכייוו אין די געוויינטלעך וועג. אָבער צוריקקומען זייַנען ינטעראַקט צו צוריקקומען צו זייַן קאַללער, while inter_return causes interact to cause a return in its caller. פֿאַר בייַשפּיל, אויב "פּראָק פאָו" גערופן ינטעראַקט אַז דעמאָלט עקסאַקיוטיד די קאַמף ינטער_רעטורן , פּראָק פאָאָ וואָלט צוריקקומען. (דאס מיינט אז אויב ינטעראַקט רופט יבערשיקן ינטעראַקטיוועלי טייפּינג קריק וועט פאַרשאַפן די ינטעראַקט צו פאָרזעצן, while inter_return will cause the interact to return to its caller.)
בעת ינטעראַקט , רוי מאָדע איז געניצט אַזוי אַז אַלע אותיות קענען זיין דורכגעגאנגען צו דעם קראַנט פּראָצעס . אויב די קראַנט פּראָצעס טוט נישט כאַפּן אַרבעט קאָנטראָל סיגנאַלז, עס וועט האַלטן אויב געשיקט אַ האַלטן סיגנאַל (דורך פעליקייַט ^ ז). צו ריסטאַרט עס, שיקן אַ פאָרויס סיגנאַל (אַזאַ ווי דורך "טייטן-קאַנט"). אויב איר טאַקע ווילן צו שיקן אַ סיגסטאָפּ צו אַזאַ אַ פּראָצעס (דורך ^ ז), באַטראַכטן ספּאַנינג קש ערשטער און דעמאָלט לויפן דיין פּראָגראַם. אויף די אנדערע האַנט, אויב איר ווילן צו שיקן אַ סיגסטאָפּ צו דערוואַרטן , ערשטער רופן די ינטערפּרעטער (טאָמער דורך ניצן אַ אַנטלויפן כאַראַקטער), און דריקן ^ ז.
שטריקל-גוף פּערז קענען זיין געניצט ווי אַ סטענאָגראַפיע צו ויסמייַדן בעת צו אַרייַן די יבערזעצער און ויספירן קאַמאַנדז ינטעראַקטיוועלי. די פרייַערדיק וואָקזאַל מאָדע איז געניצט בשעת דער גוף פון אַ שטריקל-גוף פּאָר איז זייַענדיק עקסאַקיוטאַד.
פֿאַר גיכקייַט, אַקשאַנז לויפן אין רוי מאָדע דורך פעליקייַט. די -רעסעט פאָן ריסעץ די וואָקזאַל צו די מאָדע עס האט איידער ינטעראַקט איז עקסאַקיוטיד (טאָמיד, האַלב מאָדע). באַמערקונג אַז אותיות אַרייַנגערעכנט ווען די מאָדע איז באַשטימען זאל זיין פאַרפאַלן (אַ נעבעך שטריך פון די וואָקזאַל שאָפער אויף עטלעכע סיסטעמס). דער בלויז סיבה צו נוצן- באַשטעטיק איז אויב דיין קאַמף דעפּענדס אויף פליסנדיק אין האַלב מאָדע.
די -echo פאָן סענדז אותיות וואָס גלייַכן די פאלגענדע מוסטער צוריק צו דעם פּראָצעס וואָס דזשענערייטאַד זיי ווי יעדער כאַראַקטער איז לייענען. דאָס קען זיין נוציק ווען דער באַניצער דארף צו זען באַמערקונגען פון טייל טייפּט פּאַטערנז.
אויב אַ מוסטער איז אפגעשטעלט, אָבער יווענטשאַוואַלי פיילז, די אותיות זענען געשיקט צו די ספּאַנדזשד פּראָצעס . אויב די ספּאָאָנעד פּראָצעס דעמאָלט עקאָוז זיי, דער באַניצער וועט זען די אותיות צוויי מאָל. -טשאָ איז מיסטאָמע בלויז צונעמען אין סיטואַטיאָנס ווו דער באַניצער איז אַנלייקלי צו פאַרענדיקן דעם מוסטער. למשל, דער ווייַטערדיק עקסערפּט איז פון רפטפּ, די רעקורסיווע-פטפּ שריפט, ווו דער באַניצער איז פּראַמפּטאַד צו אַרייַן ~ ג, ~ פּ, אָדער ~ ך, צו באַקומען, שטעלן אָדער רשימה די קראַנט Directory רעקורסיוועלי. דאס זענען אַזוי ווייַט אַוועק פון די נאָרמאַל פטפּ קאַמאַנדז, אַז דער באַניצער איז אַנלייקלי צו טיפּ ~ נאכגעגאנגען דורך עפּעס אַנדערש, אַחוץ מיסטייקאַנלי, אין וועלכע פאַל, זיי וועט מיסטאָמע נאָר איגנאָרירן די רעזולטאַט סייַ ווי סייַ.
interact {-echo ~ g {getcurdirectory 1} -echo ~ l {getcurdirectory 0} -echo ~ p {putcurdirectory}}דער -נאָבופפער פאָן סענדז אותיות וואָס גלייַכן די ווייַטערדיק מוסטער צו די רעזולטאַט פּראָצעס ווי אותיות זענען לייענען.
דעם איז נוציק ווען איר ווילט צו לאָזן אַ פּראָגראַם ווידערקאָל צוריק דעם מוסטער. פֿאַר בייַשפּיל, די פאלגענדע זאל זיין געניצט צו מאָניטאָר ווו אַ מענטש איז דיילינג (אַ הייַעס-מאָדע מאָדעם). יעדער צייַט "אַטד" איז געזען די שריפט לאָגס די רעשט פון די שורה.
$ 1 ',' interact -nobuffer -re "(. *) \ r 'return returns $ log [clock format]בשעת ינטעראַקט , די פריערדיקע נוצן פון log_user איז איגנאָרירט. אין באַזונדער, ינטעראַקט וועט קראַפט זייַן רעזולטאַט צו זיין לאָגד (געשיקט צו די סטאַנדאַרט רעזולטאַט), ווייַל עס איז מסתּמא דער באַניצער טוט נישט וועלן צו ינטעראַקט בליינדלי.
די -אָ פאָן זייַנען ווייַטערדיק שליסל-גוף פּערז צו זיין געווענדט צו דער רעזולטאַט פון דעם קראַנט פּראָצעס . דעם קען זיין נוציק, פֿאַר בייַשפּיל, ווען דיליווערינג מיט מחנות אַז שיקן אַנוואָנטיד אותיות בעשאַס אַ טעלנעט סעסיע.
דורך פעליקייַט, ינטעראַקט יקספּעקץ דער באַניצער צו זיין שרייַבן סטדין און לייענען סטדאָוט פון די דערוואַרטן פּראָצעס זיך. די -ו פאָן (פֿאַר "באַניצער") מאכט ינטעראַקט קוקן פֿאַר די באַניצער ווי דער פּראָצעס געהייסן דורך זייַן אַרגומענט (וואָס מוזן זייַן אַ רויאַל שייַן).
דעם אַלאַוז צוויי אַנרילייטיד פּראַסעסאַז צו זיין איינגעשריבן צוזאַמען אָן ניצן אַ יקספּליסאַט שלייף. צו העלפן דיבאַגינג, דערוואַרט דיאַגנאָסטיקס שטענדיק גיין צו סטדערר (אָדער סטדאָוט פֿאַר זיכער לאָגגינג און דיבאַגינג אינפֿאָרמאַציע). פֿאַר דער זעלביקער סיבה, די ינטערפּרעטער באַפֿעל וועט לייענען ינטעראַקטיוועלי פון סטדין.
פֿאַר בייַשפּיל, די פאלגענדע פראַגמענט קריייץ אַ לאָגין פּראָצעס . דערנאך עס רעדל דער באַניצער (ניט געוויזן), און לעסאָף קאַנעקץ די צוויי צוזאַמען. פון קורס, קיין פּראָצעס זאל זיין סאַבסטאַטוטאַד פֿאַר לאָגין. א שאָל, פֿאַר בייַשפּיל, וואָלט לאָזן די באַניצער צו אַרבעטן אָן צושטעלן אַ חשבון און פּאַראָל.
spawn login set login $ spawn_id spawn tip modem # רעדל צוריק צו באַניצער # פאַרבינדן באַניצער צו לאָגין ינטעראַקט-אַ $ loginצו שיקן רעזולטאַט צו קייפל פּראַסעסאַז, רשימה יעדער רויאַל אדווייז רשימה פּרעפאַססט דורך אַ -אָוטפּוט פאָן. אַרייַנשרייַב פֿאַר אַ גרופּע פון רעזולטאַט רויזן ידס קען זיין באשלאסן דורך אַ רויטן שייַן שייַן רשימה פּרעפאַסייד דורך אַ- אַרייַנשרייַב פאָן. (ביידע- ינפּוט און -אָוטפּוט זאל נעמען רשימות אין די זעלבע פאָרעם ווי די -י פאָן אין די דערוואַרטן באַפֿעל, חוץ אַז קיין_ספּאַוונ_יד איז נישט באַטייַטיק אין ינטעראַקט .) אַלע פאלגענדע פלאַגס און סטרינגס (אָדער פּאַטערנז) אַפּלייז צו דעם אַרייַנשרייַב ביז אנדערן - אַרייַנשרייַב פלאַג אויס. אויב ניט- ינפּוט אויס, -אָוטפּוט ימפּלייז "-ינפּוט $ user_spawn_id -output". (סימילאַרלי, מיט פּאַטערנז וואָס טאָן ניט האָבן- ינפּוט .) אויב איינער- ינפּוט איז ספּעסאַפייד, עס אָוווערריידז $ user_spawn_id. אויב אַ צווייטע- ינפּוט איז ספּעסאַפייד, עס אָוווערריידז $ spawn_id. נאָך- ינפּוט פלאַגס קענען זיין ספּעסאַפייד.
די צוויי ימפּלייד אַרייַנשרייַב פּראַסעסאַז פעליקייַט צו ווייל זייער רעזולטאטן ספּעסאַפייד ווי $ spawn_id און $ user_spawn_id (אין פאַרקערט). אויב אַ- ינפּוט פלאַג אויס מיט קיין אויסזען פאָן, אותיות פון דעם פּראָצעס זענען דיסקאַרדיד.
די -א פאָן ינטראַדוסיז אַ פאַרבייַט פֿאַר די קראַנט ספּאַוונ_יד ווען קיין אנדערע- ינפּוט אָדער -אָוטפּוט פלאַגס זענען געניצט. א -י פאָן ימפּלייז אַ -אָ פאָן.
עס איז מעגלעך צו טוישן די פּראַסעסאַז וואָס זענען ינטעראַקטיד מיט ניצן ומדירעקט רויזן ידידס. (ינדירעקט רויטן ידס זענען דיסקרייבד אין דער אָפּטיילונג אויף די דערוואַרטן באַפֿעל.) ומדירעקט רויטער ידס קען זיין ספּעסאַפייד מיט די -i, -ו, -ינפּוט, אָדער -אָוטפּוט פלאַגס.
interpreter [args]
קען דער באַניצער ינטעראַקטיוולי פּראַמפּטיד פֿאַר עקספּעקט און טקל קאַמאַנדז. דער רעזולטאַט פון יעדער באַפֿעל איז געדרוקט.
אַקטיאָנס אַזאַ ווי ברעכן און פאָרזעצן גרונט קאָנטראָל סטראַקטשערז (ד"ה, פֿאַר , פּראָק ) צו ביכייוו אין די געוויינטלעך וועג. אָבער אומקערן זייַנען איבערזעצער צו צוריקקומען צו דעם אָנפרעג, בשעת ינטער_רעטורן זייַנען יבערזעצער צו פאַרשאַפן אַ צוריקקער אין זייַן קאַללער. פֿאַר בייַשפּיל, אויב "פּראָק פאָו" גערופן יבערזעצער וואָס דעמאָלט עקסאַקיוטאַד די קאַמף ינטער_רעטורן , פּראָק פאָאָ וואָלט צוריקקומען. קיין אנדערע באַפֿעלן זייַנען יבערזעצער צו פאָרזעצן פּראַמפּטינג פֿאַר נייַ קאַמאַנדז.
דורך פעליקייַט, די פּינטלעך כּולל צוויי ינטאַדזשערז. דער ערשטער ינטעגער באשרייבט די טיפקייַט פון די עוואַלואַטיאָן סטאַק (ד"ה, ווי פילע מאל טקל_עוואַל איז גערופן). די רגע ינטעגער איז די טקל געשיכטע יידענאַפייד. די פּינטלעך קענען זיין באַשטימט דורך דיפיינינג אַ פּראָצעדור גערופן "פּמפּט 1" וועמענס קריק ווערט ווערט דער ווייַטער פּינטלעך. אויב אַ ויסזאָגונג האט עפענען קוואָטעס, פּאַרענס, ברייסאַז, אָדער בראַקאַץ, אַ צווייטיק פּינטלעך (דורך פעליקייַט "+>") איז ארויס אויף נעוולינע. די צווייטיק פּינטלעך קען זיין באַשטימט דורך דיפיינינג אַ פּראָצעדור גערופן "פּראָמפּט 2".
בעת ינטערפּרעטער , האַלב מאָדע איז געניצט, אַפֿילו אויב די קאַללער איז ניצן רוי מאָדע.
אויב סטדין איז פארשלאסן, די יבערזעצער וועט צוריקקומען אויב דער -עף פאָן איז געניצט, אין וועלכע פאַל די סאַבסאַקוואַנט אַרגומענט איז ינוווקטיד.
log_file [args] [[-a] טעקע]
אויב אַ פילענאַמע איז צוגעשטעלט, log_file וועט רעקאָרדירט אַ טראַנסקריפּציע פון די סעסיע (אָנהייב בייַ אַז פונט) אין די טעקע. לאָג_פילע וועט האַלטן רעקאָרדינג אויב קיין אַרגומענט איז געגעבן. קיין פרייַערדיק קלאָץ טעקע איז פארשלאסן.
אַנשטאָט אַ פילענאַמע, אַ טקל טעקע ידענטיפיער קענען זיין צוגעשטעלט דורך ניצן די -אָפּען אָדער -לעאַוועאָפּען פלאַגס. דאָס איז ענלעך צו דער רעגירונג באַפעלן. (זען רויטן פֿאַר מער אינפֿאָרמאַציע.)
די -א פאָן פאָרסעס רעזולטאַט צו זיין לאָגד וואָס איז געווען סאַפּרעסט דורך די לאָג_וסער באַפֿעל.
דורך פעליקייַט, די log_file באַפֿעל אַפּפּענדז צו אַלט טעקעס גאַנץ ווי טרונקייטינג זיי, פֿאַר די קאַנוויניאַנס פון זייַענדיק קענען צו ווענדן לאָגינג אַוועק און אויף קייפל מאל אין איין סעסיע. צו טראַנגקייטירן טעקעס, נוצן די -נאַפּלענד פאָן.
די- אינפֿאָרמאַציע פאָן זאָגט log_file צו צוריקקומען אַ באַשרייַבונג פון די מערסט פריש ניט-אינפֿאָרמאַציע טענות געגעבן.
log_user -info | 0 | 1
דורך פעליקייַט, די שיקן / דערוואַרטן דיאַלאָג איז לאָגד צו סטדאָוט (און אַ לאָגפילע אויב עפענען). די לאָגגינג צו סטדאָוט איז פאַרקריפּלט דורך די באַפֿעל "לאָג_וסער 0" און ריינאַבאַל דורך "לאָג_וסער 1". לאָגינג צו די לאָגפילע איז אַנטשיינדזשד.
די- אינפֿאָרמאַציע פאָן זאָגט log_user צו צוריקקריגן אַ באַשרייַבונג פון די מערסט פריש ניט-אינפֿאָרמאַציע טענות געגעבן.
match_max [-d] [-i spawn_id] [גרייס]
דיפיינז די גרייס פון די באַפער (אין ביטעס) געניצט ינעווייניק דורך דערוואַרטן . מיט קיין נומער אַרגומענט, די קראַנט גרייס איז אומגעקערט.
מיט די -ד פאָן, די פעליקייַט גרייס איז שטעלן. (די ערשטע פעליקייַט איז 2000.) מיט דעם -י פאָן, די גרייס איז באַשטימט פֿאַר די געהייסן רויטער שייַן, אַנדערש עס איז באַשטימט פֿאַר דעם קראַנט פּראָצעס .
אָוווערליי [- # spawn_id] [- # spawn_id] [...] פּראָגראַם [אַרגס]
עקסאַקיוץ "פּראָגראַם אַרגס" אין פּלאַץ פון דעם קראַנט דערוואַרטן פּראָגראַם, וואָס טערמינייץ. א נאַקעט באַפֿעלן אַרגומענט פאָרסעס אַ באַפף אין פראָנט פון די באַפֿעלן נאָמען ווי אויב עס איז אַ לאָגין שאָל. אַלע ספּאַוונ_ידס זענען פארשלאסן אַחוץ פֿאַר די געהייסן ווי טענות. די זענען מאַפּט אַנטו די געהייסן טעקע יידענטאַפייערז.
ספּאַוונ_ידס זענען מאַפּטיד צו טעקע יידענטאַפייערז פֿאַר די נייַע פּראָגראַם צו ירשענען. פֿאַר בייַשפּיל, די פאלגענדע שורה שאָוז שאָך און אַלאַוז עס צו זיין קאַנטראָולד דורך דעם קראַנט פּראָצעס - זאָגן, אַ שאָך בעל.
אָוווערליי -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id שאָךדעם איז מער עפעקטיוו ווי "ינטעראַקט-ו", אָבער, עס קרבן די פיייקייַט צו טאָן פּראָוגראַמד ינעראַקשאַן זינט די דערוואַרטן פּראָצעס איז ניט מער אין קאָנטראָל.
באַמערקונג אַז קיין קאַנטראָולינג וואָקזאַל איז צוגעשטעלט. אזוי, אויב איר דיסקאַנעקט אָדער רימאָוט נאָרמאַל אַרייַנשרייַב, מגילה וואָס טאָן אַרבעט קאָנטראָל (שעלז, לאָגין, עטק) וועט נישט אַרבעטן רעכט.
parity [-d] [-i spawn_id] [ווערט]
דיפיינז אויב פּאַריטעט זאָל זיין ריטיינד אָדער סטריפּט פון די פּראָדוקציע פון ספּאון פּראַסעסאַז. אויב ווערט איז נול, פּאַריטעט איז סטרייפּט, אַנדערש עס איז נישט סטריפּט. מיט קיין ווערט אַרגומענט, די קראַנט ווערט איז אומגעקערט.
מיט דעם -ד פאָן, די פעליקייַט פּאַריטעט ווערט איז באַשטימט. (די ערשטע פעליקייַט איז 1, דאָס הייסט, פּאַריטעט איז נישט סטריפּט.) מיט די -י פאָן, די פּאַריטעט ווערט איז באַשטימט פֿאַר די געהייסן רויף שייַן, אַנדערש עס איז באַשטימט פֿאַר דעם קראַנט פּראָצעס .
remove_nulls [-d] [-i spawn_id] [ווערט]
דיפיינז צי נולז זענען ריטיינד אָדער אראפגענומען פון די פּראָדוקציע פון ספּאָנעד פּראַסעסאַז איידער מוסטער וואָס ריכטן אָדער סטאָרינג אין די בייַטעוודיק ווייט_קאָוט אָדער ינטעראַקט_אָוט . אויב ווערט איז 1, נולז זענען אַוועקגענומען. אויב ווערט איז 0, נולז זענען נישט אַוועקגענומען. מיט קיין ווערט אַרגומענט, די קראַנט ווערט איז אומגעקערט.
מיט די -ד פאָן, די פעליקייַט ווערט איז באַשטימט. (די ערשטע פעליקייַט איז 1, ד"ה נולז זענען אַוועקגענומען.) מיט דעם -י פאָן, די ווערט איז באַשטימט פֿאַר די געהייסן רויף שייַן, אַנדערש עס איז באַשטימט פֿאַר די קראַנט פּראָצעס .
אויב ניט נולז זענען אַוועקגענומען, עקספּעקט וועט רעקאָרדירן נאַל ביטעס צו די קלאָץ און סטדאָוט.
שיקן [- פלאַגס] שטריקל
סענדז שטריקל צו דעם קראַנט פּראָצעס . פֿאַר בייַשפּיל, די באַפֿעל
סענדז די אותיות, העללאָוואָרלד צו די קראַנט פּראָצעס . (Tcl includes a printf- like command (called format ) וואָס קענען בויען אַרביטראַריש קאָמפּלעקס סטרינגס.)
אותיות זענען געשיקט מיד כאָטש מגילה מיט שורה-באַפערד אַרייַנשרייַב וועט נישט לייענען די אותיות ביז אַ צוריקקומען כאַראַקטער איז געשיקט. א צוריקקער כאַראַקטער איז דינאַמייטיד "\ r".
די - פאָן פאָרסעס די ווייַטער אַרגומענט צו זיין ינטערפּראַטאַד ווי אַ שטריקל, אָבער נישט אַ פאָן. קיין סטרינג קענען זיין פּריסידאַד דורך "-" צי אָדער ניט עס טאַקע קוקט ווי אַ פאָן. דעם פּראָווידעס אַ פאַרלאָזלעך מעקאַניזאַם צו ספּעציפיצירן בייַטעוודיק סטרינגס אָן זייַענדיק טריפּט אַרויף דורך יענע אַז אַקסאַדענאַלי קוקן ווי פלאַגס. (כל סטרינגס סטאַרטינג מיט "-" זענען רעזערווירט פֿאַר צוקונפֿט אָפּציעס.)
די -א פאָן דערקלערט אַז די שטריקל איז געשיקט צו די געהייסן spawn_id. אויב די spawn_id איז user_spawn_id , און דער וואָקזאַל איז אין רוי מאָדע, נעוולינעס אין די שטריקל זענען איבערגעזעצט צו צוריקקומען-נעוולינע סיקוואַנסיז אַזוי אַז זיי דערשייַנען ווי אויב דער וואָקזאַל איז געווען אין האַלב מאָדע. די -אַוו פאָן דיסייבאַלז דעם איבערזעצונג.
די -נאָל פאָן סענדז נול אותיות (0 ביטעס). דורך פעליקייַט, איינער נאַל איז געשיקט. אַ ינטעגער קענען נאָכפאָלגן די- נאַל צו אָנווייַזן ווי פילע נולז צו שיקן.
דער -ברייק פאָן דזשענערייץ אַ ברעכן צושטאַנד. דאָס בלויז מאכט זינען אויב דער רויטער שייַן רעפערס צו אַ טטי מיטל געעפנט דורך "רויג -אָפּען". אויב איר האָט דערשייַנען אַ פּראָצעס אַזאַ ווי שפּיץ, איר זאָל נוצן די שפּיץ קאַנווענשאַן פֿאַר דזשענערייטינג אַ ברעכן.
די פאָן פאָרסעס רעזולטאַט צו זיין געשיקט "סלאָולי", אַזוי ויסמייַדן די פּראָסט סיטואַציע וווּ אַ קאָמפּיוטער אַוטפּייפּס אַ אַרייַנשרייַב באַפער אַז איז דיזיינד פֿאַר אַ מענטש וואס וואָלט קיינמאָל אַוטאָטיפּע די זעלבע באַפער . דעם רעזולטאַט איז קאַנטראָולד דורך די ווערט פון די בייַטעוודיק "סענד_סלאָוו" וואָס נעמט אַ צוויי עלעמענט רשימה. דער ערשטער עלעמענט איז אַ ינטאַדזשער אַז באשרייבט די נומער פון ביטעס צו שיקן אַטאָמיקאַללי. די רגע עלעמענט איז אַ פאַקטיש נומער אַז דיסקרייבד די נומער פון סעקונדעס דורך וואָס די אַטאָמישע סענדז מוזן זיין אפגעשיידט. פֿאַר בייַשפּיל, "שטעלן סענד_סלאָוו {10 .001}" וואָלט קראַפט "שיקן-ס" צו שיקן סטרינגס מיט 1 מיליוסקאַנד אין יעדער 10 אותיות געשיקט.
די- ה פאָן פאָרסעס רעזולטאַט צו זיין געשיקט (עפּעס) ווי אַ מענטש פאקטיש טייפּינג. מענטשלעך ווי דעלייַס דערשייַנען צווישן די אותיות. (די אַלגערידאַם איז באזירט אויף אַ וועיבולל פאַרשפּרייטונג, מיט מאַדאַפאַקיישאַנז צו פּאַסן דעם באַזונדער אַפּלאַקיישאַן.) דעם רעזולטאַט איז קאַנטראָולד דורך די ווערט פון די בייַטעוודיק "סענד_הומאַן" וואָס נעמט אַ פינף עלעמענט רשימה. דער ערשטער צוויי עלעמענטן זענען דורכשניטלעך ינטעראַרוואַל צייַט פון אותיות אין סעקונדעס. דער ערשטער איז געניצט דורך פעליקייַט. די רגע איז געניצט אין וואָרט ענדינגז, צו סימולירן די סאַטאַל פּאָזאַז אַז טייל מאָל פאַלן בייַ אַזאַ טראַנזישאַנז. די דריט פּאַראַמעטער איז אַ מאָס פון וואַריאַביליטי ווו .1 איז גאַנץ בייַטעוודיק, 1 איז גלייַך בייַטעוודיק, און 10 איז גאַנץ ינווייראַנאַבלי. די יקסטרימז זענען 0 צו ומענדיקייַט. די לעצטע צוויי פּאַראַמעטערס זענען, ריספּעקטיוולי, אַ מינימום און מאַקסימום ינטעראַריוואַל צייַט. די מינימום און מאַקסימום זענען לעצט און "קלעמערל" די לעצט צייַט. די דורכשניטלעך דורכשניטלעך קענען זיין גאַנץ אַנדערש פון די געגעבן דורכשניטלעך אויב די מינימום און מאַקסימום קלעמערל גענוג וואַלועס.
ווי אַ בייַשפּיל, די ווייַטערדיק באַפֿעל עמיאַלייץ אַ פעסט און קאָנסיסטענט טיפּיסט:
שטעלן סענד_הומאַן {.1 .3 1 .05 2} שיקן -ה "איך בין הונגעריק. זאל ס טאָן לאָנטש."בשעת די פאלגענדע זאל זיין מער פּאַסיק נאָך אַ כאַנגאָוווער:
שטעלן סענד_הומאַן {.4.4 .2 .5 100} שיקן -ה "Goodd party break night"!באַמערקונג אַז ערראָרס זענען נישט סימיאַלייטיד, כאָטש איר קענען שטעלן אַרויף טעות קערעקשאַן סיטואַטיאָנס זיך דורך עמבעדדינג מיסטייקס און קערעקשאַנז אין אַ שיקן אַרגומענט.
די פלאַגס פֿאַר שיקן נול אותיות, פֿאַר שיקן ברייקס, פֿאַר פאָרסינג פּאַמעלעך פּראָדוקציע און פֿאַר מענטש-נוסח רעזולטאַט זענען מיוטשואַלי ויסשליסיק. נאָר דער איינער ספּעסאַפייד לעצט וועט זיין געוויינט. דערצו, קיין סטרינג אַרגומענט קענען זיין ספּעסאַפייד מיט די פלאַגס פֿאַר שיקן נול אותיות אָדער ברייקס.
עס איז אַ גוט געדאַנק צו פאָרויסזאָגן דער ערשטער שיקן צו אַ פּראָצעס דורך אַ דערוואַרטן . דערוואַרטן וועט וואַרטן פֿאַר דעם פּראָצעס צו אָנהייבן, אָבער שיקן קענען נישט. אין באַזונדער, אויב דער ערשטער שיקן קאַמפּליץ איידער די פּראָצעס סטאַרץ פליסנדיק, איר לויפן די ריזיקירן פון כאָטש דיין דאַטע איגנאָרירט. אין סיטואַטיאָנס ווו ינטעראַקטיוו מגילה פאָרשלאָגן קיין ערשט פּינטלעך, איר קענען פאָרויס שיקן דורך אַ פאַרהאַלטן ווי אין:
# צו ויסמייַדן געבן כאַקערז הינץ אויף ווי צו ברעכן אין # דעם סיסטעם טוט נישט פּינטלעך פֿאַר אַ פונדרויסנדיק פּאַראָל. # וואַרטן פֿאַר 5 סעקונדעס פֿאַר עקסאַקיוטאַד צו פאַרענדיקן די שפּאָן telnet very.secure.gov שלאָפן 5 שיקן פּאַראָל \ rעקספּ_סענד איז אַ אַליאַס פֿאַר שיקן. אויב איר זענען ניצן עקספּעקטק אָדער עטלעכע אנדערע וואַריאַנט פון דערוואַרטן אין די טק סוויווע, שיקן איז דיפיינד דורך טק פֿאַר אַ גאנץ אַנדערש ציל. עקספּ_סענד איז צוגעשטעלט פֿאַר קאַמפּאַטאַבילאַטי צווישן ינווייראַנמאַנץ. ענלעך ייליאַסיז זענען צוגעשטעלט פֿאַר אנדערע עקספּעקט ס אנדערע שיקן קאַמאַנדז.
send_error [-flags] string
איז ווי שיקן , חוץ אַז די רעזולטאַט איז געשיקט צו סטדערר אלא ווי די קראַנט פּראָצעס .
send_log [-] string
איז ווי שיקן , חוץ אַז די שטריקל איז בלויז געשיקט צו די לאָג טעקע (זען log_file .) די אַרגומענטן זענען איגנאָרירט אויב קיין לאָג טעקע איז עפענען.
send_tty [-flags] string
איז ווי שיקן , חוץ אַז די רעזולטאַט איז געשיקט צו / דעוו / טטי גאַנץ ווי די קראַנט פּראָצעס .
send_user [-flags] string
איז ווי שיקן , חוץ אַז די רעזולטאַט איז געשיקט צו סטדאָוט גאַנץ ווי די קראַנט פּראָצעס .
שלאָפן סעקונדעס
זייַנען די שריפט צו שלאָפן פֿאַר די געגעבן נומער פון סעקונדעס. סעקונדעס קען זיין אַ דעצימאַל נומער. ינטעררופּץ (און טק געשעענישן אויב איר זענט ניצן עקספּעקטק) זענען פּראַסעסט בשעת דערוואַרטן סליפּס.
[אַרג] פּראָגראַם [אַרג]
קריייץ אַ נייַ פּראָצעס פליסנדיק "פּראָגראַם אַרגס". זייַן סטדין, סטדאָוט און סטדערר זענען פארבונדן צו דערוואַרטן, אַזוי זיי קענען זיין לייענען און געשריבן דורך אנדערע עקספּעקט קאַמאַנדז. דער קשר איז צעבראכן דורך נאָענט אָדער אויב דער פּראָצעס זיך קלאָוזיז קיין פון די טעקע יידענטאַפייערז.
ווען אַ פּראָצעס איז סטאַרטעד דורך רויאַל , די בייַטעוודיק spawn_id איז באַשטימט צו אַ דעסקריפּטאָר ריפערינג צו דעם פּראָצעס . דער פּראָצעס דיסקרייבד דורך ספּאַוונ_יד איז געהאלטן די "קראַנט פּראָצעס ". ספּאַוונ_יד זאל זיין לייענען אָדער געשריבן, אין ווירקונג פּראַוויידינג אַרבעט קאָנטראָל.
user_spawn_id איז אַ גלאבאלע בייַטעוודיק מיט אַ דעסקריפּטאָר וואָס רעפערס צו דער באַניצער. פֿאַר בייַשפּיל, ווען spawn_id איז באַשטימט צו דעם ווערט, דערוואַרטן ביכייווז ווי דערוואַרטונג_וסער .
.א טעות_ספּאַוונ_יד איז אַ גלאבאלע בייַטעוודיק מיט אַ דעסקריפּטאָר וואָס רעפערס צו די נאָרמאַל טעות. למשל, ווען spawn_id איז באַשטימט צו דעם ווערט, שיקן ביכייווז ווי סענד_עראָר .
tty_spawn_id איז אַ גלאבאלע בייַטעוודיק מיט אַ דעסקריפּטאָר וואָס רעפערס צו / dev / tty. אויב / dev / tty טוט נישט עקסיסטירן (אַזאַ ווי אין אַ קראָאָן, אין, אָדער בינטל שריפט), דעמאָלט טטי_ספּאַוונ_יד איז נישט דיפיינד. דעם קען זיין טעסטעד ווי:
אויב {{אינפֿאָרמאַציע} טטי_ספּאַוון_יד]} {# / dev / tty exists} אַנדערש {# / dev / טטי טוט נישט עקסיסטירן # מיסטאָמע אין קראַן, באַטש אָדער שריפט}מאַך קערט די יוניקס פּראָצעס שייַן. אויב קיין פּראָצעס איז באדעקט, 0 איז אומגעקערט. די בייַטעוודיק spawn_out (שקלאַף, נאָמען) איז באַשטימט צו די נאָמען פון די פּטי שקלאַף מיטל.
דורך פעליקייַט, מאַך עקאָוז די באַפֿעלן נאָמען און טענות. דער -נאָטשאָ פאָן סטאַפּס דערשייַנען פון טאן דעם.
די -console flag causes console output to be redirected to the spawned process . דעם איז נישט געשטיצט אויף אַלע סיסטעמס.
אינעווייניק, רויטער ניצט אַ פּטי, ינישאַלייזד די זעלבע וועג ווי די באַניצער ס טטי. דעם איז ווייַטער ינישאַלייזד אַזוי אַז אַלע סעטטינגס זענען "באַמ זינען" (לויט סטטי (1)). אויב די בייַטעוודיק stty_init איז דיפיינד, עס איז ינטערפּראַטאַד אין די נוסח פון סטטי אַרגומענטן ווי ווייַטער קאַנפיגיעריישאַן. פֿאַר בייַשפּיל, "שטעלן סטטי_יניט רוי" וועט פאַרשאַפן ווייַטער שפּאָרן פּראַסעסאַז ס טערמינאַלס צו אָנהייבן אין רוי מאָדע. -נאָטישקאָפּי יבערקוקן די יניטיאַליזאַטיאָן באזירט אויף די באַניצער ס טטי. -נאָטיניניט סקיפּט די "געזונט" ינישייישאַן.
נאָרמאַללי, רויג נעמט ביסל צייַט צו ויספירן. אויב איר באמערקט רויף גענומען אַ באַטייַטיק סומע פון צייַט, עס איז מיסטאָמע טרעפן פּטיס וואָס זענען וועדזשד. א נומער פון טעסץ זענען פליסנדיק אויף פּטיס צו ויסמייַדן קלאָגינג פּראָצעס. (די נעמען 10 סעקונדעס פּער וועדזשד פּטי.) פליסנדיק דערוואַרטן מיט די -ד אָפּציע וועט ווייַזן אויב דערוואַרטן איז ינקריסינג פילע פּטיס אין מאָדנע שטאַטן. אויב איר קענען נישט טייטן די פּראַסעסאַז וואָס די פּטיס זענען אַטאַטשט, דיין בלויז בריירע קען זיין רעבאָאָט.
אויב די פּראָגראַם קענען נישט שפּאַלטן הצלחה ווייַל די עקסאַקצפּי (2) פיילז (למשל ווען דער פּראָגראַם טוט נישט עקסיסטירן), אַ טעות אָנזאָג וועט זיין אומגעקערט דורך די ווייַטער ינעראַקט אָדער דערוואַרטן באַפֿעל, ווי אויב פּראָגראַם איז פליסנדיק און געשאפן די טעות אָנזאָג ווי רעזולטאַט. דעם אָפּפירונג איז אַ נאַטירלעך קאַנסאַקוואַנס פון די ימפּלאַמענטיישאַן פון רויג . אינעווייניק, רייף פאָרקס, נאָך וואָס דער ספּאָון פּראָצעס האט קיין וועג צו יבערגעבן מיט דער אָריגינעל עקספּעקט פּראָצעס חוץ דורך קאָמוניקאַציע דורך די ספּאַוונ_יד.
די -אָפּען פאָן זייַנען דער ווייַטער אַרגומענט צו זיין ינטערפּראַטאַד ווי אַ טקל טעקע יידענטאַפייער (ד"ה, אומגעקערט דורך עפענען .) די רויף שייַן קענען דעריבער ווערן געניצט ווי אויב עס איז אַ ספּאָון פּראָצעס . (דער טעקע יידענטאַפייער זאָל ניט זיין געניצט.) דאס לעץ איר באַהאַנדלען רוי דעוויסעס, טעקעס, און פּייפּליינז ווי ספּאַנדזשד פּראַסעסאַז אָן ניצן אַ פּטי. 0 איז אומגעקערט צו אָנווייַזן עס איז קיין פארבונדן פּראָצעס . ווען די קשר צו די ספּאָאָנעד פּראָצעס איז פארמאכט, אַזוי איז די טקל טעקע ידענטיפיער. די -לעאַוועאָפּען פאָן איז ענלעך צו -אָפּען אַחוץ אַז -לעאַוועאָפּען זייַנען די טעקע ידענטיפיער צו זיין לינקס עפענען אַפֿילו נאָך די רויג שייַן איז פארשלאסן.
די- ליידיק פאָן זייַנען אַ פּטי צו זיין געעפנט אָבער קיין פּראָצעס סאָונדס. 0 איז אומגעקערט צו אָנווייַזן עס איז קיין פארבונדן פּראָצעס . ספּאַוונ_יד איז באַשטימט ווי געוויינטלעך.
די בייַטעוודיק spawn_out (שקלאַף, פד) איז באַשטימט צו אַ טעקע ידענטיפיער קאָראַספּאַנדינג צו די פּטי שקלאַף. עס קענען זיין פארשלאסן ניצן "נאָענט-סלאַווע".
די -יגנאָרע פאָן נעמען אַ סיגנאַל צו זיין איגנאָרירט אין די ספּאַנדזשד פּראָצעס . אַנדערש, סיגנאַלז באַקומען די פעליקייַט אָפּפירונג. סיגנאַלז זענען געהייסן ווי אין דער טראַפּ באַפֿעל, חוץ אַז יעדער סיגנאַל ריקווייערז אַ באַזונדער פאָן.
strace level
ברענגט ווייַטערדיקע סטייטמאַנץ צו זיין געדרוקט איידער זיי זענען עקסאַקיוטיד. (טקל ס שפּור באַפֿעל טראַסעס וועריאַבאַלז.) גלייַך ינדיקייץ ווי ווייַט אַראָפּ אין די רופן אָנלייגן צו שפּור. פֿאַר בייַשפּיל, די ווייַטערדיק באַפֿעלן לויף דערוואַרטן בשעת טראַסינג די ערשטער 4 לעוועלס פון רופט, אָבער קיינער ונטער אַז.
די- אינפֿאָרמאַציע פאָן זע סטראַסע צו צוריקקומען אַ באַשרייַבונג פון די מערסט פריש ניט-אינפֿאָרמאַציע טענות געגעבן.
stty args
ענדערונגען וואָקזאַל מאָדעס סימאַלערלי צו די פונדרויסנדיק סטטי באַפֿעל.
דורך פעליקייַט, די קאַנטראָולינג וואָקזאַל איז אַקסעסט. אנדערע טערמינאַלס קענען זיין אַקסעסט דורך אַפּפּענדינג "רעקווירעס פֿאַר סטאַטוס צוריקקומען עס ווי דער רעזולטאַט פון די באַפֿעל. אויב קיין סטאַטוס איז געבעטן און די קאַנטראָולינג וואָקזאַל איז אַקסעסט, די פריערדיקע סטאַטוס פון רוי און עקאָו אַטראַביוץ זענען אומגעקערט אין אַ פאָרעם וואָס קענען שפּעטער זיין געניצט דורך די באַפֿעל.
פֿאַר בייַשפּיל, די אַרגומענטן רוי אָדער -קוקעד שטעלן די וואָקזאַל אין רוי מאָדע. די אַרגומענטן - דיין אָדער קאָכן שטעלן די וואָקזאַל אין האַלב מאָדע. די אַרגומענטן עקאָו און -עטשאָ שטעלן די וואָקזאַל אין אפקלאנג און נעעטשאָ מאָדע ריספּעקטיוולי.
די פאלגענדע בייַשפּיל ילאַסטרייץ ווי צו טעמפּערעראַלי דיסייבאַל עקאָוינג. דעם קען זיין געניצט אין אַנדערש-אָטאַמאַטיק סקריפּס צו ויסמייַדן עמבעדדינג פּאַסווערדז אין זיי. (זען מער דיסקוסיע אויף דעם אונטער דערוואַרטן אונטן.)
stty -echo send_user "שפּריכוואָרט:" expect_user -re "(. *) \ n" שטעלן פּאַראָל $ expected_out (1, string) stty echo system args
גיט ארץ צו ש (1) ווי אַרייַנשרייַב, פּונקט ווי אויב עס איז געווען טייפּט ווי אַ באַפֿעל פון אַ וואָקזאַל. דערוואַרטן וואַרטן ביז די שאָל טערמאַנייץ. דער צוריקקער סטאַטוס פון ש איז כאַנדאַלד די זעלבע וועג אַז עקסעל כאַנדאַלז זייַן קריק סטאַטוס.
אין קאַנטראַסט צו דורכפירן וואָס רעדירעקץ סטדין און סטדאָוט צו די שריפט, סיסטעם טוט נישט רעדירעקטיאָן (אנדערע ווי אַז אנגעוויזן דורך די שטריקל זיך). אזוי עס איז מעגלעך צו נוצן מגילה אַז מוזן רעדן גלייַך צו / dev / tty. פֿאַר דער זעלביקער סיבה, די רעזולטאַטן פון די סיסטעם זענען נישט רעקאָרדעד אין די קלאָץ.
טימעסטאַמפּ [אַרג]
קערט אַ טימעסטאַמפּ. מיט קיין אַרגומענטן, די נומער פון סעקונדעס זינט דעם עפּאָס איז אומגעקערט.
די -פאָרמאַט פאָן ינטראַדוסיז אַ שטריקל וואָס איז אומגעקערט אָבער מיט סובסטיטושאַנז געמאכט לויט די פּאָסיקס כּללים פֿאַר סטרייפּ. פֿאַר בייַשפּיל% a איז ריפּלייסט דורך אַ אַבריוויייטיד וויקדיי נאָמען (ד"ה, געזעסן). אנדערע זענען:
% אַ אַבריוויייטאַד וויקדאַמין נאָמען א פול וויקדיי נאָמען ב אַבריוויייטיד חודש% ב גאַנץ חודש נאָמען C דאַטע-צייַט ווי: Wed 6 אקטאבער 11:45:56 1993% ד טאָג פון די חודש (01-31% ה שעה (00-23)% איך בין צייט (01-12)% דזש טאָג (001-366)% ב חודש (01-12)% מ מינוט (00-59) % u טאָג (1-7, מאנטאג איז ערשטער טאָג פון וואָך)% ו וואָך (00-53, ערשטער זונטיק איז ערשטער טאָג פון וואָך איין)% V וואָך (01-53, ISO 8601 סטיל) 6) וו וו (00-53, ערשטער מאנטאג איז ערשטער טאָג פון וואָך איינער)% x דאַטע-צייַט ווי: Wed 6 אקטאבער 1993% X צייַט ווי: 23:59:59% י יאָר (00-99) י יאָר ווי אין: 1993% ז צייַט זאָנע (אָדער גאָרנישט אויב ניט דיטערמאַנאַבאַל) %% אַ נאַקעט פּראָצענט צייכןאנדערע% ספּעסאַפאַקיישאַנז זענען ונדעפינעד. אנדערע אותיות וועלן דורכגעגאנגען דורך אַנאַטשט. בלויז די C לאָקאַל איז געשטיצט.
די- סעקאָנדס פאָן ינטראַדוסיז אַ נומער פון סעקונדעס זינט דעם עפּאָס צו זיין געוויינט ווי אַ מקור פון וואָס צו פֿאָרמאַט. אַנדערש, די קראַנט צייַט איז געניצט.
די- גט פאָן קראַפט טימעסטאַמפּ רעזולטאַט צו נוצן די GMT טימזאָנע. מיט קיין פאָן, די היגע צייַט זאָנע איז געניצט.
טראַפּ [[באַפֿעלן] סיגנאַלז]
זייַנען די געגעבן באַפֿעל צו זיין עקסאַקיוטאַד אויף צוקונפֿט קאַבאָלע פון קיין פון די געגעבן סיגנאַלז. דער באַפֿעל איז עקסאַקיוטאַד אין די גלאבאלע פאַרנעם. אויב באַפֿעל איז ניטאָ, די סיגנאַל קאַמף איז אומגעקערט. אויב דער באַפֿעל איז די סיג_יג שטריקל, די סיגנאַלז זענען איגנאָרירט. אויב דער באַפֿעל איז די סטרינג סיג_דפל, די סיגנאַלז זענען רעזולטאַט צו דעם סיסטעם ניט נאָרמאַל. סיגנאַלז זענען אָדער אַ איין סיגנאַל אָדער אַ רשימה פון סיגנאַלז. סיגנאַלז קענען זיין ספּעסאַפייד נומעריק אָדער סימבאַליקלי ווי פּער סיגנאַל (3). די "סיג" פּרעפיקס קען זיין איבערגעהיפּערט.
מיט קיין אַרגומענטן (אָדער אַרגומענט-נומער), טראַפּ ריפּאָרץ די סיגנאַל נומער פון די טראַפּ באַפֿעל איצט זייַענדיק עקסאַקיוטיד.
די-קאָד פאָן ניצט די צוריקקומען קאָד פון די באַפֿעל אין אָרט פון וועלכער קאָד טקל איז געווען וועגן צו צוריקקומען ווען דער באַפֿעל ערידזשנאַלי סטאַרטעד פליסנדיק.
די -ינטערפּ פאָן זייַנען די באַפֿעל צו זיין עוואַלואַטעד ניצן די יבערזעצער אַקטיוו אין די צייַט די באַפֿעל אנגעהויבן פליסנדיק אלא ווי ווען דער טראַפּ איז דערקלערט.
די -נאַמע פאָן ז אַז דער טראַפּ באַפֿעל צו צוריקקומען די סיגנאַל נאָמען פון די טראַפּ באַפֿעל איצט זייַענדיק עקסאַקיוטיד.
דער- מאַקס פאָן ז די טראַפּ באַפֿעל צו צוריקקומען די גרעסטן סיגנאַל נומער וואָס קענען זיין שטעלן.
פֿאַר בייַשפּיל, די באַפֿעל "טראַפּ {סענד_וסער" אָוטש! "} סיגנט" וועט דרוקן "אָטש!" יעדער מאָל די באַניצער דריקט * C.
דורך פעליקייַט, סיגינט (וואָס קענען יוזשאַוואַלי זיין דזשענערייטאַד דורך דרינגלעך * C) און סיגטערם גרונט דערוואַרטן צו אַרויסגאַנג. דעם איז רעכט צו דער ווייַטערדיק טראַפּ, באשאפן דורך פעליקייַט ווען עקספּעקט סטאַרץ.
טראַפּ עקסיט {סיגנט סיגטערם}אויב איר נוצן די -ד פאָן צו אָנהייבן די דעבוגגער, סיגינט איז רידיפיינד צו אָנהייבן די ינטעראַקטיוו דעבוגגער. דאָס איז רעכט צו דער ווייַטערדיק טראַפּ:
טראַפּ {exp_debug 1} סיגנטדי דעבוגגער טראַפּ קענען זיין געביטן דורך באַשטעטיקן די סוויווע בייַטעוודיק EXPECT_DEBUG_INIT צו אַ נייַ טראַפּ באַפֿעל.
איר קענען, פון קורס, אָווועררייד ביידע פון די נאָר דורך לייגן טראַפּ קאַמאַנדז צו דיין שריפט. אין באַזונדער, אויב איר האָבן דיין אייגן "טראַפּ אַרויסגאַנג סיגנט", דאָס וועט אָווועררייד די דעבוגגער טראַפּ. דעם איז נוציק אויב איר ווילן צו פאַרמייַדן ניצערס צו באַקומען צו די דעבוגגער בייַ אַלע.
אויב איר ווילן צו באַשיצן אייער אייגן טראַפּ אויף סיגינט אָבער נאָך טראַפּ צו די דעבוגגער ווען עס איז פליסנדיק, נוצן:
אויב {! [exp_debug]} {טראַפּ מיסטאָף סיגנט}אַלטערנאַטיוועלי, איר קענען טראַפּ צו די דעבוגגער ניצן עטלעכע אנדערע סיגנאַלז.
טראַפּ וועט ניט לאָזן איר אָווועררייד די קאַמף פֿאַר סיגאַלרם ווי דאָס איז געניצט ינערלעך צו דערוואַרטן . די דיסקאַנעקט באַפֿעל שטעלט SIGALRM צו SIG_IGN (איגנאָרירן). איר קענען רינואַבאַל דאָס ווי לאַנג ווי איר דיסייבאַל עס בעשאַס סאַבסאַקוואַנט רויאַל קאַמאַנדז.
זען סיגנאַל (3) פֿאַר מער אינפֿאָרמאַציע.
וואַרטן [אַרג]
דעלייַס ביז אַ ספּאָאָנעד פּראָצעס (אָדער די קראַנט פּראָצעס אויב קיינער איז געהייסן) טערמינייץ.
וואַרטן נאָרמאַלי קערט אַ רשימה פון פיר נומערן. דער ערשטער ינטאַדזשער איז דער פּיד פון דעם פּראָצעס וואָס איז געווען ווארטן אויף. די רגע ינטעגער איז די קאָראַספּאַנדינג רויאַל שייַן. די דריט ינטאַדזשער איז -1 אויב אַ אַפּערייטינג סיסטעם טעות אריבער, אָדער 0 אַנדערש. אויב די דריט ינטאַדזשער איז 0, די פערט ינטעגער איז די סטאַטוס אומגעקערט דורך די ספּאָון פּראָצעס . אויב די דריט ינטאַדזשער איז -1, די פערט ינטעגער איז די ווערט פון ערנאָ שטעלן דורך די אַפּערייטינג סיסטעם. די גלאבאלע בייַטעוודיק טעות קאָד איז אויך באַשטימט.
נאָך עלעמענטן קענען דערשייַנען אין די סוף פון די צוריקקומען ווערט פון וואַרטן . אַ אַפּשאַנאַל פינפט עלעמענט באשטייט אַ קלאַס פון אינפֿאָרמאַציע. דערווייַל, די בלויז מעגלעך ווערט פֿאַר דעם עלעמענט איז טשילדקיללד אין וואָס פאַל די ווייַטער צוויי וואַלועס זענען די C-נוסח סיגנאַל נאָמען און אַ קורץ טעקסטשעל באַשרייַבונג.
דער -י פאָן דערקלערט דעם פּראָצעס צו וואַרטן קאָראַספּאַנדינג צו די נאָמען געהייסן spawn_id (NOT דער פּראָצעס שייַן). ין אַ SIGCHLD האַנדלער, עס איז מעגלעך צו וואַרטן פֿאַר קיין ספּאָאָנעד פּראָצעס דורך ניצן די רויג שייַן -1.
דער -נאָוואַיט פאָן זע די וואַרטן צו צוריקקומען מיד מיט די אָנווייַז פון אַ מצליח וואַרטן. ווען דער פּראָצעס יקסידז (שפּעטער), עס וועט אויטאָמאַטיש פאַרשווינדן אָן די נויט פֿאַר אַ יקספּליסאַט וואַרטן.
די ווארט באַפֿעל קען אויך נוצן וואַרטן פֿאַר אַ פאָרקעד פּראָצעס ניצן די אַרגומענטן "-י -1". ניט ענלעך זייַן נוצן מיט ספּאַנדזשד פּראַסעסאַז, דעם באַפֿעל קענען זיין עקסאַקיוטאַד אין קיין צייַט. עס איז קיין קאָנטראָל איבער וואָס פּראָצעס איז רייפּט. אָבער, די צוריקקומען ווערט קענען זיין אָפּגעשטעלט פֿאַר דעם פּראָצעס שייַן.
LIBRARIES
דערוואַרטן אָטאַמאַטיק ווייסט וועגן צוויי געבויט-אין לייברעריז פֿאַר דערוואַרטונג סקריפּס. דאס זענען דיפיינד דורך די דירעקטעריז געהייסן אין די וועריאַבאַלז עקספּליבראַרי און עקספּ_עקסעק_library. ביידע זענען מענט צו אַנטהאַלטן נוצן טעקעס וואָס קענען זייַן גענוצט דורך אנדערע סקריפּס.
exp_library כּולל אַרקאַטעקטשער-פרייַ טעקעס. עקספּ_עקסעק_library כּולל אַרקאַטעקטשער-אָפענגיק טעקעס. דעפּענדינג אויף דיין סיסטעם, ביידע דירעקטעריז זאל זיין גאָר ליידיק. דער עקזיסטענץ פון דער טעקע $ exp_exec_library / cat-buffers שרייבט אייַערע / בין / קאווע בופערס דורך פעליקייַט.
PRETTY-PRINTING
א ווגרינד דעפֿיניציע איז פאַראַנען פֿאַר שיין-דרוקן דערוואַרטן סקריפּס. אַסומינג די וויידלד דעפֿיניציע סאַפּלייד מיט די עקספּעקט פאַרשפּרייטונג איז ריכטיק אינסטאַלירן, איר קענען נוצן עס ווי:
vgrind -lexpect fileביישפילן
עס איז פיל ניט קלאָר ווי צו שטעלן אַלץ צוזאַמען אַז די מענטש באשרייבט מענטש. איך מוטיקן איר צו לייענען און פּרובירן אויס די ביישפילן אין דעם בייַשפּיל וועגווייַזער פון דער עקספּעקט פאַרשפּרייטונג. עטלעכע פון זיי זענען פאַקטיש מגילה. אנדערע זענען פשוט ילאַסטיסאַטי פון עטלעכע טעקניקס, און פון קורס, אַ פּאָר זענען נאָר שנעל כאַקס. די ינסטאַלל טעקע האט אַ שנעל איבערבליק פון די מגילה.
די עקספּעקט פּאַפּערס (זען זען אויך) זענען אויך נוצלעך. בשעת עטלעכע פּאַפּערס נוצן סינטאַקס קאָראַספּאַנדינג צו פריער ווערסיעס פון דערוואַרט, די אַקאַמפּאַניינג ראַטיאָנאַלעס זענען נאָך גילטיק און גיין אין אַ פּלאַץ מער דעטאַל ווי דעם מענטש בלאַט.
CAVEATS
עקסטענסיאָנס קען קאַלייד מיט עקספּעקט ס באַפֿעל נעמען. פֿאַר בייַשפּיל, שיקן איז דיפיינד דורך טק פֿאַר אַ גאנץ אַנדערש ציל. דעריבער, רובֿ פון די עקספּעקט קאַמאַנדז זענען אויך בנימצא ווי "עקספּ_קסקסקסקס". קאַמאַנדז און וועריאַבאַלז אָנהייב מיט "עקספּ", "ינטער", "רויג", און "טיימאַוט" טאָן ניט האָבן אַליאַסיז. ניצן די עקסטענדעד באַפֿעלן נעמען אויב איר דאַרפֿן דעם קאַמפּאַטאַבילאַטי צווישן ינווייראַנמאַנץ.
דערוואַרטן גענומען אַ גאַנץ ליבעראַל מיינונג פון סקייפּינג. אין באַזונדער, וועריאַבאַלז לייענען דורך קאַמאַנדז ספּעציפיש צו די עקספּעקט פּראָגראַם וועט זיין געזוכט ערשטער פון די היגע פאַרנעם, און אויב ניט געפונען, אין די גלאבאלע פאַרנעם. למשל, דאָס אָבוויייץ דעם דאַרפֿן צו אָרט "גלאבאלע טיימאָוט" אין יעדער פּראָצעדור איר שרייַבן אַז ניצט דערוואַרטן . אויף די אנדערע האַנט וועראַביליטיעס געשריבן זענען שטענדיק אין די היגע פאַרנעם (סייַדן אַ "גלאבאלע" באַפֿעל איז ארויס). די מערסט פּראָסט פּראָבלעם דעם סיבה איז ווען רויטער איז עקסאַקיוטאַד אין אַ פּראָצעדור. אַרויס די פּראָצעדור, spawn_id ניט מער יגזיסץ, אַזוי דער ספּאָאָנעד פּראָצעס איז ניט מער צוטריטלעך פשוט ווייַל פון סקייפּינג. לייג אַ "גלאבאלע spawn_id" צו אַזאַ אַ פּראָצעדור.
אויב איר קענען נישט געבן די מאַלטיספּאַוונינג פיייקייַט (ד"ה, דיין סיסטעם שטיצט ניט אויסקלייַבן (בסד *. *), באַקומען (סוור> 2), אדער עפּעס עקוויוואַלענט), עקספּעקט וועט בלויז קענען צו קאָנטראָלירן אַ איין פּראָצעס אין אַ צייַט. אין דעם פאַל, טאָן ניט פּרווון צו שטעלן spawn_id , אדער זאָל איר ויספירן פּראַסעסאַז דורך עקסאַקיוט ווען אַ ספּאָון פּראָצעס איז פליסנדיק. דערצו, איר וועט ניט קענען צו דערוואַרטן פון קייפל פּראַסעסאַז (אַרייַנגערעכנט דער באַניצער ווי איין) אין דער זעלביקער צייַט.
טערמינאַל פּאַראַמעטערס קענען האָבן אַ גרויס ווירקונג אויף סקריפּס. פֿאַר בייַשפּיל, אויב אַ שריפט איז געשריבן צו קוקן פֿאַר עקאָוינג, עס וועט זיין אומבאַקאַנט אויב עקאָוינג איז פארקערט אַוועק. פֿאַר דעם סיבה, דערוואַרטן סיין וואָולטידזש פּאַראַמעטערס דורך פעליקייַט. צום באַדויערן, דאָס קען מאַכן פּריקרע פֿאַר אנדערע מגילה. ווי אַ בייַשפּיל, די עמאַקס שאָל וויל צו טוישן די "געוויינטלעך" מאַפּפּינגס: נעוולינעס באַקומען מאַפּאַטאַד צו נעוולינעס אַנשטאָט פון קאַרריאַגע-צוריקקומען נעוולינעס, און עקאָוינג איז פאַרקריפּלט. דאָס אַלאַוז איינער צו נוצן עמאַקס צו רעדאַגירן די אַרייַנשרייַב שורה. צום באַדויערן, דערוואַרטן קענען נישט זיין מעגלעך.
איר קענען בעטן אַז דערוואַרטן נישט אָווועררייד זייַן פעליקייַט באַשטעטיקן פון וואָקזאַל פּאַראַמעטערס, אָבער איר מוזן זיין זייער אָפּגעהיט ווען סקריפּס פֿאַר אַזאַ ינווייראַנמאַנץ. אין דעם פאַל פון עמאַקס, ויסמייַדן דיפּענדינג אויף זאכן ווי עקאָוינג און סוף-פון-שורה מאַפּפּינגס.
די קאַמאַנדז אַז אנגענומען אַרמאַמאַנץ ברעסט אין אַ איין רשימה (די דערוואַרטן וועריאַנץ און ינטעראַקט ) נוצן אַ כיוריסטיק צו באַשליסן אויב די רשימה איז פאקטיש איינער אַרגומענט אָדער פילע. די כיוריסטיק קענען פאַרלאָזן בלויז אין דעם פאַל ווען די רשימה אַקשלי פאָרשטעלן אַ איין אַרגומענט וואָס האט קייפל עמבעדיד \ n 'ס מיט ניט-ווהיטעספּאַסע אותיות צווישן זיי. דאָס מיינט גענוג ימפּראָבאַבלע, אָבער די אַרגומענט "נאָובאַלז" קענען זיין געניצט צו צווינגען אַ איין אַרגומענט צו זיין כאַנדאַלד ווי אַ איין אַרגומענט. דעם קען קאַנסיוואַבלי זיין געוויינט מיט מאַשין-דזשענערייטאַד דערוואַרט קאָד. סימילאַרלי - בראַסע פאָרסעס אַ איין אַרגומענט צו זיין שעפּן ווי קייפל פּאַטערנז / אַקשאַנז.
BUGS
עס איז טאַקע געפרואווט צו נעמען די פּראָגראַם "געשלעכט" (פֿאַר יעדער "סמאַרט עקסעק" אָדער "שיקן-עקספּעקט"), אָבער גוט זינען (אָדער טאָמער נאָר פּוריטאַניסם) פּריוויילד.
אויף עטלעכע סיסטעמס, ווען אַ שאָל איז דערשראָקן, עס קליימז וועגן ניט זייַענדיק קענען צוטריט די טטי, אָבער לויפט סייַ ווי סייַ. דעם מיטל דיין סיסטעם האט אַ מעקאַניזאַם פֿאַר גיינינג די קאַנטראָולינג טטי אַז דערוואַרט טוט ניט וויסן וועגן. ביטע געפינען אויס וואָס עס איז, און שיקן דעם אינפֿאָרמאַציע צוריק צו מיר.
ולטריקס 4.1 (בייַ מינדסטער די לעצט ווערסיעס אַרום דאָ) באטראכט טיימדאַוץ פון אויבן 1,000,000 צו זיין עקוויוואַלענט צו 0.
דיגיטאַל יוניקס 4.0 אַ (און מיסטאָמע אנדערע ווערסיעס) וויל צו אַלאַקייט פּטיס אויב איר באַשליסן אַ סיגטשלד האַנדלער. זען גראַנטינג זייַט פֿאַר מער אינפֿאָרמאַציע.
יריקס 6.0 טוט ניט שעפּן פּטי פּערמישאַנז ריכטיק אַזוי אַז אויב עקספּעקט פרווון צו אַלאַקייט אַ פּטי פריער געניצט דורך עמעצער אַנדערש, עס פיילז. אַפּגרייד צו יריקס 6.1.
טעלנעט (וועראַפייד בלויז אונטער SunOS 4.1.2) כאַנגז אויב TERM איז ניט שטעלן. דעם איז אַ פּראָבלעם אונטער קראָאָן, בייַ און אין קגי סקריפּס, וואָס טאָן ניט דעפינירן טעם. אזוי, איר מוזן שטעלן עס בישליימעס - צו וואָס טיפּ איז יוזשאַוואַלי ירעלאַוואַנט. עס נאָר האט צו זיין שטעלן צו עפּעס! די פאלגענדע מיסטאָמע איז גענוג פֿאַר רובֿ קאַסעס.
שטעלן ענוו (טעם) ווט 100שפּיץ (באזירט בלויז אונטער BSDI BSD / OS 3.1 i386) כאַנגז אויב שעל און היים זענען נישט שטעלן. דעם איז אַ פּראָבלעם אונטער קראָאָן , בייַ און אין קגי סקריפּס, וואָס טאָן ניט דעפינירן די סוויווע וועריאַבאַלז. אזוי, איר מוזן שטעלן זיי בישליימעס - צו וואָס טיפּ איז יוזשאַוואַלי ירעלאַוואַנט. עס נאָר האט צו זיין שטעלן צו עפּעס! די פאלגענדע מיסטאָמע איז גענוג פֿאַר רובֿ קאַסעס.
שטעלן יוו (שעל) / בין / ש שטעלן יוו (HOME) / וסר / היגע / ביןעטלעכע ימפּלאַמענטיישאַנז פון פּטיס זענען דיזיינד אַזוי אַז די קערנעל ווארפט ער אַוועק קיין אַנרעד פּראָדוקציע נאָך 10-15 סעקונדעס (פאַקטיש נומער איז ימפּלאַמענטיישאַן-אָפענגיק) נאָך דעם פּראָצעס האט פארמאכט די טעקע דעסקריפּטאָר. אזוי דערוואַרטן מגילה אַזאַ ווי
שפּאַן דאַטע שלאָפן 20 דערוואַרטןוועט פאַרלאָזן. צו ויסמייַדן דעם, יבערקוקן ניט-ינטעראַקטיוו מגילה מיט אַפּלאַקיישאַן אלא ווי רויאַל . בשעת אַזאַ סיטואַטיאָנס זענען פאַרוויילט, אין פיר איך האָבן קיינמאָל געפּלאָנטערט אַ סיטואַציע אין וואָס די לעצט רעזולטאַט פון אַ באמת ינטעראַקטיוו פּראָגראַם וואָלט זיין פאַרפאַלן רעכט צו דעם נאַטור.
אויף די אנדערע האַנט, Cray UNICOS פּטיס וואַרפן אַוועק קיין אַנרעד רעזולטאַט מיד נאָך דעם פּראָצעס האט פארמאכט די טעקע דעסקריפּטאָר. איך האָבן געמאלדן דעם צו Cray און זיי אַרבעטן אויף אַ פאַרריכטן.
מאל אַ פאַרהאַלטן איז פארלאנגט צווישן אַ פּינטלעך און אַ ענטפער, אַזאַ ווי ווען אַ טטי צובינד איז טשאַנגינג UART סעטטינגס אָדער וואָס ריכטן באָד ראַטעס דורך זוכן פֿאַר אָנהייב / האַלטן ביץ. יוזשאַוואַלי אַלע דעם דאַרף צו שלאָפן פֿאַר אַ צווייט אָדער צוויי. א מער געזונט טעכניק איז צו צוריקקריגן ביז די ייַזנוואַרג איז גרייט צו באַקומען אַרייַנשרייַב. די ווייַטערדיק בייַשפּיל ניצט ביידע סטראַטעגיעס:
שיקן "גיכקייַט 9600 \"; שלאָפן 1 דערוואַרטן {טיימאַוט {שיקן "ר"; exp_continue} $ prompt}טראַפּ-קאָד וועט נישט אַרבעטן מיט קיין באַפֿעל אַז זיצט אין טקל ס געשעעניש שלייף, אַזאַ ווי שלאָפן. דער פּראָבלעם איז אַז אין דער געשעעניש שלייף, טקל דיסקאַרדז די צוריקקומען קאָודז פון אַסינק געשעעניש האַנדלערס. א אַרבעטאַראָונד איז צו שטעלן אַ פאָן אין דער טראַפּ קאָד. דעמאָלט טשעק די פאָן מיד נאָך די באַפֿעל (ד"ה, שלאָפן).
די דערוואַרטונג_באַקקסטראַקט באַפֿעלן יגנאָרז-טיימינג אַרגומענטן און האט קיין קאַנסעפּס פון צייַטאָוץ אין אַלגעמיין.
& # 34; עקספּרעס הינץ & # 34;
עס זענען אַ פּאָר פון זאכן וועגן דערוואַרטן אַז קען זיין ניט-ינטואַטיוו. דעם אָפּטיילונג פרווון צו אַדרעס עטלעכע פון די זאכן מיט אַ פּאָר פון פֿירלייגן.
א פּראָסט דערוואַרטן פּראָבלעם איז ווי צו דערקענען שאָל פּראַמפּס. זינט זיי זענען קאַסטאַמייזד דיפערענטלי דורך דיפערענטלי מענטשן און פאַרשידענע שעלז, פּאָרטאַבלי אָטאַמייטינג ראָגלין קענען זיין שווער אָן געוואוסט די פּינטלעך. א גלייַך קאַנווענשאַן איז צו האָבן ניצערס קראָם אַ רעגולער אויסדרוק וואָס דיסקרייבז זייער פּינטלעך (אין באַזונדער, דער סוף פון עס) אין די סוויווע בייַטעוודיק EXPECT_PROMPT. קאָד ווי די ווייַטערדיק קענען זיין געוויינט. אויב EXPECT_PROMPT טוט נישט עקסיסטירן, די קאָד נאָך האט אַ גוט געלעגנהייַט פון פאַנגקשאַנז ריכטיק.
set prompt "(% | # | \\ $) $"; # default prompt catch {set prompt $ env (EXPECT_PROMPT)} expect -re $ promptאיך בעטן איר צו שרייַבן דערוואַרטן פּאַטערנז אַז אַרייַננעמען די סוף פון וואָס איר דערוואַרטן צו זען. דעם אַוווידז די מעגלעכקייט פון ענטפֿערן אַ קשיא איידער געזען די גאנצע זאַך. דערצו, בשעת איר זאלט קענען צו ענטפֿערן פֿראגן איידער געזען זיי לעגאַמרע, אויב איר ענטפֿערן פרי, דיין ענטפער קען זיין אנטפלעקט אין דער מיטן פון די קשיא. אין אנדערע ווערטער, די ריזאַלטינג דיאַלאָג וועט זיין ריכטיק אָבער קוק סקראַמבאַלד.
רובֿ פּראַמפּס אַרייַננעמען אַ אָרט כאַראַקטער אין די סוף. פֿאַר בייַשפּיל, די פּינטלעך פון פטפּ איז 'f', 't', 'פּ', '>' און. צו גלייַכן דעם פּינטלעך, איר מוזן חשבון פֿאַר יעדער פון די אותיות. עס איז אַ פּראָסט גרייַז נישט צו אַרייַננעמען דעם פּוסט. שטעלן דעם ליידיק אין בארעכטיגט.
אויב איר נוצן אַ מוסטער פון די פאָרעם X *, די * וועט גלייַכן אַלע דער רעזולטאַט באקומען פון די סוף פון X צו די לעצטע זאַך באקומען. דאָס סאָונדס ינטואַטיוו אָבער קען זיין עפּעס קאַנפיוזינג ווייַל די פראַזע "לעצטע זאַך באקומען" קענען בייַטן דיפּענדינג אויף די גיכקייַט פון די קאָמפּיוטער און די פּראַסעסינג פון איך / אָ ביי ביידע די קערן און די מיטל דרייווער.
אין באַזונדער, יומאַנז טענד צו זען פּראָגראַם רעזולטאַט ערייווינג אין ריזיק טשאַנגקס (אַטאָמיקאַללי) ווען אין פאַקט רובֿ מגילה פּראָדוצירן רעזולטאַט איין שורה אין אַ צייַט. אויב דאָס איז דער פאַל, די * אין די מוסטער פון די פריערדיקע פּאַראַגראַף קען נאָר גלייַכן די סוף פון די קראַנט שורה, אַפֿילו כאָטש עס מיינט צו זיין מער, ווייַל אין די צייַט פון די גלייַכן וואָס איז געווען אַלע די פּראָדוקציע וואָס איז געווען באקומען.
דערוואַרטן קיין וועג צו וויסן וואָס ווייַטער רעזולטאַט איז קומענדיק סייַדן דיין מוסטער ספּאַסיפיקלי אַקאַונץ פֿאַר אים.
אפילו דיפּענדינג אויף שורה-אָריענטיד באַפערינג איז אַנווייז. נישט בלויז טאָן די מגילה ראַרעלי מאַכן הבטחות וועגן די טיפּ פון באַפערינג זיי טאָן, אָבער די סיסטעם ינדיידזשעסטשאַן קענען ברעכן רעזולטאַט שורות אַזוי אַז שורות ברעכן בייַ פּאָנעם טראַפיק ערטער. אזוי, אויב איר קענען אויסדריקן די לעצטע ביסל אותיות פון אַ פּינטלעך ווען שרייבן פּאַטערנז, עס איז קלוג צו טאָן אַזוי.
אויב איר וואַרטן פֿאַר אַ מוסטער אין די לעצט רעזולטאַט פון אַ פּראָגראַם און די פּראָגראַם עמיץ עפּעס אַנדערש אַנשטאָט, איר וועט נישט קענען צו דעטעקט אַז מיט די טיימאָוט קיווערד. די סיבה איז אַז דערוואַרטן וועט נישט טיימאַוט - אַנשטאָט עס וועט באַקומען אַ עף ינדיקאַטיאָן. ניצן אַז אַנשטאָט. אפילו בעסער, נוצן ביידע. דער וועג אויב אַז שורה איז אלץ אריבערגעפארן אַרום, איר וועט נישט האָבן צו רעדאַגירן די שורה זיך.
Newlines זענען יוזשאַוואַלי קאָנווערטעד צו וועגעלע קריק, לינעעפעד סיקוואַנסיז ווען רעזולטאַט דורך די וואָקזאַל שאָפער. אזוי, אויב איר ווילן אַ מוסטער אַז בישליימעס שוועבעלעך די צוויי שורות, פון, זאָגן, printf ("foo \ nbar"), איר זאָל נוצן דעם מוסטער "foo \ r \ nbar".
א ענלעך איבערזעצונג אַקערז ווען לייענען פון דער באַניצער, via expect_user . אין דעם פאַל, ווען איר דריקן צוריקקומען, עס וועט זיין איבערגעזעצט צו אַ נעוולינע. אויב דערוואַרטן דעמאָלט פּאַסיז אַז צו אַ פּראָגראַם וואָס שטעלט צו זייַן וואָקזאַל צו רוי מאָדע (ווי טעלנעט), עס וועט זיין אַ פּראָבלעם, ווי די פּראָגראַם יקספּעקץ אַ אמת צוריקקומען. (עטלעכע מגילה זענען פאקטיש פאַרפעלן אין אַז זיי וועלן אויטאָמאַטיש איבערזעצן נעוולינעס צו קערט, אָבער רובֿ טאָן ניט.) צום באַדויערן, עס איז קיין וועג צו געפינען אַז אַ פּראָגראַם שטעלן זייַן וואָקזאַל אין רוי מאָדע.
אויב איר טאָן ניט דאַרפֿן צו מאַניואַלי ריפּלייסינג נעוולינעס מיט קערטאַנז, די לייזונג איז צו נוצן די באַפֿעל "סטטי רוי", וואָס וועט האַלטן די איבערזעצונג. באַמערקונג, however, that this means that you will no longer get the cooked line-editing features.
ינטעראַקט ימפּליסאַטלי שטעלט דיין וואָקזאַל צו רוי מאָדע אַזוי דעם פּראָבלעם וועט נישט אויפשטיין דעמאָלט.
עס איז אָפט נוציק צו קראָם פּאַסווערדז (אָדער אנדערע פּריוואַט אינפֿאָרמאַציע) אין דערוואַרטן סקריפּס. דאס איז נישט רעקאַמענדיד זינט עפּעס וואָס איז סטאָרד אויף אַ קאָמפּיוטער איז סאַסעפּטאַבאַל צו זיין אַקסעסט דורך ווער עס יז. אזוי, ינטעראַקטיוולי פּראַמפּטינג פֿאַר פּאַסווערדז פון אַ שריפט איז אַ סמאַרטער געדאַנק ווי עמבעדדינג זיי ממש. דערנאָך, מאל אַזאַ עמבעדדינג איז די בלויז מעגלעכקייט.
צום באַדויערן, די UNIX טעקע סיסטעם האט ניט גלייַך וועג פון שאפן סקריפּס וואָס זענען עקסאַקיוטאַבאַל אָבער אַנרידאַבאַל. סיסטעמס וואָס שטיצן סעטגיד שאָל סקריפּס קען ינטראַטאַלי סימולירן דעם ווי גייט:
שאַפֿן די עקספּעקט שריפט (אַז כּולל די סוד דאַטן) ווי געוויינטלעך. מאַכן זיין פּערמישאַנז זיין 750 (-רווקסר-רענטגענ ---) און אָונד דורך אַ טראַסטיד גרופּע, הייסט אַ גרופּע וואָס איז דערלויבט צו לייענען עס. אויב נייטיק, שאַפֿן אַ נייַע גרופּע פֿאַר דעם צוועק. ווייַטער, מאַכן אַ / בין / ש שריפט מיט פּערמישאַנז 2751 (-רווקסר-s - X) אָונד דורך די זעלבע גרופּע ווי פריער.
דער רעזולטאַט איז אַ שריפט וואָס קען זיין עקסאַקיוטאַד (און לייענען) דורך ווער עס יז. ווען ינוואָוקט, עס לויפט די עקספּעקט שריפט.
& # 34; זען אויך & # 34;
טקל (3), ליבאַקספּעקט (3)
"Exploring Expect: א טקל-באַזירט טאָאָלקיט פֿאַר אַוטאָמאַטינג ינטעראַקטיווע מגילה" דורך דאָן ליבעס, pp. 602, ISBN 1-56592-090-2, O'Reilly and Associates, 1995.
"דערוואַרטן: Curing יענע ונקאָנטראָללאַבלע פיץ פון ינטעראַקטיוויטי" דורך דאָן ליבעס, פאַרהאַנדלונג פון דער זומער 1990 וסעניקס קאָנפערענסע, אַנאַהעים, קאַליפאָרניאַ, יוני 11-15, 1990.
. "ניצן דערוואַרטן צו אַוטאָמאַטע סיסטעם אַדמיניסטראַטיאָן טאַסקס" דורך דאָן ליבעס, פאַרהאַנדלונג פון די 1990 וסעניקס גרויס ינסטאַללאַטיאָן סיסטעמס אַדמיניסטראַטיאָן קאָנפערענסע, קאָלאָראַדאָ ספּרינגס, קאָלאָראַדאָ, 17-19 אקטאבער 1990.
. "טקל: אַ עמבעדדאַבלע קאָממאַנד שפּראַך" דורך יוחנן אָוסטערהאָוט, פּראָזעדינגס פון די ווינטער 1990 וסעניקס קאָנפערענסע, וואַשינגטאָן, דק, יאנואר 22-26, 1990 .. איך "דערוואַרטן: סקריפּץ פֿאַר קאַנטראָולינג ינטעראַקטיווע מגילה" דורך דאָן ליבעס, קאָמפּוטינג סיסטעמס , Vol. 4, No. 2, אוניווערסיטעט פון קאַליפאָרניאַ פּרעסע דזשאָורנאַלס, נאוועמבער 1991 .. איך "רעגרעססיאָן טעסטינג און קאָנפאָרמאַנסע טעסטינג ינטעראַקטיווע מגילה", דורך דאָן ליבעס, פאַרהאַנדלונג פון דער זומער 1992 וסעניקס קאָנפערענסע, pp. 135-144, San Antonio, TX, יוני 12-15, 1992 .. איך "קיביטז - קאָננעקטינג Multiple Interactive Programs Together", דורך דאָן ליבעס, ווייכווארג - פּראַקטיס & עקספּעריענסע, יוחנן ווילי & סאָנס, מערב סוססעקס, ענגלאַנד, חלק.
23, נומ '5, מייַ, 1993. איך "אַ דעבוגגער פֿאַר טקל פּראָגראַמען", דורך דאָן ליבעס, פאַרהאַנדלונג פון די 1993 טקל / טק וואָרקשאָפּ, בערקלי, CA, יוני 10-11, 1993.
AUTHOR
דאָן ליבעס, נאַשאַנאַל אינסטיטוט פון סטאַנדאַרדס און טעכנאָלאָגיע
ACKNOWLEDGMENTS
דאַנק צו יוחנן אָסטרעראָוט פֿאַר טקל, און סקאַט פּאַיסליי פֿאַר ינספּיראַציע. דאַנק צו ראָב סאַווויע פֿאַר עקספּעקט ס אַוטאָקאָנפיגוראַטיאָן קאָד.
די היסטאָרי טעקע דאָקומענטן פיל פון דער עוואַלושאַן פון דערוואַרטן . עס מאכט טשיקאַווע לייענען און זאל געבן איר ווייַטער ינסייט צו דעם ווייכווארג. דאַנקען צו די מענטשן דערמאנט אין עס וואס געשיקט מיר זשוק פיקסיז און געגעבן אנדערע הילף.
פּלאַן און ימפּלאַמענטיישאַן פון עקספּעקט איז געווען באַצאָלט אין טייל פון די יו. עס. רעגירונג און איז דעריבער אין דער ציבור פעלד. אָבער דער מחבר און NIST וואָלט ווי קרעדיט אויב דאָס פּראָגראַם און דאַקיומענטיישאַן אָדער פּאָרשאַנז פון זיי זענען געניצט.