8.5 בקרת גרסאות 1 פתיח הרצאה

בקרת גרסאות - version control¶

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

גיט - git¶

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

התקנת גיט¶

בתוכנת PyCharm מותקן גיט
אפשר להתקין גיט גם בקישור הבא: https://gitforwindows.org/

גיט¶

נלמד איך לתפעל גיט על המחשב שלנו.

הפעלת גיט בפרויקט¶

כדי להפעיל גיט בפרויקט שלכם כתבו את הפקודה בתקיית הפרויקט שלכם:
```
git init
```
כרגע יצרתם "גיט רפוזטורי" חדש, או באנגלית - "git repository"
שימו לב - כשאנחנו יוצרים פרויקט PyCharm חדש נוצר אוטמטית גיט רפו לפרויקט שלכם.

גיט קומיט - commit¶

אז יצרנו פרויקט גיט חדש, התחלנו לכתוב קוד ועכשיו אנחנו רוצים להעלות את הקוד שכתבנו לגיט רפו, קודם כל - נרצה לראות את הקוד שנוסף לפרויקט, נעשה זאת באמצעות הפקודה:
```
git status
```
נבחר איזה קבצים אנחנו נרצה להעלות לגיט באמצעות הפקודות:
```
git add main.py  # Will add main.py changes!
```
נוכל גם לבחור את כל הקבצים בפקודה אחת:
```
git add .  # Will add all changes in the current directory
```
עכשיו אחרי שבחרנו איזה קבצים נרצה לעלות, נעלה אתם לגיט באמצעות הפקודה "גיט קומייט"
```
git commit -m "initiate project (uploaded main.py)"
```
מעולה! העלנו את הקוד שבחרנו בהצלחה לגיט. מה אם נרצה להוסיף עוד קוד?
נוסיף עוד קוד ונחזור על הפקודות שהרצנו כדי להעלות גם אותו:
```
git status
git add .
git commit -m 
```
נשתמש בפקודה git log כדי לראות את כל הקומייטים שהעלנו עד כו.
```
git log
```
מעולה, כך נוכל להשתמש בגיט כדי להעלות את הקוד שלנו וליצור כמה גרסאות שונות.

עץ הגיט¶

כדי לשפט את גיט נצייר אותו כמו עץ
ניתן לראות בציור שעשינו 2 קומייטים, בציור "HEAD" זה מבציע שאומר איפה שאנחנו נמצאים כעט בפרויקט (איזה קומייט אנחנו כרגע)

גיט צ'ק אוט - checkout¶

אז יצרנו כמה גרסאות של הקוד, כמה קומייטים שונים. מה אם נרצה לראות את ההיסטוריה של הקוד שלנו? נוכל להתחבר לקומייטים שונים באמצעות הפקודה הבאה:
```
git checkout <commit-id>
```
נצטרך לבחור קומייט שאליו אנחנו רוצים להתחבר, נוכל לראות את כל הקומייטים באמצעות
```
git log
```
נבחר קומייט לפי ID , למשל נבחר את הקומייט הראשון שלנו ונריץ
```
git checkout <commit-id>
```
כעט אנחנו מסתכלים על הקומייט הראשון, נוכל לחזור לקומייט הקודם שלנו באמצעות שוב הרצת git checkout

ענפי גיט - git branches¶

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

הדבר הזה נקרא "ענפי גיט"
ענפי גיט מאפשרים לנו לצור שני גרסאות שונות של הקוד שלנו, דוגמאות לשימושים:
- גרסת פרודקשן: נוכל לעשות ענף של הקוד שהוא במצב של פרודקשן, בלי באגים ובלי בעיות
- גרסת פיתוח: נוכל לעשות ענף של הקוד שהוא במצב פיתוח, משמע עלול להיות בו באגים, ושם נפתח את הקוד בעיקר
- הוספת פיצ'ר כלשהו: כשנרצה להוסיף פיצ'ר לקוד נוכל לפתוח ענף חדש שיוצא מהגרסת פיתוח שבו נוכל לכתוב את הפיצ'ר החדש, כך נאפשר למתכנתים אחרים לעבוד על פיצ'רים אחרים בקוד מבלי להפריע להם.
כדי לראות את כל הענפים שיש לנו בפרויקט, נריץ את הפקודה:
```
git branch
```
אפשר לראות שהענף הראשי בכל פרויקט נקרא "main" והוא ענף שנוצר אוטומטית בכל פרויקט.
אנחנו יכולים להוסיף ענפים מהקומייט הנוכחי באמצעות הפקודה:
```
git branch dev  # Adds a new branch called "dev"
```
ניתן לראות שיצרנו ענף חדש בשם "dev"

אם נריץ את הפקודה "git branch" נוכל לראות את הענף החדש שיצרנו וגם נראה שכרגע אנחנו מסתכלים בענף "main",

אנחנו יכולים להשתמש בפקודה git checkout כדי להחליף בין ענפים

git checkout dev
# Adding changes..
git status
git add .
git commit -m "added main function"

החלפנו לענף של dev, והוספנו קוטמייט, איך יראה העץ עכשיו?
אנחנו יכולים לחזור לענף "main" תמיד
```
git checkout main
git checkout dev
```
עכשיו בואו נוסיף קומייט לענף "main", קודם נעבור אליו ואז נעשה קומייט
```
git checkout main
# Adding changes..
git status
git add .
git commit -m "some changes.."
```
עכשיו העץ יראה כך:
עכשיו יש לנו 2 גרסאות שונות של קוד! גרסא שנקראת main וגרסא שנקראת dev.