git-read-tree - אונליין בענן

תָכְנִית:

שֵׁם

git-read-tree - קורא מידע מהעץ לתוך האינדקס

תַקצִיר

סילון עץ קריאה [[-m [--טריוויאלי] [--אגרסיבי] | --איפוס | --קידומת= ]
[-u [--הדרה-לכל-ספרייה= ] | -י]]
[--פלט-אינדקס= ] [--ללא-קופה-דלילה]
(--ריק | [ [ ]])

תיאור

קורא את מידע העץ שניתן על ידי לתוך האינדקס, אבל לא באמת
עדכון כל אחד מהקבצים שהוא "מאחסן במטמון". (ראה: git-checkout-index(1))

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

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

אפשרויות

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

--אִתחוּל
זהה ל- -m, פרט לכך שרשומות שלא ממוזגות נמחקות במקום להיכשל.

-u
לאחר מיזוג מוצלח, עדכן את הקבצים בעץ העבודה עם תוצאת ה-
לְמַזֵג.

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

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

-v
הצג את התקדמות הוצאת הקבצים.

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

--תוֹקפָּנִי
בדרך כלל מיזוג משולש על ידי סילון עץ קריאה פותר את המיזוג עבור מקרים טריוויאליים באמת
ומשאיר מקרים אחרים לא פתורים באינדקס, כך שפורצלנים יוכלו ליישם
מדיניות מיזוג שונות. דגל זה גורם לפקודה לפתור עוד כמה מקרים
כְּלַפֵּי פְּנִים:

כאשר צד אחד מסיר נתיב והצד השני משאיר את הנתיב ללא שינוי.
הפתרון הוא להסיר את הנתיב הזה.

כאשר שני הצדדים מסירים נתיב. הפתרון הוא להסיר את הנתיב הזה.

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

--קידומת= /
שמור את תוכן האינדקס הנוכחי, וקרא את תוכן העץ בעל השם תחת ה-
ספרייה ב הפקודה תסרב לדרוס ערכים שכבר
היה קיים בקובץ האינדקס המקורי. שימו לב ש- / ערך חייב להסתיים ב-
לַחתוֹך.

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

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

--קופה ללא דלילה
השבת תמיכה בקופה דלילה גם אם core.sparseCheckout הוא true.

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


המזהה של אובייקט/י העץ שיש לקרוא/למזג.

מיזוג

אם מצוין -m, סילון עץ קריאה יכול לבצע 3 סוגים של מיזוג, מיזוג עץ יחיד אם
ניתן רק עץ אחד, מיזוג מהיר עם 1 עצים, או מיזוג תלת-כיווני אם יש 2 עצים
בתנאי.

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

זה אומר שאם אתה מבצע git read-tree -m ואחריו git checkout-index -f
-u -a, ה- סילון אינדקס קופה בודק רק את הדברים שבאמת השתנו.

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

שני עֵץ למזג
בדרך כלל, פעולה זו מופעלת כ- git read-tree -m $H $M, כאשר $H הוא ה- head commit של ה-
המאגר הנוכחי, ו-$M הוא ראש של עץ זר, שנמצא פשוט לפני $H
(כלומר, אנחנו נמצאים במצב של התקפה מהירה).

כאשר מצוינים שני עצים, המשתמש אומר סילון עץ קריאה הבא:

1. האינדקס ועץ העבודה הנוכחיים נגזרים מ-$H, אך ייתכן שלמשתמש יש פונקציות מקומיות
שינויים בהם מאז $H.

2. המשתמש רוצה להריץ קדימה ל-$M.

במקרה זה, הפקודה git read-tree -m $H $M מוודאת שלא יאבד שינוי מקומי.
כתוצאה מ"מיזוג" זה. להלן כללי ה"העברה קדימה", כאשר "I" מציין את
אינדקס, "נקי" פירושו שהאינדקס ועץ העבודה חופפים, ו"קיים"/"כלום" מתייחסים ל
נוכחות של נתיב ב-commit שצוין:

תוצאה של IHM
-------------------------------------------------- -----
0 כלום כלום כלום (לא קורה)
1 כלום כלום לא קיים השתמש ב-M
2 שום דבר לא קיים שום דבר הסר נתיב מהאינדקס
3 כלום לא קיים קיים, השתמש ב-M אם "קופה ראשונית",
H == M שמור את האינדקס אחרת
קיים, נכשל
H != M

נקי I=HI==M
------------------
4 כן לא רלוונטי כלום כלום שמור אינדקס
5 לא N/AN/A כלום כלום שמור אינדקס

6 כן לא רלוונטי כן שום דבר לא קיים שמור אינדקס
7 לא לא רלוונטי כן שום דבר לא קיים שמור אינדקס
8 כן לא רלוונטי לא כלום קיים נכשל
9 לא לא רלוונטי לא כלום קיים נכשל

10 כן כן לא רלוונטי קיים כלום הסר נתיב מהאינדקס
11 לא כן לא רלוונטי קיים כלום נכשל
12 כן לא לא רלוונטי קיים כלום נכשל
13 לא לא לא רלוונטי קיים כלום נכשל

נקי (H==M)
------
14 כן קיים קיים שמור אינדקס
15 לא קיים קיים שמור אינדקס

נקי I=HI==M (H!=M)
------------------
16 כן לא לא קיים קיים נכשל
17 לא לא לא קיים קיים נכשל
18 כן לא כן קיים קיים שמור אינדקס
19 לא לא כן קיים קיים שמור אינדקס
20 כן כן לא קיים קיים השתמש ב-M
21 לא כן לא קיים קיים נכשל

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

כאשר צורה זו של סילון עץ קריאה חוזר בהצלחה, אתה יכול לראות איזה מה"מקומיים"
שינויים" שביצעת הועברו הלאה על ידי הרצת git diff-index --cached $M. הערה
שזה לא בהכרח תואם את מה ש-git diff-index --cached $H היה מייצר
לפני מיזוג כזה של שני עצים. זה בגלל מקרים 18 ו-19 --- אם כבר היה לך
השינויים ב-$M (למשל, אולי קיבלת את זה בדוא"ל בטופס תיקון), git diff-index
--cached $H היה מודיע לך על השינוי לפני המיזוג הזה, אבל זה לא היה מוצג
בפלט של $M ב-git diff-index --cached לאחר מיזוג שני העצים.

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

3-Way למזג
לכל ערך "אינדקס" יש שני סיביות של מצב "שלב". שלב 0 הוא הרגיל, והוא
היחיד שתראו בשימוש רגיל כלשהו.

עם זאת, כאשר אתה עושה סילון עץ קריאה עם שלושה עצים, ה"שלב" מתחיל ב-1.

זה אומר שאתה יכול לעשות

$ git read-tree -m

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

יתר על כן, סילון עץ קריאה יש לוגיקת מקרה מיוחד שאומרת: אם אתה רואה קובץ ש
תואם בכל המובנים במצבים הבאים, הוא "קורס" חזרה ל"שלב 0":

· שלב 2 ו-3 זהים; קחו אחד מהם או את השני (אין הבדל - אותו הדבר)
נעשתה עבודה על הסניף שלנו בשלב 2 ועל הסניף שלהם בשלב 3)

· שלב 1 ושלב 2 זהים ושלב 3 שונה; קחו את שלב 3 (הסניף שלנו ב
שלב 2 לא עשה דבר מאז האב הקדמון בשלב 1 בעוד הענף שלהם בשלב
3 עבדו על זה)

· שלב 1 ושלב 3 זהים ושלב 2 שונה, קחו את שלב 2 (עשינו זאת)
משהו בזמן שהם לא עשו כלום)

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

אוקיי, כל זה נשמע כמו אוסף של חוקים חסרי היגיון לחלוטין, אבל זה בעצם...
בדיוק מה שאתה רוצה כדי לבצע מיזוג מהיר. השלבים השונים מייצגים את
"עץ התוצאות" (שלב 0, המכונה "מאוחד"), העץ המקורי (שלב 1, המכונה "מקורי"), וה-
שני עצים שאתם מנסים למזג (שלב 2 ו-3 בהתאמה).

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

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

· קובץ שיש בו כל ההבדל שיהיה בין שלושת העצים יישאר נפרד
ערכים באינדקס. "מדיניות הפורצלן" היא זו שקובעת כיצד להסיר את
שלבים שאינם 0, והכנס גרסה ממוזגת.

· קובץ האינדקס נשמר ומשוחזר עם כל המידע הזה, כך שתוכל למזג דברים
באופן הדרגתי, אך כל עוד יש בו ערכים בשלבים 1/2/3 (כלומר, "לא ממוזג"
"רשומות") אינך יכול לכתוב את התוצאה. אז עכשיו אלגוריתם המיזוג הופך להיות באמת
הפש you

· אתה עובר על האינדקס לפי הסדר, ומתעלם מכל הערכים של שלב 0, מכיוון שהם
כבר נעשה.

· אם תמצאו "שלב 1", אך לא "שלב 2" או "שלב 3" תואמים, אתם יודעים שזה היה
הוסר משני העצים (הוא היה קיים רק בעץ המקורי), ואתה מסיר
הערך הזה.

אם תמצא עץ תואם של "שלב 2" ו"שלב 3", תסיר אחד מהם, ו
הפוך את השני לערך "stage0". הסר כל ערך "stage1" תואם אם הוא
קיים גם... כל הכללים הטריוויאליים הרגילים...

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

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

זה נעשה כדי למנוע ממך לאבד את השינויים שלך בעבודה בתהליך ולערבב את
שינויים אקראיים ב-commit מיזוג לא קשור. לשם המחשה, נניח שאתה מתחיל ממה
הועבר לאחרונה למאגר שלך:

$ JC=`git rev-parse --אמת "HEAD^0"`
$ git checkout-index -f -u -a $JC

אתה מבצע עריכות אקראיות, בלי להריץ סילון עדכון-אינדקסואז אתה שם לב שקצה של
העץ "במעלה הזרם" שלך התקדם מאז שסגרת ממנו:

$ git fetch git://.... לינוס
$ LT=`git rev-parse FETCH_HEAD`

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

$ git read-tree -m -u `git merge-base $JC $LT` $JC $LT
$ git merge-index git-merge-one-file -a
$ echo "מיזוג עם ליינוס" | \
עץ commit של git `עץ כתיבה של git` -p $JC -p $LT

מה שהיית מבצע הוא מיזוג טהור בין $JC ו-$LT ללא העבודה בתהליך שלך
שינויים, ועץ העבודה שלך יעודכן לתוצאת המיזוג.

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

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

דליל CHECKOUT

""Sparse checkout"" מאפשר אכלוס דליל של ספריית העבודה. הוא משתמש ב-
ביט לדלג על עץ העבודה (ראה אינדקס עדכון גיט(1)) כדי להודיע ​​ל-Git האם קובץ נמצא במערכת העבודה
שווה להסתכל על הספרייה.

סילון עץ קריאה ופקודות אחרות מבוססות מיזוג (סילון למזג, סילון לתשלום...) יכול לעזור
שמירה על עדכון מפת הסיביות וספריית העבודה של skip-worktree.
‏$GIT_DIR/info/sparse-checkout משמש להגדרת מפת הסיביות של עץ העבודה של skip-worktree. כאשר
סילון עץ קריאה צריך לעדכן את ספריית העבודה, זה מאפס את הסיבית skip-worktree ב
האינדקס המבוסס על קובץ זה, המשתמש באותו תחביר כמו קבצי .gitignore. אם ערך
תואם לתבנית בקובץ זה, skip-worktree לא יוגדר על ערך זה. אחרת,
skip-worktree יוגדר.

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

בעוד ש-$GIT_DIR/info/sparse-checkout משמש בדרך כלל כדי לציין אילו קבצים נמצאים בתוכו, ניתן
וגם לציין אילו קבצים הם לֹא בתוך, באמצעות תבניות שלילה. לדוגמה, כדי להסיר את הקובץ
לא רצוי:

/*
לא רצוי

דבר נוסף שמאתגר אתכם הוא אכלוס מחדש של ספריית העבודה כשאתם כבר לא רוצים
קופה דלילה. אי אפשר פשוט להשבית את "קופה דלילה" מכיוון שסיביות של "skip-worktree" הן
עדיין באינדקס וספריית העבודה שלך עדיין מאוכלסת בדלילות. עליך
מלא מחדש את ספריית העבודה עם תוכן הקובץ $GIT_DIR/info/sparse-checkout כ-
התעופה

/*

לאחר מכן ניתן להשבית את קופה דלילה. תמיכה בקופה דלילה ב סילון עץ קריאה וכדומה
הפקודות מושבתות כברירת מחדל. עליך להפעיל את core.sparseCheckout כדי שיהיה לך
תמיכה דלילה בקופה.

השתמש ב-git-read-tree באופן מקוון באמצעות שירותי onworks.net