הסביר גיט משיכה

סיכום:

Git Pull הוא פקודה נפוצה ב- GIT המשמשת להביא ולמזגת שינויים ממאגר מרוחק למאגר המקומי שלך. זה מעדכן את המאגר המקומי שלך עם השינויים האחרונים מהמאגר המרוחק.

נקודות מפתח:

1. משיכת GIT משלבת את הפקודות של Git Fetch ו- Git לפקודה אחת נוחה.
2. הוא משמש כדי להביא את השינויים האחרונים מהמאגר המרוחק ולמזג אותם עם הסניף המקומי שלך.
3. ניתן להשתמש במשיכת GIT כדי לעדכן סניפים מרובים במאגר המקומי שלך.
4. כשאתה מפעיל משיכה של Git, הוא בודק אם יש שינויים חדשים במאגר המרוחק מאז המשיכה האחרונה שלך או תביא.
5. אם יש שינויים חדשים, הורדות משיכה של GIT ומיישם את השינויים הללו במאגר המקומי שלך.
6. משיכת GIT ממזגת אוטומטית את השינויים עם הסניף המקומי שלך.
7. אם יש קונפליקטים בתהליך המיזוג, עליך לפתור אותם באופן ידני.
8. אתה יכול להשתמש במקור המשיכה Git פקודה לעדכון סניף ספציפי.
9. Git Pull היא פקודה שימושית לשמירה על המאגר המקומי שלך מעודכנת עם המאגר המרוחק.
10. מומלץ להפעיל משיכת GIT באופן קבוע כדי להבטיח שיש לך את השינויים האחרונים.

שאלות:

1. האם Git מושך את כל הענפים?

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

2. איך Git מושך עובד?

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

3. יכול Git למשוך עדכון סניף ספציפי?

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

4. באיזו תדירות עלי להפעיל משיכת git?

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

5. מה קורה אם יש קונפליקטים במהלך משיכת GIT?

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

6. האם אוכל לבטל משיכה?

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

7. יכול לשחוף את השינויים המקומיים?

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

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

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

9. האם אוכל להשתמש ב- Git Pull כדי לעדכן סניפים מרובים?

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

10. האם git מושך אותו כמו Git להביא?

לא, משיכת גיט אינה זהה ל- Git להביא. Git Fetch רק מוריד את השינויים האחרונים מהמאגר המרוחק אך אינו ממזג אותם עם הסניף המקומי שלך. לעומת זאת, משיכת GIT משיגה את השינויים וממזגת אותם עם הענף המקומי שלך.

11. ניתן להשתמש במשיכת GIT כדי לעדכן סניף ממאגר מרוחק אחר?

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

12. האם אוכל להפעיל משיכת GIT מבלי לציין סניף?

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

13. האם אוכל להשתמש ב- Git Pull כדי לעדכן סניף להתחייבות ספציפית?

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

14. כיצד אוכל להימנע מתנגשויות במהלך משיכת GIT?

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

15. יכול Git למשוך קבצים למחוק במאגר המקומי שלי?

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

הסביר גיט משיכה

לָרוּץ סניף גיט שוב ובדוק אם הסניפים קיימים באופן מקומי:

האם Git מושך את כל הענפים

שינויים ב- Git-Pull מדריך ל

1. 2.40.1 אין שינויים
2. 2.40.0 03/12/23
3. 2.36.1 → 2.39.3 אין שינויים
4. 2.36.0 04/18/22
5. 2.35.1 → 2.35.8 אין שינויים
6. 2.35.0 01/24/22
7. 2.34.1 → 2.34.8 אין שינויים
8. 2.34.0 11/15/21
9. 2.33.2 → 2.33.8 אין שינויים
10. 2.33.1 10/12/21
11. 2.33.0 08/16/21
12. 2.32.1 → 2.32.7 אין שינויים
13. 2.32.0 06/06/21
14. 2.31.1 → 2.31.8 אין שינויים
15. 2.31.0 03/15/21
16. 2.30.1 → 2.30.9 אין שינויים
17. 2.30.0 12/27/20
18. 2.29.1 → 2.29.3 אין שינויים
19. 2.29.0 10/19/20
20. 2.27.1 → 2.28.1 אין שינויים
21. 2.27.0 06/01/20
22. 2.25.2 → 2.26.3 אין שינויים
23. 2.25.1 02/17/20
24. 2.25.0 01/13/20

בדוק את הגרסה שלך ל- Git על ידי ריצה

שֵׁם

Git -Pull – להביא ולהשתלב עם מאגר אחר או סניף מקומי

תַקצִיר

משיכה גיט [] [[...]]

תיאור

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

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

צריך להיות שמו של מאגר מרוחק כפי שעבר ל- Git-Fetch [1]. יכול לתת שם לנקוט מרחוק שרירותי (לדוגמה, שם התג) או אפילו אוסף של שופטים עם ענפים מתאימים למעקב מרחוק (ה.ז., REFS/HEADS/*: Refs/Remotes/Origin/*), אך בדרך כלל זה שם של סניף במאגר המרוחק.

ערכי ברירת מחדל עבורם וקוראים מתצורת “מרחוק” ו- “מיזוג” עבור הסניף הנוכחי כפי שנקבע על ידי Git-Sanch [1]-Track .

נניח שההיסטוריה הבאה קיימת והסניף הנוכחי הוא “אדון”:

A --- B --- C אדון על מקור / D --- E --- F --- G מאסטר ^ מקור / אדון במאגר שלך

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

A --- B --- C מקור / מאסטר / \ d --- e --- f --- g --- h מאסטר

ראה Git-Merge [1] לפרטים, כולל כיצד מוצגים ומטופלים קונפליקטים.

בגיט 1.7.0 ואילך, כדי לבטל מיזוג סותר, השתמש ב- Git Reset -MERGE . אַזהָרָה: בגרסאות ישנות יותר של GIT, ריצה משיכה גיט עם שינויים בלתי מחויבים מתייאשים: למרות שהוא אפשרי, הוא משאיר אותך במצב שעשוי להיות קשה לגבות ממנו במקרה של סכסוך.

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

אפשרויות

זה מועבר לשני Git-Fetch הבסיסיים לדיווח על Squelch על במהלך ההעברה, והן בבסיס Git-Merge לתפוקה Squelch במהלך המיזוג.

לעבור-verbose ל- Git-Fetch ו- Git-Merge.

אפשרות זו שולטת אם יש להביא התחייבויות חדשות של תת-מודולות מאוכלסות, ואם יש לעדכן את העצים העובדים של תת-מודולות פעילות (ראה Git-Fetch [1], Git-Config [1] ו- GitModules [5]).

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

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

אפשרויות הקשורות למיזוג

–להתחייב-ללא התחייבות

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

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

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

–עריכה -E -לא עריכה

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

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

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

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

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

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

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

-S []-gpg-sign [=]-no-gpg-sign

GPG-חתום על התחייבות המיזוג המתקבלת. טיעון המפתח הוא אופציונלי וברירות מחדל לזהות הקומטר; אם צוין, זה חייב להיתקע באפשרות ללא שטח. –NO-GPG-SING שימושי להתייחס לשניהם להתחייב.משתנה תצורת GPGSign, ומקדמים יותר-GPG-SING .

בנוסף לשמות הענפים, אכלס את הודעת היומן עם תיאורים של קו אחד מכל היותר התחייבויות בפועל שממזגות. ראו גם Git-FMT-Merge-MSG [1]. שימושי רק בעת מיזוג.

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

–סימן-לא-סימן

הוסף טריילר חתום-על ידי הקומטר בסוף הודעת יומן ההתחייבות. המשמעות של סימן תלויה בפרויקט שאליו אתה’מתחייב מחדש. לדוגמה, היא עשויה לאשר כי למפקח יש את הזכויות להגיש את העבודה במסגרת הפרויקט’S רישיון או מסכים לייצוג תורם כלשהו, ​​כגון תעודת מוצא מפתח. (ראה http: // festercertificate.org עבור זה המשמש את פרויקטים של גרעיני לינוקס ו- Git.) עיין בתיעוד או במנהיגותו של הפרויקט שאליו אתה’תורם מחדש להבנה כיצד משתמשים בסימנים בפרויקט זה.

ניתן להשתמש באפשרות-No-Signoff כדי להתייצב באפשרות קודמת-Signoff בשורת הפקודה.

–STAT -N -NO -STAT

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

עם -n או -לא -סטט לא מראים דיפרסטט בסוף המיזוג.

–דלעת-לא-סקווד

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

עם-לא-סקווש מבצע את המיזוג ומבצע את התוצאה. אפשרות זו יכולה לשמש לבריחת -Squash.

עם -Squash, -התחייבות אסורה, והיא תיכשל.

שימושי רק בעת מיזוג.

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

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

העבירו אפשרות ספציפית לאסטרטגיה לאסטרטגיית המיזוג.

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

שימושי רק בעת מיזוג.

–סיכום-לא-סאמר

מילים נרדפות ל-Stat ו–No-stat; אלה מיושמים ויוסרו בעתיד.

צור אוטומטית כניסה של STASH זמנית לפני תחילת הפעולה, רשמו אותה ב- Special Ref merge_autostash והחלו אותה לאחר סיום הפעולה. המשמעות היא שאתה יכול להריץ את המבצע ב- Worktree מלוכלך. עם זאת, שימוש בטיפול: יישום ה- STASH הסופי לאחר מיזוג מוצלח עלול לגרום לסכסוכים שאינם טריוויאליים.

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

שימושי רק בעת מיזוג.

-R -REBASE [= FALSE | TRUE | מיזוג | אינטראקטיבי]

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

כאשר הוא מוגדר להתמזג, מחדש באמצעות GIT Rebase-Rebase-Merges כך שהמיזוג המקומי מחויב כלול ב- Rebase (ראה Git-Rebase [1] לפרטים).

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

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

ראה משיכה.Rebase, סניף..מחדש וסניף.AutoSetupRebase ב- Git-Config [1] אם אתה רוצה לגרום ל- Git משיכה תמיד להשתמש-REBase במקום להתמזג.

זה שורטורני ל -REBASE = FALSE.

אפשרויות הקשורות להביא

להביא את כל המרחקים.

הוספה שמות שופטים ושמות אובייקטים של שופטים שהובלו לתוכן הקיים של .git/fetch_head . ללא אפשרות זו נתונים ישנים ב .Git/fetch_head יוחלף.

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

הגבל את ההפעלה למספר שצוין של התחייבויות מהקצה של כל היסטוריה של סניף מרוחק. אם משיגים ל רָדוּד מאגר שנוצר על ידי GIT Clone עם — מעמיק = אפשרות (ראה git-clone [1]), העמיק או קצר את ההיסטוריה למספר ההתחייבויות שצוין. תגיות עבור ההתחייבויות המעומקות אינן מבוטלות.

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

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

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

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

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

–רעת עדכון

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

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

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

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

ראו גם את האב.משא ומתן -גוריתם ודחיפה.לנהל משא ומתן על משתני תצורה שתועדו ב- Git-Config [1], ובאפשרות-NecoTiate-Lonly להלן.

–לנהל משא ומתן בלבד

אל תביא שום דבר מהשרת, ובמקום זאת להדפיס את אבותיהם של הוויכוחים המסופקים-Necotiation-tip =*, שיש לנו במשותף לשרת.

זה לא תואם-RECURSE-SUBMODULES = [כן | על פי דרישה] . באופן פנימי זה משמש ליישום הדחיפה.לנהל משא ומתן, ראה Git-Config [1].

הראה מה ייעשה, מבלי לבצע שינויים.

מתי Git להביא משמש עם: RefSpec זה עשוי לסרב לעדכן את הסניף המקומי כפי שנדון בחלק התיעוד של Git-Fetch [1]. אפשרות זו מבטלת את הבדיקה.

שמור על הורדת חבילה.

שנה את ה- RefSpec המוגדר כדי למקם את כל השופטים לתוך השופטים/ מרחב השמות/ מרחב השמות. עיין במשימה Prefetch בגיט-תחזוקה [1].

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

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

בעת ביצוע שופטים המופיעים בשורת הפקודה, השתמש ב- RefSpec שצוין (ניתן לתת יותר מפעם אחת) כדי למפות את השופטים לענפי מעקב מרחוק, במקום ערכי השלט מרחוק.*.להביא משתני תצורה למאגר המרוחק. מתן אפשרות ריקה לאפשרות-Efrefmap גורם ל- GIT להתעלם מה- RefSPECs המוגדרים ולהסתמך לחלוטין על ה- RefSPECs המסופקים כטיעוני שורת פקודה. עיין בסעיף בנושא “סניפי מעקב מרחוק מוגדרים” לפרטים.

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

מספר הילדים המקבילים שישמשו לכל צורות הביצוע.

אם צוינה אפשרות -מרובי, המרחקים השונים יובאו במקביל. אם יובאו מספר תת -מודולות מרובות, הן יובאו במקביל. כדי לשלוט בהם באופן עצמאי, השתמש בהגדרות התצורה להביא.מקביל ותת -מודול.Fetchjobs (ראה Git-Config [1]).

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

–SET-UPSTREAM

אם השלט מביא בהצלחה, הוסף הפניה במעלה הזרם (מעקב), המשמשת על ידי Git-Pull ללא טיעון [1] ופקודות אחרות. למידע נוסף, ראה סניף..להתמזג ולסניף..מרוחק ב- Git-Config [1].

כאשר ניתן לו, והמאגר להביא ממנו מטופל על ידי Git Fetch-Pack, –Exec = מועבר לפקודה כדי לציין נתיב שאינו מפתח לשרת הפקודה בקצה השני.

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

העבירו את המחרוזת הנתונה לשרת בעת תקשורת באמצעות פרוטוקול גרסה 2. המחרוזת הנתונה אסור להכיל תו NUL או LF. השרת’S טיפול באפשרויות שרת, כולל לא ידועות, הוא ספציפי לשרת. כאשר ניתנים מרובים-server-option =.

כברירת מחדל, GIT בודק אם סניף מתוארך בכוח במהלך אחזור. ניתן להשבית זאת באמצעות אחזור.ShowForCaceUpdates, אך האפשרות-מעודכנת-עדכונים-מעודכנת מבטיחה בדיקה זו מתרחשת. ראה Git-Config [1].

כברירת מחדל, GIT בודק אם סניף מתוארך בכוח במהלך אחזור. מעבר-לא-מעודכנים עם תערוכות או הגדר להביא.showforcedupdates ל- false כדי לדלג על בדיקה זו מסיבות ביצועים. אם משתמשים בו במהלך Git-Pull האפשרות –ף בלבד תבדוק עדכונים מאולצים לפני שתנסה עדכון מהיר קדימה. ראה Git-Config [1].

השתמש בכתובות IPv4 בלבד, תוך התעלמות מכתובות IPv6.

השתמש בכתובות IPv6 בלבד, תוך התעלמות מכתובות IPv4.

המאגר “מרוחק” שהוא מקור הפעלת אחזור או משיכה. פרמטר זה יכול להיות כתובת URL (עיין בכתובות האתר של Sect.

מציין אילו שופעים להביא ואילו שופטים מקומיים לעדכן. כאשר אף S לא מופיעים בשורת הפקודה, השופטים להביא נקראים משלט מרחוק..במקום זאת, השגני משתנים (עיין בסעיף “ענפי מעקב מרחוק מוגדרים” ב- Git-Fetch [1]).

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

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

אם RefSpec מקודם על ידי ^, הוא יתפרש כ- RefSpec שלילי. במקום לציין אילו שופטים להביא או לאילו שופטים מקומיים לעדכן, REFSPEC כזה יציין במקום זאת refs כדי להוציא. REF ייחשב להתאים אם הוא תואם לפחות refSPEC חיובי אחד, ואינו תואם כל שופט שלילי. Refspecs שלילי יכול להיות שימושי להגבלת היקף התבנית refspec כך שהוא לא יכלול שופטים ספציפיים. Refspecs שליליים יכולים לעצמם להיות Refspecs. עם זאת, הם עשויים להכיל רק ולא לציין א . גם שמות אובייקטים של משושה לא נתמכים גם הם לא נתמכים.

תג פירושו זהה לשופטים/תגיות/: refs/תגיות/; זה מבקש להביא הכל עד לתג הנתון.

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

האם עדכון זה מותר ללא -כוח תלוי במרחב השמות של השם אותו’S מופרז אליו, סוג האובייקט מביא, והאם העדכון נחשב למהיר קדימה. באופן כללי, אותם כללים חלים על השבה כמו דחיפה, ראו את . קטע של git-push [1] עבור מה שהם. חריגים לאותם כללים ספציפיים ל- Git להביא מצוינים להלן.

עד שגיט גרסה 2.20, ובניגוד לדחיפה עם git-push [1], כל עדכונים לשופטים/תגיות/* יתקבלו ללא + ב- RefSpec (או-לכוח). כשמבצעים, שקלנו באופן מופקר את כל עדכוני התגים משלט מרחוק להביא להביא. מאז Git גרסה 2.20, אחזור לעדכון שופטים/תגיות/* עובד באותו אופן כמו דחיפה. אני.ה. כל עדכונים יידחו ללא + ב- RefSpec (או -Force).

שלא כמו דחיפה עם git-push [1], כל עדכונים מחוץ ל- Refs //* יתקבלו ללא + ב- RefSpec (או-לכוח), בין אם זה’s החלפת e.ז. אובייקט עץ לבלוב, או להתחייבות להתחייבות אחרת’s לא’יש את ההתחייבות הקודמת כאב קדמון וכו ‘.

שלא כמו דוחפים עם git-push [1], אין תצורה אשר’לתקן את הכללים האלה, ושום דבר כמו וו שלפני ראש מקביל לוו-קדם.

בדומה לדחיפה עם Git-Push [1], כל הכללים שתוארו לעיל על מה’S אסור כי ניתן לעקוף עדכון על ידי הוספת האפשרות המובילה + האופציונלית ל- RefSpec (או באמצעות אפשרות שורת פקודה -כוח). היוצא מן הכלל היחיד לכך הוא ששום כמות של אילוץ לא תגרום לשופט/ראשים/* מרחב השמות לקבל אובייקט שאינו מתחייב.

הסביר גיט משיכה

Git Pull היא פקודת GIT המשמשת לעדכון הגרסה המקומית של מאגר משלט מרחוק.

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

1. מעדכן את סניף העבודה המקומי הנוכחי (סניף שנבדק כעת)
2. מעדכן את סניפי המעקב המרוחקים עבור כל הסניפים האחרים.

git משיכת Fetchs (Git Fetch) החדש מתחייב וממזג (git מיזוג) אלה לסניף המקומי שלך.

פקודה זו’תחביר S הוא כדלקמן:

# פורמט כללי git אפשרויות משיכה מאגר Refspec # משוך מסניף ספציפי git משוך שם שמו של שם סניף

• אפשרויות האם אפשרויות הפקודה, כגון -Quiet או -Verbose . תוכל לקרוא עוד על האפשרויות השונות בתיעוד GIT
• מאגר האם כתובת האתר לריפו שלך. דוגמה: https: // github.com/freecodecamp/freecodecamp.גיט
• RefSpec מציין אילו שופעים להביא ואילו שופטים מקומיים לעדכן
• שם מרוחק הוא שם המאגר המרוחק שלך. לדוגמה: מָקוֹר.
• שם הסניף הוא שם הסניף שלך. לדוגמה: לְפַתֵחַ.

הערה

אם יש לך שינויים לא מחויבים, חלק המיזוג בפקודה של Git Pull ייכשל והענף המקומי שלך לא יושם.

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

תוכן העניינים

• באמצעות משיכת GIT
• בקרת גרסאות מופצת
• Git Fetch + Git Molge
• git משיכת IDES

באמצעות משיכת GIT

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

אבל, יש כמה דברים שכדאי לזכור שהדוגמה הזו תהיה נכונה:

למאגר המקומי יש מאגר מרחוק מקושר

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

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

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

בקרת גרסאות מופצת

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

אינטראקציות ברשת ב- GIT

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

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

• שיבוט גיט
• Git להביא
• משיכה גיט
• Git Push

סניפים ב- DVCs

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

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

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

Git Fetch Plus git molge

Git Pull היא פקודה משולבת, שווה ל- Git Fetch + Git Molge .

Git להביא

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

מיזוג Git

ללא טיעונים, Git Merge ימזג את סניף המעקב המרוחק המתאים לסניף העבודה המקומי.

משיכה גיט

Git Fetch עדכוני סניפי מעקב מרחוק. Git Merge מעדכן את הסניף הנוכחי עם סניף המעקב המרוחק המתאים. בעזרת משיכת GIT, אתה מקבל את שני החלקים מהעדכונים הללו. אבל, המשמעות היא שאם אתה נבדק לסניף תכונות ואתה מבצע משיכת GIT, כשאתה מתקין לשלוט, כל עדכונים חדשים לא ייכללו. בכל פעם שאתה בודק לסניף אחר שיש לו שינויים חדשים, זה’תמיד רעיון טוב לבצע משיכה של Git .

git משיכת IDES

שפה נפוצה ב- IDEs אחרים עשויים שלא לכלול את המילה משיכה . אם אתה מחפש את המילים git משיכה אבל אל תעשה’לא לראות אותם, חפש במקום זאת את המילה סנכרון.

הבאת יחסי ציבור מרוחקים (בקשת משיכה) לרפו מקומי

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

Git להביא משיכה/מזהה/ראש/ראש: שם סניף

מזהה הוא מזהה בקשת המשיכה ושם הסניף הוא שם הסניף שאתה רוצה ליצור. לאחר שנוצר הסניף אתה יכול להשתמש ב- Git Checkout כדי לעבור לברך הזה.

משאבים אחרים ב- Git אולי תרצו:

• Git Molge ו- Git Rebase
• קופה גיט
• Git התחייבות
• Git Stash
• סניף גיט

איך למשוך את כל הענפים בגיט

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

במדריך זה תלמד כיצד למשוך את כל הענפים ב- Git.

• Git מותקן (ראה כיצד להתקין את Git באובונטו, MacOS, Windows, Centos 7 או Centos 8).
• מאגר גיט.

מושך את כל הענפים בגיט

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

שתי הפקודות של GIT המשמשות להורדת תוכן ממאגר מרוחק הן משיכת GIT ו Git להביא :

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

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

Git שיטת Fetch

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

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

Git להביא

• הפקודה משיגה רק את הענף שצוין מהמאגר המרוחק.

Git להביא -הכל

• פקודה נחשבת למהלך כוח מכיוון שהיא מביא את כל המרחקים הרשומים והענפים שלהם.

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

1. פתח שורת פקודת GIT BASH ב- Windows או פתח חלון מסוף חדש בלינוקס (Ctrl+אלט+T) או MacOS.

2. נווט אל הספרייה בה ברצונך לאחסן את קבצי המאגר. השתמש בפקודה CD כדי לשנות את הספרייה.

3. ב- GitHub, אתר את המאגר המרוחק שברצונך לשכפל ולחץ על קוד לַחְצָן. לדוגמה, אנו נשחשט. פלטפורמת הפעולות של BMC GitHub מאפשרת לך לבצע אוטומציה של משימות במאגר GIT שלך.

4. מהתפריט הנפתח, בחר באפשרות האבטחה שברצונך להשתמש בו עבור GIT ו העתק את כתובת האתר. במדריך זה נשתמש ב- HTTPS מכיוון שהוא הכי קל להגדיר. אם אתה רוצה אפשרות מאובטחת יותר, עבור עם SSH.

5. ב- Git Bash, משובטים את המאגר המרוחק באמצעות ה- שיבוט גיט פקודה וכתובת האתר שהעתקת. התחביר הוא:

שיבוט גיט

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

סניף גיט

בדוק סניפים זמינים מרחוק על ידי הפעלה:

סניף גיט -ר

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

7. הביאו את המטא נתונים לסניפים מרוחקים והתחילו לעקוב אחריהם. לָרוּץ:

Git להביא -הכל

ה –את כל דגל אומר ל- GIT להביא את המטא נתונים לכל הענפים במאגר.

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

סניף גיט -ר | GREP -V '\ ->' | sed "s, \ x1b \ [[0-9;]*[a-za-z] ,, g" | בעוד שקראו מרוחק; עשה סניף Git -מסלול "$" "$ מרוחק"; בוצע

הפקודה מגדירה את הסניפים במאגר המקומי וגורמת להם לעקוב אחר מקביליהם במאגר המרוחק.

לָרוּץ סניף גיט שוב ובדוק אם הסניפים קיימים באופן מקומי:

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

הערה: קרא את ההשוואה שלנו ל- SSH ו- HTTPS עבור GIT.

שיטת משיכה של Git

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

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

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

1. פתח חלון Bash Git ושנה את המיקום למאגר המקומי שלך.

2. הפעל את הפקודה הבאה כדי להבטיח ש- GIT תתחיל לעקוב אחר כל הענפים המרוחקים, כולל אלה שאינם קיימים בעותק המקומי שלך:

סניף גיט -ר | GREP -V '\ ->' | sed "s, \ x1b \ [[0-9;]*[a-za-z] ,, g" | בעוד שקראו מרוחק; עשה סניף Git -מסלול "$" "$ מרוחק"; בוצע

7. משוך את כל הענפים ממאגר GIT המרוחק:

Git משיכה -הכל

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

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

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

גיט: משוך את כל הענפים

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

במדריך זה אנו מדברים כיצד להשתמש בפקודה של Git – All ו- Git – All כדי לאחזר שינויים ממאגר מרוחק.

מה מסתעף?

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

מצא את התאמת Bootcamp שלך

• קריירה קארמה תואמת אותך עם מחסני האתחול הטכניים המובילים
• גישה למלגות בלעדיות וקורסי הכנה

בחר את העניין שלך
שם פרטי

שם משפחה

אימייל

מספר טלפון

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

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

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

Git: להביא את כל הענפים

אָנוּ’עובד על פרויקט בשם Blog-Site. פרויקט זה מכיל שני סניפים: מקור Master ו- Origin Dev.

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

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

כדי לעקוב אחר כל הענפים המרוחקים ולהביא את המטא נתונים עבור אותם סניפים, נוכל להשתמש בפקודה Git Fetch עם דגל – כל הדגל:

פקודה זו חוזרת:

להביא שלט מקור: מונה אובייקטים: 5, נעשה. מרוחק: ספירת אובייקטים: 100% (5/5), נעשה. מרחוק: סה"כ 3 (דלתא 0), שימוש חוזר 0 (דלתא 0), חריכה חוזרת 0 אובייקטים מפרקים: 100% (3/3), נעשה. מ- https: // github.COM/קריירה-קרמה-טוריאליז/אתר בלוג 3FCEA0C..da74d68 dev -> מקור/dev

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

אנו יכולים לאחזר את המטא נתונים לסניף בודד באמצעות פקודת מקור Git Fetch.

גיט: משוך את כל הענפים

מה אם אתה רוצה לעדכן את עותק העבודה המקומי שלך כמו גם לאחזר מטא נתונים? זֶה’S איפה הפקודה המשיכה Git מועילה.

“קריירה קארמה נכנסה לחיי כשהייתי הכי זקוקה לזה ומהר מאוד עזרה לי להתאים עם Bootcamp. חודשיים לאחר סיום הלימודים מצאתי את עבודת החלומות שלי שהתאימה לערכים ובמטרות שלי בחיים!”

ונוס, מהנדס תוכנה ברוקבוט

מצא את התאמת Bootcamp שלך

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

אָנוּ’השתמשו בדגל – כל הדגל כדי לציין שאנחנו רוצים לאחזר שינויים מכל סניף. הפקודה שלנו חוזרת:

להביא שלט מקור: מונה אובייקטים: 5, נעשה. מרוחק: ספירת אובייקטים: 100% (5/5), נעשה. מרחוק: סה"כ 3 (דלתא 0), שימוש חוזר 0 (דלתא 0), חריכה חוזרת 0 אובייקטים מפרקים: 100% (3/3), נעשה. מ- https: // github.COM/קריירה-קרמה-טוריאליז/אתר בלוג 3FCEA0C..da74d68 dev -> מקור/dev מעדכן את 3FCEA0C..DA74D68 Readme קדימה.MD | קובץ 1 + 1 השתנה, הכנסת 1 ( +)

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

אנחנו יכולים לראות את ה- Readme.קובץ MD השתנה במאגר המרוחק שלנו. עכשיו כשאנחנו’יש להפעיל פעולת משיכה, יש לנו את השינוי במכונה המקומית שלנו.

כדי לאחזר את הקוד מסניף אחד, נוכל להשתמש בפקודה של git Pull Origin.

סיכום

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

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

מה הלאה?

ג’יימס גלאגר

על הסופר: ג’יימס גלאגר הוא מתכנת בהדרכה עצמית ומנהל התוכן הטכני בקריירה קארמה. הוא בעל ניסיון במגוון שפות תכנות ומומחיות נרחבת ב- Python, HTML, CSS ו- JavaScript. ג’יימס כתב מאות הדרכות תכנות, והוא תורם לעתים קרובות לפרסומים כמו Codecademy, Treehouse, Repl.זה, אפרוטק ואחרים.

מאמרים קשורים

• משיכה גיט
• שגיאה: נכשלה לדחוף כמה שופטים לשלט
• GIT: רשימת סניפים מרוחקים
• בטל את משיכת Git: מדריך
• גיט: משוך את כל הענפים

• Git איפוס להצלה
• בקשת משיכה GIT: כיצד ליצור בקשת משיכה
• Git Fetch: מדריך שלב אחר שלב
• כיצד להשתמש במיזוג Git
• פיק דובדבן של GIT: מדריך צעד אחר צעד