mksh - מקוון בענן

תָכְנִית:

שֵׁם

מקש, sh - מעטפת מירבסד קורן

תַקצִיר

מקש [-+abCefhiklmnprUuvXx] [-T [!]tty | -] [-+o אוֹפְּצִיָה] [-c מחרוזת | -s | פילה
[טענה ...]]
שם מובנה [טענה ...]

תיאור

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

אני an אנדרואיד מִשׁתַמֵשׁ, so מה מקש?
מקש הוא מתורגמן של מעטפת UNIX / פקודה, בדומה ל COMMAND.COM or CMD.EXE, שיש
נכלל ב-Android Open Source Project כבר זמן מה. בעיקרון, זו תוכנית
שרץ בטרמינל (חלון מסוף), לוקח קלט משתמש ומריץ פקודות או סקריפטים,
מה שאפשר לבקש ממנו לעשות גם על ידי תוכנות אחרות, אפילו ברקע. כל פריבילגיה
חלונות קופצים שאתה עשוי להיתקל בהם לא מקש בעיות אבל שאלות של מישהו אחר
תוכנית המשתמשת בו.

הזמנה
ניתן לקרוא ישירות לרוב ה-buildins, למשל אם קישור מצביע מהשם שלו ל-
צדף; לא כולם הגיוניים, אבל נבדקו או עובדים בכלל.

האפשרויות הן כדלקמן:

-c מחרוזת מקש יבצע את הפקודות הכלולות ב מחרוזת.

-i מעטפת אינטראקטיבית. מעטפת שקוראת פקודות מקלט סטנדרטי היא
"אינטראקטיבי" אם נעשה שימוש באפשרות זו או אם גם קלט סטנדרטי וגם שגיאה סטנדרטית
מחוברים לא tty(4). למעטפת אינטראקטיבית יש בקרת עבודה מופעלת, מתעלמת
האותות SIGINT, SIGQUIT ו- SIGTERM, ומדפיס הנחיות לפני קריאת קלט
(ראה את הפרמטרים של PS1 ו-PS2). זה גם מעבד את פרמטר ENV או את
mkshrc קובץ (ראה להלן). עבור קונכיות לא אינטראקטיביות, ה trackall האפשרות מופעלת
כברירת מחדל (ראה את סט הפקודה למטה).

-l מעטפת כניסה. אם הבסיס נקרא עם המעטפת (כלומר argv[0]) מתחיל עם
'-' או אם נעשה שימוש באפשרות זו, ההנחה היא שהמעטפת היא מעטפת כניסה; לִרְאוֹת
אתחול קבצים לְהַלָן.

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

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

· אל האני cd (ו chdir) הפקודה מושבתת.
· לא ניתן לשנות את הפרמטרים SHELL, ENV ו-PATH.
· לא ניתן לציין שמות פקודות עם נתיבים מוחלטים או יחסיים.
· אל האני -p אפשרות של הפקודה המובנית הפקודה לא ניתן להשתמש.
· לא ניתן להשתמש בהפניות שיוצרות קבצים (כלומר '>', '>|', '>>', '<>').

-s המעטפת קוראת פקודות מקלט סטנדרטי; כל הטיעונים שאינם אופציונליים הם
פרמטרים מיקוםיים.

-T שם תַפטִיר מקש על tty(4) מכשיר נתון. השבילים שם, /dev/ttyCname ו
/dev/ttyname מנסים לפי הסדר. אֶלָא אִם שם מתחיל בסימן קריאה
('!'), זה נעשה ב-subshell וחוזר מיד. אם שם הוא מקף
('-'), התנתק ממסוף השליטה (דימון) במקום זאת.

בנוסף לאמור לעיל, האפשרויות המתוארות ב סט ניתן להשתמש גם בפקודה מובנית
בשורת הפקודה: שניהם [-+abCefhkmnuvXx] ו [-+o אוֹפְּצִיָה] יכול לשמש עבור אות בודדת
או אפשרויות ארוכות, בהתאמה.

אם גם לא ה -c וגם לא -s האפשרות מוגדרת, הארגומנט הראשון שאינו אופציה מציין
שם הקובץ שממנו המעטפת קוראת פקודות. אם אין טיעונים שאינם אופציונליים, ה
shell קורא פקודות מהקלט הסטנדרטי. שם הקליפה (כלומר התוכן של
$0) נקבע באופן הבא: אם ה -c נעשה שימוש ב-option ויש ארגומנט של non-option,
הוא משמש כשם; אם קוראים פקודות מקובץ, הקובץ משמש בתור
שֵׁם; אחרת, נעשה שימוש בשם הבסיס שאיתו נקראה המעטפת (כלומר argv[0]).

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

אתחול קבצים
למיקום בפועל של קבצים אלה, ראה קבצים. מעטפת כניסה מעבדת את המערכת
תחילה פרופיל. מעטפת מועדפת מעבדת את פרופיל suid. כניסה לא מוסמכת
shell מעבד את פרופיל המשתמש הבא. מעטפת אינטראקטיבית לא מוסמכת בודקת את הערך
של הפרמטר ENV לאחר הכפפתו לפרמטר, פקודה, אריתמטיקה וטילדה ('~')
החלפה; אם לא מוגדר או ריק, פרופיל המשתמש mkshrc מעובד; אחרת, אם קובץ
ששמה הוא תוצאת ההחלפה קיימת, היא מעובדת; אי קיום הוא בשקט
התעלמו. מעטפת מועדפת מורידה את ההרשאות אם אף אחת מהן לא הייתה -p אפשרות שניתנה על
שורת הפקודה ולא מוגדרת במהלך ביצוע קבצי האתחול.

פיקוד תחביר
לאחר מכן, המעטפת מתחילה לנתח את הקלט שלה על ידי הסרת שילובי קו נטוי אחורי-שורה חדשה
לפרוץ את זה מילים. מילים (שהן רצפים של תווים) מופרדות על ידי ללא ציטוטים
תווי רווח לבן (רווח, טאב ושורה חדשה) או מטא-תווים ('<', '>', '|', ';', '(',
')', ו-'&'). מלבד תיחום מילים, מתעלמים מרווחים וטאבים, בעוד שורות חדשות
בדרך כלל תוחם פקודות. המטא-תווים משמשים בבניית הדברים הבאים אסימונים:
'<', '<&', '<<', '<<<', '>', '>&', '>>', '&>' וכו' משמשים לציון הפניות מחדש (ראה
פלט קלט ניתוב מחדש לְהַלָן); '|' משמש ליצירת צינורות; '|&' משמש ליצירת שיתוף
תהליכים (ראה תהליכים משותפים לְהַלָן); ';' משמש להפרדת פקודות; '&' משמש ליצירת
צינורות אסינכרוניים; '&&' ו-'||' משמשים לציון ביצוע מותנה; ';;', ';&'
ו-';|' משמשים ב מקרה הצהרות; '(( .. ))' משמש בביטויים אריתמטיים; ו
לבסוף, '( .. )' משמש ליצירת קונכיות משנה.

ניתן לצטט רווח לבן ומטא-תווים בנפרד באמצעות קו נטוי אחורי ('\'), או ב
קבוצות באמצעות מרכאות כפולות ('"') או בודדות ("'"). שימו לב שהתווים הבאים הם
גם מטופלים במיוחד על ידי המעטפת ויש לצטט אותם אם הם רוצים לייצג את עצמם:
'\', '"', ''', '#', '$', '`', '~', '{', '}', '*', '?' ו-'['. שלושת הראשונים מהם
הם דמויות הציטוט שהוזכרו לעיל (ראה ציטוט לְהַלָן); '#', אם נעשה בו שימוש ב-
תחילת מילה, מציג הערה - הכל אחרי ה-'#' עד הקרוב ביותר
התעלמות מהשורה החדשה; '$' משמש להצגת פרמטר, פקודה וחשבון
החלפות (ראה החלפה לְהַלָן); '`' מציג תחליף פקודה בסגנון ישן
(ראה החלפה לְהַלָן); '~' מתחיל הרחבת ספרייה (ראה טילדה הרחבה לְהַלָן); '{'
ו-'}' תוחמים CSH(1) חלופות בסגנון (ראה לְהַדֵק הרחבה לְהַלָן); ולבסוף, '*',
'?', ו-'[' משמשים ביצירת שמות קבצים (ראה שלח שם דפוסי להלן).

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

פקודה פשוטה מורכבת משילוב כלשהו של הקצאות פרמטרים (ראה פרמטרים
להלן), כיווני קלט/פלט (ראה פלט קלט הפניות למטה), ומילות פקודה;
ההגבלה היחידה היא שהקצאת פרמטרים באה לפני כל מילת פקודה. ה
מילות פקודה, אם קיימות, מגדירות את הפקודה שיש לבצע ואת הארגומנטים שלה. ה
הפקודה יכולה להיות פקודה מובנית של מעטפת, פונקציה או פקודה חיצונית (כלומר פקודה נפרדת
קובץ הפעלה הממוקם באמצעות הפרמטר PATH; לִרְאוֹת פיקוד הוצאת להורג להלן).
שימו לב שלכל מבני הפקודות יש סטטוס יציאה: עבור פקודות חיצוניות, זה קשור
לסטטוס שהוחזר על ידי לחכות(2) (אם לא ניתן היה למצוא את הפקודה, מצב היציאה הוא
127; אם לא ניתן היה לבצע, מצב היציאה הוא 126); מצב היציאה של פקודה אחרת
בונים (פקודות מובנות, פונקציות, פקודות מורכבות, צינורות, רשימות וכו') כולם
מוגדרים היטב ומתוארים היכן שמתואר המבנה. מצב היציאה של א
הפקודה המורכבת רק מהקצאות פרמטרים היא זו של החלפת הפקודה האחרונה
בוצע במהלך הקצאת הפרמטר או 0 אם לא היו החלפות פקודות.

ניתן לשרשר פקודות יחד באמצעות ה-'|' אסימון ליצירת צינורות, שבהם
פלט סטנדרטי של כל פקודה אך האחרונה מועברת (ראה מקטרת(2)) לקלט הסטנדרטי של
את הפקודה הבאה. מצב היציאה של צינור הוא זה של הפקודה האחרונה שלו, אלא אם כן
מה היא תקלה בצינור האפשרות מוגדרת (ראה שם). כל הפקודות של צינור מבוצעות בנפרד
קונכיות משנה; זה מותר על ידי POSIX אך שונה משתי הגרסאות של AT&T UNIX ksh, שם
הכל מלבד הפקודה האחרונה בוצעו בתת-קונכיות; לראות את לקרוא תיאור של מובנה עבור
השלכות ודרכים לעקיפת הבעיה. צינור עשוי להיות קידומת '!' מילה שמורה אשר
גורם לסטטוס היציאה של הצינור להיות השלמה לוגית: אם הסטטוס המקורי
היה 0, הסטטוס המשלים יהיה 1; אם הסטטוס המקורי לא היה 0, הסטטוס המשלים
המצב יהיה 0.

רשימות ניתן ליצור פקודות על ידי הפרדת צינורות באמצעות כל אחד מהאסימונים הבאים:
'&&', '||', '&', '|&', ו-';'. השניים הראשונים מיועדים לביצוע מותנה: "cmd1 && cmd2"
מבצע cmd2 רק אם מצב היציאה של cmd1 הוא אפס; '||' זה ההפך - cmd2 is
מבוצע רק אם סטטוס היציאה של cmd1 אינו אפס. '&&' ו-'||' בעלי עדיפות שווה
שהוא גבוה יותר מזה של '&', '|&' ו-';', שגם להם יש קדימות שווה. הערה
שה-'&&' ו-'||' אופרטורים הם "אסוציאטיביים לשמאל". למשל, שניהם
הפקודות ידפיסו רק "סרגל":

$ false && echo foo || אקו בר
$ נכון || echo foo && echo bar

האסימון '&' גורם לפקודה הקודמת להתבצע באופן אסינכרוני; כלומר, הקליפה
מתחיל את הפקודה אך לא מחכה להשלמה (המעטפת אכן עוקבת אחר ה-
מצב של פקודות אסינכרוניות; לִרְאוֹת עבודה לִשְׁלוֹט לְהַלָן). כאשר פקודה אסינכרונית היא
התחילה כאשר בקרת העבודה מושבתת (כלומר ברוב הסקריפטים), הפקודה מתחילה עם
התעלמו מאותות SIGINT ו-SIGQUIT ועם קלט מנותב מ- / dev / null (למרות זאת,
להפניות מחדש שצוינו בפקודה האסינכרונית יש עדיפות). האופרטור '|&'
מתחיל תהליך משותף שהוא סוג מיוחד של תהליך אסינכרוני (ראה תהליכים משותפים
לְהַלָן). שים לב שפקודה חייבת לעקוב אחר ה-'&&' ו-'||' מפעילים, בזמן שזה לא צריך
עקוב אחר '&', '|&', או ';'. מצב היציאה של רשימה הוא זה של הפקודה האחרונה שבוצעה,
למעט רשימות אסינכרוניות, שסטטוס היציאה שלהן הוא 0.

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

במקרה אחר פונקציה אז! (
עשה esac אם זמן [[ ((
נעשה fi in עד {
elif for select while }

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

$ { echo foo; אקו בר; }
$ { echo foo; אקו בר }
$ { { echo foo; אקו בר; } }

זה לא תקף:

$ { echo foo; סרגל הד }

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

{ רשימה; }
מבנה מורכב; רשימה מבוצע, אך לא בתת-מעטפת. שים לב ש'{' ו-'}'
הן מילים שמורות, לא מטא-תווים.

מקרה מילה ב-[[(] דפוס [| דפוס]...) רשימה שליחות קטלנית] ... esac
אל האני מקרה אמירה מנסה להתאים מילה נגד מוגדר דפוס; ה רשימה
המשויכת לדפוס הראשון המותאם בהצלחה מבוצע. דפוסים בשימוש ב
מקרה ההצהרות זהות לאלו המשמשות עבור דפוסי שמות קבצים פרט לכך שה
הגבלות לגבי '.' ו-'/' נשמטים. שים לב שכל רווח לא מצוטט לפני
ואחרי תבנית מופשטת; יש לצטט כל רווח בתוך תבנית. גם ה
המילה והתבניות כפופות לפרמטר, פקודה והחלפה אריתמטית,
כמו גם החלפת טילדה.

מסיבות היסטוריות, ניתן להשתמש בפלטה פתוחה וסגורה במקום in ו esac לְמָשָׁל
מקרה $foo { *) הד בָּר ;; }.

הרשימה שליחות קטלניתs הם:

';;' סיים אחרי הרשימה.

';&' ליפול לתוך הרשימה הבאה.

';|' הערך את שאר הטפולים ברשימת הדפוסים.

מצב היציאה של א מקרה ההצהרה היא של ההוצאה להורג רשימה; אם לא רשימה is
מבוצע, מצב היציאה הוא אפס.

ל שם [ב מילה ...]; לַעֲשׂוֹת רשימה; בוצע
עבור כל מילה ברשימת המילים שצוינה, הפרמטר שם מוגדר למילה ו
רשימה מוצא להורג. אם in אינו משמש לציון רשימת מילים, הפרמטרים המיקוםיים
($1, $2 וכו') משמשים במקום זאת. מסיבות היסטוריות, עשויות להיות סוגרים פתוחים וסגורים
בשימוש במקום do ו עשה לְמָשָׁל ל i; { הד $i; }. מצב היציאה של א ל
הצהרה היא סטטוס היציאה האחרון של רשימה; אם רשימה אף פעם לא מבוצע, מצב היציאה
הוא אפס.

if רשימה; לאחר מכן רשימה; [elif רשימה; לאחר מכן רשימה;] ... [אחר רשימה;] פי
אם מצב היציאה של הראשון רשימה הוא אפס, השני רשימה מוצא להורג; אחרת,
מה היא רשימה לאחר אליף, אם בכלל, מבוצע עם השלכות דומות. אני נופל
הרשימות הבאות if ו אליףs נכשל (כלומר יציאה עם מצב שאינו אפס), ה רשימה
לאחר אחר מוצא להורג. מצב היציאה של an if ההצהרה היא של לא-
מותנה רשימה שמתבצעת; אם לא ללא תנאי רשימה מבוצע, היציאה
המצב הוא אפס.

בחר שם [ב מילה ...]; לַעֲשׂוֹת רשימה; בוצע
אל האני בחר הצהרה מספקת שיטה אוטומטית להצגת תפריט למשתמש
ולבחור מתוכו. רשימה רשומה של המצוינים מילה(s) מודפס על
שגיאה סטנדרטית, ואחריה הנחיה (PS3: בדרך כלל '#? '). מספר המקביל ל
לאחר מכן נקראת אחת מהמילים המנויות מקלט סטנדרטי, שם מוגדר ל
המילה שנבחרה (או לא הוגדרה אם הבחירה אינה חוקית), REPLY מוגדר למה שנקרא
(חלל מוביל/נגרר מופשט), ו רשימה מוצא להורג. אם שורה ריקה (כלומר
אפס או יותר אוקטטים של IFS), התפריט מודפס מחדש ללא ביצוע רשימה.

מתי רשימה מסתיים, הרשימה המצוינת מודפסת אם REPLY הוא NULL, ההנחיה היא
מודפס, וכן הלאה. תהליך זה נמשך עד קריאת סוף הקובץ, פסיקה
מתקבל, או א לשבור המשפט מבוצע בתוך הלולאה. אם "במילה..." הוא
מושמט, נעשה שימוש בפרמטרים המיקוםיים (כלומר $1, $2 וכו'). בשביל היסטורי
מסיבות, ניתן להשתמש בפלטה פתוחה וסגורה במקום do ו עשה לְמָשָׁל בחר i; {
הד $i; }. מצב היציאה של א בחר ההצהרה היא אפס אם א לשבור הצהרה היא
משמש ליציאה מהלולאה, אחרת לא אפס.

עד רשימה; לַעֲשׂוֹת רשימה; בוצע
זה עובד כמו בזמן, אלא שהגוף מבוצע רק בעוד סטטוס היציאה של
1 רשימה הוא לא אפס.

בזמן רשימה; לַעֲשׂוֹת רשימה; בוצע
A בזמן הוא לולאה שנבדקה מראש. הגוף שלה מבוצע באותה תדירות כמו סטטוס היציאה של
1 רשימה הוא אפס. מצב היציאה של א בזמן הצהרה היא סטטוס היציאה האחרון
של רשימה בגוף הלולאה; אם הגוף לא מבוצע, מצב היציאה הוא
אפס.

פונקציה שם { רשימה; }
מגדיר את הפונקציה שם (ראה פונקציות לְהַלָן). שים לב שצוינו הפניות מחדש
לאחר הגדרת פונקציה מבוצעים בכל פעם שהפונקציה מבוצעת, לא מתי
הגדרת הפונקציה מבוצעת.

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

פונקציה שם() { רשימה; }
זהה ל שם() (לחבוטאיזם). ה פונקציה מתעלמים ממילת המפתח.

זמן [-p] [צינור]
אל האני פיקוד הוצאת להורג סעיף מתאר את זמן מילה שמורה.

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

[[ ביטוי ]]
בדומה ל מבחן ו [ ... ] פקודות (מתוארות מאוחר יותר), עם הדברים הבאים
חריגים:

· פיצול שדות ויצירת שם קובץ אינם מבוצעים על ארגומנטים.

· אל האני -a (ו ו -o (OR) אופרטורים מוחלפים ב-'&&' ו-'||', בהתאמה.

· מפעילים (למשל '-f', '=', '!') חייבים להיות ללא ציטוט.

· החלפות פרמטר, פקודה וחשבון מבוצעות כמו ביטויים
הערכת ביטוי מוערך ועצלן משמשת עבור '&&' ו-'||' מפעילים.
המשמעות היא שבהצהרה הבאה, $( מוערך אם ורק אם
הקובץ Foo קיים וניתן לקריאה:

$ [[ -r foo && $(

· האופרנד השני של הביטויים '!=' ו-'=' הם תת-קבוצה של תבניות (למשל
ההשוואה [[ פו בר = f*r ]] מצליח). זה אפילו עובד בעקיפין:

$ bar=foobar; baz='f*r'
$ [[ $bar = $baz ]]; הד $?
$ [[ $bar = "$baz" ]]; הד $?

אולי באופן מפתיע, ההשוואה הראשונה מצליחה, ואילו השנייה לא.
זה לא חל על כל המטא-תווים extglob, כרגע.

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

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

קו אחורי הרחבה
במקומות שבהם נטויים אחוריים מורחבים, C ו-AT&T UNIX מסוימים ksh או גנו לחבוט סגנון
בריחות מתורגמות. אלה כוללים '\a', '\b', '\f', '\n', '\r', '\t', '\U########',
'\u####', ו-'\v'. עבור '\U########' ו-'\u####', "#" פירושו ספרה הקסדצימלית של זה
ייתכן שלא יהיו כאלה עד ארבע או שמונה; בריחות אלו מתרגמות נקודת קוד של Unicode ל-UTF-8.
יתר על כן, '\E' ו-'\e' מתרחבים לדמות הבריחה.

ב הדפסה מצב מובנה, '\"', '\'' ו-'\?" אינם נכללים במפורש; רצפים אוקטליים
חייב להיות בעל עד שלוש ספרות אוקטליות "#" בראשית הספרה אפס ('\0###');
רצפים הקסדצימליים '\x##' מוגבלים לאף אחד עד שתי ספרות הקסדצימליות "#"; שניהם
רצפים אוקטליים והקסדצימליים הופכים לאוקטטים גולמיים; '\#', כאשר # אינו אחד מהדברים לעיל,
מתורגם ל-\# (הלוכסים האחוריים נשמרים).

הרחבת האלכסון האחורי במצב C סגנון שונה מעט: רצפים אוקטליים '\###' חייבים להיות
אין ספרה אפס המקבילה לאחת עד שלוש ספרות אוקטליות "#" ותפוקת אוקטטים גולמיים;
רצפים הקסדצימליים '\x#*' אוכלים בתאווה כמה שיותר ספרות הקסדצימליות "#" ו
להסתיים עם הספרה הלא הקסדצימלית הראשונה; אלה מתרגמים נקודת קוד של Unicode ל
UTF-8. הרצף '\c#', שבו "#" הוא כל אוקטטה, מתורגם ל-Ctrl-# (שבעצם
פירושו, '\c?' הופך ל-DEL, כל השאר מודדים בסיביות עם 0x1F). לבסוף, '\#', איפה
# אינו אחד מהאפשרויות לעיל, מתורגם ל-# (הקו הנטוי האחורי חתוך), גם אם הוא
שורה חדשה.

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

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

autoload='\typeset -fu'
functions='\typeset -f'
hash='\builtin alias -t'
history='\builtin fc -l'
integer='\typeset -i'
local='\typeset'
login='\exec login'
nameref='\typeset -n'
nohup='nohup '
r='\builtin fc -e -'
type='\builtin מאיפה -v'

כינויים במעקב מאפשרים למעטפת לזכור היכן היא מצאה פקודה מסוימת. הראשון
כאשר המעטפת מבצעת חיפוש נתיב עבור פקודה שמסומנת ככינוי במעקב, היא שומרת
הנתיב המלא של הפקודה. בפעם הבאה שהפקודה מבוצעת, המעטפת בודקת את
נתיב שמור כדי לראות שהוא עדיין בתוקף, ואם כן, נמנע מלחזור על חיפוש הנתיב.
ניתן לרשום וליצור כינויים במעקב באמצעות כינוי -t. שימו לב ששינוי ה-PATH
פרמטר מנקה את הנתיבים השמורים עבור כל הכינויים במעקב. אם ה trackall האפשרות מוגדרת
(כלומר סט -o trackall or סט -h), המעטפת עוקבת אחר כל הפקודות. אפשרות זו מוגדרת
אוטומטית עבור קונכיות לא אינטראקטיביות. עבור קונכיות אינטראקטיביות, רק את הדברים הבאים
מעקב אחר פקודות מתבצע באופן אוטומטי: חתול(1), cc(1), chmod(1), cp(1), נתונים(1), ed(1),
Emacs(1), grep(1), ls(1), לעשות(1), mv(1), pr(1), rm(1), צמא(1), sh(1), vi(1), ו מי(1).

החלפה
הצעד הראשון שהקליפה עושה בביצוע פקודה פשוטה הוא לבצע החלפות על
את דברי הפקודה. ישנם שלושה סוגים של החלפה: פרמטר, פקודה ו
חֶשְׁבּוֹן. החלפות פרמטרים, המתוארות בפירוט בסעיף הבא,
קח את הטופס $שם או ${...}; החלפות פקודות לוקחות את הצורה $(הפקודה) או
(הוצא משימוש) `הפקודה` או (מופעל בסביבה הנוכחית) ${ הפקודה;} ופשט
שורות חדשות נגררות; והחלפות אריתמטיות לובשות את הצורה $((ביטוי)). ניתוח של
החלפת פקודות בסביבה הנוכחית דורשת רווח, טאב או שורה חדשה לאחר הפתיחה
סד ושהסוגר הסוגר יוכר כמילת מפתח (כלומר לפניה שורה חדשה
או נקודה-פסיק). הם נקראים גם funsubs (החלפות פונקציות) ומתנהגים כמו
מתפקד בזה מקומי ו לַחֲזוֹר עבודה, ובזה יציאה מסיים את מעטפת האב; צדף
אפשרויות משותפות.

וריאנט נוסף של החלפה הם valsubs (החלפות ערך) ${|הפקודה;} שהם
מבוצעים גם בסביבה הנוכחית, כמו funsubs, אבל חולקים את ה-I/O שלהם עם ההורה;
במקום זאת, הם מעריכים לפי מה שהמשתנה REPLY, הריק בתחילה, הביטוי המקומי
מוגדר בתוך הפקודהs.

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

דוגמה: אם IFS מוגדר ל" :", ו-VAR מוגדר ל
" א : B::D", ההחלפה ב-$VAR גורמת לארבעה שדות: 'A',
'B', '' (שדה ריק) ו-'D'. שים לב שאם הפרמטר IFS מוגדר לריק
מחרוזת, לא נעשה פיצול שדה; אם הוא לא מוגדר, ערך ברירת המחדל של רווח, טאב ו
נעשה שימוש ב-newline.

כמו כן, שים לב שפיצול השדות חל רק על התוצאה המיידית של ה-
החלפה. באמצעות הדוגמה הקודמת, ההחלפה ב-$VAR:E גורמת ל-
שדות: 'A', 'B', '' ו-'D:E', לא 'A', 'B', '', 'D' ו-'E'. התנהגות זו היא POSIX
תואם, אך אינו תואם לכמה יישומי מעטפת אחרים שעושים פיצול שדות
על המילה שהכילה את ההחלפה או השתמשו ב-IFS כמפריד רווח כללי.

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

החלפת פקודה מוחלפת בפלט שנוצר על ידי הפקודה שצוינה שהיא
לרוץ בתת-קליפה. תמורת $(הפקודה) ו-${|הפקודה;} ו-${ הפקודה;} החלפות, רגילות
כללי ציטוט משמשים כאשר הפקודה מנותח; עם זאת, עבור `הפקודה` טופס, א
'\' ואחריו כל אחד מ-'$', '`' או '\' מופשט (כמו '"' כאשר ההחלפה היא חלק
של מחרוזת במירכאות כפולות); קו נטוי אחורי '\' ואחריו כל תו אחר אינו משתנה.
כמקרה מיוחד בהחלפות פקודה, פקודה בצורהפילה מתפרש ל
מתכוון להחליף את התוכן של פילה. שים לב ש $( יש את אותה השפעה כמו $(חתול פו).

שימו לב שחלק מהקליפות אינן משתמשות במנתח רקורסיבי להחלפות פקודות, מה שמוביל ל
כישלון עבור מבנים מסוימים; כדי להיות נייד, השתמש כדרך לעקיפת הבעיה 'x=$(cat) <<"EOF"' (או
הרחבת newline-keeping 'x=<<"EOF"') במקום זאת רק כדי לשטוף את המחרוזת. IEEE Std 1003.1
(“POSIX.1”) ממליץ להשתמש בהצהרות מקרה בצורת 'x=$(case $foo ב-(bar) echo $bar
;; (*) echo $baz ;; esac)' במקום, שיעבוד אך לא ישמש דוגמה לכך
בעיית ניידות.

x=$(מקרה $foo בסרגל) echo $bar ;; *) echo $baz ;; esac)
# לעיל לא מצליח לנתח על קונכיות ישנות; להלן הפתרון לעקיפת הבעיה
x=$(eval $(cat)) <<"EOF"
מקרה $foo בבר) echo $bar ;; *) echo $baz ;; esac
EOF

החלפות אריתמטיות מוחלפות בערך של הביטוי שצוין. ל
לדוגמה, הפקודה הדפסה $((2+3*4)) מציג 14. ראה חשבון ביטויים עבור
תיאור של ביטוי.

פרמטרים
פרמטרים הם משתני מעטפת; ניתן להקצות להם ערכים וניתן לגשת לערכים שלהם
באמצעות החלפת פרמטרים. שם פרמטר הוא אחד מהסינגלים המיוחדים
פרמטרים של סימני פיסוק או ספרות המתוארים להלן, או אות ואחריה אפס או
יותר אותיות או ספרות ('_' נחשב כאות). ניתן להתייחס לצורה האחרונה כאל מערכים
על ידי הוספת אינדקס מערך של הטופס [ביטוי] איפה ביטוי הוא ביטוי אריתמטי.
מדדי מערך ב מקש מוגבלים לטווח 0 עד 4294967295, כולל. זה,
הם מספר שלם ללא סימן של 32 סיביות.

החלפות פרמטרים לובשות את הצורה $שם, ${שם}, או ${שם[ביטוי]} איפה שם הוא
שם פרמטר. החלפה של כל רכיבי המערך ב-${שם[*]} ו-${שם[@]} עובד
שווה ערך ל-$* ו-$@ עבור פרמטרים מיקוםיים. אם מבוצעת החלפה על א
פרמטר (או אלמנט פרמטר מערך) שאינו מוגדר, מחרוזת null מוחלפת
אלא אם כן ה שם עצם האפשרות (סט -o שם עצם or סט -u) מוגדר, ובמקרה זה מתרחשת שגיאה.

ניתן להקצות לפרמטרים ערכים במספר דרכים. ראשית, המעטפת מתקבעת באופן מרומז
כמה פרמטרים כמו '#', 'PWD' ו-'$'; זו הדרך היחידה לדמות יחידה מיוחדת
פרמטרים מוגדרים. שנית, פרמטרים מיובאים מסביבת המעטפת ב-
סטארט - אפ. שלישית, ניתן להקצות לפרמטרים ערכים בשורת הפקודה: לדוגמה, FOO=בר
מגדיר את הפרמטר "FOO" ל"בר"; ניתן לתת הקצאות פרמטרים מרובות על יחיד
שורת הפקודה וניתן לעקוב אחריהן פקודה פשוטה, ובמקרה זה המשימות הן
בתוקף רק למשך הפקודה (משימות כאלה מיוצאות גם; ראה
להלן לגבי ההשלכות של זה). שים לב שגם שם הפרמטר וגם ה-'=' חייבים להיות
ללא ציטוט כדי שהמעטפת תזהה הקצאת פרמטר. המבנה FOO+=baz גם
מוּכָּר; הערכים הישנים והחדשים משורשרים מיד. הדרך הרביעית להגדרה
פרמטר הוא עם יצוא, גלוֹבָּלִי, באופן קריא, ו ערכת סוגים פקודות; לראות את שלהם
תיאורים ב פיקוד הוצאת להורג סָעִיף. חמישי, ל ו בחר לולאות קובעות פרמטרים
כמו גם קמצנים, לקרוא, ו סט -A פקודות. לבסוף, ניתן להקצות פרמטרים
ערכים באמצעות אופרטורים של הקצאה בתוך ביטויים אריתמטיים (ראה חשבון ביטויים
למטה) או באמצעות ${שם=ערך} הצורה של החלפת הפרמטרים (ראה להלן).

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

ניתן להחיל שינויים ב-${שם} צורה של החלפת פרמטרים:

${שם:-מילה}
If שם מוגדר ולא NULL, הוא מוחלף; אחרת, מילה מוחלף.

${שם:+מילה}
If שם מוגדר ולא NULL, מילה מוחלף; אחרת, שום דבר לא יוחלף.

${שם:=מילה}
If שם מוגדר ולא NULL, הוא מוחלף; אחרת, הוא מוקצה מילה ו
הערך המתקבל של שם מוחלף.

${שם:?מילה}
If שם מוגדר ולא NULL, הוא מוחלף; אחרת, מילה מודפס על
שגיאת תקן (שלפניה שם:) ומתרחשת שגיאה (בדרך כלל גורמת לסיום
של סקריפט מעטפת, פונקציה או סקריפט שמקורם ב-'.' מובנה). אם מילה is
הושמט, המחרוזת "פרמטר null or not set" משמשת במקום זאת. כרגע באג,
if מילה הוא משתנה שמתרחב למחרוזת null, הודעת השגיאה היא גם
מודפס.

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

במתנים לעיל, ניתן להשמיט את ה-':', ובמקרה זה התנאים תלויים רק
שם להיות מוגדר (בניגוד ל-set ולא NULL). אם מילה דרוש, פרמטר, פקודה,
מתבצעות בו אריתמטיקה והחלפת טילדה; אם מילה אין צורך, אין צורך
העריך.

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

${#שם}
מספר הפרמטרים המיקוםיים אם שם הוא '*', '@', או לא צוין; אחרת
האורך (בתווים) של ערך המחרוזת של הפרמטר שם.

${#שם[*]}
${#שם[@]}
מספר האלמנטים במערך שם.

${%שם}
הרוחב (בעמודות המסך) של ערך המחרוזת של הפרמטר שם, או -1 אם
${שם} מכיל תו שליטה.

${!שם}
שם המשתנה שאליו מתייחס שם. זה יהיה שם אלא מתי שם is
הפניה לשם (משתנה כבול), שנוצרה על ידי ה- nameref פקודה (שהיא כינוי
ל ערכת סוגים -n).

${!שם[*]}
${!שם[@]}
שמות המדדים (מפתחות) במערך שם.

${שם#דפוס}
${שם##דפוס}
If דפוס מתאים לתחילת הערך של הפרמטר שם, הטקסט המותאם הוא
נמחק מתוצאת ההחלפה. '#' בודד מביא לקצר ביותר
התאמה, ושניים מהם מביאים למשחק הארוך ביותר. לא ניתן להחיל על וקטור
(${*} או ${@} או ${array[*]} או ${array[@]}).

${שם%דפוס}
${שם%%דפוס}
כמו החלפה ${..#..}, אבל זה מוחק מסוף הערך. לא יכול להיות
מוחל על וקטור.

${שם/דפוס/מחרוזת}
${שם/#דפוס/מחרוזת}
${שם/%דפוס/מחרוזת}
${שם//דפוס/מחרוזת}
המשחק הארוך ביותר של דפוס בערך של פרמטר שם מוחלף ב מחרוזת
(נמחק אם מחרוזת זה ריק; ניתן להשמיט את הלוכסן הנגרר ('/') במקרה זה).
קו נטוי מוביל ואחריו '#' או '%' גורם לעיגון הדפוס ב-
התחלה או סוף של הערך, בהתאמה; ריק ללא עיגון דפוססיבה לא
תַחֲלִיף; נטוי מוביל יחיד או שימוש ב-a דפוס שמתאים לריק
מחרוזת גורמת להחלפה להתרחש פעם אחת בלבד; שני חתכים מובילים גורמים לכל
מופעים של התאמות בערך שיוחלף. לא ניתן להחיל על וקטור.
מיושם בצורה לא יעילה, עשוי להיות איטי.

${שם:להציב:לן}
1 לן דמויות של שם, מתחיל בעמדה להציב, מוחלפים. שניהם
להציב ו:לן הם אופציונליים. אם להציב הוא שלילי, הספירה מתחילה בסוף ה-
חוּט; אם הוא מושמט, ברירת המחדל היא 0. אם לן מושמט או גדול מה-
אורך המחרוזת הנותרת, הכל מוחלף. שניהם להציב ו לן יש לו
מוערכים כביטויים אריתמטיים. כַּיוֹם, להציב חייב להתחיל עם רווח,
סוגרי פתיחה או ספרה לזיהוי. לא ניתן להחיל על וקטור.

${שם@#}
ה-hash (באמצעות אלגוריתם BAFH) של ההרחבה של שם. זה משמש גם
פנימי עבור טבלאות האשטיות של המעטפת.

${שם@Q}
ביטוי מצוטט בטוח לכניסה חוזרת, שערכו הוא הערך של שם
פרמטר, מוחלף.

שים לב כי דפוס עשוי להזדקק לדפוס גלוב מורחב (@(...)), יחיד ('...') או כפול
("...") ציטוט בורח אלא אם כן -o sh מוגדר.

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

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

# מספר הפרמטרים המיקוםיים ($1, $2 וכו').

$ ה-PID של המעטפת, או ה-PID של המעטפת המקורית אם היא תת-שריון. לַעֲשׂוֹת לא
השתמש במנגנון זה ליצירת שמות קבצים זמניים; לִרְאוֹת mktemp(1) במקום זאת.

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

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

0 שם הקליפה, נקבע כדלקמן: הטיעון הראשון ל מקש אם זה היה
מופעל עם ה -c ניתנו אפשרות וטיעונים; אחרת ה פילה טיעון, אם
הוא סופק; או בשם הבסיס איתו הופעלה המעטפת (כלומר argv[0]). $0
מוגדר גם לשם של הסקריפט הנוכחי או לשם הפונקציה הנוכחית,
אם זה היה מוגדר עם פונקציה מילת מפתח (כלומר פונקציה בסגנון מעטפת קורן).

1 .. 9 תשעת הפרמטרים המיקוםיים הראשונים שסופקו למעטפת, לפונקציה או
סקריפט שמקורו ב-'.' מובנה. פרמטרים מיקוםיים נוספים עשויים להיות
גישה באמצעות ${מספר}.

* כל הפרמטרים המיקוםיים (למעט 0), כלומר $1, $2, $3, ...
אם משתמשים בהם מחוץ למירכאות כפולות, פרמטרים הם מילים נפרדות (שנתונות
לפיצול מילים); אם משתמשים במירכאות כפולות, הפרמטרים מופרדים על ידי ה-
התו הראשון של הפרמטר IFS (או המחרוזת הריקה אם IFS הוא NULL).

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

הפרמטרים הבאים מוגדרים ו/או בשימוש על ידי המעטפת:

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

BASHPID ה-PID של המעטפת או המשנה.

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

COLUMNS הגדר למספר העמודות בטרמינל או בחלון. תמיד מוגדר, ברירת מחדל
עד 80, אלא אם הערך כפי שדווח על ידי stty(1) אינו אפס ושפוי מספיק
(המינימום הוא 12x3); דומה עבור LINES. פרמטר זה משמש את
מצבי עריכת קו אינטראקטיביים, ולפי בחר, סט -o, ו להרוג -l פקודות
לעיצוב עמודות מידע. ייבוא ​​מהסביבה או ביטול הגדרה
פרמטר זה מסיר את הקישור לגודל הטרמינל בפועל לטובת ה-
ערך מסופק.

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

ERRNO ערך מספר שלם של המעטפת ארנו מִשְׁתַנֶה. זה מציין את הסיבה האחרונה
שיחת המערכת נכשלה. עדיין לא מיושם.

EXECSHELL אם מוגדר, מניחים שהפרמטר הזה מכיל את המעטפת שאליה יש להשתמש
לבצע פקודות ש בכיר(2) נכשל בביצוע ושאינם מתחילים בא
"#!פָּגָז" סדר פעולות.

FCEDIT העורך המשמש את fc פקודה (ראה להלן).

FPATH כמו PATH, אך משמש כאשר מופעלת פונקציה לא מוגדרת לאיתור הקובץ
הגדרת הפונקציה. הוא גם נחפש כאשר לא ניתן למצוא פקודה באמצעות
נָתִיב. לִרְאוֹת פונקציות להלן למידע נוסף.

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

הערות: אם HISTFILE לא מוגדר או ריק, לא נעשה שימוש בקובץ היסטוריה. זה
שונה מ-AT&T UNIX ksh.

HISTSIZE מספר הפקודות המאוחסנות בדרך כלל עבור ההיסטוריה. ברירת המחדל היא 2047. עשה
לא להגדיר את הערך הזה לערכים גבוהים בטירוף כגון 1000000000 כי מקש יכול
אז לא הקצו מספיק זיכרון להיסטוריה ולא יתחיל.

HOME ספריית ברירת המחדל עבור cd הפקודה והערך במקום an
לֹא מוּסמָך ~ (ראה טילדה הרחבה להלן).

מפריד שדות פנימי של IFS, בשימוש במהלך ההחלפה ועל ידי ה לקרוא פקודה, ל
לפצל ערכים לארגומנטים נפרדים; בדרך כלל מוגדר לרווח, טאב ושורה חדשה.
לִרְאוֹת החלפה לעיל לפרטים.

הערות: פרמטר זה אינו מיובא מהסביבה כאשר המעטפת
התחיל.

KSHEGID מזהה הקבוצה היעיל של המעטפת.

KSHGID מזהה הקבוצה האמיתי של הקליפה.

KSHUID מזהה המשתמש האמיתי של המעטפת.

KSH_VERSION השם והגרסה של המעטפת (לקריאה בלבד). ראה גם את פקודות הגרסה
in אמאק עריכה מצב ו Vi עריכה מצב סעיפים, להלן.

LINENO מספר השורה של הפונקציה או סקריפט המעטפת שנמצא כעת
יצא לפועל.

LINES הגדר למספר הקווים בטרמינל או בחלון. מוגדר תמיד, ברירת המחדל היא
24. ראה עמודות.

EPOCHREALTIME
זמן מאז העידן, כפי שהוחזר על ידי השעות היום(2), בפורמט כעשרוני
tv_sec ואחריו נקודה ('.') ו tv_usec מרופד עד שש עשרוניות בדיוק
ספרות.

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

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

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

PATH רשימה מופרדת של נקודתיים (נקודה-פסיק ב-OS/2) של ספריות שמחפשים
כאשר מחפשים פקודות וקבצים שמקורם ב-'.' פקודה (ראה להלן).
מחרוזת ריקה הנובעת מנקודתיים מובילה או נגררת, או שניים סמוכים
נקודתיים, מתייחסים אליו כאל '.' (הספרייה הנוכחית).

PGRP מזהה התהליך של מנהיג קבוצת התהליך של המעטפת.

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

PPID מזהה התהליך של האב של המעטפת.

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

ההנחיה המוגדרת כברירת מחדל היא '$ ' עבור משתמשים שאינם שורש, '# ' עבור root. אם מקש is
מופעל על ידי root ו-PS1 אינו מכיל תו '#', ערך ברירת המחדל
ישמש גם אם PS1 כבר קיים בסביבה.

אל האני מקש ההפצה מגיעה עם דוגמה dot.mkshrc מכיל מתוחכם
לדוגמה, אבל אולי תאהב את הבא (שים לב
${HOSTNAME:=$(hostname)} וסעיף ההבחנה בין שורש לעומת משתמש הם (ב
דוגמה זו) מבוצע בזמן הקצאת PS1, בעוד שה-$USER ו-$PWD כן
נמלט וכך יוערך בכל פעם שמוצגת הנחיה):

PS1='${USER:=$(id -un)}'"@${HOSTNAME:=$(hostname)}:\$PWD $(
if ((USER_ID)); לאחר מכן הדפס \$; אחרת הדפס \#; פי) "

שימו לב שמאחר שעורכי שורת הפקודה מנסים להבין כמה זמן ההנחיה
הוא (כדי שידעו כמה זה רחוק לקצה המסך), קודי בריחה ב-
הודעה נוטה לבלבל את העניינים. אתה יכול להגיד לקליפה לא לספור בטוח
רצפים (כגון קודי בריחה) על ידי הקדמת ההנחיה שלך עם תו
(כגון Ctrl-A) ואחריו החזרת כרכרה ואז תוחם את הבריחה
קודים עם תו זה. כל המופעים של אותו תו בהנחיה הם
לא מודפס. אגב, אל תאשים אותי בפריצה הזו; זה נגזר מה-
מְקוֹרִי ksh88(1), שאכן הדפיס את תו המפריד כך שיצא לך
מזל אם לא היו לך תווים שאינם מודפסים.

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

x=$(הדפס \\001)
PS1="$x$(הדפס \\r)$x$(tput so)$x\$PWD$x$(tput se)$x> "

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

PS1=$'\1\r\1\e[7m\1$PWD\1\e[0m\1> '

מחרוזת הנחיה משנית של PS2, כברירת מחדל '> ', משמשת כאשר יש צורך בקלט נוסף
להשלים פקודה.

הפקודה PS3 בשימוש על ידי בחר הצהרה בעת קריאת בחירת תפריט. ברירת המחדל
הוא '#? '.

PS4 משמש לקידומת פקודות המודפסות במהלך מעקב אחר ביצוע (ראה את סט
-x הפקודה למטה). תחליפי פרמטר, פקודה וחשבון הם
מבוצע לפני הדפסתו. ברירת המחדל היא '+'. אולי תרצה להגדיר את זה
במקום '[$EPOCHREALTIME] ' כדי לכלול חותמות זמן.

PWD ספריית העבודה הנוכחית. עשוי להיות מבוטל או NULL אם המעטפת לא יודעת
איפה זה.

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

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

SECONDS מספר השניות מאז תחילת המעטפת או, אם הפרמטר היה
הוקצה ערך של מספר שלם, מספר השניות מאז ההקצאה בתוספת ה-
ערך שהוקצה.

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

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

USER_ID מזהה המשתמש היעיל של המעטפת.

טילדה הרחבה
הרחבת טילדה הנעשית במקביל להחלפת פרמטרים, נעשית על מילים
מתחיל עם '~' ללא מרכאות. התווים העוקבים אחר הטילדה, עד ה-'/' הראשון, אם
כל, מניחים שהם שם התחברות. אם שם הכניסה ריק, '+' או '-', הערך של
הפרמטר HOME, PWD או OLDPWD מוחלף, בהתאמה. אחרת, הסיסמה
מחפשים את שם הכניסה לקובץ, וביטוי tilde מוחלף בביטוי של המשתמש
ספריית הבית. אם שם הכניסה לא נמצא בקובץ הסיסמה או אם כל ציטוט או
החלפת פרמטר מתרחשת בשם הכניסה, לא מתבצעת החלפה.

בהקצאות פרמטרים (כגון אלו שלפני פקודה פשוטה או אלו המתרחשות ב-
טיעונים של כינוי, יצוא, גלוֹבָּלִי, באופן קריא, ו ערכת סוגים), הרחבת טילדה נעשית לאחר מכן
כל הקצאה (כלומר אחרי סימן השוויון) או אחרי נקודתיים ללא ציטוט (':'); שמות כניסה
מופרדים גם על ידי נקודתיים.

ספריית הבית של שמות התחברות שהורחבו בעבר נשמרות במטמון ונעשה בהם שימוש חוזר. ה כינוי -d
ניתן להשתמש בפקודה כדי לרשום, לשנות ולהוסיף למטמון זה (למשל כינוי -d
fac=/usr/local/מתקנים; cd ~fac/bin).

לְהַדֵק הרחבה (הִתחַלְפוּת)
ביטויי הפלטה לובשים את הצורה הבאה:

קידומת{עמ' 1, ...,strN}סִיוֹמֶת

הביטויים מורחבים ל N מילים, שכל אחת מהן היא שרשור של קידומת, stri,
ו סִיוֹמֶת (למשל "a{c,b{X,Y},d}e" מתרחב לארבע מילים: "ace", "abXe", "abYe" ו-"ade").
כפי שצוין בדוגמה, ניתן לקנן את ביטויי הסוגרים והמילים המתקבלות לא
מְמוּיָן. ביטויי הסוגריים חייבים להכיל פסיק ללא מרכאות (',') כדי שתתרחש הרחבה (למשל
{} ו {פו} לא מורחבים). הרחבת הסד מתבצעת לאחר החלפת פרמטרים
ולפני יצירת שם קובץ.

שלח שם דפוסי
תבנית שם קובץ היא מילה המכילה '?', '*', '+', '@' או '!' אחד או יותר ללא ציטוט.
תווים או רצפים של "[..]". לאחר ביצוע הרחבת הפלטה, המעטפת מתחלפת
דפוסי שמות קבצים עם השמות הממוינים של כל הקבצים התואמים לדפוס (אם לא
קבצים תואמים, המילה נשארת ללא שינוי). למרכיבי הדפוס יש את המשמעות הבאה:

? מתאים לכל תו בודד.

* מתאים לכל רצף של אוקטטים.

[..] מתאים לכל אחת מהשמיניות בתוך הסוגריים. ניתן לציין טווחים של אוקטטים על ידי
הפרדה בין שתי אוקטטים ב-'-' (למשל "[a0-9]" תואם את האות 'a' או כל ספרה).
על מנת לייצג את עצמו, יש לצטט "-" או את השמינייה הראשונה או האחרונה
ברשימת האוקטטים. באופן דומה, יש לצטט את ']' או את השמינייה הראשונה ברשימה
אם הוא אמור לייצג את עצמו במקום את סוף הרשימה. גם '!' מופיעים
בתחילת הרשימה יש משמעות מיוחדת (ראה להלן), אז לייצג אותה
יש לצטט או להופיע מאוחר יותר ברשימה.

[!..] כמו [..], אלא שהוא מתאים לכל אוקטט שאינו בתוך הסוגריים.

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

+(דפוס|...|דפוס)
מתאים לכל מחרוזת אוקטטים התואמת מופע אחד או יותר של המופע שצוין
דפוסים. דוגמה: התבנית +(פו|בָּר) מתאים למחרוזות "foo", "bar",
"foobar" וכו'.

?(דפוס|...|דפוס)
מתאים למחרוזת הריקה או למחרוזת התואמת לאחת מהדפוסים שצוינו.
דוגמה: התבנית ?(פו|בָּר) מתאים רק למחרוזות "", "foo" ו-"bar".

@(דפוס|...|דפוס)
מתאים למחרוזת התואמת לאחת מהדפוסים שצוינו. דוגמה: התבנית
@(פו|בָּר) תואם רק את המיתרים "foo" ו-"bar".

!(דפוס|...|דפוס)
מתאים לכל מחרוזת שאינה תואמת לאחת מהדפוסים שצוינו. דוגמאות: ה
דפוס !(פו|בָּר) מתאים לכל המיתרים מלבד "foo" ו-"bar"; הדפוס !(*)
תואם ללא מיתרים; הדפוס !(?)* תואם את כל המחרוזות (תחשוב על זה).

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

שים לב כי מקש (ו pdksh) אף פעם לא תואם את '.' ו-'..', אבל AT&T UNIX ksh, בורן sh, וגנו
לחבוט לעשות.

שים לב שאף אחד ממרכיבי הדפוס שלעיל אינו תואם לנקודה ('.') בתחילת א
שם קובץ או לוכסן ('/'), גם אם נעשה בהם שימוש מפורש ברצף [..]; וגם ה
שמות '.' ו-'..' לעולם אינם מתאימים, אפילו על ידי התבנית '.*'.

אם markdirs האפשרות מוגדרת, כל ספריות הנובעות מיצירת שמות קבצים הן
מסומן ב-'/' נגרר.

פלט קלט ניתוב מחדש
כאשר מופעלת פקודה, הקלט הסטנדרטי שלה, הפלט הסטנדרטי ושגיאת התקן שלה (קובץ
המתארים 0, 1 ו-2, בהתאמה) עוברים בדרך כלל בירושה מהקליפה. שְׁלוֹשָׁה
חריגים לכך הם פקודות בצינורות, שעבורן קלט סטנדרטי ו/או תקן
פלט הם אלה שהוגדרו על ידי הצינור, פקודות אסינכרוניות שנוצרות כאשר בקרת עבודה היא
מושבת, שעבורו הקלט הסטנדרטי מוגדר בהתחלה להיות מאת / dev / null, ופקודות עבור
אשר כל אחת מההפניות הבאות צוינה:

>פילה הפלט הסטנדרטי מופנה אל פילה. אם פילה לא קיים, הוא נוצר;
אם הוא קיים, הוא קובץ רגיל, וה- נוקלובר האפשרות מוגדרת, שגיאה
מתרחש; אחרת, הקובץ נחתך. שימו לב שזה אומר הפקודה cmd
<פו > פו יפתח Foo לקריאה ולאחר מכן לקטוע אותו כאשר הוא פותח אותו עבור
כתיבה, לפני cmd מקבל הזדמנות לקרוא באמת Foo.

>|פילה כמו >, אלא שהקובץ קטוע, גם אם ה- נוקלובר האפשרות מוגדרת.

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

<פילה קלט סטנדרטי מופנה מ פילה, שנפתח לקריאה.

<>פילה כמו <, אלא שהקובץ נפתח לקריאה וכתיבה.

<<סמן לאחר קריאת שורת הפקודה המכילה סוג זה של ניתוב מחדש (נקרא a
"מסמך כאן"), המעטפת מעתיקה שורות ממקור הפקודה ל-a
קובץ זמני עד להתאמת שורה סמן נקרא. כאשר הפקודה היא
מבוצע, קלט סטנדרטי מנותב מחדש מהקובץ הזמני. אם סמן
אינו מכיל תווים במירכאות, תוכן הקובץ הזמני מעובד
כאילו מוקף במירכאות כפולות בכל פעם שהפקודה מבוצעת, אז פרמטר,
פקודה וביצוע החלפות אריתמטיות, יחד עם קו נטוי אחורי ('\')
escapes עבור '$', '`', '\' ו-'\newline', אך לא עבור '"'. אם כאן יש מספר נקודות
מסמכים משמשים באותה שורת פקודה, הם נשמרים לפי הסדר.

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

<<-סמן כמו <<, למעט כרטיסיות מובילות מופשטות מהשורות במסמך כאן.

<<מילה כמו <<חוץ מזה מילה is המסמך כאן. זה נקרא כאן
מחרוזת.

<&fd הקלט הסטנדרטי משוכפל מתאר הקובץ fd. fd יכול להיות מספר,
ציון המספר של מתאר קובץ קיים; האות 'p', המציינת
מתאר הקובץ המשויך לפלט של התהליך המשותף הנוכחי; או ה
תו '-', המציין שיש לסגור את הקלט הסטנדרטי. ציין זאת fd is
מוגבל לספרה אחת ברוב יישומי מעטפת.

>&fd כמו <&, אלא שהפעולה נעשית על פלט סטנדרטי.

&>פילה כמו >פילה 2> & 1. זהו GNU שהוצא משימוש (מורשת). לחבוט הרחבה נתמכת
by מקש שתומך גם במספר ה-fd המפורש הקודם, למשל,
3&>פילה הוא זהה 3>פילה 2> & 3 in מקש אבל שגיאת תחביר ב-GNU לחבוט.

&>|פילה, &>>פילה, &>&fd
כמו >|פילה, >>פילה, או >&fd, ואחריו 2> & 1, כאמור לעיל. אלו הם מקש
הרחבות.

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

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

$ cat /foo/bar 2>&1 >/dev/null | pr -n -t

מתארי קבצים שנוצרו על-ידי הפניות מחדש של I/O הם פרטיים למעטפת.

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

ביטויים מחושבים באמצעות חשבון סימנים ו- mksh_ari_t סוג (חתימה של 32 סיביות
מספר שלם), אלא אם הם מתחילים בתו '#' היחיד, ובמקרה זה הם משתמשים mksh_uari_t (a
מספר שלם ללא סימן של 32 סיביות).

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

אופרטורים אונריים:

+ - ! ~ ++ --

מפעילים בינאריים:

,
= += -= *= /= %= <<<= >>>= <<= >>= &= ^= |=
||
&&
|
^
&
==! =
<<=>> =
<<< >>> << >>
+ -
* /%

מפעילים טרנריים:

?: (העדיפות גבוהה מיד מההקצאה)

מפעילי קיבוץ:

()

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

בתור מיוחד מקש הרחבה, מספרים לבסיס אחד מטופלים כאחד (8-bit
שקוף) נקודות קוד ASCII או Unicode, בהתאם למעטפת מצב utf8 דגל (נוכחי
הגדרה). AT&T UNIX ksh93 גם תחביר של "'x'" במקום "1#x" נתמך. הערה
שלא ניתן להשתמש בתים NUL (ערך אינטגרלי של אפס). פרמטר לא מוגדר או ריק
מוערך ל-0 בהקשר של מספר שלם. במצב Unicode, אוקטטים גולמיים ממופים לטווח
EF80..EFFF כמו ב-OPTU-8, שנמצא ב-PUA והוקצה על ידי CSUR לשימוש זה. אם
יותר מאוקטט אחד במצב ASCII, או רצף של יותר מאוקטט אחד שאינו יוצר תקף
ורצף CESU-8 מינימלי מועבר, ההתנהגות אינה מוגדרת (בדרך כלל, המעטפת מפסיקה
עם שגיאת ניתוח, אך לעיתים רחוקות היא מצליחה, למשל ברצף C2 20). בגלל זה אתה
תמיד צריך להשתמש במצב ASCII אלא אם כן אתה יודע שהקלט בנוי היטב UTF-8 ב-
טווח של 0000..FFFD אם אתה משתמש בתכונה זו, בניגוד ל לקרוא -a.

המפעילים מוערכים באופן הבא:

unary +
התוצאה היא הטיעון (כלול לצורך שלמות).

אוניארי -
שְׁלִילָה.

! לא הגיוני; התוצאה היא 1 אם הארגומנט הוא אפס, 0 אם לא.

~ אריתמטי (באופן סיביות) לא.

++ הגדלה; יש להחיל על פרמטר (לא ביטוי מילולי או אחר).
הפרמטר גדל ב-1. כאשר משתמשים בו כאופרטור קידומת, התוצאה
הוא הערך המוגדל של הפרמטר; כאשר משתמשים בו בתור אופרטור postfix,
התוצאה היא הערך המקורי של הפרמטר.

-- דומה ל ++, אלא שהפרמטר מופחת ב-1.

, מפריד בין שני ביטויים אריתמטיים; הצד השמאלי מוערך תחילה,
ואז הימין. התוצאה היא הערך של הביטוי בצד ימין
צַד.

= משימה; המשתנה משמאל מוגדר לערך מימין.

+= -= *= /= %= <<<= >>>= <<= >>= &= ^= |=
מפעילי מטלות.היה><op>=ביטוי> זהה להיה>=היה><op><ביטוי>,
עם עדיפות מפעיל כלשהי בביטוי> נשמר. לדוגמה, "var1 *= 5 +
3" זהה לציון "var1 = var1 * (5 + 3)".

|| OR לוגי; התוצאה היא 1 אם אחד מהארגומנטים אינו אפס, 0 אם לא. ה
ארגומנט ימני מוערך רק אם הארגומנט השמאלי הוא אפס.

&& לוגי AND; התוצאה היא 1 אם שני הארגומנטים אינם אפס, 0 אם לא. ה
ארגומנט ימני מוערך רק אם הארגומנט השמאלי אינו אפס.

| אריתמטי (באופן סיביות) OR.

^ אריתמטי (בבחינת סיביות) XOR (בלעדי-OR).

& אריתמטי (באופן סיביות) AND.

== שווה; התוצאה היא 1 אם שני הארגומנטים שווים, 0 אם לא.

!= לא שווה; התוצאה היא 0 אם שני הארגומנטים שווים, 1 אם לא.

< פחות מ; התוצאה היא 1 אם הארגומנט השמאלי קטן מהימין, 0 אם
לֹא.

<= > >=
פחות או שווה, גדול מ, גדול או שווה. לִרְאוֹת <.

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

<< >> העבר שמאלה (ימינה); התוצאה היא הארגומנט השמאלי עם הקטעים שלו מוזזים שמאלה
(נכון) לפי הסכום שניתן בטיעון הנכון.

+ - * /
חיבור, חיסור, כפל וחילוק.

% היתרה; התוצאה היא השארית הסימטרית של החלוקה של השמאל
טיעון של הימין. כדי לקבל את המודולוס המתמטי של "א mod b", השתמש ב-
נוסחה "(a % b + b) % b".

<arg1>?arg2>:arg3>
אםarg1> אינו אפס, התוצאה היאarg2>; אחרת התוצאה היאarg3>.
הטיעון ללא תוצאה אינו מוערך.

תהליכים משותפים
תהליך משותף (שהוא צינור שנוצר עם האופרטור '|&') הוא תהליך אסינכרוני
שהקליפה יכולה גם לכתוב אליו (באמצעות הדפסה -p) וקרא מתוך (באמצעות לקרוא -p). הקלט
והפלט של התהליך המשותף ניתן גם לתמרן באמצעות >&עמ' ו <&p הפניות מחדש,
בהתאמה. לאחר שהתחיל תהליך משותף, לא ניתן להתחיל תהליך נוסף עד שהמשותף
תהליך יוצא, או עד שהקלט של התהליך המשותף הופנה מחדש באמצעות Exec n>&עמ'
הפנייה מחדש. אם הקלט של תהליך משותף מנותב מחדש בדרך זו, התהליך המשותף הבא יהיה
started ישתף את הפלט עם התהליך המשותף הראשון, אלא אם כן הפלט של המקור
תהליך משותף הופנה מחדש באמצעות an Exec n<&p הפנייה מחדש.

כמה הערות לגבי תהליכים משותפים:

· הדרך היחידה לסגור את הקלט של התהליך המשותף (כך שהתהליך המשותף יקרא סוף קובץ) היא
כדי לנתב מחדש את הקלט לתיאור קובץ ממוספר ולאחר מכן לסגור את מתאר הקובץ הזה:
Exec 3>&p; Exec 3>&-

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

· הדפסה -p יתעלם מאותות SIGPIPE במהלך כתיבה אם האות אינו נלכד או
התעלמו; אותו הדבר נכון אם הקלט בעיבוד המשותף שוכפל לקובץ אחר
מתאר ו הדפסה -un משמש.

פונקציות
פונקציות מוגדרות באמצעות מעטפת Korn פונקציה שם פונקציה תחביר או ה
מעטפת בורן/POSIX שם פונקציה() תחביר (ראה להלן את ההבדל בין השניים
טפסים). פונקציות הן כמו .‐scripts (כלומר סקריפטים שמקורם ב-'.' המובנה) בכך
הם מבוצעים בסביבה הנוכחית. עם זאת, שלא כמו .‐scripts, ארגומנטים של מעטפת
(כלומר פרמטרים מיקוםיים $1, $2 וכו') לעולם אינם נראים בתוכם. כשהקליפה
קביעת המיקום של פקודה, פונקציות נבדקות לאחר מובנה מיוחד
פקודות, לפני חיפוש מובנה וה-PATH.

ניתן למחוק פונקציה קיימת באמצעות ביטול ההגדרה -f שם פונקציה. רשימה של פונקציות יכולה
להשיג באמצעות ערכת סוגים +f וניתן לרשום את הגדרות הפונקציה באמצעות ערכת סוגים -f.
אל האני autoload פקודה (שהיא כינוי עבור ערכת סוגים -פו) ניתן להשתמש כדי ליצור לא מוגדר
פונקציות: כאשר מופעלת פונקציה לא מוגדרת, המעטפת מחפשת את הנתיב שצוין ב
פרמטר FPATH עבור קובץ בעל שם זהה לפונקציה, שאם נמצאה, נקראת
והוצאה להורג. אם לאחר ביצוע הקובץ נמצא שהפונקציה בעלת השם מוגדרת, ה-
הפונקציה מבוצעת; אחרת, חיפוש הפקודה הרגיל נמשך (כלומר המעטפת
מחפש בטבלת הפקודות המובנית הרגילה וב-PATH). שימו לב שאם לא נמצא פקודה
באמצעות PATH, נעשה ניסיון לטעון אוטומטית פונקציה באמצעות FPATH (זהו לא מתועד
תכונה של מעטפת קורן המקורית).

לפונקציות יכולות להיות שתי תכונות, "עקבות" ו"ייצוא", אשר ניתן להגדיר איתן ערכת סוגים -פט
ו ערכת סוגים -FX, בהתאמה. כאשר מבוצעת פונקציית מעקב, המעטפת xtrace
האפשרות מופעלת למשך הפונקציה. התכונה "ייצוא" של פונקציות היא
כרגע לא בשימוש. במעטפת Korn המקורית, פונקציות מיוצאות גלויות למעטפת
סקריפטים שמבוצעים.

מכיוון שפונקציות מבוצעות בסביבת המעטפת הנוכחית, בוצעו הקצאות פרמטרים
פונקציות פנימיות גלויות לאחר השלמת הפונקציה. אם זה לא הרצוי
אפקט, ה ערכת סוגים ניתן להשתמש בפקודה בתוך פונקציה כדי ליצור פרמטר מקומי. הערה
כי AT&T UNIX ksh93 משתמש בהיקף סטטי (היקף גלובלי אחד, היקף מקומי אחד לכל פונקציה)
ומאפשר משתנים מקומיים רק בפונקציות בסגנון Korn, ואילו מקש משתמש בהיקף דינמי
(היקפים מקוננים של יישוב משתנה). שים לב שפרמטרים מיוחדים (למשל $$, $!) לא יכול להיות
תחום בצורה זו.

מצב היציאה של פונקציה הוא זה של הפקודה האחרונה שבוצעה בפונקציה. א
ניתן לגרום לפונקציה לסיים באופן מיידי באמצעות לַחֲזוֹר פקודה; ניתן להשתמש גם בזה
כדי לציין במפורש את מצב היציאה.

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

· הפרמטר $0 מוגדר לשם הפונקציה (פונקציות בסגנון Bourne משאירות $0
ללא נגיעה).

· הקצאות פרמטרים לפני קריאות פונקציה אינן נשמרות בסביבת המעטפת
(ביצוע פונקציות בסגנון Bourne ישמור מטלות).

· OPTIND נשמר/מאפס ומשוחזר בכניסה וביציאה מהפונקציה כך קמצנים יכול להיות
בשימוש נכון הן בתוך הפונקציה והן מחוצה לה (פונקציות בסגנון Bourne עוזבות את OPTIND
לא נגע, אז משתמש קמצנים בתוך פונקציה מפריעה לשימוש קמצנים מחוץ ל
פוּנקצִיָה).

· אפשרויות מעטפת (סט -o) יש היקף מקומי, כלומר שינויים בתוך פונקציה מתאפסים
היציאה שלו.

בעתיד, ייתכן שיתווספו גם ההבדלים הבאים:

· בסביבת מלכודת/אות נפרדת תשמש במהלך ביצוע הפונקציות. זֶה
פירושו שמלכודות המוצבות בתוך פונקציה לא ישפיעו על המלכודות והאותות של הקונכייה
שלא מתעלמים מהם במעטפת (אך עלולים להיות לכודים) תהיה אפקט ברירת המחדל שלהם
תפקוד.

· מלכודת ה-EXIT, אם מוגדרת בפונקציה, תתבצע לאחר החזרת הפונקציה.

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

המקורי ksh ו-POSIX שונים במקצת באילו פקודות נחשבות מיוחדות או
רגיל.

כלי עזר מובנים מיוחדים של POSIX:

., :, לשבור, להמשיך, הערכה, Exec, יציאה, יצוא, באופן קריא, לַחֲזוֹר, סט, משמרת, פִּי, מלכודת,
ביטול ההגדרה

נוסף מקש פקודות שמירה על מטלות:

בנוי, גלוֹבָּלִי, מָקוֹר, ערכת סוגים, לחכות

מבנים שאינם מיוחדים:

[, כינוי, bg, לאגד, חתול, cd, הפקודה, הד, שקר, fc, fg, קמצנים, משרות, להרוג, לתת, הדפסה,
pwd, לקרוא, שביל אמיתי, שינוי השם, לִישׁוֹן, לְהַשְׁעוֹת, מבחן, נָכוֹן, אולימיט, אומסק, כינוי, מֵאֵין

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

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

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

: [...]
הפקודה null. מצב היציאה מוגדר לאפס.

[ ביטוי ]
לִרְאוֹת מבחן.

כינוי [-d | -t [-r] | +-x] [-p] [+] [שם [=ערך] ...]
בלי ויכוחים, כינוי מפרט את כל הכינויים. עבור כל שם ללא ערך, ה-
מופיע הכינוי הקיים. כל שם עם ערך מגדיר כינוי (ראה כינויים
לעיל).

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

אל האני -d האפשרות גורמת לרשימה כינויים של ספריות המשמשים בהרחבת tilde
או הגדר (ראה טילדה הרחבה לעיל).

אם -p בשימוש, כל כינוי מקבל את הקידומת של המחרוזת "כינוי".

אל האני -t האפשרות מציינת שיש לרשום/להגדיר כינויים במעקב (הערכים שצוינו
בשורת הפקודה מתעלמים עבור כינויים במעקב). ה -r האפשרות מציינת את זה
יש לאפס את כל הכינויים במעקב.

אל האני -x ערכות אפשרויות (+x מנקה) את תכונת הייצוא של כינוי, או, אם אין שמות
given, מפרט את הכינויים עם תכונת הייצוא (ליצוא כינוי אין
השפעה).

bg [עבודה ...]
המשך את העבודות שהופסקו שצוינו ברקע. אם לא צוינו משרות, %+
מניחים. לִרְאוֹת עבודה לִשְׁלוֹט להלן למידע נוסף.

לאגד [-l]
הכריכות הנוכחיות מפורטות. אם ה -l ניתן דגל, לאגד במקום זאת מפרט את
שמות הפונקציות שאליהן ניתן לקשור מפתחות. לִרְאוֹת אמאק עריכה מצב במשך יותר
מידע.

לאגד [-m] מחרוזת=[תחליף] ...
לאגד מחרוזת=[פקודת עריכה] ...
פקודת העריכה שצוינה קשורה לנתון מחרוזת, שאמור להיות מורכב מא
תו שליטה אופציונלי לפניו אחד משני תווי הקידומת ו
אופציונלי יורש על ידי דמות טילדה. קלט עתידי של מחרוזת יגרום
פקודת עריכה שתופעל מיד. אם ה -m נתון הדגל, המצוין
קלט מחרוזת יוחלף לאחר מכן מיד בנתון תחליף מחרוזת
אשר עשוי להכיל פקודות עריכה אך לא פקודות מאקרו אחרות. אם tilde postfix הוא
נתון, טילדה אחרי ההקדמה האחת או שתיים ומתעלמת מתווית הבקרה,
כל דמות נגררת אחרת תעובד לאחר מכן.

ניתן לכתוב תווי בקרה באמצעות סימון סימנים, כלומר ^X מייצג Ctrl-X.
שימו לב שלמרות שרק שני תווי קידומת (בדרך כלל ESC ו-^X) נתמכים,
ניתן לתמוך בכמה רצפים מרובי תווים.

כריכות ברירת המחדל הבאות מציגות כיצד מקשי החצים, הבית, מקש הסיום והמחיקה
על BSD wsvt25, xterm-xfree86 או מסוף מסך GNU קשורים (כמובן שחלק
רצפי בריחה לא יסתדרו כל כך יפה):

לאגד '^X'=תחילית-2
לאגד '^[['=תחילית-2
bind '^XA' = up-history
bind '^XB'=היסטוריית מטה
bind '^XC'=forward-char
bind '^XD'=לאחור-char
bind '^X1~'=תחילת-של-שורה
bind '^X7~'=תחילת-של-שורה
bind '^XH'=תחילת-של-שורה
bind '^X4~'=סוף שורה
bind '^X8~'=סוף שורה
bind '^XF'=סוף שורה
bind '^X3~'=delete-char-forward

לשבור [רָמָה]
צא רָמָההפנימי ביותר ל, בחר, עד, או בזמן לולאה. רָמָה ברירת המחדל היא 1.

בנוי [--] הפקודה [גדול מ ...]
בצע את הפקודה המובנית הפקודה.

חתול [-u] [פילה ...]
קרא קבצים ברצף, בסדר שורת הפקודה, וכתוב אותם לפלט סטנדרטי.
אם פילה הוא מקף בודד ('-') או נעדר, נקרא מקלט רגיל. עבור ישיר
שיחות מובנות, ה-POSIX -u האפשרות נתמכת כאופציה ללא הפעלה. לשיחות מ- shell, if
כל אפשרויות ניתנות, חיצונית חתול(1) השירות מועדף על פני המובנה.

cd [-L] [dir]
cd -P [-e] [dir]
chdir [-eLP] [dir]
הגדר את ספריית העבודה ל dir. אם הפרמטר CDPATH מוגדר, הוא מפרט את
נתיב חיפוש עבור הספרייה המכילה dir. נתיב NULL פירושו הזרם
מַדרִיך. אם dir נמצא בכל רכיב של נתיב החיפוש CDPATH מלבד ה-
נתיב NULL, השם של ספריית העבודה החדשה ייכתב לפלט סטנדרטי.
If dir חסר, נעשה שימוש בספריית הבית HOME. אם dir הוא '-', הקודם
נעשה שימוש בספריית העבודה (ראה פרמטר OLDPWD).

אם -L אופציה (נתיב לוגי) משמש או אם גופני האפשרות לא מוגדרת (ראה את
סט הפקודה למטה), הפניות ל'..' ב dir הם יחסית לנתיב שנהג להגיע אליו
הספרייה. אם ה -P אופציה (נתיב פיזי) משמש או אם גופני האפשרות היא
set, '..' הוא יחסית לעץ ספריות מערכת הקבצים. ה-PWD ו-OLDPWD
הפרמטרים מתעדכנים כך שישקפו את ספריית העבודה הנוכחית והישנה,
בהתאמה. אם ה -e האפשרות מוגדרת למעבר מערכת קבצים פיזית ו-PWD
לא ניתן להגדיר, קוד היציאה הוא 1; גדול מ-1 אם אירעה שגיאה, 0
אחרת.

cd [-eLP] זקן חדש
chdir [-eLP] זקן חדש
המיתר חדש הוחלף עבור זקן בספרייה הנוכחית ובקליפה
מנסה לעבור לספרייה החדשה.

הפקודה [-pVv] cmd [גדול מ ...]
אם גם לא ה -v ולא -V ניתנת אפשרות, cmd מבוצע בדיוק כאילו הפקודה היה
לא צוין, למעט שני חריגים: ראשית, cmd לא יכולה להיות פונקציית מעטפת; ו
שנית, פקודות מובנות מיוחדות מאבדות את המיוחדות שלהן (כלומר ניתוב מחדש ו
שגיאות שירות אינן גורמות ליציאה מהמעטפת, והקצאות פקודות אינן גורמות לכך
קבוע).

אם -p ניתנת אפשרות, נעשה שימוש בנתיב חיפוש ברירת מחדל במקום הערך הנוכחי
של PATH, שהערך האמיתי שלו תלוי במערכת.

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

להמשיך [רָמָה]
קופץ לתחילת ה- רָמָההפנימי ביותר ל, בחר, עד, או בזמן לולאה.
רָמָה ברירת המחדל היא 1.

הד [-עין] [גדול מ ...]
אַזהָרָה: כלי זה אינו נייד; השתמש במעטפת קורן המובנית הדפסה במקום.

מדפיס את הארגומנטים שלו (מופרדים ברווחים) ואחריהם שורה חדשה, לפי התקן
תְפוּקָה. השורה החדשה מדוכאת אם אחד מהארגומנטים מכיל את הנטוי האחורי
רצף '\c'. ראה את הדפסה הפקודה למטה לרשימה של רצפי נטוי אחורי אחרים
שמוכרים.

האפשרויות מסופקות עבור תאימות עם סקריפטים של מעטפת BSD. ה -n אוֹפְּצִיָה
מדכא את השורה החדשה הנגררת, -e מאפשר פרשנות נטוי לאחור (אין הפעלה, שכן
זה נעשה בדרך כלל), ו -E מדכא את פרשנות ההטיה האחורית.

אם פוסיקס or sh האפשרות מוגדרת או שזו שיחה ישירה מובנית, רק הראשונה
לטיעון מתייחסים כאל אופציה, ורק אם הוא בדיוק "-n". מַהֲלָך סְרָק
הפרשנות מושבתת.

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

Exec [-a argv0] [-c] [הפקודה [גדול מ ...]]
הפקודה מבוצעת ללא התפצלות, ומחליפה את תהליך המעטפת. זה
כרגע מוחלט, כלומר Exec לעולם לא חוזר, גם אם הפקודה לא נמצא. ה
-a האפשרות מאפשרת להגדיר ערך argv[0] שונה, ו -c מנקה את הסביבה
לפני ביצוע תהליך הצאצא, למעט המשתנים _ והקצאות ישירות.

אם לא ניתנת פקודה מלבד ניתוב קלט/פלט, הפניית הקלט/פלט היא קבועה
והקליפה לא מוחלפת. כל מתארי קבצים גדולים מ-2 שנפתחים
or dup(2)'d בדרך זו אינם זמינים לפקודות אחרות המבוצעות (כלומר
פקודות שאינן מובנות במעטפת). שימו לב שקונכיית בורן שונה
כאן; זה כן מעביר את מתארי הקבצים האלה הלאה.

יציאה [מצב]
המעטפת יוצאת עם סטטוס היציאה שצוין. אם מצב לא צוין, היציאה
סטטוס הוא הערך הנוכחי של $? פָּרָמֶטֶר.

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

אם לא צוינו פרמטרים, כל הפרמטרים עם ערכת מאפייני הייצוא הם
מודפס אחד בכל שורה; או שמותיהם, או, אם '-' ללא אות אופציה היא
שצוין, צמדי שם=ערך, או, עם -p, יצוא פקודות המתאימות לכניסה חוזרת.

שקר פקודה שיוצאת במצב שאינו אפס.

fc [-e עורך | -l [-n]] [-r] [ראשון [אחרון]]
ראשון ו אחרון בחר פקודות מההיסטוריה. ניתן לבחור פקודות לפי ההיסטוריה
מספר (מספרים שליליים הולכים אחורה מהשורה הנוכחית, העדכנית ביותר) או א
מחרוזת המציינת את הפקודה האחרונה שמתחילה במחרוזת זו. ה -l אוֹפְּצִיָה
מפרט את הפקודה על פלט סטנדרטי, ו -n מעכב את מספרי הפקודות המוגדרים כברירת מחדל.
אל האני -r אפשרות הופכת את סדר הרשימה. לְלֹא -l, הפקודות שנבחרו הן
נערך על ידי העורך שצוין ב- -e אפשרות, או אם לא -e מוגדר, ה-
עורך שצוין על ידי הפרמטר FCEDIT (אם פרמטר זה אינו מוגדר, /bin/ed is
בשימוש), ולאחר מכן בוצע על ידי המעטפת.

fc -e - | -s [-g] [זקן=חדש] [קידומת]
בצע מחדש את הפקודה שנבחרה (הפקודה הקודמת כברירת מחדל) לאחר ביצוע
ההחלפה האופציונלית של זקן עם חדש. אם -g מצוין, כל המופעים של
זקן מוחלפים ב חדש. המשמעות של -e - ו -s זהה: בצע מחדש את
הפקודה שנבחרה מבלי להפעיל עורך. פקודה זו נגישה בדרך כלל עם
המוגדר מראש: כינוי r='fc -e -'

fg [עבודה ...]
המשך את העבודה שצוינו בחזית. אם לא צוינו משרות, %+ is
הניח. לִרְאוֹת עבודה לִשְׁלוֹט להלן למידע נוסף.

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

בכל פעם קמצנים מופעל, הוא מציב את האפשרות הבאה בפרמטר המעטפת שם
ואינדקס הטיעון שיעובד בקריאה הבאה אל קמצנים ב
פרמטר מעטפת OPTIND. אם האפשרות הוצגה עם '+', האפשרות הוצבה
in שם יש קידומת '+'. כאשר אפשרות דורשת טיעון, קמצנים מקומות
זה בפרמטר המעטפת OPTARG.

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

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

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

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

גלוֹבָּלִי ...
לִרְאוֹת ערכת סוגים.

שירים [-r] [שם ...]
ללא ארגומנטים, כל שמות הנתיבים של הפקודות הניתנות להפעלה מפורטות. ה -r אוֹפְּצִיָה
גורם להסרת כל פקודות הגיבוב מטבלת הגיבוב. כל אחד שם מתבצע חיפוש
כאילו זה שם פקודה ונוסף לטבלת ה-hash אם זה קובץ הפעלה
פקודה.

משרות [-lnp] [עבודה ...]
הצגת מידע על העבודה שצוינה; אם לא צוינו משרות, כל העבודות
מוצגים. ה -n האפשרות גורמת להצגת מידע רק עבור עבודות ש
שינו מצב מאז ההודעה האחרונה. אם ה -l נעשה שימוש באפשרות, ה
מזהה תהליך של כל תהליך בעבודה מופיע גם כן. ה -p אפשרות גורמת רק ל
קבוצת תהליך של כל עבודה להדפסה. לִרְאוֹת עבודה לִשְׁלוֹט להלן עבור הפורמט של עבודה
והעבודה המוצגת.

להרוג [-s סימן | -חתימה | -סימן] { עבודה | PID | pgrp } ...
שלח את האות שצוין למשימות, מזהי התהליך או קבוצות התהליך שצוינו. אם
לא צוין אות, אות TERM נשלח. אם צוינה עבודה, האות
נשלח לקבוצת התהליך של העבודה. לִרְאוֹת עבודה לִשְׁלוֹט להלן עבור הפורמט של עבודה.

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

לתת [ביטוי ...]
כל ביטוי מוערך (ראה חשבון ביטויים מֵעַל). אם כל הביטויים
מוערכים בהצלחה, מצב היציאה הוא 0 (1) אם הביטוי האחרון הוערך
ללא אפס (אפס). אם מתרחשת שגיאה במהלך הניתוח או ההערכה של
ביטוי, סטטוס היציאה גדול מ-1. מכיוון שייתכן שביטויים צריכים להיות
מצוטט, (( ביטוי )) הוא סוכר תחבירי עבור { תן 'ביטוי'; }.

תן] כינוי בשימוש פנימי עבור לתת.

מקנוד [-m מצב] שם b|c גדול קטין
מקנוד [-m מצב] שם p
צור קובץ מיוחד למכשיר. סוג הקובץ עשוי להיות b (מכשיר מסוג בלוק), c
(מכשיר מסוג תווים), או p (שמו צינור, FIFO). הקובץ שנוצר עשוי להשתנות
לפי שלה מצב (דרך ה- -m אוֹפְּצִיָה), גדול (מספר מכשיר מרכזי), ו קטין
(מספר מכשיר קטן). זה בדרך כלל לא חלק מקש; עם זאת, מפיצים רשאים
הוסיפו את זה כמובנה כפריצת מהירות.

הדפסה [-nprsu[n] | -R [-en]] [טענה ...]
הדפסה מדפיס את הארגומנטים שלו על הפלט הסטנדרטי, מופרד ברווחים ומסתיים
עם קו חדש. ה -n האפשרות מדכאת את השורה החדשה. כברירת מחדל, C מסוימות בורחות
מתורגמים. אלה כוללים את אלה שהוזכרו ב קו אחורי הרחבה גם למעלה
בתור '\c', המקבילה לשימוש ב- -n אוֹפְּצִיָה. ייתכן שהרחבת נטוי אחורי
מעוכב עם -r אוֹפְּצִיָה. ה -s אפשרות מודפסת לקובץ ההיסטוריה במקום
פלט סטנדרטי; ה -u אפשרות מודפסת לתיאור הקובץ n (n ברירת המחדל היא 1 אם
הושמט); וה -p אפשרות הדפסה לתהליך המשותף (ראה תהליכים משותפים לעיל).

אל האני -R האופציה משמשת לחיקוי, במידה מסוימת, את ה-BSD הד(1) פקודה שעושה
לא לעבד רצפים '\' אלא אם כן -e ניתנת אפשרות. כאמור לעיל, ה -n אוֹפְּצִיָה
מדכא את השורה החדשה הנגררת.

הדפס פוּרמָט [טיעונים ...]
פלט מעוצב. בערך זהה ל- הדפס(1), שירות, אלא שהוא משתמש
אותו דבר קו אחורי הרחבה וקוד I/O ואינו מטפל בנקודה צפה כ-
שאר מקש. כלי עזר חיצוני מועדף על פני המובנה. זה לא
בדרך כלל חלק מ מקש; עם זאת, ייתכן שהמפיצים הוסיפו את זה כמובנה כמו א
גרזן מהירות. אין להשתמש בקוד חדש.

pwd [-LP]
הדפס את ספריית העבודה הנוכחית. אם ה -L נעשה שימוש באפשרות או אם ה גופני
האפשרות לא מוגדרת (ראה את סט הפקודה למטה), הנתיב הלוגי מודפס (כלומר ה
שביל רגיל cd לספרייה הנוכחית). אם ה -P נעשה שימוש באפשרות (נתיב פיזי).
או אם גופני האפשרות מוגדרת, הנתיב נקבע ממערכת הקבצים (על ידי
ספריות '..' הבאות לספריית השורש) מודפסת.

לקרוא [-A | -a] [-d x] [-N z | -n z] [-p | -u[n]] [-t n] [-rs] [p ...]
קורא שורת קלט, מפריד את הקלט לשדות באמצעות פרמטר IFS (ראה
החלפה למעלה), ומקצה כל שדה לפרמטרים שצוינו p. אם לא
פרמטרים מצוינים, הפרמטר REPLY משמש לאחסון התוצאה. עם ה
-A ו -a אפשרויות, רק לא או פרמטר אחד מתקבלים. אם יש עוד
פרמטרים מאשר שדות, הפרמטרים הנוספים מוגדרים למחרוזת הריקה או 0; אם
יש יותר שדות מפרמטרים, לפרמטר האחרון מוקצה הפרמטר הנותר
שדות (כולל מפריד המילים).

האפשרויות הן כדלקמן:

-A אחסן את התוצאה בפרמטר p (או REPLY) כמערך של מילים.

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

-d x השתמש בבייט הראשון של x, NUL אם ריק, במקום תו ASCII newline
כמפריד קו קלט.

-N z במקום לקרוא עד סוף השורה, קרא בדיוק z בתים. אם EOF או א
מתרחש פסק זמן, קריאה חלקית מוחזרת עם סטטוס יציאה 1.

-n z במקום לקרוא עד סוף השורה, קרא עד z בתים אבל תחזור בהקדם
כל בתים נקראים, למשל מהתקן מסוף איטי, או אם EOF או פסק זמן
מתרחשת.

-p קרא מהתהליך המשותף הפעיל כעת, ראה תהליכים משותפים לעיל לפרטים
על זה.

-u[n] קרא מתוך מתאר הקובץ n (ברירת המחדל היא 0, כלומר קלט סטנדרטי). ה
על הארגומנט לעקוב מיד אחר תו האופציה.

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

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

-s שורת הקלט נשמרת בהיסטוריה.

אם הקלט הוא טרמינל, הן ה -N ו -n אפשרויות מכניסות אותו למצב גולמי; הֵם
קרא קובץ שלם אם -1 מועבר בתור z ויכוח.

ייתכן שלפרמטר הראשון יש סימן שאלה ומצרף אליו מחרוזת, שבה
במקרה שהמחרוזת משמשת כהנחיה (מודפסת לפי שגיאת תקן לפני קלט כלשהו
קרא) אם הקלט הוא א tty(4) (למשל לקרוא nfoo?'מספר of foos: ').

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

עוד סט שימושי של טריקים: אם לקרוא מתנהל בלולאה כגון בזמן לקרוא פו do ...;
עשה לאחר מכן יוסר הרווח הלבן המוביל (IFS) והקו נטוי האחורי יעובד. אתה
אולי תרצה להשתמש בזמן IFS= לקרוא -r פו do ...; עשה עבור I/O טהור. באופן דומה,
בעת השימוש ב- -a אפשרות, שימוש ב- -r אפשרות עשויה להיות נבונה; אותו דבר חל
עבור:

למצוא . -סוג f -print0 |& \
בעוד IFS= read -d '' -pr name file; לַעֲשׂוֹת
print -r -- "נמצא <${filename#./}>"
עשה

הלולאה הפנימית תתבצע ב-subshell ולא ניתן לבצע שינויים משתנים
מופץ אם מבוצע בצינור:

בר | baz | בזמן קריאת foo; לעשות ...; בוצע

השתמש בתהליכים משותפים במקום זאת:

בר | baz |&
בזמן קריאה -p foo; לעשות ...; בוצע
exec 3>&p; exec 3>&-

באופן קריא [-p] [פרמטר [=ערך] ...]
מגדיר את התכונה לקריאה בלבד של הפרמטרים בעלי השם. אם ניתנים ערכים,
פרמטרים מוגדרים להם לפני הגדרת התכונה. ברגע שנעשה פרמטר
לקריאה בלבד, לא ניתן לבטל אותו ולא ניתן לשנות את הערך שלו.

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

שביל אמיתי [--] שם
מדפיס את שם הנתיב המוחלט שנפתר המתאים לו שם. אם שם מסתיים עם א
slash ('/'), זה גם נבדק על קיומו והאם זה ספרייה;
אחרת, שביל אמיתי מחזירה 0 אם שם הנתיב קיים או שניתן ליצור
באופן מיידי, כלומר כולם מלבד הרכיב האחרון קיימים והם ספריות.

שינוי השם [--] החל מ- ל
משנה את שם הקובץ החל מ- ל ל. שניהם חייבים להיות שמות נתיבים שלמים ועל אותו מכשיר.
מובנה זה מיועד למצבי חירום שבהם /bin/mv הופך לבלתי שמיש, ו
מתקשר ישירות שינוי השם(2).

לַחֲזוֹר [מצב]
מחזירה מפונקציה או . סקריפט, עם סטטוס יציאה מצב. אם לא מצב נתון,
נעשה שימוש במצב היציאה של הפקודה האחרונה שבוצעה. אם משתמשים בו מחוץ לפונקציה
or . סקריפט, יש לו אותה השפעה כמו יציאה. שים לב ש מקש מתייחס גם לפרופיל וגם
קבצי ENV as . סקריפטים, בעוד שהמעטפת המקורית של Korn מתייחסת רק לפרופילים כאל .
תסריטים.

סט [+-abCefhiklmnprsUuvXx] [+-o אוֹפְּצִיָה] [+-א שם] [--] [גדול מ ...]
אל האני סט ניתן להשתמש בפקודה כדי להגדיר (-) או ברור (+) אפשרויות מעטפת, הגדר את המיקום
פרמטרים, או הגדר פרמטר מערך. ניתן לשנות את האפשרויות באמצעות +-o אוֹפְּצִיָה
תחביר, היכן אוֹפְּצִיָה הוא השם הארוך של אפשרות, או שימוש ב- +-מכתב תחביר,
איפה מכתב הוא שם האות הבודדת של האפשרות (לא לכל האפשרויות יש אות אחת
שֵׁם). הטבלה הבאה מפרטת גם אותיות אופציות (אם קיימות) וגם שמות ארוכים
יחד עם תיאור של מה שהאופציה עושה:

-A שם
מגדיר את האלמנטים של פרמטר המערך שם ל גדול מ ... If -A משמש, את
מערך מאופס (כלומר מרוקן) ראשון; אם +A נעשה שימוש, ה-N האלמנטים הראשונים מוגדרים
(כאשר N הוא מספר הארגומנטים); השאר נותרים ללא נגיעה.

תחביר חלופי לפקודה סט -A Foo -- a b c אשר תואם ל
גנה לחבוט וגם נתמך על ידי AT&T UNIX ksh93 היא: foo=(א b ג); foo+=(ד e)

-a | -o allexport
כל הפרמטרים החדשים נוצרים עם תכונת הייצוא.

-b | -o תודיע
הדפס הודעות הודעת עבודה באופן אסינכרוני, במקום ממש לפני
מיידי. משמש רק אם בקרת עבודה מופעלת (-m).

-C | -o נוקלובר
מנע > ניתוב מחדש מדריסת קבצים קיימים. במקום זאת, >| חייב להשתמש
כדי לאלץ את ההחלפה. שים לב שזה לא בטוח לשימוש ליצירה של
קבצים זמניים או נעילה עקב TOCTOU בצ'ק המאפשר לאחד להפנות מחדש
פלט אל / dev / null או קבצי מכשיר אחרים אפילו ב נוקלובר מצב.

-e | -o errexit
צא (לאחר ביצוע מלכודת ERR) ברגע שמתרחשת שגיאה או פקודה
נכשל (כלומר יוצא עם מצב שאינו אפס). זה לא חל על פקודות
שסטטוס היציאה שלו נבדק במפורש על ידי מבנה מעטפת כגון if, עד,
בזמן, או ! הצהרות. ל && או ||, רק המצב של הפקודה האחרונה הוא
בָּדוּק.

-f | -o נוגלוב
אל תרחיב תבניות של שמות קבצים.

-h | -o trackall
צור כינויים במעקב עבור כל הפקודות המבוצעות (ראה כינויים מֵעַל). מופעל
כברירת מחדל עבור קונכיות לא אינטראקטיביות.

-i | -o אינטראקטיבי
הקליפה היא קליפה אינטראקטיבית. אפשרות זו יכולה לשמש רק כאשר המעטפת
מופעל. ראה למעלה לתיאור מה זה אומר.

-k | -o מילות מפתח
הקצאות פרמטרים מזוהות בכל מקום בפקודה.

-l | -o התחבר
הקליפה היא מעטפת כניסה. ניתן להשתמש באפשרות זו רק כאשר המעטפת נמצאת
מופעל. ראה למעלה לתיאור מה זה אומר.

-m | -o צג
אפשר בקרת עבודה (ברירת מחדל עבור קונכיות אינטראקטיביות).

-n | -o noexec
אל תבצע שום פקודה. שימושי לבדיקת התחביר של סקריפטים (התעלם
אם אינטראקטיבי).

-p | -o חסוי
הקליפה היא קליפה מיוחסת. זה מוגדר באופן אוטומטי אם, כאשר הקליפה
מתחיל, ה-UID או GID האמיתיים אינם תואמים ל-UID (EUID) או GID היעילים
(EGID), בהתאמה. ראה למעלה לתיאור מה זה אומר.

-r | -o מוגבל
הקליפה היא קליפה מוגבלת. ניתן להשתמש באפשרות זו רק כאשר המעטפת נמצאת
מופעל. ראה למעלה לתיאור מה זה אומר.

-s | -o סטדין
אם נעשה בו שימוש כאשר המעטפת מופעלת, הפקודות נקראות מקלט סטנדרטי. מַעֲרֶכֶת
אוטומטית אם המעטפת מופעלת ללא ארגומנטים.

מתי -s משמש עם ה- סט הפקודה היא גורמת לארגומנטים שצוינו להיות
ממוינים לפני הקצאתם לפרמטרים המיקוםיים (או למערך שם, אם
-A משמש).

-U | -o מצב utf8
אפשר תמיכה ב-UTF-8 ב- אמאק עריכה מצב וטיפול פנימי במיתרים
פונקציות. דגל זה מושבת כברירת מחדל, אך ניתן להפעיל אותו על ידי הגדרתו
בשורת הפקודה של המעטפת; מופעל אוטומטית עבור קונכיות אינטראקטיביות אם
המבוקש בזמן הקומפילציה, המערכת שלך תומכת setlocale(LC_CTYPE, "") ו
אופציונאלי nl_langinfo(CODESET), או סביבת LC_ALL, LC_CTYPE או LANG
משתנים, ולפחות אחד מאלה מחזיר משהו שתואם "UTF-8" או
"utf8" ללא רגישות רישיות; לשיחות מובנות ישירות בהתאם ל
משתני סביבה שהוזכרו לעיל; או עבור stdin או סקריפטים, אם הקלט
מתחיל עם UTF-8 Byte Order Mark.

בעתיד הקרוב, ייושם מעקב מקומי, מה שאומר ש סט -+U is
השתנה בכל פעם שאחד ממשתני הסביבה הקשורים לאזור POSIX משתנה.

-u | -o שם עצם
התייחסות לפרמטר לא מוגדר, מלבד "$@" או "$*", מטופלת כאל
שגיאה, אלא אם נעשה שימוש באחד מהמתאמים '-', '+' או '='.

-v | -o מִלוּלִי
כתוב קלט מעטפת לשגיאה סטנדרטית בזמן הקריאה.

-X | -o markdirs
סמן ספריות עם '/' נגרר במהלך יצירת שם קובץ.

-x | -o xtrace
הדפס עצי פקודה כשהם מבוצעים, לפנים הערך של PS4.

-o בגניס
עבודות רקע מופעלות בעדיפות נמוכה יותר.

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

-o Emacs
אפשר עריכת שורת פקודה דמוית BRL emacs (קונכיות אינטראקטיביות בלבד); לִרְאוֹת אמאק
עריכה מצב.

-o gmacs
אפשר עריכת שורת פקודה דמוית gmacs (קונכיות אינטראקטיביות בלבד). כַּיוֹם
זהה לעריכת emacs פרט לכך ש-transpose-chars (^T) פועל מעט
באופן שונה.

-o מתעלם ממנו
המעטפת לא תצא (בקלות) כאשר סוף הקובץ נקרא; יציאה חייב להשתמש.
כדי למנוע לולאות אינסופיות, המעטפת תצא אם EOF ייקרא 13 פעמים ברציפות.

-o inherit-xtrace
אין לאפס -o xtrace עם הכניסה לפונקציות. זה מופעל כברירת מחדל.

-o nohup
אל תהרוג עבודות פועלות עם אות SIGHUP כאשר מעטפת כניסה יוצאת.
כרגע מוגדר כברירת מחדל, אבל זה עשוי להשתנות בעתיד כדי להיות תואם
עם AT&T UNIX ksh, שאין לו אפשרות זו, אבל כן שולח את ה-SIGHUP
אות.

-o נולוג
ללא השפעה. במעטפת קורן המקורית, זה מונע מהגדרות פונקציות
נשמר בקובץ ההיסטוריה.

-o גופני
גורם ל cd ו pwd פקודות לשימוש ב-"physical" (כלומר ב-'..' של מערכת הקבצים)
ספריות במקום ספריות "לוגיות" (כלומר, המעטפת מטפלת ב-'..', אשר
מאפשר למשתמש להתעלם מקישורים סמליים לספריות). נקה לפי
בְּרִירַת מֶחדָל. שימו לב שהגדרת אפשרות זו אינה משפיעה על הערך הנוכחי של ה-
פרמטר PWD; רק ה cd הפקודה משנה PWD. ראה את cd ו pwd פקודות
למעלה לפרטים נוספים.

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

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

-o sh
אפשר / Bin / sh (kludge) mode (ראה SH מצב). מופעל אוטומטית אם
שם הבסיס של הפקת המעטפת מתחיל ב-"sh" ובתכונת הזיהוי האוטומטית הזו
מורכב ב (לא ב-MirBSD). כתופעת לוואי, הגדרת דגל זה נכבית
סד להרחיב מצב, שניתן להפעיל מחדש באופן ידני, ו פוסיקס מצב (אלא אם כן
שניהם מופעלים בו זמנית).

-o vi
אפשר vi(1) עריכה כמו שורת פקודה (קונכיות אינטראקטיביות בלבד). לִרְאוֹת Vi
עריכה מצב לתיעוד ומגבלות.

-o vi-esccomplete
בעריכת שורת הפקודה vi, בצע השלמת פקודות ושם קובץ בעת אסקייפ (^[)
מוכנס במצב פקודה.

-o vi-tabcomplete
בעריכת שורת הפקודה vi, בצע השלמת פקודות ושם קובץ כאשר הכרטיסייה (^I) היא
הוכנס במצב הכנסה. זוהי ברירת המחדל.

-o viraw
ללא השפעה. במעטפת קורן המקורית, אלא אם כן viraw הוגדר, הפקודה vi-
מצב קו יאפשר ל tty(4) הנהג יעשה את העבודה עד להזנת ESC (^[).
מקש הוא תמיד במצב viraw.

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

הארגומנטים הנותרים, אם קיימים, הם פרמטרים מיקוםיים והם מוקצים, לפי הסדר, ל
הפרמטרים המיקוםיים (כלומר $1, $2 וכו'). אם האפשרויות מסתיימות ב-'--' ושם
אין ארגומנטים שנותרו, כל הפרמטרים המיקוםיים נמחקים. אם אין אפשרויות או
ניתנים ארגומנטים, הערכים של כל השמות מודפסים. עבור היסטורי לא ידוע
מסיבות לכך, אפשרות '-' בודדת מטופלת במיוחד - היא מנקה גם את -v ו -x
אפשרויות.

משמרת [מספר]
הפרמטרים המיקוםיים מספר+ 1, מספרשמות +2 וכו' משתנים ל-'1', '2' וכו'.
מספר ברירת המחדל היא 1.

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

מָקוֹר פילה [גדול מ ...]
כמו . ("נקודה"), אלא שמדריך העבודה הנוכחי מצורף לחיפוש
נתיב (GNU לחבוט סיומת).

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

מבחן ביטוי
[ ביטוי ]
מבחן מעריך את ביטוי ומחזיר סטטוס אפס אם נכון, 1 אם לא נכון, או יותר
מ-1 אם הייתה שגיאה. הוא משמש בדרך כלל כפקודה של התנאי של if ו
בזמן הצהרות. קישורים סמליים נעשים עבור כולם פילה ביטויים למעט -h ו
-L.

הביטויים הבסיסיים הבאים זמינים:

-a פילה פילה קיים.

-b פילה פילה הוא מכשיר מיוחד בלוק.

-c פילה פילה הוא מכשיר מיוחד לדמות.

-d פילה פילה הוא ספרייה.

-e פילה פילה קיים.

-f פילה פילה הוא קובץ רגיל.

-G פילה פילההקבוצה של היא מזהה הקבוצה היעיל של המעטפת.

-g פילה פילהבמצב של ה-setgid bit מוגדר.

-H פילה פילה הוא ספרייה תלוית הקשר (שימושי רק ב-HP-UX).

-h פילה פילה הוא קישור סמלי.

-k פילה פילהלמצב של יש את דביק(8) סט סיביות.

-L פילה פילה הוא קישור סמלי.

-O פילה פילההבעלים של המעטפת הוא מזהה המשתמש האפקטיבי של המעטפת.

-o אוֹפְּצִיָה פָּגָז אוֹפְּצִיָה מוגדר (ראה את סט הפקודה למעלה לרשימה של
אפשרויות). בתור הרחבה לא סטנדרטית, אם האופציה מתחילה ב
a '!', המבחן מבוטל; המבחן תמיד נכשל אם אוֹפְּצִיָה
לא קיים (לכן [ -o foo -o -o !foo ] מחזיר אמת אם ורק
אם אפשרות Foo קיים). ניתן להשיג את אותו הדבר עם [-o ?foo]
כמו ב-AT&T UNIX ksh93. אוֹפְּצִיָה יכול להיות גם הדגל הקצר בראשות
או '-' או '+' (ללא שלילה לוגית), למשל '-x' או '+x'
במקום 'xtrace'.

-p פילה פילה הוא צינור בשם (FIFO).

-r פילה פילה קיים וניתן לקריאה.

-S פילה פילה הוא יוניקס(4)-שקע תחום.

-s פילה פילה זה לא ריק.

-t fd מתאר קובץ fd הוא tty(4) מכשיר.

-u פילה פילהבמצב של ה-setuid bit מוגדר.

-w פילה פילה קיים וניתן לכתוב.

-x פילה פילה קיים וניתן להפעלה.

file1 -nt file2 file1 חדש מ- file2 or file1 קיים ו file2 לא.

file1 -לא file2 file1 יותר מבוגר מ file2 or file2 קיים ו file1 לא.

file1 -ef file2 file1 הוא אותו קובץ כמו file2.

מחרוזת מחרוזת בעל אורך שאינו אפס.

-n מחרוזת מחרוזת זה לא ריק.

-z מחרוזת מחרוזת זה ריק.

מחרוזת = מחרוזת מיתרים שווים.

מחרוזת == מחרוזת מיתרים שווים.

מחרוזת > מחרוזת אופרנד המחרוזת הראשון גדול מאופרנד המחרוזת השני.

מחרוזת < מחרוזת אופרנד המחרוזת הראשונה קטן מאופרנד המחרוזת השני.

מחרוזת != מחרוזת מיתרים אינם שווים.

מספר -eq מספר מספרים משווים שווים.

מספר -נה מספר מספרים להשוות אינם שווים.

מספר -ge מספר מספרים משווים גדולים או שווים.

מספר -גמ ' מספר מספרים להשוות גדול מ.

מספר -לה מספר מספרים משווים פחות או שווים.

מספר -לט מספר מספרים משווים פחות מ.

הביטויים הבסיסיים לעיל, שבהם לאופרטורים אונריים יש עדיפות על פני בינארי
אופרטורים, ניתן לשלב עם האופרטורים הבאים (הרשומים בסדר עולה
עדיפות):

expr -o expr OR לוגי.
expr -a expr AND לוגי.
! expr לוגי לא.
( expr ) קיבוץ.

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

x=1; [ "x" -eq 1 ] מוערך כאמת

שים לב שחלים כמה כללים מיוחדים (באדיבות POSIX) אם מספר
טיעונים ל מבחן או בתוך הסוגריים [ ... ] הוא פחות מחמש: אם מוביל '!'
ניתן להסיר טיעונים כך שיישאר רק טיעון אחד עד שלושה, ואז
ההשוואה הנמוכה מבוצעת; (תודה ל-XSI) סוגריים \( ... \) ארבע תחתונות ו
צורות של שלושה טיעונים לצורות של שני ואחד, בהתאמה; שלושה טיעונים
צורות מעדיפות בסופו של דבר פעולות בינאריות, ואחריהן שלילה וסוגריים
הוֹרָדָה; צורות של שני וארבעה טיעונים מעדיפות שלילה ואחריה סוגריים; ה
צורה של טיעון אחד תמיד מרמזת -n.

הערות: טעות נפוצה היא להשתמש ב-"if [ $foo = bar ]" שנכשל אם הפרמטר "foo"
הוא NULL או לא מוגדר, אם יש לו רווחים מוטבעים (כלומר אוקטטים IFS), או אם הוא unary
מפעיל כמו '!' או '-n'. השתמש במבחנים כמו "if [ x"$foo" = x"bar" ]" במקום זאת, או
אופרטור בסוגריים כפולים "if [[ $foo = bar ]]" או, כדי למנוע התאמת דפוסים (ראה [[
למעלה): "אם [[ $foo = "$bar" ]]”

אל האני [[ ... ]] הבנייה היא לא רק בטוחה יותר לשימוש אלא גם מהירה יותר.

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

0m0.00s אמיתי 0m0.00s משתמש 0m0.00s מערכת

אם -p ניתנת לאפשרות שהפלט ארוך מעט יותר:

אמיתי 0.00
משתמש 0.00
sys 0.00

זו שגיאה לציין את -p אפשרות אלא אם כן צינור היא פקודה פשוטה.

כיוונים פשוטים של שגיאת תקן אינם משפיעים על הפלט של זמן פקודה:

$ זמן שינה 1 2>קובץ
$ { זמן שינה 1; } 2>קובץ

הזמנים של הפקודה הראשונה לא עוברים ל-"file", אבל אלו של הפקודה השנייה כן.

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

0m0.00s 0m0.00s
0m0.00s 0m0.00s

מלכודת n [אוֹת ...]
אם האופרנד הראשון הוא מספר שלם עשרוני ללא סימן, זה מאפס את כל האותות שצוינו
לפעולת ברירת המחדל, כלומר זהה להתקשרות מלכודת עם סימן מינוס ('-') כמו
מטפל, ואחריו הטיעונים (n [אוֹת ...]), שכולם מטופלים כאל
אותות.

מלכודת [מטפל אוֹת ...]
מגדיר מטפל מלכודות שאמור להתבצע כאשר כל אחד מהמפורטים אוֹתזה
קיבלו. מטפל הוא מחרוזת ריקה, מה שמציין שהאותות אמורים להיות
התעלמו, סימן מינוס ('-'), המציין שיש לבצע את פעולת ברירת המחדל
האותות (ראה אוֹת(3)), או מחרוזת המכילה פקודות מעטפת לביצוע ב
ההזדמנות הראשונה (כלומר כשהפקודה הנוכחית מסתיימת, או לפני ההדפסה
ההנחיה הבאה של PS1) לאחר קבלת אחד האותות. אוֹת הוא שמו של א
אות (למשל PIPE או ALRM) או מספר האות (ראה את להרוג -l הפקודה
לעיל).

ישנם שני אותות מיוחדים: EXIT (הידוע גם בשם 0), אשר מבוצע כאשר
shell עומד לצאת, ו-ERR, שמתבצע לאחר מתרחשת שגיאה; שגיאה היא
משהו שיגרום ליציאת המעטפת אם סט -e or סט -o errexit אוֹפְּצִיָה
נקבעו. מטפלי EXIT מבוצעים בסביבה של המבצע האחרון שהוצא להורג
פקודה.

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

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

מלכודת DEBUG המקורית של קורן מעטפת והטיפול במלכודות ERR ו-EXIT פנימה
הפונקציות עדיין לא מיושמות.

נָכוֹן פקודה שיוצאת עם ערך אפס.

גלוֹבָּלִי [[+-alpnrtUux] [-L[n]] [-R[n]] [-Z[n]] [-i[n]] | -f [-טוקס]] [שם [=ערך] ...]
ערכת סוגים [[+-alpnrtUux] [-LRZ[n]] [-i[n]] | -f [-טוקס]] [שם [=ערך] ...]
הצג או הגדר תכונות פרמטר. ללא שם ארגומנטים, תכונות פרמטרים
מוצגים; אם לא נעשה שימוש באפשרויות, התכונות הנוכחיות של כל הפרמטרים הן
מודפס כ ערכת סוגים פקודות; אם ניתנת אפשרות (או '-' ללא אות אופציה),
כל הפרמטרים והערכים שלהם עם התכונות שצוינו מודפסים; אם אפשרויות
מוצגים עם '+', ערכי פרמטרים אינם מודפסים.

If שם ניתנים ארגומנטים, התכונות של הפרמטרים הנקובים נקבעות (-) או
ניקה (+). ניתן לציין ערכים עבור פרמטרים באופן אופציונלי. ל שם[*], ה
השינוי משפיע על המערך כולו, ולא ניתן לציין ערך.

If ערכת סוגים נמצא בשימוש בתוך פונקציה, כל הפרמטרים שצוינו הם מקומיים. זֶה
לא נעשה על ידי זהה אחרת גלוֹבָּלִי. הערות: זה אומר ש מקש 's גלוֹבָּלִי
פקודה היא לֹא שווה ערך לשפות תכנות אחרות מכיוון שהוא אינו מאפשר א
פונקציה נקראת מפונקציה אחרת כדי לגשת לפרמטר בהיקף גלובלי באמת,
אלא רק מונעת הכנסת אחד שנגיש לטווח המקומי.

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

-a תכונת מערך באינדקס.

-f מצב פונקציה. הצג או הגדר פונקציות ותכונותיהן, במקום
פרמטרים.

-i[n] תכונת מספר שלם. n מציין את הבסיס לשימוש בעת הצגת המספר השלם
(אם לא צוין, נעשה שימוש בבסיס שניתן במטלה הראשונה).
לפרמטרים עם תכונה זו ניתן להקצות ערכים המכילים אריתמטיקה
ביטויים.

-L[n] תכונת הצדקה שמאלה. n מציין את רוחב השדה. אם n לא מצוין,
הרוחב הנוכחי של פרמטר (או הרוחב של הערך הראשון שלו)
משמש. רווח לבן מוביל (ואפסים, אם משתמשים בהם עם ה- -Z אפשרות) היא
חָשׂוּף. במידת הצורך, הערכים קטועים או מרופדים ברווח כדי להתאים
רוחב השדה.

-l תכונת אותיות קטנות. כל התווים הגדולים בערכים מומרים ל
אוֹתִיוֹת קְטָנוֹת. (במעטפת קורן המקורית, פרמטר זה פירושו "מספר שלם ארוך"
כאשר משתמשים ב- -i אוֹפְּצִיָה.)

-n צור משתנה מאוגד (הפניה לשם): כל גישה למשתנה שם
ייגש למשתנה ערך בהיקף הנוכחי (זה שונה מ
AT&T UNIX ksh93!) במקום זאת. שונה גם מ-AT&T UNIX ksh93 הוא כי
ערך מוערך בעצלתיים בזמנו שם נגישה. זה יכול לשמש על ידי
פונקציות לגישה למשתנים ששמותיהם מועברים כפרמטרים, במקום זאת
של שימוש הערכה.

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

-R[n] נכון להצדיק תכונה. n מציין את רוחב השדה. אם n לא
שצוין, הרוחב הנוכחי של פרמטר (או הרוחב של הראשון שלו
ערך מוקצה) משמש. הרווח הלבן הנגרר נמחק. אם נחוץ,
הערכים מופשטים מהתווים המובילים או מרופדים ברווח כדי ליצור אותם
להתאים את רוחב השדה.

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

-t מאפיין תג. אין משמעות לקליפה; מסופק לשימוש באפליקציה.

עבור פונקציות, -t היא תכונת העקבות. כאשר מתפקד עם המעקב
התכונה מבוצעות, ה xtrace (-x) אפשרות המעטפת הופכת זמנית
על.

-U מאפיין מספר שלם לא חתום. מספרים שלמים מודפסים כערכים ללא סימנים (שילוב
עם -i אוֹפְּצִיָה). אפשרות זו אינה במעטפת קורן המקורית.

-u תכונת אותיות רישיות. כל התווים הקטנים בערכים מומרים ל
אוֹתִיוֹת גְדוֹלוֹת. (במעטפת קורן המקורית, פרמטר זה פירושו "לא חתום
מספר שלם" בשימוש עם ה- -i אפשרות שמשמעותה היא שאותיות גדולות יהיו
לעולם אל תשמש עבור בסיסים גדולים מ-10. ראה את -U אוֹפְּצִיָה.)

עבור פונקציות, -u היא התכונה הלא מוגדרת. לִרְאוֹת פונקציות לעיל עבור
ההשלכות של זה.

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

-Z[n] תכונת מילוי אפס. אם לא משולב עם -L, זה אותו דבר כמו -R, מלבד
נעשה שימוש בריפוד אפס במקום ריפוד חלל. עבור מספרים שלמים, המספר
במקום הבסיס מרופד.

אם מישהו מה- -i, -L, -l, -R, -U, -u, או -Z האפשרויות משתנות, כל השאר מכאן
הסט מנוקים, אלא אם הם ניתנים גם באותה שורת פקודה.

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

-a הצג את כל המגבלות; אֶלָא אִם -H בשימוש, מוצגות גבולות רכים.

-B n הגדר את גודל מאגר השקע ל n kibibytes.

-C n הגדר את מספר השרשורים המאוחסנים במטמון ל n.

-c n להטיל מגבלת גודל של n בלוקים בגודל של מזבלות הליבה.

-d n להטיל מגבלת גודל של n kibibytes על גודל אזור הנתונים.

-e n הגדר את מקסימום הנחמדות ל n.

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

-H הגדר את הגבול הקשה בלבד (ברירת המחדל היא להגדיר גבולות קשים ורכים כאחד).

-i n הגדר את מספר האותות הממתינים ל n.

-l n להטיל גבול של n kibibytes על כמות הזיכרון הפיזי הנעול (קווית).

-M n הגדר את זיכרון AIO נעול ל n kibibytes.

-m n להטיל גבול של n kibibytes על כמות הזיכרון הפיזי בשימוש.

-n n להטיל גבול של n מתארי קבצים שיכולים להיות פתוחים בבת אחת.

-O n הגדר את מספר פעולות AIO ל n.

-P n הגבל את מספר השרשורים לכל תהליך ל n.

-p n להטיל גבול של n תהליכים שניתן להפעיל על ידי המשתמש בכל עת.

-q n הגבל את הגודל של תורי הודעות POSIX ל n בתים.

-r n הגדר את העדיפות המקסימלית בזמן אמת ל n.

-S הגדר את המגבלה הרכה בלבד (ברירת המחדל היא להגדיר מגבלות קשות ורכות כאחד).

-s n להטיל מגבלת גודל של n kibibytes על גודל שטח המחסנית.

-T n להטיל מגבלת זמן של n שניות אמיתיות לשימוש בכל תהליך.

-t n להטיל מגבלת זמן של n שניות מעבד שהושקעו במצב משתמש לשימוש כל אחד
התהליך.

-V n הגדר את מספר צגי vnode ב-Haiku ל n.

-v n להטיל גבול של n קיביבייט על כמות הזיכרון הווירטואלי (מרחב כתובות)
מְשׁוּמָשׁ.

-w n להטיל גבול של n kibibytes על כמות שטח ההחלפה בשימוש.

כל עוד אולימיט הוא מודאג, בלוק הוא 512 בתים.

אומסק [-S] [מסכה]
הצג או הגדר את מסכת יצירת הרשאות הקובץ, או umask (ראה אומסק(2)). אם ה -S
נעשה שימוש באפשרות, המסכה המוצגת או המוגדרת היא סמלית; אחרת, זה אוקטלי
מספר.

מסכות סמליות הן כמו אלה המשמשות chmod(1). כאשר משתמשים בהם, הם מתארים מה
הרשאות עשויות להיות זמינות (בניגוד למסיכות אוקטליות שבהן פירוש סיביות מוגדר
יש לנקות את הסיביות המקבילה). לדוגמה, "ug=rwx,o=" מגדיר את המסכה כך
קבצים לא יהיו ניתנים לקריאה, כתיבה או הפעלה על ידי "אחרים", וזה שווה ערך
(ברוב המערכות) למסכה האוקטלית "007".

כינוי [-adt] [שם ...]
הכינויים של השמות הנתונים מוסרים. אם ה -a נעשה שימוש באפשרות, כל הכינויים
מוסרים. אם ה -t or -d נעשה שימוש באפשרויות, הפעולות המצוינות מתבצעות
על כינויים במעקב או בספרייה, בהתאמה.

ביטול ההגדרה [-fv] פרמטר ...
בטל את הגדרת הפרמטרים בעלי השם (-v, ברירת המחדל) או פונקציות (-f). עם פרמטר[*],
התכונות נשמרות, רק הערכים לא מוגדרים.

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

לחכות [עבודה ...]
המתן עד שהעבודות שצוינו יסתיימו. מצב היציאה של לחכות הוא של האחרון
עבודה שצוינה; אם העבודה האחרונה נהרגה על ידי אות, מצב היציאה הוא 128 + ה
מספר האות (ראה להרוג -l מצב יציאה מֵעַל); אם העבודה האחרונה שצוינה לא יכולה
להימצא (מכיוון שהוא מעולם לא היה קיים, או כבר הסתיים), את סטטוס היציאה של לחכות
הוא 127. ראה עבודה לִשְׁלוֹט להלן עבור הפורמט של עבודה. לחכות יחזור אם אות
שעבורו הוגדרה מלכודת מתקבלת, או אם אות SIGHUP, SIGINT או SIGQUIT
מתקבל.

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

מֵאֵין [-pv] [שם ...]
בלי ה -v אפשרות, זה זהה ל הפקודה -v, למעט כינויים אינם מודפסים
כפקודה כינוי. עם ה -v אפשרות, זה בדיוק כמו הפקודה -V. ב
בכל מקרה, ה -p אפשרות שונה: נתיב החיפוש אינו מושפע ב מֵאֵין, אבל
החיפוש מוגבל לנתיב.

עבודה לִשְׁלוֹט
בקרת עבודה מתייחסת ליכולת של המעטפת לנטר ולשלוט בעבודות שהן תהליכים או
קבוצות של תהליכים שנוצרו עבור פקודות או צינורות. לכל הפחות, הקליפה עוקבת אחריה
של מצב משרות הרקע (כלומר אסינכרוניות) הקיימות כיום; זֶה
ניתן להציג מידע באמצעות משרות פקודות. אם בקרת העבודה מופעלת במלואה
(באמצעות סט -m or סט -o צג), כפי שהוא עבור קונכיות אינטראקטיביות, התהליכים של עבודה
ממוקמים בקבוצת תהליכים משלהם. ניתן לעצור עבודות בחזית על ידי הקלדת ההשעיה
תו מהמסוף (בדרך כלל ^Z), ניתן להפעיל מחדש עבודות בחזית או
רקע באמצעות fg ו bg פקודות, ומצב הטרמינל נשמר או משוחזר
כאשר עבודת חזית נעצרת או מופעלת מחדש, בהתאמה.

שימו לב שרק פקודות שיוצרות תהליכים (למשל פקודות אסינכרוניות, תת-מעטפת
פקודות, ופקודות שאינן מובנות, שאינן פועלות) ניתן לעצור; פקודות כמו לקרוא לא יכול
לִהיוֹת.

כאשר משרה נוצרת, מוקצה לה מספר עבודה. עבור קונכיות אינטראקטיביות, המספר הזה הוא
מודפס בתוך "[..]", ואחריו מזהי התהליך של התהליכים בעבודה כאשר an
מופעלת פקודה אסינכרונית. ניתן להתייחס למשרה ב bg, fg, משרות, להרוג, ו לחכות
פקודות לפי מזהה התהליך של התהליך האחרון בצינור הפקודה (כפי שמאוחסן ב
מה היא $! פרמטר) או על ידי הקדמת מספר העבודה עם סימן אחוז ('%'). אחוז אחר
ניתן להשתמש ברצפים גם כדי להתייחס לעבודות:

%+ | %% | % העבודה שהופסקה לאחרונה, או, אם אין עבודות שהופסקו, הוותיקה ביותר
עבודת ריצה.

%- העבודה שתהיה %+ עבודה אם האחרון לא היה קיים.

%n העבודה עם מספר המשרה n.

%?מחרוזת העבודה עם הפקודה שלה המכילה את המחרוזת מחרוזת (מתרחשת שגיאה אם
מספר משרות מותאמות).

%מחרוזת העבודה עם הפקודה שלה מתחילה במחרוזת מחרוזת (מתרחשת שגיאה אם
מספר משרות מותאמות).

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

[מספר] דגל מצב הפקודה

שבו ...

מספר הוא מספר המשרה של המשרה;

דגל הוא התו '+' או '-' אם העבודה היא %+ or %- עבודה, בהתאמה, או שטח
אם זה לא אחד מהם;

מצב מציין את המצב הנוכחי של העבודה ויכול להיות:

בוצע [מספר]
העבודה יצאה. מספר הוא מצב היציאה של המשרה שהושמט
אם המצב הוא אפס.

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

עצר [אוֹת]
העבודה הופסקה על ידי המצוין אוֹת (אם לא ניתן אות, ה
העבודה הופסקה על ידי SIGTSTP).

תיאור אות ["הליבה הושלכה"]
העבודה נהרגה על ידי אות (למשל תקלת זיכרון, ניתוק); להשתמש להרוג -l
לרשימה של תיאורי אותות. ההודעה "הליבה הושלכה" מציינת
התהליך יצר קובץ ליבה.

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

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

POSIX מצב
הזנה סט -o פוסיקס מצב יגרום מקש להתנהג אפילו יותר תואם POSIX במקומות
כאשר ברירות המחדל או הדעות שונות. ציין זאת מקש עדיין יפעל עם לא חתום
אריתמטיקה של 32 סיביות; להשתמש לקש אם חשבון על המארח ארוך סוג נתונים, שלם עם ISO C
התנהגות לא מוגדרת, נדרשים; עיין ב לקש(1) דף מדריך לפרטים. רוב האחר
היסטורי, AT&T UNIX kshניתן להשבית הבדלים תואמים או דעתניים באמצעות זה
מצב; אלו הם:

· ה- GNU לחבוט הפניית קלט / פלט &>פילה כבר לא נתמך.

· מתארי קבצים שנוצרו על ידי הפניות מחדש של I/O עוברים בירושה על ידי תהליכי צאצא.

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

· אל האני הד מובנה אינו מפרש נטויים אחוריים ותומך רק באפשרות המדויקת "-n".

· ... (הרשימה אינה מלאה ועשויה להשתנות עבור R53)

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

· ה- GNU לחבוט הפניית קלט / פלט &>פילה כבר לא נתמך.

· מתארי קבצים שנוצרו על ידי הפניות מחדש של I/O עוברים בירושה על ידי תהליכי צאצא.

· אל האני הד מובנה אינו מפרש נטויים אחוריים ותומך רק באפשרות המדויקת "-n".

· ... (הרשימה אינה מלאה ועשויה להשתנות עבור R53)

אינטרקטיווי קלט קו עריכה
המעטפת תומכת בשלושה מצבים של קריאת שורות פקודה מ-a tty(4) באינטראקטיבי
מושב, נשלט על ידי Emacs, gmacs, ו vi אפשרויות (אפשר להגדיר לכל היותר אחת מהן ב
פַּעַם). ברירת המחדל היא Emacs. ניתן להגדיר באופן מפורש מצבי עריכה באמצעות ה סט מובנית.
אם אף אחת מהאפשרויות הללו לא מופעלת, המעטפת פשוט קוראת שורות באמצעות הרגיל tty(4)
נהג. אם ה Emacs or gmacs האפשרות מוגדרת, המעטפת מאפשרת עריכה דמוית emacs של
פקודה; באופן דומה, אם ה vi האפשרות מוגדרת, המעטפת מאפשרת עריכה של vi-like של
פקודה. מצבים אלה מתוארים בפירוט בסעיפים הבאים.

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

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

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

להלן רשימה של פקודות עריכה זמינות. כל תיאור מתחיל ב-
שם הפקודה, עם סיומת נקודתיים; an [n] (אם ניתן להקדים את הפקודה עם a
לספור); וכל המפתחות שהפקודה קשורה אליהם כברירת מחדל, כתובה באמצעות סימון אבן, למשל
תו ASCII ESC כתוב בתור ^[. רצפי בקרה אלה אינם תלויי רישיות.
קידומת ספירה לפקודה מוזנת באמצעות הרצף ^[n, שם n הוא רצף של 1
או יותר ספרות. אלא אם צוין אחרת, אם ספירה מושמטת, ברירת המחדל היא 1.

שים לב ששמות פקודות עריכה משמשים רק עם ה לאגד פקודה. יתר על כן, רבים
פקודות עריכה שימושיות רק במסופים עם סמן גלוי. כריכות ברירת המחדל
נבחרו כדי להידמות לכריכות מקשיות של Emacs. של המשתמש tty(4) תווים
(לדוגמה ERASE) מחויבים לתחליפים סבירים ודוברים על כריכות ברירת המחדל.

הפלה: ^C, ^G
בטל את הפקודה הנוכחית, רוקן את מאגר השורות והגדר את מצב היציאה למצב
מוּפרָע.

הוספה אוטומטית: [n]
פשוט גורם לדמות להופיע כקלט מילולי. דמויות רגילות ביותר
כבולים לכך.

אחורה-char: [n] ^B, ^XD, ANSI-CurLeft, PC-CurLeft
מזיז את הסמן אחורה n תווים.

מילה לאחור: [n] ^[b, ANSI-Ctrl-CurLeft, ANSI-Alt-CurLeft
מזיז את הסמן אחורה לתחילת המילה; מילים מורכבות מ
תווים אלפאנומריים, קו תחתון ('_') וסימן דולר ('$').

תחילת ההיסטוריה: ^[
עובר לתחילת ההיסטוריה.

תחילת השורה: ^A, ANSI-Home, PC-Home
מעביר את הסמן לתחילת שורת הקלט הערוכה.

השתמש באותיות רישיות: [n] ^[C, ^[ג
באותיות רישיות את התו הראשון בתווים הבאים n מילים, תוך השארת הסמן מעבר לסוף
של המילה האחרונה.

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

תגובה: ^[#
אם השורה הנוכחית לא מתחילה עם תו הערה, אחד נוסף ב-
תחילת השורה והשורה מוזנת (כאילו לחצו חזרה);
אחרת, תווי ההערה הקיימים יוסרו והסמן ימוקם ב
תחילת השורה.

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

פקודה מלאה: ^X^[
משלים באופן אוטומטי כמה שייחודי של שם הפקודה עם החלקית
מילה עד הסמן בתור הקידומת שלה, כמו ב- להשלים הפקודה למעלה.

קובץ שלם: ^[^X
משלים באופן אוטומטי כמה שייחודי של שם הקובץ עם החלקי
מילה עד הסמן בתור הקידומת שלה, כמו ב- להשלים פקודה שתוארה לעיל.

רשימה מלאה: ^I, ^[=
השלם כמה שאפשר מהמילה הנוכחית, ורשום את האפשרויות
השלמות עבורו. אם אפשר רק השלמה אחת, התאימו כמו ב- להשלים
הפקודה למעלה. שימו לב ש-^I נוצר בדרך כלל על ידי מקש TAB (טבולטור).

מחק-char-backward: [n] מחק, ^?, ^H
מוחק n תווים לפני הסמן.

delete-char-forward: [n] ANSI-Del, PC-Del
מוחק n תווים אחרי הסמן.

מחק-מילה-לאחור: [n] WERASE, ^[^?, ^[^H, ^[h
מוחק n מילים לפני הסמן.

מחק-מילה קדימה: [n] ^[ד
מוחק תווים אחרי הסמן עד לסוף n מילים.

היסטוריה למטה: [n] ^N, ^XB, ANSI-CurDown, PC-CurDown
גוללת את מאגר ההיסטוריה קדימה n שורות (מאוחר יותר). כל שורת קלט במקור
מתחיל מיד אחרי הערך האחרון במאגר ההיסטוריה, אז היסטוריה למטה לא
שימושי עד שניהם חפש היסטוריה, חיפוש-היסטוריה למעלה or up-היסטוריה כבר
מְבוּצָע.

מילה קטנה: [n] ^[L, ^[l
באותיות קטנות הבאות n מילים.

שורת עריכה: [n] ^Xe
ערוך שורה n או הקו הנוכחי, אם לא צוין, באופן אינטראקטיבי. בפועל
הפקודה שבוצעה היא fc -e ${VISUAL:-${EDITOR:-vi}} n.

סוף ההיסטוריה: ^[>
עובר לסוף ההיסטוריה.

סוף קו: ^E, ANSI-End, PC-End
מזיז את הסמן לסוף שורת הקלט.

eot: ^_
פועל כסוף קובץ; זה שימושי מכיוון שהקלט במצב עריכה משבית את הרגיל
קנוניזציה של קלט מסוף.

eot-or-delete: [n] ^D
פועל כ eot אם לבד על קו; אחרת מתנהג כמו מחק-char-forward.

שגיאה: (לא קשור)
שגיאה (צלצל בפעמון).

החלפה-נקודה-וסימון: ^X^X
ממקם את הסמן במקום בו נמצא הסמן ומגדיר את הסמן למקום בו היה הסמן.

הרחבת קובץ: ^[*
מוסיף '*' למילה הנוכחית ומחליף את המילה בתוצאה של
ביצוע קובץ גלוב על המילה. אם אין קבצים תואמים לדפוס, הפעמון כן
שָׁלָב.

קדימה-char: [n] ^F, ^XC, ANSI-CurRight, PC-CurRight
מזיז את הסמן קדימה n תווים.

מילה קדימה: [n] ^[f, ANSI-Ctrl-CurRight, ANSI-Alt-CurRight
מזיז את הסמן קדימה לסוף ה- nהמילה.

goto-history: [n] ^[ג
עובר למספר היסטוריה n.

kill-line: KILL
מוחק את כל שורת הקלט.

kill-region: ^W
מוחק את הקלט בין הסמן לסימון.

Kill-to-eol: [n] ^K
מוחק את הקלט מהסמן לסוף השורה אם n לא מצוין;
אחרת מוחק תווים בין הסמן והעמודה n.

רשימה: ^[?
מדפיס רשימה ממוינת בעמודות של שמות פקודות או שמות קבצים (אם יש) שיכולים
השלימו את המילה החלקית המכילה את הסמן. שמות ספריות צורפו '/'
להם.

פקודה רשימה: ^X?
מדפיס רשימה ממוינת בעמודות של שמות פקודות (אם יש) שיכולות להשלים את
מילה חלקית המכילה את הסמן.

קובץ רשימה: ^X^Y
מדפיס רשימה ממוינת בעמודות של שמות קבצים (אם יש כאלה) שיכולה להשלים את
מילה חלקית המכילה את הסמן. מחווני סוג קובץ מצורפים כמתואר
תחת רשימה מֵעַל.

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

newline-and-next: ^O
גורם לעיבוד שורת הקלט הנוכחית על ידי המעטפת, והשורה הבאה מ
ההיסטוריה הופכת לקו הנוכחי. זה שימושי רק לאחר א up-היסטוריה,
חפש היסטוריה or חיפוש-היסטוריה למעלה.

no-op: QUIT
זה לא עושה כלום.

קידומת-1: ^[
מציג רצף פקודות בן 2 תווים.

קידומת-2: ^X, ^[[, ^[O
מציג רצף פקודות בן 2 תווים.

prev-hist-word: [n] ^[., ^[_
המילה האחרונה, או, אם ניתנת, ה nהמילה (על בסיס אפס) מהקודמת (בחזרה
ביצוע, שנייה אחרונה, שלישית אחרונה וכו') הפקודה מוכנסת בסמן. שימוש ב
פקודת עריכה זו מוציאה את הסימן לאשפה.

ציטוט: ^^, ^V
התו הבא נלקח מילולית ולא כפקודת עריכה.

צייר מחדש: ^L
מדפיס מחדש את השורה האחרונה של מחרוזת ההנחיה ואת שורת הקלט הנוכחית בשורה חדשה
קו.

חיפוש-דמות-לאחור: [n] ^[^]
חפש אחורה בשורה הנוכחית עבור ה nהמופע של הדמות הבאה
הקלד.

חיפוש-תו-לפנים: [n] ^]
חפש קדימה בשורה הנוכחית עבור ה nהמופע של הדמות הבאה
הקלד.

חיפוש-היסטוריה: ^R
היכנס למצב חיפוש מצטבר. רשימת ההיסטוריה הפנימית נחפשת לאחור
פקודות התואמות את הקלט. '^' ראשוני במחרוזת החיפוש מעגן את ה-
לחפש. מקש היציאה יעזוב את מצב החיפוש. פקודות אחרות, כולל רצפים
של בריחה כמו קידומת-1 ואחריו א קידומת-1 or קידומת-2 מפתח יבוצע לאחר
עוזב את מצב החיפוש. ה ביטול הפקודה (^G) תשחזר את שורת הקלט לפני
החיפוש התחיל. רצוף חפש היסטוריה הפקודות ממשיכות לחפש אחורה אל
ההופעה הקודמת הבאה של התבנית. מאגר ההיסטוריה שומר רק על א
מספר סופי של קווים; העתיקים ביותר נזרקים לפי הצורך.

חיפוש-היסטוריה למעלה: ANSI-PgUp, PC-PgUp
חפש אחורה במאגר ההיסטוריה עבור פקודות שתחילתן תואמת את
חלק משורת הקלט לפני הסמן. בשימוש על קו ריק, זה קרה
אותו אפקט כמו up-היסטוריה.

חיפוש-היסטוריה למטה: ANSI-PgDn, PC-PgDn
חפש קדימה דרך מאגר ההיסטוריה עבור פקודות שההתחלה שלהן תואמת את
חלק משורת הקלט לפני הסמן. בשימוש על קו ריק, זה קרה
אותו אפקט כמו היסטוריה למטה. זה שימושי רק לאחר א up-היסטוריה,
חפש היסטוריה or חיפוש-היסטוריה למעלה.

set-mark-command: ^[
הגדר את הסימון במיקום הסמן.

transpose-chars: ^T
אם בסוף השורה, או אם ה gmacs האפשרות מוגדרת, זה מחליף את השניים
דמויות קודמות; אחרת, הוא מחליף את התווים הקודמים והנוכחיים ו
מזיז את הסמן תו אחד ימינה.

up-history: [n] ^P, ^XA, ANSI-CurUp, PC-CurUp
גלילה של מאגר ההיסטוריה אחורה n קווים (קודם לכן).

upcase-word: [n] ^[U, ^[u
האותיות הגדולות הבאות n מילים.

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

למשוך: ^Y
מוסיף את מחרוזת הטקסט שנרצחה לאחרונה במיקום הסמן הנוכחי.

יאנק-פופ: ^[y
מיד לאחר א יאנק, מחליף את מחרוזת הטקסט שהוכנסה במחרוזת הבאה קודם
מחרוזת טקסט נהרגה.

Vi עריכה מצב
הערה: מצב העריכה של שורת הפקודה vi הוא יתום, אך עדיין פונקציונלי. זה 8 סיביות נקי
אך באופן ספציפי אינו תומך ב-UTF-8 או ב-MBCS.

עורך שורת הפקודה vi ב מקש יש בעצם את אותן פקודות כמו ל- vi(1) עורך עם
החריגים הבאים:

· אתה מתחיל במצב הוספה.

· יש שם קובץ ופקודות השלמת פקודות: =, \, *, ^X, ^E, ^F, ו,
באופן אופציונלי, ו .

· אל האני _ הפקודה שונה (ב מקש, זוהי פקודת הארגומנט האחרונה; ב vi(1) זה הולך
לתחילת השורה הנוכחית).

· אל האני / ו G הפקודות נעות בכיוון ההפוך ל- j פקודה.

· פקודות שאינן הגיוניות בעורך שורה אחת אינן זמינות (למשל מסך
פקודות תנועה ו exנקודתיים בסגנון (1) (:) פקודות).

כמו vi(1), ישנם שני מצבים: מצב "הוספה" ומצב "פקודה". במצב הוספה, רוב
תווים פשוט מכניסים למאגר במיקום הסמן הנוכחי תוך כדי הקלדתם;
עם זאת, חלק מהדמויות מטופלות במיוחד. בפרט, הדמויות הבאות הן
נלקח מהזרם tty(4) הגדרות (ראה stty(1)) ומשמעותם הרגילה (ערכים נורמליים
נמצאים בסוגריים): להרוג (^U), מחק (^?), werase (^W), eof (^D), intr (^C), וצא (^\).
בנוסף לאמור לעיל, התווים הבאים מטופלים במיוחד ב-insert
מצב:

^E ספירת פקודות ושם קובץ (ראה להלן).

^F השלמת פקודה ושם קובץ (ראה להלן). אם נעשה שימוש פעמיים ברציפות, הרשימה של
השלמות אפשריות מוצגות; אם נעשה בו שימוש שלישי, ההשלמה תבוטל.

^H מוחק את התו הקודם.

^J | ^M סוף שורה. השורה הנוכחית נקראת, מנותחת ומבוצעת על ידי המעטפת.

^V מילולית הבא. התו הבא שהוקלד אינו מטופל במיוחד (ניתן להשתמש בו
הכנס את התווים המתוארים כאן).

^X הרחבת פקודה ושם קובץ (ראה להלן).

מכניס את העורך למצב פקודה (ראה להלן).

שם קובץ אופציונלי והשלמת פקודה (ראה ^F למעלה), מופעל עם סט -o
vi-tabcomplete.

במצב פקודה, כל תו מתפרש כפקודה. דמויות שלא
מתאימות לפקודות, הן שילובים לא חוקיים של פקודות, או שהן פקודות שאינן יכולות להיות
מבוצע, כולם גורמים לצפצופים. בתיאורי הפקודות הבאים, [n] מציין את
פקודה עשויה להיות קידומת של מספר (למשל 10l זז ימינה 10 תווים); אם אין מספר
נעשה שימוש בקידומת, n ההנחה היא 1 אלא אם צוין אחרת. המונח "נוכחי
מיקום" מתייחס למיקום בין הסמן לבין התו שלפני הסמן.
"מילה" היא רצף של אותיות, ספרות ותווי קו תחתון או רצף של לא-
תווים של אותיות, ללא ספרות, ללא קו תחתון ולא רווח לבן (למשל "ab2*&^" מכיל שניים
מילים) ו"מילה גדולה" היא רצף של תווים שאינם רווחים.

מיוחד מקש פקודות vi:

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

[n]_ הכנס רווח ואחריו ה- nהמילה הגדולה מהפקודה האחרונה בהיסטוריה
במיקום הנוכחי והיכנס למצב הוספה; אם n לא מצוין, האחרון
הוכנסה מילה.

# הכנס את תו ההערה ('#') בתחילת השורה הנוכחית וחזור
הקו לקליפה (שווה ערך ל אני #^J).

[n]g לייק G, למעט אם n לא צוין, הוא עובר אל האחרון שנזכר
קו.

[n]v ערוך שורה n באמצעות vi(1) עורך; אם n לא צוין, השורה הנוכחית היא
עָרוּך. הפקודה שבוצעה בפועל היא fc -e ${VISUAL:-${EDITOR:-vi}} n.

* ו-^X הרחבת הפקודה או שם הקובץ מוחלת על המילה הגדולה הנוכחית (עם
מצורף '*' אם המילה אינה מכילה תווים בולטים בקובץ) - המילה הגדולה היא
הוחלף במילים שהתקבלו. אם המילה הגדולה הנוכחית היא הראשונה ב-
קו או עוקב אחר אחד מהתווים ';', '|', '&', '(' או ')', ואינו
מכילים קו נטוי ('/'), ואז הרחבת הפקודה מתבצעת; אחרת שם הקובץ
הרחבה מתבצעת. הרחבת הפקודה תתאים את המילה הגדולה נגד כולם
כינויים, פונקציות ופקודות מובנות, כמו גם כל קבצי הפעלה שנמצאו
על ידי חיפוש בספריות בפרמטר PATH. הרחבת שם הקובץ תואמת
המילה הגדולה נגד הקבצים בספרייה הנוכחית. לאחר ההרחבה, ה
הסמן ממוקם רק אחרי המילה האחרונה והעורך במצב הכנסה.

[n]\, [n]^F, [n] , ו-[n]
השלמת שם פקודה/קובץ. החלף את המילה הגדולה הנוכחית במילה הארוכה ביותר
התאמה ייחודית שהתקבלה לאחר ביצוע הרחבת פקודות ושם קובץ.
מוכר רק אם vi-tabcomplete האפשרות מוגדרת, בעוד רק
מוכר אם ה vi-esccomplete האפשרות מוגדרת (ראה סט -o). אם n מצוין,
מה היא nנבחרה ההשלמה האפשרית (כפי שדווח לפי שם הפקודה/קובץ
פקודת ספירה).

= ו-^E ספירת שם פקודה/קובץ. רשום את כל הפקודות או הקבצים התואמים את
המילה הגדולה הנוכחית.

^V הצג את הגרסה של מקש. מאגר העריכה הנוכחי משוחזר ברגע א
מקש נלחץ. מתעלמים מהקשה המשחזרת.

@c הרחבת מאקרו. בצע את הפקודות שנמצאו בכינוי c.

פקודות תנועה תוך-שורות:

[n]יד [n]^ח
זוז שמאלה n תווים.

[n]ארץ [n]
זוז ימינה n תווים.

0 עבור לעמודה 0.

^ עבור אל התו הראשון שאינו רווח לבן.

[n]| עבור לעמודה n.

$ עבור לדמות האחרונה.

[n]ב זז אחורה n מילים.

[n]ב זז אחורה n מילים גדולות.

[n]e עבור קדימה לסוף המילה, n פעמים.

[n]ה התקדם לסוף המילה הגדולה, n פעמים.

[n]w התקדם n מילים.

[n]W התקדם n מילים גדולות.

% מצא התאמה. העורך מצפה לסוגריים, סוגריים או סוגריים הקרובים ביותר
ולאחר מכן מעביר את הסמן לסוגריים, סוגריים או סוגריים תואמים.

[n]fc התקדם ל- nהמופע של הדמות c.

[n]Fc זז אחורה אל nהמופע של הדמות c.

[n]tc התקדם לרגע לפני ה nהמופע של הדמות c.

[n]Tc זז אחורה לרגע לפני nהמופע של הדמות c.

[n]; חוזר על האחרון f, F, t, או T פקודה.

[n], חוזר על האחרון f, F, t, או T פקודה, אך נע בכיוון ההפוך.

פקודות תנועה בין שורות:

[n]j, [n]+, ו-[n]^נ
עברו אל התנועה nהשורה הבאה בהיסטוריה.

[n]ק, [n]-, ו-[n]^פ
עברו אל התנועה nהשורה הקודמת בהיסטוריה.

[n]G עבור לשורה n בהיסטוריה; אם n לא מצוין, המספר של הראשון
נעשה שימוש בקו זכור.

[n]g לייק G, למעט אם n לא מצוין, הוא עובר לשורה הזכורה ביותר.

[n]/מחרוזת
חפש אחורה בהיסטוריה עבור ה nהשורה המכילה מחרוזת; אם מחרוזת
מתחיל ב-'^', שאר המחרוזת חייב להופיע בתחילת ההיסטוריה
קו כדי שזה יתאים.

[n]?מחרוזת
כמו /, אלא שהוא מחפש קדימה בהיסטוריה.

[n]n חפש את nהמופע ה-th של מחרוזת החיפוש האחרונה; כיוון החיפוש
זהה לחיפוש האחרון.

[n]N חפש את nהמופע ה-th של מחרוזת החיפוש האחרונה; כיוון החיפוש
הוא ההפך מהחיפוש האחרון.

ANSI-CurUp, PC-PgUp
קח את התווים מתחילת השורה למיקום הסמן הנוכחי כמו
חפש מחרוזת ובצע חיפוש היסטורי לאחור עבור שורות שמתחילות בזה
חוּט; לשמור על מיקום הסמן. זה עובד רק במצב הוספה ושומר אותו
מאופשר.

ערוך פקודות

[n]a הוסף טקסט n פִּי; עובר למצב הוספה מיד לאחר המיקום הנוכחי. ה
append משוכפל רק אם מצב הפקודה נכנס מחדש, כלומר משמש.

[n]אותו כמו a, אלא שהוא מצורף בסוף השורה.

[n]i הוסף טקסט n פִּי; עובר למצב הכנסה במיקום הנוכחי. ההכנסה
משוכפל רק אם מצב הפקודה נכנס מחדש, כלומר משמש.

[n]אני אותו דבר כמו i, אלא שההוספה מתבצעת ממש לפני התו הראשון שאינו ריק.

[n]s תחליף את הבא n תווים (כלומר מחק את התווים ועבור ל-insert
מצב).

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

[n]cהעבר-cmd
שנה מהמיקום הנוכחי למיקום הנובע ממנו n העבר-cmds (כלומר
מחק את האזור המצוין ועבור למצב הוספה); אם העבר-cmd is c, את הקו
החל מהתו הראשון שאינו ריק משתנה.

C שנה מהמיקום הנוכחי לסוף השורה (כלומר מחק לסוף
את הקו ועבור למצב הוספה).

[n]x מחק את הבא n תווים.

[n]X מחק את הקודם n תווים.

D מחק עד סוף השורה.

[n]dהעבר-cmd
מחק מהמיקום הנוכחי למיקום הנובע ממנו n העבר-cmds;
העבר-cmd הוא פקודת תנועה (ראה למעלה) או d, ובמקרה זה הקו הנוכחי הוא
נמחק.

[n]rc החלף את הבא n דמויות עם הדמות c.

[n]R החלף. היכנס למצב הוספה אך החלף תווים קיימים במקום להוסיף
לפני הדמויות הקיימות. ההחלפה חוזרת על עצמה n פעמים.

[n]~ שנה את האותיות של האותיות הבאות n תווים.

[n]yהעבר-cmd
דחף מהמיקום הנוכחי למיקום הנובע ממנו n העבר-cmds לתוך
מושך חיץ; אם העבר-cmd is y, כל הקו נמשך.

Y ינק מהמיקום הנוכחי לסוף השורה.

[n]p הדבק את התוכן של מאגר המשיכה רק אחרי המיקום הנוכחי, n פעמים.

[n]P אותו דבר כמו p, מלבד המאגר מודבק במיקום הנוכחי.

פקודות vi שונות

^J ו^M
השורה הנוכחית נקראת, מנותחת ומבוצעת על ידי המעטפת.

^L ו-^R
צייר מחדש את הקו הנוכחי.

[n]. בצע שוב את פקודת העריכה האחרונה n פעמים.

u בטל את פקודת העריכה האחרונה.

U בטל את כל השינויים שבוצעו בשורה הנוכחית.

מקשי PC Home, End, Del ומקשי הסמן
הם זזים כצפוי, הן במצב הוספה והן במצב פקודה.

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

השתמש ב-mksh באינטרנט באמצעות שירותי onworks.net