git-stash - אונליין בענן

תָכְנִית:

שֵׁם

git-stash - אחסון השינויים בספריית עבודה מלוכלכת

תַקצִיר

סילון סְלִיק רשימה [ ]
סילון סְלִיק הצג [ ]
סילון סְלִיק זרוק [-q|--שקט] [ ]
סילון סְלִיק (פופ | החל) [--index] [-q|--quiet] [ ]
סילון סְלִיק עָנָף [ ]
סילון סְלִיק [שמור [-p|--patch] [-k|--[no-]שמור-אינדקס] [-q|--שקט]
[-u|--include-untracked] [-a|--all] [ ]]
סילון סְלִיק ברור
סילון סְלִיק ליצור [ ]
סילון סְלִיק אחסון [-m|--הודעה ] [-q|--שקט]

תיאור

השתמש ב-git stash כשרוצים לתעד את המצב הנוכחי של ספריית העבודה ושל ה-
אינדקס, אבל רוצה לחזור לספריית עבודה נקייה. הפקודה שומרת את הקובץ המקומי שלך
מסיר שינויים ומחזיר את ספריית העבודה למצב ה-commit של HEAD.

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

המאחסן האחרון שיצרת מאוחסן ב-refs/stash; מאגרי נתונים ישנים יותר נמצאים ב-
רפלוג של הפניה זו וניתן לנקוב בשם באמצעות תחביר רפלוג הרגיל (לדוגמה, stash@{0} הוא
הסטש שנוצר לאחרונה, stash@{1} הוא זה שלפניו, stash@{2.hours.ago} הוא
גם אפשרי).

אפשרויות

שמור [-p|--patch] [-k|--[no-]שמור-אינדקס] [-u|--include-untracked] [-a|--all] [-q|--quiet]
[ ]
שמור את השינויים המקומיים שלך בקובץ חדש סְלִיק, ולהריץ git reset --hard כדי לבטל אותם.
ה החלק הוא אופציונלי ומספק את התיאור יחד עם המצב המאוחסן.
כדי ליצור תמונת מצב במהירות, ניתן להשמיט שניהם "שמור" ו , אבל רק נותן
לא מפעיל פעולה זו כדי למנוע ביצוע של פקודה משנה עם שגיאת איות
מאגר לא רצוי.

אם נעשה שימוש באפשרות --keep-index, כל השינויים שכבר נוספו לאינדקס יישארו
שָׁלֵם.

אם נעשה שימוש באפשרות --include-untracked, כל הקבצים שלא עוקבים יאוחסנו גם הם ו...
לאחר מכן ניקיתי באמצעות git clean, והותיר את ספריית העבודה במצב נקי מאוד.
אם משתמשים באפשרות --all במקום זאת, הקבצים שהתעלמו מהם מאוחסנים ומנוקים ב-
בנוסף לקבצים שלא עוקבים אחריהם.

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

האפשרות --patch מרמזת על --keep-index. ניתן להשתמש ב--no-keep-index כדי לעקוף זאת.

רשימה [ ]
רשום את המלאי שיש לך כרגע. כל אחד סְלִיק רשום עם שמו (למשל
stash@{0} הוא ה-stash האחרון, stash@{1} הוא הקודם וכו'), שם ה-
ענף שהיה עדכני כאשר נוצר הסטאק, ותיאור קצר של ה-commit
על מה התבסס המאגר.

stash@{0}: WIP בעת שליחה: 6ebd0e2... עדכון תיעוד git-stash
stash@{1}: במאסטר: 9cc0589... הוסף git-stash

הפקודה מקבלת אפשרויות רלוונטיות ל- סילון היכנס פקודה לשליטה במה שמוצג
ואיך. ראה git-log(1).

הצג [ ]
הצג את השינויים שנרשמו במאגר כהבדל בין המצב המאוחסן לבין המצב שלו
הורה מקורי. כאשר לא ניתן, מציג את האחרון. כברירת מחדל, ה-
הפקודה מציגה את diffstat, אך היא תקבל כל פורמט הידוע ל- סילון הבדל (לדוגמה, גיט
stash show -p stash@{1} כדי לצפות ב-stash השני הכי חדש בצורת תיקון). אתה יכול
השתמש במשתני התצורה stash.showStat ו/או stash.showPatch כדי לשנות את ברירת המחדל.
התנהגות.

פופ [--index] [-q|--quiet] [ ]
הסר מצב מאוחסן יחיד מרשימת המאגרים והחיל אותו על גבי הנוכחי
מצב עץ עבודה, כלומר, לבצע את הפעולה ההפוכה של שמירת git stash. הפעולה העבודה
הספרייה חייבת להתאים לאינדקס.

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

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

כאשר לא ניתן, stash@{0} מניחים, אחרת חייב להיות הפניה
מהצורה stash@{ }.

החל [--index] [-q|--quiet] [ ]
כמו פופ, אבל אל תסיר את המדינה מרשימת האחסון. שלא כמו פופ, עשוי להיות
כל קומיט שנראה כמו קומיט שנוצר על ידי stash save או stash create.

עָנָף [ ]
יוצר ומוציא סניף חדש בשם החל מה-commit ב-
אשר ה- נוצר במקור, מיישם את השינויים שנרשמו ב אֶל
עץ העבודה והאינדקס החדשים. אם זה יצליח, ו הוא הפניה של ה-
טופס stash@{ }, לאחר מכן הוא מפיל את כאשר לא ניתן, חל
האחרון.

זה שימושי אם הענף עליו הרצתם את git stash save השתנה מספיק כדי
יישום ה-git stash נכשל עקב התנגשויות. מכיוון שה-stash מוחל מעל ה-
commit שהיה HEAD בזמן שה-git stash הרצה, הוא משחזר את הקובץ המקורי שהוחדר.
מדינה ללא סכסוכים.

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

זרוק [-q|--שקט] [ ]
הסר מצב מאוחסן יחיד מרשימת המאגרים. כאשר אין ניתן, זה
מסיר את העדכני ביותר. כלומר stash@{0}, אחרת חייב להיות יומן אחסון תקף
הפניה של הטופס stash@{ }.

לִיצוֹר
צור stash (שהוא אובייקט commit רגיל) והחזר את שם האובייקט שלו, מבלי
אחסון זה בכל מקום במרחב השמות של refer. זה נועד להיות שימושי עבור סקריפטים.
כנראה שזו לא הפקודה שברצונך להשתמש בה; ראה "שמירה" לעיל.

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

דיון

סטש מיוצג כ-commit שעץ ה-commit שלו מתעד את מצב ספריית העבודה,
וההורה הראשון שלו הוא ה-commit ב-HEAD כאשר ה-stash נוצר. עץ ה-
ההורה השני מתעד את מצב האינדקס כאשר נוצר הסטאק, והוא נוצר
צאצא של commit HEAD. גרף השושלת נראה כך:

.----W
/ /
-----H----I

כאשר H הוא ה-HEAD commit, I הוא commit שרושם את מצב האינדקס, ו-W הוא
commit שרושם את מצב עץ העבודה.

דוגמאות

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

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

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

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

# ... האק האק האק ...
$ git checkout -b my_wip
$ git commit -a -m "עבודה פעילה"
$ git checkout master
עריכת תיקון חירום
$ git commit -a -m "לתקן במהירות"
$ git checkout my_wip
איפוס גיט --soft HEAD^
# ... המשך פריצה ...

אתה יכול להשתמש סילון סְלִיק כדי לפשט את האמור לעיל, כך:

# ... האק האק האק ...
$ גיט סטש
עריכת תיקון חירום
$ git commit -a -m "לתקן במהירות"
$ גיט סטש פופ
# ... המשך פריצה ...

בדיקת קומיטים חלקיים
ניתן להשתמש בפונקציה git stash save --keep-index כשרוצים לבצע שני קומיטים או יותר.
של השינויים בעץ העבודה, ואתה רוצה לבדוק כל שינוי לפני ביצוע:

# ... האק האק האק ...
$ git add --patch foo # הוסף רק את החלק הראשון לאינדקס
$ git stash save --keep-index # שמור את כל השינויים האחרים במאגר
עריכה/בנייה/בדיקה של החלק הראשון
$ git commit -m 'חלק ראשון' # commit שינוי שנבדק במלואו
$ git stash pop # התכונן לעבוד על כל שאר השינויים
# ... חזור על חמשת השלבים לעיל עד שיישאר קומיט אחד ...
$ עריכה/בנייה/בדיקה של החלקים הנותרים
$ git commit foo -m 'חלקים שנותרו'

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

git fsck --לא ניתן להשגה |
grep commit | cut -d\ -f3 |
יומן גיט של xargs --merges --no-walk --grep=עבודה פעילה

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