מדריך ל-Git (גיט) – ניהול גרסאות קוד

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

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

ניווט לפרקי המדריך:
פרק ראשון – הכרה והתקנה של Git + הגדרה ראשונית של המשתמש שלנו
פרק שני – יצירת Repository והוספת קבצי הפרויקט
פרק שלישי – Unstage לקובץ, יצירת Commit וצפייה בקומיטים קודמים
פרק רביעי – השוואת גרסאות, פקודת Checkout, מחיקת/העברת קבצים ועבודה עם GitHub
פרק חמישי – פקודות Push + Pull, ענפים ו-GUI Clients לגיט

פרק ראשון – הכרה והתקנה של Git + הגדרה ראשונית של המשתמש שלנו

אז מה זה בעצם Git ולמה כדאי להשתמש בזה?

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

התקנת Git

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

לינוקס

הריצו את הפקודה הבאה:

$ sudo yum install git-all

Mac

לחיצה כפולה על .pkg והתקנה פשוטה.

חלונות

הרצת התקנה פשוטה כמו כל תוכנה רגילה.

חשוב: במדריך זה אנו נעבוד עם Git באמצעות חלון ה-bash, זהו חלון הפקודות של Git, לכן, במהלך ההתקנה יש לוודא כי האפשרות "Use Git Bash only" מסומנת.

לאחר ההתקנה נוודא שהכל תקין

פתחו את Git Bash והריצו את הפקודה הבאה:

git --version

קיבלתם את מספר הגרסא המותקנת לכם על המחשב? ברכות! אפשר להתחיל עם הכיף האמיתי 🙂

קבלת הגרסא של Git המותקנת על מחשבנו
קבלת הגרסא של Git המותקנת על מחשבנו

הגדרת המשתמש האישי שלנו

כפי שכבר אמרתי, בדרך כלל העבודה עם Git מתבצעת בצוות, לכן, נורא חשוב שנדע מי אחראי ל-Commit מסוים (ואם הוא גרם לבאג אולי אפילו לנזוף בו קלות 😀 ), מי העלה גרסא מסויימת וכו'.
לכל "חבר" ב-Repository יש שם משתמש וכתובת מייל המוגדרים ב-Git.
על מנת להגדיר את שם המשתמש שלנו ב-Git, נריץ את הפקודה הבאה:

git config --global user.name "David"

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

git config --global user.email "david@example.com"

כיצד נוודא שההגדרות נקלטו?

נריץ את הפקודה הבאה:

git config --list

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

טיפ קטן לסיום…

אם תרצו לנקות את מסך ה-Bash, הפקודה הבאה תעשה זאת :

clear

פרק שני – יצירת Repository, קובץ gitignore. והוספת קבצי הפרויקט

יצירת Repository

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

cd /c/xampp/htdocs/myRepo

טיפ למשתמשי Windows: מקש ימני בתיקייה הרצויה ובחירה ב-"Git Bash Here" תעשו את אותה הפעולה.

מלבד הכתובית הצהובה מצד ימין, נוכל לקבל את התיקייה עליה Git "צופה" באמצעות הפקודה pwd:

פקודת pwd ב-Git
פקודת pwd ב-Git

כעת, נוכל ליצור את ה-Repository שלנו על ידי הפקודה git init:

פקודת git init
פקודת git init

כפי שאתם רואים, מיד קיבלנו הודעה שיצרנו Repository בתיקיה myRepo.

כעת, לפני שנעבור להוספת קבצי הפרויקט שלנו ל-Repository שלנו, אני רוצה שתבינו כיצד Git עובדת.
אני רוצה שתחשבו על Git כבעלת 3 תחנות עיקריות: Working Copy, Staging Copy, Committed Copy.

Working Copy

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

Staging Copy

כאשר ביצענו שינוי, אנו צריכים "להוסיף" את השינויים שביצענו למעקב של Git.
ה-Staging Copy הוא האיזור שבו נמצאים הקבצים שהועלו. יש לשים לב – עדיין לא עשינו Commit לקבצים אלו!

Committed Copy

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

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

כרגע יש לנו מאגר "ריק" שרק אתחלנו אותו על ידי הפקודה git init אבל הוא איננו "עוקב" אחר הפרויקט שלנו. על מנת שיעשה זאת, עלינו להוסיף את הקבצים.
לצורך הדוגמא, נאמר והפרויקט שלנו מכיל כרגע קובץ אחד ויחיד בשם index.html.
באפשרותנו להבין מה קורה ב-Repository שלנו על ידי הפקודה git status:

מה בעצם אנחנו רואים כאן? Git מודיעה לנו שיש לנו קבצים שהיא "לא מכירה" ("Untracked files"), הקובץ הוא כמובן, index.html.
כרגע index.html נמצא בתחנת "Working Copy".
כיצד נוסיף אותו ל-Repository שלנו? על ידי הפקודה git add:

פקודת git add
פקודת git add

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

git add .

כן, נקודה, קולטים? 🙂

כעת נבדוק את מצב ה-Repository שלנו שוב:

בדיקה חוזרת לאחר הוספת הקובץ
בדיקה חוזרת לאחר הוספת הקובץ

ירוק זה כבר יותר טוב 🙂
הצבע הירקרק מבשר לנו כי הקבצים שלנו עברו "תחנה" אל Staging Copy. אפשר לראות את זה כ-"חצי דרך".

קובץ gitignore.

סביר להניח כי ברוב הפרויקטים שלנו, ישנם קבצים/תיקיות שנרצה ש-Git לא תעקוב אחריהם והם יועלו ל-Repository שלנו.
קובץ gitignore. הוא הפיתרון.
יצירת הקובץ מתבצעת על ידי הפקודה touch:

touch .gitignore

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

.cms
/db.php

השורה הראשונה תגרום להתעלמות מתיקייה שלמה בשם cms והשורה השנייה תגרום להתעלמות מקובץ בשם db.php.
ניתן ולפעמים אף רצוי להוסיף את קובץ gitignore ל-Repository שלנו, כל מקרה לגופו.

אז איך מבצעים Commit? קצת סבלנות! בפרק הבא 🙂

פרק שלישי – Unstage לקובץ, יצירת Commit וצפייה בקומיטים קודמים

Unstage לקובץ

זכרו, כעת יש לנו קובץ שנמצא ב-Staging Copy, אך מה אם התחרטנו ואנו מעוניינים להחזיר אותו אל ה-Working Copy שלנו?
בבקשה:

git rm --cached index.html

כעת ניתן לשים לב שחזרנו "צעד אחורה" בדרך אל ה-Commit המיוחל:

unstage לקובץ
unstage לקובץ

יצירת Commit

כמובן שכעת, על מנת לעשות Commit נוסיף את הקובץ שוב על ידי git add.
על מנת לבצע Commit, נשתמש בפקודה הבאה:

git commit -m "init commit"

כמובן שבין המרכאות נכתוב את מהות ה-Commit הנוכחי, מה בידיוק בוצע.

יצירת Commit
יצירת Commit

ביצוע Commit מהיר

במידה ונרצה לבצע Commit "מהיר", ולדלג על הוספת הוקבץ על ידי פקודת git add, נוכל לעשות זאת על ידי הפקודה הבאה:

git commit -am "index.html"

הערה: אישית, אני פחות ממליץ לעשות זאת מאחר ואין לנו את האופציה לעשות unsgate לקובץ.

צפייה בקומיטים קודמים

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

git log

על מנת לצפות בקומיטים שנוצרו על ידי משתמש מסוים:

git log --author "David"

כמובן ש-David זה שם המשתמש.

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

git log -n 10

פרק רביעי – השוואת גרסאות, פקודת Checkout, מחיקת/העברת קבצים ועבודה עם GitHub

השוואת גרסאות

השוואה בין ה-Working Copy ל-Staging Copy

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

git diff --staged

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

פקודת diff --staged
פקודת diff –staged

השוואה בין ה-Working Copy ל-Repostiory

על מנת להשוות בין הגרסא שיש לנו ב-Working Copy לבין ה-Repostiory, נשתמש בפקודה הבאה:


git diff

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

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

פקודת Checkout

פקודת Checkout מאפשרת לנו "להחזיר" את הקובץ שלנו ל-Commit מסוים.
כפי שהוסבר, פקודת git log תחזיר לנו את הקומיטים שבוצעו, ניתן לראות כי על יד כל קומיט ישנה מחרוזת בצהוב, זהו המזהה של אותו קומיט.
דוגמא:

דוגמא לפלט - git log
דוגמא לפלט – git log

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

git checkout 45bee -- index.html

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

מחיקת/העברת קבצים

מחיקת קובץ

על מנת למחוק קובץ מה-Working Copy שלנו יש להשתמש בפקודה git rm באופן הבא:

git rm index.html

חשוב מאוד: יש לבצע Commit לאחר מכן מאחר ובוצע שינוי ב-Working Copy שלנו:

לאחר מחיקת קובץ
לאחר מחיקת קובץ

העברת קובץ

על מנת להעביר קובץ, בדוגמא זו לתיקייה כלשהי, יש להשתמש בפקודה git mv באופן הבא:

git mv index.html folder/index.html

עבודה עם GitHub

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

פקודת Clone

פקודת Clone מאפשרת לנו ליצור עותק של Repostiory מרוחק על המחשב שלנו.
בדוגמא זו המאגר הוא של Bootstrap והוא נמצא ב-GitHub.
על מנת לקבל העתק של המאגר נפתח את חלון ה-Bash ונשתמש בפקודה הבאה:

git clone https://github.com/twbs/bootstrap.git

את הכתובת של ה-Repostiory העתקתי מהעמוד של המאגר ב-GitHub.

GitHub - clone url
GitHub – clone url

יצירת Repostiory ב-GitHub

לאחר ההרשמה ל-GitHub נוכל ליצור מאגר חדש על ידי הקישור היעודי לכך:

GitHub - new repostory
GitHub – new repostory

במסך שיפתח לנו נמלא את הפרטים הבאים:

Repository name – השם של המאגר שלנו. מאחר ומאגר זה הוא תחת השם משתמש שלנו נוכל לבחור איזה שם שנרצה.
Description – כמה מילים על המאגר שלכם – אופציונלי.
Public/Private – מאגר ציבורי או פרטי. מאגר פרטי הוא בתשלום.

שליחת הטופס תיצור את המאגר, מגניב! 🙂

פרק חמישי – פקודות Push + Pull, ענפים ו-GUI Clients לגיט

פקודת Push

אז יש לנו מאגגר מקומי ומרוחק, על מנת לדחוף את המאגר המקומי למאגר המרוחק נצטרך להגדיר את ה-Remote שלנו על ידי הפקודה הבאה:

git remote add origin https://github.com/YourGitHubUserName/YourGitHubRepositoryName.git

*כמובן שיש לשנות את הערכים המתאימים בהתאם למאגר המרוחק שלכם.

Origin הוא השם של ה-Remote שלנו.

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

git push -u origin master

Master זהו השם של הענף הראשי שלנו.
מה זה ענף? בבקשה:

ענפים

אז מהם בידיוק ענפים (branches)?
ענף הוא "גרסא" של ה-Repostiory שלנו.
לצורך דוגמא, נאמר ופיתחנו מערכת כלשהי, הענף הראשי נקרא master והוא "מכיל" המערכת בגרסתא "הקלאסית".
אם נרצה להעתיק את המערכת ולהוסיף לה יכולות מיוחדות/מותאמות אישית ללקוח כלשהו או בכלל לעבוד על גרסא חדשה למערכת, כדאי לנו ליצור ענף חדש.
לאחר סיום העבודה ניתן גם למזג (merge) בין הענפים.

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

git branch newbranch

על מנת לקבל את רשימת הענפים שיש ברשותינו:

git branch

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

git checkout newbranch

ניתן לראות כי גיט בישרה לנו כי ביצענו החלפה לענף בשם newbranch.

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


git checkout -b version2

כיצד נמחק ענף?

git branch -D newbranch

פקודת Pull

לאחר שלמדנו על עבודה עם שרת מרוחק וענפים, נשאלת השאלה מה יקרה אם ביצענו clone למאגר מרוחק, ביצענו שינויים כלשהם אבל הענף המקורי (זה שבשרת המרוחק) עודכן?
אנו בוודאי נרצה "למשוך" אלינו את השינויים.
פקודת git pull תעשה זאת:

git pull origin master

origin הוא הכינוי לשרת המרוחק שלנו וה-master זהו השם של הענף אותו נרצה "למשוך".

Gui Clients לגיט

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

TortoiseGit

תוכנה קלילה, די פשוטה ומאוד מתאימה למתחילים.
יתרון נוסף שהיא גם מתממשקת עם Windows explorer (לא הדפדפן! 🙂 ), כלומר באמצעות המקש ימני תוכלו לבצע פעולות נפוצות.
תומכת בחלונות בלבד.
TortoiseGit

SourceTree

תוכנה מעולה, נפוצה מאוד, בעלת תמיכה בחלונות ו-Mac.
SourceTree

GitHub Desktop

תוכנה מדהימה ומומלצת מאוד מבית GitHub.
תומכת בחלונות ו-Mac.
GitHub Desktop

אני בטוח שנהנתם אבל…זה נגמר

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

בהצלחה!

נהנת ממאמר זה? הירשם לרשימת התפוצה וקבל עדכונים על מאמרים חדשים!


19 תגובות בנושא “מדריך ל-Git (גיט) – ניהול גרסאות קוד”

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

  1. תודה!
    אחד המדריכים הכי טובים לגיט בעברית שמצאתי ברשת!! הסברים מעולים ומפורטים. עזר לי מאד.

  2. מדריך מצוין!
    מצאתי "באג" בפסקה הזאת:
    Committed Copy
    ה-Staging Copy זוהי התחנה בה נמצאים הקבצים "שעברו" Commit.
    אני חושב שצריך לשנות את המילה Staging ל- Committed

      1. "ה-Staging Copy הוא האיזור שבו נמצאים הקבצים שהועלו. יש לשים לב – עדיין לא עשינו Commit לקבצים אלו!

        Committed Copy
        ה-Staging Copy זוהי התחנה בה נמצאים הקבצים "שעברו" Commit."
        אתה לא מזהה סתירה בין הדברים..?

      2. אכן מדריך מעולה!תודה רבה דור!
        שייקי צודק,
        הפסקה המסבירה מהו שלב ה-Committed Copy פותחת ככה:
        ה-Staging Copy זוהי התחנה בה נמצאים הקבצים "שעברו" Commit.
        וצריך להיות ככה:
        ה-Committed Copy זוהי התחנה בה נמצאים הקבצים "שעברו" Commit.

  3. תודה על המדריך המעולה. אני יושב עליו כבר יומיים. התחלתי מאפס ידע בגיט ועכשיו מתחיל להרגיש בבית ;).
    האם אתה ממליץ לעבוד עם git רק בפרויקטים מסדר גודל מסוים? ואם כן מהו?

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

כתיבת תגובה

האימייל לא יוצג באתר. שדות החובה מסומנים *