Git Reflog: הבנת ושימוש ביומן ההפניות ב-Git

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

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

מהו git reflog?

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

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

מתי נוצרות רשומות reflog?

נכנסים הזנים נוצרים בכל פעולה שמשנה את מצב ה-HEAD או ההפניית הענפית. סצינריואים נפוצים כוללים את הבאים:

• ביצוע שינויים באמצעות git commit.

• החלפת ענף שונה באמצעות git checkout branch_name.

• יצירת ענף חדש באמצעות git branch new_branch.

• Rebasing git rebase

• איפוס להתחילה לקודמת git reset --hard.

• מיזוג ענפים באמצעות git merge.

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

git reflog

שימוש ב-git reflog כדי לעקוב אחרי עדכונים במאגר המקומי. תמונה מאת המחבר.

איך אתה מפרש את הפלט של git reflog?

אתה יכול לפרש את הפלט כך:

• HEAD@{0}: הפעולה האחרונה הייתה המעבר לסניף HEAD.

• HEAD@{1}: לפני כן, שיניתי את סוג הקובץ מ־.xlxs לתבנית .csv.

• HEAD@{2}: ביצעתי את הקומיט הראשון בעת דחיפת הקבצים למאגר.

כל רשומה מציגה:

• ה־commit hash (fa82776)

• אינדקס ה-reflog (HEAD@{0}, HEAD@{1} וכו')

• תיאור של הפעולה שננקטה (התחייבות, בדיקה, rebasing)

איך להשתמש ב-git reflog

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

פקודת reflog בסיסית של git

להלן הפקודה הבסיסית של reflog:

git reflog

הפקודה למעלה מציגה רשימה של פעולות אחרונות שעידכנו את HEAD או הפניות של הענפים, כולל קומיטים, החלפות ענפים, איפוסים, rebases ועוד. כל רשומה ממוספרת, כגון HEAD@{0} ו-HEAD@{1}, כדי לייצג את מקומה בהיסטוריית reflog.

הפניה למצבים קודמים

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

HEAD@{n}: מתייחס לפריט reflog ספציפי, כאשר n הוא האינדקס. לדוגמה, HEAD@{2} מתייחס למצב השלישי הכי עדכני של HEAD.

git checkout HEAD@{2}

שימוש ב-git checkout כדי לעקוב אחרי שינויים קודמים. תמונה מאת המחבר.

branch@{time}: מתייחס למצב של סניף בזמן ספציפי. לדוגמה, main@{1.week.ago} מתייחס למצב של הסניף הראשי לפני שבוע, בעוד שfeature@{yesterday} מתייחס למצב של סניף הפיצ'רים אתמול.

git checkout main@{1.week.ago}

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

מאפייני זמן

git reflog לא רק עוזר לנו לשחזר מצבים קודמים אלא גם מאפשר לנו להשוות ביניהם. מכיוון שreflog עוקב אחרי עדכוני הפניות, אנו יכולים להשתמש בו כדי לראות כיצד המאגר שלנו השתנה עם הזמן. עכשיו, נסתכל כיצד git diff עושה שימוש בנכ entries reflog כדי להשוות בין מצבים קודמים להווה.

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

git checkout HEAD@{1.minute.ago}     # מצב לפני דקה אחת

git checkout HEAD@{1.hour.ago}       # מצב לפני שעה אחת

git checkout HEAD@{1.week.ago}       # מצב לפני שבוע אחת

git checkout HEAD@{yesterday}        # מצב מהאתמול

git checkout HEAD@{2024-01-01.12:00:00} # מצב בנקודת זמן מסוימת

השוואת מצבים קודמים עם git diff

אתה יכול להשוות מצבים קודמים באמצעות פקודות כמו git diff. הפקודה הבאה משווה את המצב הנוכחי של הענף הראשי main@{0} עם המצב שלו לפני יום אחד, main@{1.day.ago}. הפלט יראה כל שינוי בין שתי התמונות הללו.

git diff main@{0} main@{1.day.ago}

השוואת מצבים קודמים עם git diff. תמונה מאת המחבר.

שימושים נפוצים ב-Git Reflog

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

ביטול reset לא טוב

אם בטעות ביצעת reset לענף שלך באמצעות git reset --hard, תוכל להשתמש ב-reflog כדי לשחזר את מצבך הקודם.

git reset --hard HEAD@{3}

שחזור קבוצות אבודות

אם נמחקה סניפה בטעות או אם אבדו קבוצות עקב איפוס או rebase, ניתן למצוא את הקומיט האבוד באמצעות git reflog.

git reflog

איתור גיבוב הקומיט מתוצאות ה-reflog וביצוע checkout:

git checkout <commit-hash>

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

git branch recovered-branch <commit-hash>

תיקון rebase פגום

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

git reset --hard HEAD@{3}  # התאם את המספר בהתאם לפלט של reflog

שחזור ענף שנמחק

אם נמחק לך ענף בטעות, ניתן לשחזר אותו בעזרת git reflog. מצא את הקומיט האחרון שנודע עבור הענף שנמחק ובנה אותו מחדש:

git branch restored-branch <commit-hash>

מעקב אחר היסטוריית ה- stash

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

git reflog stash

כדי להחיל רשומה קודמת מהמאגר, השתמש בצו הבא:

git stash apply stash@{2}

עיין במדריך שלנו Git Pull Force: כיצד לדרוס סעיף מקומי עם מרוחק כדי ללמוד את הפרקטיקות הטובות ביותר לדריסת שינויים מקומיים.

תתי פקודות ואופציות של Git Reflog

Git מספק מספר תתי פקודות ואופציות לניהול ואינטראקציה עם reflogs.

תתי פקודות של Git reflog

להלן פירוט מסודר של תתי הפקודות העיקריות git reflog והשימוש שלהן.

git reflog show: מציג את רשומות ה-reflog עבור HEAD כברירת מחדל או עבור הפנייה ספציפית כמו סעיף.

git reflog show

שימוש ב- git reflog show כדי להציג רשומות עבור ההתייחסות המצוינת. תמונה מאת הכותב.

git reflog list: פקודה זו מציגה את כל ההתייחסויות עם reflog. זה מועיל לזיהוי ענפים והתייחסויות HEAD עם רשומות reflog שמאוחסנות.

git reflog list

git reflog delete <ref>@{<specifier>}: מנקה רשומות reflog ישנות שחורגות מהגבול הזמן המצוין. לדוגמה, הפקודה הבאה מסירה רשומות מגילם של 30 ימים.

git reflog expire --expire=30.days.ago

git reflog delete <ref>@{<specifier>}: מוחק רשומת reflog מסוימת על סמך ההתייחסות והמיקום שלה. הפקודה להלן מסירה את רשומת ה-reflog באינדקס 2 עבור HEAD.

git reflog delete HEAD@{2}

git reflog קיים <ref>: מאמת האם יש reflog עבור פנימה מסוימת. לדוגמה, הפקודה למטה מחזירה הצלחה אם לסניף הראשי יש reflog.

git reflog exists main

אפשרויות עבור פקודות משנה של git reflog

הנה האפשרויות הזמינות עבור פקודות המשנה של git reflog ושימושן.

--expire-unreachable=<זמן>: מנקה רק את רשומות ה-reflog שאינן נגישות מכל פנימה. לדוגמה, הפקודה למטה מסירה רשומות reflog שאינן נגישות יותר מ-7 ימים.

git reflog expire --expire-unreachable=7.days.ago

--all: מעבד reflogs עבור כל הפניות, ולא רק HEAD. הפקודה למטה מנקה את כל רשומות ה-reflog הישנות מ-60 ימים בסניפים הכוללים.

git reflog expire --expire=60.days.ago --all

--dry-run: מדמה ביצוע פקודה, מראה מה יימחק מבלי למחוק שום דבר בפועל. לדוגמה, הפקודה למטה מציגה אילו פריטים יוסרו.

git reflog expire --expire=30.days.ago --dry-run

--verbose: מספקת פלט מפורט על הפעולות שביצעה הפקודה. הפקודה למטה מציגה פרטים מפורטים בזמן שתוקפים רשומות reflog ישנות.

git reflog expire --expire=90.days.ago --verbose

Git Reflog מול Git Log: הבדלים מרכזיים

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

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

• git reflog מרשום עדכונים לכתובות כמו HEAD, ענפים ו-stashes, כולל פעולות כמו החלפות ענפים, איפוסים, rebases ועוד. זה מעקב אחר שינויים שעשויים שלא להיות חלק מהשושלת של ה-commit.

• git reflog הוא מקומי בצורה מוחלטת על המחשב שלך ואינו משותף עם מאגרים מרוחקים.

• בעוד git log לא יכול לשחזר קומיטים שכבר אינם חלק מהזנבות של הענף, git reflog יכולה לעזור לשחזר קומיטים "אבודים" על ידי מעקב אחר עדכוני ההפניה, גם אם אלה הקומיטים כבר לא נגישים מכל ענף.

הטבלה למטה מסכמת את ההבדלים המרכזיים הללו.

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

• השתמשו ב-Reflog לשחזור ודיבוג: אם בטעות reset או rebased סניף בצורה לא נכונה, בדקו את git reflog כדי למצוא הפניה קודמת ולשחזר אותה.

• היה זהיר עם git reset --hard: git reset --hard עשוי להסיר לצמיתות שינויים שלא נשמרו. תמיד יש לבדוק את ה־reflog תחילה על מנת לוודא שניתן לשחזר אם משהו הולך לאיבוד.

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

• אל תסתמך באופן בלעדי על Reflog לשחזור ארוך טווח:כברירת מחדל, רשומות ה-reflog שמורות למשך 90 ימים. לאחר תקופה זו, ייעשה איסוף אשפה ויתכן שהן יהיו בלתי משיבות. יש לשלוח באופן קבוע את ה-commitים שלך לריפוזיטורי רחוק כדי להבטיח את שמירתם מעבר ל-reflog המקומי שלך.

• השתמש ב־git reflog expire כדי לנהל רשומות ישנות: אם רשומות ה-reflog של המאגר שלך מתמלאות, ניתן לזקק רשומות ישנות או לא נגישות באמצעות git reflog expire.

סיכום

ניהול יעיל של היסטוריית פרויקט ב-Git דורש יותר מפקודות בסיסיות. חקירה בכלים מתקדמים שמעקבים אחר עדכוני ההפנייה עשויה לספק רשת ביטחון יקרה לשחזור התחייבויות אבודות, שחזור ענפים שנמחקו ותיקון טעויות. רכישת ניסיון ידיים עם כלים אלה, יחד עם פקודות כמו git reset, git checkout, ו־git revert, עשויה לשפר באופן משמעותי את הידע והמיומנות שלך בשליטה בגרסאות.

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