git-rebase - מקוון בענן

תָכְנִית:

שֵׁם

git-rebase - מחויבות מקומית של Forward-port לראש ה-upstream המעודכן

תַקצִיר

סילון השבה מחדש [-i | --אינטראקטיבי] [אפשרויות] [--exec ] [--על פני ]
[ [ ]]
סילון השבה מחדש [-i | --אינטראקטיבי] [אפשרויות] [--exec ] [--על פני ]
--שורש [ ]
סילון השבה מחדש --המשך | --דלג | --להפסיק | --edit-todo

תיאור

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

אם לא צוין, ה-Upstream מוגדר בסניף. .מרוחק ו
ענף. ייעשה שימוש באפשרויות .merge (ראה git-config(1) לפרטים) ואת
ההנחה היא אפשרות --fork-point. אם אתה כרגע לא באף סניף או אם הנוכחי
לסניף אין תצורה במעלה הזרם, הבסיס מחדש יבטל.

כל השינויים שנעשו על ידי commits בסניף הנוכחי אך אינם בפנים נשמרים
לאזור זמני. זוהי אותה קבוצה של commits שתוצג על ידי git log
..רֹאשׁ; או על ידי git log 'fork_point'..HEAD, אם --fork-point פעיל (ראה את
תיאור ב--fork-point למטה); או על ידי git log HEAD, אם צוינה אפשרות --root.

הסניף הנוכחי מאופס ל , או אם האפשרות --onto סופקה.
יש לזה את אותה השפעה בדיוק כמו git reset --hard (אוֹ ). ORIG_HEAD הוא
מוגדר כך שיצביע על קצה הענף לפני האיפוס.

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

יתכן שכשל מיזוג ימנע תהליך זה מלהיות לחלוטין
אוֹטוֹמָטִי. תצטרך לפתור כל כשל מיזוג כזה ולהפעיל git rebase --continue.
אפשרות נוספת היא לעקוף את ה-commit שגרם לכישלון המיזוג עם git rebase
--לדלג. כדי לבדוק את המקור והסר את קובצי העבודה .git/rebase-apply,
השתמש בפקודה git rebase --abort במקום זאת.

נניח שההיסטוריה הבאה קיימת והענף הנוכחי הוא "נושא":

א---ב---ג נושא
/
ד---ה---פ---ג מאסטר

מנקודה זו, התוצאה של אחת מהפקודות הבאות:

git rebase master
נושא מאסטר git rebase

יהיה:

נושא א'--ב'--ג'
/
ד---ה---פ---ג מאסטר

הערה: הטופס האחרון הוא רק קיצור של נושא ה-git checkout ואחריו git rebase
לִשְׁלוֹט. כאשר יציאת בסיס מחדש, הנושא יישאר הענף שעזב.

אם הסניף במעלה הזרם כבר מכיל שינוי שביצעת (למשל, בגלל ששלחת בדואר א
תיקון שהוחל במעלה הזרם), ואז ה-commit הזה ידלג. למשל ריצה
git rebase master על ההיסטוריה הבאה (בה A' ו-A מציגים את אותה קבוצה של
שינויים, אך יש להם מידע מחויב שונה):

א---ב---ג נושא
/
ד---ה---א'---ו מאסטר

יביא ל:

ב'---ג' נושא
/
ד---ה---א'---ו מאסטר

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

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

o---o---o---o---o master
\
o---o---o---o---o הבא
\
o---o---o נושא

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

o---o---o---o---o master
| \
| o'--o'--o' נושא
\
o---o---o---o---o הבא

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

git rebase --onto master הנושא הבא

דוגמה נוספת לאפשרות --onto היא בסיס מחדש של חלק מענף. אם יש לנו את הדברים הבאים
מַצָב:

ח---אי---י נושא ב
/
E---F---G נושאA
/
א---ב---ג---ד מאסטר

ואז הפקודה

git rebase --onto master topicA topicB

יביא:

ח'--אי'--י' נושא ב
/
| E---F---G נושאA
|/
א---ב---ג---ד מאסטר

זה שימושי כאשר נושא B אינו תלוי בנושאA.

ניתן גם להסיר מגוון של commits עם rebase. אם יש לנו את המצב הבא:

E---F---G---H---I---J נושאA

ואז הפקודה

git rebase --onto topicA~5 topicA~3 topicA

יביא להסרה של התחייבויות F ו-G:

E---H'---I'---J' נושאא

זה שימושי אם F ו-G היו פגומים בדרך כלשהי, או לא אמור להיות חלק מ-topicA. הערה
שהטיעון ל--onto וה- פרמטר יכול להיות כל commit-ish חוקי.

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

git add

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

git rebase - המשך

לחלופין, אתה יכול לבטל את סילון השבה מחדש עם

git rebase --abort

תְצוּרָה

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

rebase.autoSquash
אם מוגדר ל-true, אפשר --אוטוסקווש אפשרות כברירת מחדל.

rebase.autoStash
אם מוגדר ל-true, אפשר --אוטומאטאש אפשרות כברירת מחדל.

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

rebase.instructionFormat
פורמט רשימת התחייבויות מותאם אישית לשימוש במהלך א --אינטראקטיבי rebase.

אפשרויות

--עַל גַבֵּי
נקודת התחלה שבה ניתן ליצור את המחויבויות החדשות. אם האפשרות --onto אינה
שצוין, נקודת ההתחלה היא . יכול להיות כל התחייבות תקפה, ולא רק
שם הסניף הקיים.

כמקרה מיוחד, אתה יכול להשתמש ב-"A...B" כקיצור דרך לבסיס המיזוג של A ו-B if
יש בדיוק בסיס מיזוג אחד. אתה יכול להשאיר לכל היותר אחד מ-A ו-B, שבו
למקרה שהוא כברירת מחדל ל-HEAD.


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


ענף עובד; ברירת המחדל היא HEAD.

--לְהַמשִׁיך
הפעל מחדש את תהליך הבסיס מחדש לאחר פתרון התנגשות מיזוג.

--לְהַפִּיל
בטל את פעולת ה-rebase ואפס את HEAD לענף המקורי. אם היה
בתנאי כאשר פעולת ה-rebase הוחלה, אז HEAD יאופס ל- .
אחרת HEAD יאופס למקום שבו הוא היה כשהחלה פעולת ה-rebase.

--שמור-ריק
שמור על המחויבויות שלא משנות דבר מהוריו בתוצאה.

--לדלג
הפעל מחדש את תהליך הבסיס מחדש על ידי דילוג על התיקון הנוכחי.

--edit-todo
ערוך את רשימת המשימות במהלך בסיס מחדש אינטראקטיבי.

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

שימו לב שמיזוג rebase עובד על ידי השמעה חוזרת של כל commit מהענף הפועל למעלה
של ה ענף. בגלל זה, כאשר מתרחש סכסוך מיזוג, הצד
דווח כ לשאת היא הסדרה המבוססת עד כה מחדש, החל מ- , ו שֶׁלָהֶם is
הענף העובד. במילים אחרות, הצדדים מוחלפים.

-ס , --אסטרטגיה=
השתמש באסטרטגיית המיזוג הנתונה. אם אין אפשרות -s סילון מיזוג-רקורסיבי משמש
במקום זאת. זה מרמז על --מיזוג.

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

-איקס , --strategy-option=
תעביר את ה עד לאסטרטגיית המיזוג. זה מרמז על --מיזוג ואם
לא צוינה אסטרטגיה, -s רקורסיבי. שימו לב להיפוך של לשאת ו שֶׁלָהֶם as
צוין לעיל עבור האפשרות -m.

-S[ ], --gpg-sign[= ]
GPG-sign מתחייב. הארגומנט keyid הוא אופציונלי וברירת המחדל הוא ה-committer
זהות; אם צוין, זה חייב להיות דבוק לאפשרות ללא רווח.

-ש, -שקט
תהיה בשקט. מרמז על --no-stat.

-v, --מלל
היו מילוליים. מרמז על --סטט.

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

-n, --לא-סטט
אל תציג diffstat כחלק מתהליך ה-rebase.

--לא-אמת
אפשרות זו עוקפת את ה-pre-rebase וו. ראה גם githooks(5).

--תאשר
מאפשר ל-Pre-rebase Hook לפעול, שזו ברירת המחדל. ניתן להשתמש באפשרות זו
לעקוף --לא-אימות. ראה גם githooks(5).

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

-f, --force-rebase
כפה בסיס מחדש גם אם הענף הנוכחי מעודכן והפקודה בלי
--הכוח יחזור מבלי לעשות דבר.

ייתכן שתמצא את זה (או --no-ff עם בסיס מחדש אינטראקטיבי) מועיל לאחר החזרת א
מיזוג ענף נושא, שכן אפשרות זו יוצרת מחדש את ענף הנושא עם התחייבויות חדשות כך שהוא
ניתן להרכיב מחדש בהצלחה ללא צורך "להחזיר את החזרה" (ראה את
revert-a-faulty-merge How-To[1] לפרטים).

--fork-point, --no-fork-point
השתמש ב-relog כדי למצוא אב קדמון משותף טוב יותר ביניהם ו מתי
חישוב על ידי אילו commits הוכנסו .

כאשר --fork-point פעילה, fork_point ישמש במקום ל
חשב את קבוצת ההתחייבויות ל-rebase, איפה fork_point הוא תוצאה של git
merge-base --fork-point פקודה (ראה git-merge-base(1)). אם
fork_point בסופו של דבר ריק, ה ישמש כחלופה.

או זה או זה או --root נתון בשורת הפקודה, ואז ברירת המחדל היא
--no-fork-point, אחרת ברירת המחדל היא --fork-point.

--התעלם מרווח לבן, --רווח לבן=
הדגלים הללו מועברים ל- סילון להגיש מועמדות תוכנית (ראה git-apply(1)) המחיל את
תיקון. לא תואם לאפשרות --אינטראקטיבית.

--committer-date-is-author-date, --ignore-date
דגלים אלה מועברים ל סילון am כדי לשנות בקלות את תאריכי ההתחייבויות המבוטלות מחדש
(ראה git-am(1)). לא תואם לאפשרות --אינטראקטיבית.

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

ניתן לשנות את פורמט רשימת ההתחייבויות על ידי הגדרת אפשרות התצורה
rebase.instructionFormat. פורמט הוראות מותאם אישית יכלול אוטומטית את
long commit hash שהוצב לפני הפורמט.

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

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

-איקס , --exec
הוסף את "exec לאחר כל שורה יצירת commit בהיסטוריה הסופית. רָצוֹן
להתפרש כפקודה של מעטפת אחת או יותר.

ניתן להשתמש באפשרות זו רק עם האפשרות --interactive (ראה מצב אינטראקטיבי
להלן).

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

git rebase -i --exec "cmd1 && cmd2 && ..."

או על ידי מתן יותר מ--exec אחד:

git rebase -i --exec "cmd1" --exec "cmd2" --exec ...

אם נעשה שימוש ב--autosquash, שורות "exec" לא יצורפו עבור הביניים
מתחייב, ויופיע רק בסוף כל סדרת סקווש/תיקון.

--שורש
בסיס מחדש את כל ההתחייבויות שניתן להגיע מ , במקום להגביל אותם עם an
. זה מאפשר לך לבסס מחדש את ה-root commit(s) על ענף. בשימוש עם
--עליו, הוא ידלג על שינויים שכבר נכללו ב (במקום )
ואילו ללא --על זה יפעל בכל שינוי. בשימוש יחד עם שניהם
--על ו --שמר-מתמזג, את כל התחייבויות שורש ישכתבו כך שיהיו כפי ש
הורה במקום.

--autosquash, --לא-אוטוסקוש
כאשר הודעת יומן ההתחייבות מתחילה ב"סקווש! ..." (או "תיקון! ..."), ויש
commit שהכותרת שלו מתחילה באותו ..., שנה אוטומטית את רשימת המשימות של
rebase -i כך שה-commit המסומן למעיכה מגיע מיד אחרי ה-commit להיות
שונה, ושנה את הפעולה של ה-commit שהועבר מבחירה לסקווש (או תיקון).
מתעלם מ"תיקון!" או "סקווש!" לאחר הראשון, למקרה שהפנית לאחד
תיקון/סקווש מוקדם יותר עם git commit --fixup/--squash.

אפשרות זו תקפה רק כאשר --אינטראקטיבי נעשה שימוש באופציה.

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

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

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

ללא --אינטראקטיבי, זוהי מילה נרדפת ל --force-rebase.

ייתכן שתמצא את זה מועיל לאחר החזרת מיזוג ענפי נושא, כאפשרות זו
יוצר מחדש את ענף הנושא עם התחייבויות חדשות כדי שניתן יהיה להחזיר אותו בהצלחה
מבלי צורך "להחזיר את החזרה" (ראה את revert-a-faulty-merge How-To[1] עבור
פרטים).

מיזוג אסטרטגיות

מנגנון המיזוג (הפקודות git merge ו-git pull) מאפשר את ה-backend למזג אסטרטגיות
להיבחר עם אפשרות -s. אסטרטגיות מסוימות יכולות גם לקחת אפשרויות משלהן, מה שיכול להיות
עבר במתן -X ארגומנטים ל-git merge ו/או git pull.

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

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

השמיים רקורסיבית האסטרטגיה יכולה לקחת את האפשרויות הבאות:

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

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

שֶׁלָהֶם
זה ההיפך מ לשאת.

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

diff-algorithm=[סבלנות|מינימלית|היסטוגרמה|myers]
אומר מיזוג-רקורסיבי להשתמש באלגוריתם הבדל אחר, שיכול לעזור להימנע
מיזוג שגוי המתרחש עקב קווי התאמה לא חשובים (כגון פלטה מ
פונקציות שונות). ראה גם git-diff(1) ---diff-algorithm.

התעלם-חלל-שינוי, התעלם-כל-חלל, התעלם-חלל-at-eol
מתייחס לקווים עם הסוג המצוין של שינוי רווח לבן כלא השתנה עבור
לשם מיזוג משולש. שינויים ברווח לבן מעורבב עם שינויים אחרים בקו
לא מתעלמים. ראה גם git-diff(1) -b, -w, ו--ignore-space-at-eol.

· אם שֶׁלָהֶם הגרסה מציגה רק שינויים במרחב הלבן בשורה, שלנו גרסה
בשימוש;

· אם שלנו הגרסה מציגה שינויים במרחב הלבן אבל שֶׁלָהֶם הגרסה כוללת א
שינוי מהותי, שֶׁלָהֶם נעשה שימוש בגרסה;

· אחרת, המיזוג ממשיך בדרך הרגילה.

לנרמל מחדש
זה מפעיל צ'ק-אאוט וצ'ק-אין וירטואלי של כל שלושת השלבים של קובץ כאשר
פתרון מיזוג תלת כיווני. אפשרות זו מיועדת לשימוש בעת מיזוג סניפים
עם מסננים נקיים שונים או כללי נורמליזציה של סוף קו. ראה "מיזוג
סניפים עם תכונות צ'ק-אין/צ'ק-אאוט שונות" ב תכונות גיטרה(5) עבור
פרטים.

ללא נורמליזציה
משבית את אפשרות ה-renormalize. זה עוקף את ה-merge.renormalize
משתנה תצורה.

rename-threshold=
שולט בסף הדמיון המשמש לזיהוי שינוי שם. ראה גם git-diff(1)
-M.

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

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

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

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

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

אורים

אתה צריך להבין את ההשלכות של השימוש סילון השבה מחדש במאגר שאתה משתף.
ראה גם התאוששות מ-UPSTREAM REBASE להלן.

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

עם השלמה, יהיה הסניף הנוכחי.

אינטראקטיבי MODE

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

המצב האינטראקטיבי מיועד לסוג זה של זרימת עבודה:

1. יש רעיון נפלא

2. לפרוץ לקוד

3. להכין סדרה להגשה

4. להגיש

כאשר נקודה 2. מורכבת ממספר מקרים של

א) שימוש קבוע

1. לסיים משהו ראוי להתחייבות

2. להתחייב

ב) תיקון עצמאי

1. להבין שמשהו לא עובד

2. לתקן את זה

3. לבצע את זה

לפעמים הדבר תוקן ב-b.2. לא ניתן לתקן את התחייבותו הלא ממש מושלמת
תיקונים, כי ההתחייבות הזו קבורה עמוק בסדרת תיקונים. זה בדיוק מה
בסיס מחדש אינטראקטיבי מיועד ל: השתמש בו אחרי הרבה "a" ו-"b" על ידי סידור מחדש ו
עריכת התחייבויות, ומחיצת התחייבויות מרובות לאחד.

התחל עם ההתחייבות האחרונה שברצונך לשמור כפי שהיא:

git rebase -i

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

pick deadbee הקו האחד של ההתחייבות הזו
pick fa1afe1 השורה האחת של ה-commit הבא
...

התיאורים האחדים הם אך ורק להנאתך; סילון השבה מחדש לא יסתכל עליהם
אבל בשמות ה-commit ("deadbee" ו-"fa1afe1" בדוגמה זו), אז אל תמחק או
לערוך את השמות.

על ידי החלפת הפקודה "בחר" בפקודה "ערוך", אתה יכול לדעת סילון השבה מחדש להפסיק
לאחר החלת ה-commit הזה, כדי שתוכל לערוך את הקבצים ו/או את הודעת ה-commit,
לתקן את ההתחייבות ולהמשיך בבסיס מחדש.

אם אתה רק רוצה לערוך את הודעת ה-commit עבור commit, החלף את הפקודה "pick" ב
הפקודה "ניסוח מחדש".

כדי לבטל commit, החלף את הפקודה "בחר" ב"דרופ", או פשוט מחק את ההתאמה
קו.

אם אתה רוצה לקפל שניים או יותר מחויבות לאחד, החלף את הפקודה "בחר" עבור
השני ואחריו מתחייבים עם "סקווש" או "תיקון". אם ההתחייבויות היו שונות
מחברים, ה-commit המקופל ייוחס למחבר ה-commit הראשון. ה
הודעת ה-commit המוצעת עבור ה-commit המקופלת היא שרשור הודעות ה-commit
של ה-commit הראשון ושל בעלי הפקודה "סקווש", אבל משמיט את הודעות ה-commit
של commits עם הפקודה "fixup".

סילון השבה מחדש יפסיק כאשר "בחר" הוחלף ב"ערוך" או כאשר פקודה נכשלת עקב
למזג שגיאות. לאחר שתסיים לערוך ו/או לפתור התנגשויות תוכל להמשיך
עם git rebase --continue.

לדוגמה, אם אתה רוצה לסדר מחדש את 5 ההתקשרויות האחרונות, כך שמה שהיה HEAD~4 יהפוך
ה-HEAD החדש. כדי להשיג זאת, היית מתקשר סילון השבה מחדש ככה:

$ git rebase -i HEAD~5

ולהעביר את התיקון הראשון לסוף הרשימה.

אולי תרצה לשמר מיזוגים, אם יש לך היסטוריה כזו:

X
\
א---מ---ב
/
---o---O---P---Q

נניח שאתה רוצה לשנות את הבסיס של הענף הצדדי החל מ-"A" ל-"Q". ודא כי
HEAD הנוכחי הוא "B", והתקשר

$ git rebase -i -p --onto QO

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

בחר deadbee יישום תכונה XXX
תיקון f1a5c00 תקן לתכונה XXX
ביצוע המנהלים
pick c0ffeee השורה האחת של ה-commit הבא
edit deadbab השורה האחת של ה-commit לאחר
exec cd subdir; לעשות מבחן
...

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

הפקודה "exec" מפעילה את הפקודה במעטפת (זו שצוינה ב-$SHELL, או ב-
מעטפת ברירת מחדל אם $SHELL אינו מוגדר), כך שתוכל להשתמש בתכונות מעטפת (כמו "cd", ">", ";"
...). הפקודה מופעלת מהשורש של עץ העבודה.

$ git rebase -i --exec "עשה בדיקה"

פקודה זו מאפשרת לך לבדוק ש-commits ביניים ניתנים להידור. רשימת המשימות
הופך להיות כזה:

בחר 5928aea one
exec make test
בחר 04d0fda שני
exec make test
בחר ba46169 שלוש
exec make test
בחר f4593f9 ארבע
exec make test

פְּצִיחָה מתחייב

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

· התחל rebase אינטראקטיבי עם git rebase -i ^, איפה היא ההתחייבות
אתה רוצה לפצל. למעשה, כל טווח מחויבות יתאים, כל עוד הוא מכיל את זה
לְבַצֵעַ.

· סמן את ה-commit שברצונך לפצל בפעולת "עריכה".

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

· כעת הוסף את השינויים לאינדקס שאתה רוצה שיהיו ב-commit הראשון. אתה יכול
השתמש ב-git add (אולי באופן אינטראקטיבי) או סילון GUI (או שניהם) לעשות זאת.

· הגדר את המדד הנוכחי עם כל הודעת התחייבות המתאימה כעת.

· חזור על שני השלבים האחרונים עד שעץ העבודה שלך נקי.

· המשך את ה-rebase עם git rebase --continue.

אם אינך בטוח לחלוטין שתיקוני הביניים עקביים (הם
הידור, לעבור את ה-testsuite וכו') אתה צריך להשתמש סילון סְלִיק להחביא את
שינויים שעדיין לא בוצעו לאחר כל התחייבות, בדיקה ותיקון התחייבות אם יש תיקונים
נחוץ.

מתאושש מן בְּמַעֲלֶה הַזֶרֶם REBASE

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

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

o---o---o---o---o---o---o---o---o master
\
o---o---o---o---o תת מערכת
\
*---*---* נושא

If תת מערכת מבוסס מחדש נגד אב, קורה הדבר הבא:

o---o---o---o---o---o---o---o master
\ \
o---o---o---o---o o'--o'--o'--o'--o' תת מערכת
\
*---*---* נושא

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

o---o---o---o---o---o---o---o master
\ \
o---o---o---o---o o'--o'--o'--o'--o'--M תת מערכת
\/
*---*---*-..........-*--* נושא

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

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

מקרה קל: השינויים ממש זהים.
זה קורה אם תת מערכת rebase היה rebase פשוט ולא היו לו התנגשויות.

מקרה קשה: השינויים אינם זהים.
זה קורה אם תת מערכת ל-rebase היו התנגשויות, או השתמשו ב--interactive כדי להשמיט,
התחייבויות עריכה, סקוואש או תיקון; או אם במעלה הזרם השתמש באחת של commit --לתקן, לאפס,
או סניף מסנן.

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

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

$ git rebase subsystem

אתה תסיים עם ההיסטוריה המתוקנת

o---o---o---o---o---o---o---o master
\
תת-מערכת o'--o'--o'--o'--o'
\
*---*---* נושא

השמיים קָשֶׁה מקרה
הדברים מסתבכים יותר אם תת מערכת השינויים לא בדיוק תואמים את אלה
לפני הבסיס מחדש.

הערות
בעוד ש"התאוששות קלה" לפעמים נראה מוצלח גם במצבים הקשים
במקרה, עשויות להיות לכך השלכות לא מכוונות. לדוגמה, commit שהוסרה באמצעות
git rebase --interactive יהיה קם לתחייה!

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

· עם ה תת מערכת reflog: לאחר סילון לְהָבִיא, הקצה הישן של תת מערכת ישבתי
subsystem@{1}. השליפות הבאות יגדילו את המספר. (לִרְאוֹת git-reflog(1).)

· יחסית לקצה של נושא: לדעת שאת נושא יש שלושה commits, הטיפ הישן
of תת מערכת חייב להיות נושא~3.

לאחר מכן תוכל להשתיל את תת המערכת הישנה..נושא לטיפ החדש על ידי אמירת (עבור ה-relog
מקרה, ובהנחה שאתה על נושא כְּבָר):

$ git rebase --onto subsystem subsystem@{1}

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

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