C.74–2.Learngitbranching_Git Remotes_Push & Pull
Published in
34 min readJul 28, 2024
- 參考
· Push & Pull - Git Remotes!
∘ 1. Git clone
∘ 2. Remote branch （遠端分支）
∘ 3. Git fetch
∘ 4. Git pull
∘ 5. 模擬合作
∘ 6. Git push
∘ 7. Diverged history
∘ 8. 被鎖定的 Main 分支 ( Locked Main )
· 關於 origin 和其它 repo，git remote 的進階指令
∘ 1. Push main
∘ 2. Merge with remotes
∘ 3. Remote Tracking Branches
∘ 4. Git Push 的參數( git push <remote> <place> )
∘ 5. Git push 的參數 (git push origin <source>:<destination>)
∘ 6. Fetch 的參數
∘ 7. 沒有 source 的情況
∘ 8. Git Pull 的參數Git 的遠端（remotes）功能是非常重要的，特別是需要和他人協作開發時。
Push & Pull — Git Remotes!
- 遠端倉庫（remote repository）就是儲存在另一台電腦上的 Git 倉庫。這個遠端倉庫可以是我們自己的，也可以是其他開發者的。遠端倉庫主要有以下兩個用途：
1. 備份：遠端倉庫可以作為本地倉庫的備份，防止資料丟失。
2. 協作：遠端倉庫讓多個開發者能夠共同協作，分享最新的修改。1. Git clone
- 目標
在本地倉庫中，git clone 會創建一個名為 origin 的遠端，指向我們要 clone 的遠端倉庫。
這裡的 main 分支會跟蹤遠端的 main 分支 (origin/main)。
// 在clone之前，git remote -v 和 git branch -a 不會顯示任何遠端倉庫的資訊。
git remote -v
git branch -a
// clone遠端倉庫後，git remote -v 會顯示遠端倉庫配置 origin (fetch)、origin (push)。
git clone
git remote -v
// clone後，git branch -a 會顯示本地和遠端跟蹤分支，包括 `origin/main`。
git branch -a - 補充：git clone
2. Remote branch （遠端分支）
- 遠端分支：遠端分支是指向遠端倉庫中某個分支的引用。它們保存在本地倉庫中，但反映的是遠端倉庫的狀態。
- 命名規則：遠端分支的命名規則是
<遠端名稱>/<分支名稱>。
例如，origin/main 表示這個分支叫 main，來自於遠端名稱 origin。origin是什麼？
origin 是 Git 默認的遠端名稱。
當我們克隆一個遠端倉庫時，Git 會自動將這個遠端倉庫命名為 origin。
也可以為遠端倉庫取其他名字，但 origin 是最常見的默認名稱。origin/main是什麼？
這是一個遠端分支，它表示遠端倉庫（名稱為 origin）中的 main 分支。
在本地倉庫中，origin/main 讓你可以查看遠端倉庫 main 分支的狀態。- 目標
先在 main branch 上面做一次 commit，再移動到 o/main 上做一次 commit。
這有助於了解到 remote branch 的不同，它們只會反應 remote 的狀態。
1.當 (checkout) 遠端分支 （origin/main）：
- 這會進入分離 HEAD 狀態。
2.分離 HEAD 狀態：
- HEAD 不是指向某個分支，而是直接指向一個提交。
- 你可以查看和修改文件，但不能直接提交。
3.創建新分支：
- 如果需要保存更改，創建一個新的本地分支並在這個分支上進行提交。- 補充：Remote Branch、分離 HEAD
3. Git fetch
git fetch的特性
下載新提交：
- git fetch 會將遠端的新提交下載到本地，但不會合併到你的本地分支。
更新遠端分支：
- git fetch 會更新本地的遠端分支狀態，使其反映遠端倉庫的最新狀態。git fetch不做的事情
不更新本地分支：
- git fetch 不會改變你當前本地分支的狀態。
- 如果你想要將遠端分支的更改合併到本地分支，你需要使用 git merge 或 git pull。- 目標：
通過 git fetch 並且下載全部的 commit
圖中：
遠端倉庫（在 GitHub 上）
C0 - C1 - C2 - C4 - C5(main)
\- C3 - C6 - C7(bugFix)
本地倉庫（克隆後）:
C0 - C1 - C2(main、o/main)
\- C3(bugFix*、o/bugFix)
// 使用 git fetch 更新本地遠端分支
git fetch
// 本地 main 分支仍然停留在 C2，但 origin/main 分支已更新到 C5。
// 本地 bugFix 分支仍然停留在 C3，但 origin/bugFix 分支已更新到 C7。
C0 - C1(main) - C2 - C4 - C5 ( origin/main)
\- C3(bugFix) - C6 - C7 (origin/bugFix)
## git branch 查看本地分支：
main
bugFix*
## git branch -r 查看遠端分支：
o/main
o/bugFix
## git branch -a 查看所有分支：
main
* bugFix
remotes/origin/main
remotes/origin/bugFix- 補充：git fetch
4. Git pull
git pull用於自動執行git fetch和git merge兩個步驟。這意味著它會從遠端倉庫抓取最新的提交並將這些提交合併到當前的本地分支。git pull的工作流程
git fetch：從遠端倉庫抓取最新的提交，更新本地的遠端分支（例如 origin/main）。
git merge：將抓取到的最新提交合併到當前的本地分支。
(git merge、git rebase、git cherry-pick：將遠端的更改合併到本地分支的不同方法。)- 目標
可以利用循序執行的方式來執行 fetch 以及 merge 來完成這個關卡。
但是相對於 git pull，就得多打一個指令。
5. 模擬合作
1. 克隆遠端倉庫
2. 模擬同事的提交
3. 拉取遠端更新- 目標：
現在先把 remote 下載下來（利用 git clone），假裝送幾個 commit 給 remote 做更新，
然後 pull 這些 commit 下來 。
git clone // 首先從遠端倉庫克隆一個本地副本。
git fakeTeamwork 2 // 模擬同事在遠端倉庫上的提交。在 main 分支上添加新的提交C2、C3。
git commit // 在本地倉庫的 main commit C4
git pull // 將遠端倉庫的最新提交拉取到本地。並合併到本地 main 分支 C5。- 補充：git pull 與協作
6. Git push
git push用於將本地的 commit 推送到遠端倉庫，使遠端倉庫中的分支與本地分支同步。這樣，其他人就可以從遠端倉庫下載你的最新提交。
1. git clone：
- 從遠端倉庫克隆一個本地副本。
2. 本地提交：
- 在本地倉庫中進行 commit ，更新本地分支。
3. git push：
- 將本地分支的 commit 推送到遠端倉庫，讓其他人可以下載並查看你的更新。- 目標
上傳兩個新的 commit 給 remote
已經先 git clone 從遠端倉庫克隆一個本地副本。
// 在本地倉庫 main branch commit 兩次
git commit
git commit
// git push 將本地 main 分支的提交推送到遠端的 main 分支。
git push- 補充： git push
7. Diverged history
- 當 Git 的歷史分歧（diverge）時的處理方式。這些方法幫助我們在本地和遠端分支發生分歧時正確地合併和推送我們的提交。
* git fetch：
- 從遠端倉庫抓取最新的提交，更新本地的遠端分支。
* git rebase：
- 將本地提交重新應用在遠端分支的最新提交之後。
* git merge：
- 將遠端分支的最新提交合併到本地分支，創建一個合併提交。
-----------------------------------------------------------------
* git pull：
- 執行 git fetch 並將遠端提交合併到本地分支，創建合併提交。
* git pull --rebase：
- 執行 git fetch 拉取遠端提交並重新應用本地提交，實現拉取和重新應用的組合。- 原先狀態（模擬直接push）
## 遠端倉庫（在 GitHub 上）
C0 - C1 (main)
## 本地倉庫（克隆後）
C0 - C1 (main, o/main)
## 使用 git fakeTeamwork 模擬同事在遠端倉庫上的提交，遠端倉庫狀態：
C0 - C1 - C2 (main)
## 本地倉庫 git commit 本地倉庫狀態：
C0 - C1 (origin/main) - C3 (main)
## 使用 git push 嘗試推送
看到推送失敗的提示，因為本地的提交 C3 與遠端的提交 C4 發生了分歧。
- 目標
1. clone 你的 repo
2. 假裝送一個 commit 給 remote
3. 送一個 commit 給 local repo
4. 透過 rebase 送自己的 commit- 方法一：使用
git rebase
使用 git rebase 時正確地將本地提交重新應用在遠端最新提交之後，
然後使用 git push 將這些更改推送到遠端倉庫。
這樣做可以保持提交歷史的整潔，並避免合併提交的混亂。
## fetch 拉取遠端 commit C2
git fetech
## 進行 rebase o/main main，會將本地提交 C3 重新應用在遠端最新的提交 C2 之後。
git rebase o/main main
## 使用 git push 推送本地 C3' commit 送到遠端倉庫。
git push - 方法二：使用
git merge
在本地和遠端分支發生分歧時正確地合併和推送提交。
## fetch 拉取遠端 commit C2
git fetech
## 進行 git merge o/main，會將本地提交 C3 與遠端最新的提交 C2 合併成新的合併提交 C4。
git merge o/main
## 使用 git push 會將本地合併提交 C4 推送到遠端倉庫。
git push- 方法三：使用
git pull --rebase
git pull --rebase 是 git fetch 和 git rebase 的組合，它會從遠端倉庫抓取最新的提交，
然後將本地提交重新應用在遠端提交之後。
## 這將會重新應用本地提交 C3 在遠端最新的提交 C2 之後。
git pull --rebase
## 使用 git push 推送本地 C3' commit 送到遠端倉庫。
git push- 方法四：使用 git pull（
git fetch 和 git merge 的組合）
* git pull 是 git fetch 和 git merge 的組合。
自動從遠端倉庫抓取最新的提交，並將這些提交 merge 到當前的本地分支，創建合併提交。
* 如果更喜歡將本地提交重新應用在遠端分支的最新提交之後，可以使用 git pull --rebase。
## 會自動執行 git fetch 和 git merge，將遠端倉庫的最新提交合併到本地 main 分支 C4。
git pull
## 使用 git push 會將本地合併提交 C4 推送到遠端倉庫。
git push- 補充： Diverged history
8. 被鎖定的 Main 分支 ( Locked Main )
- 在大型多人合作專案中，通常
main分支是被鎖定的，不允許直接更動。這時需要通過Pull Request (PR)來處理更動。如果嘗試直接在本地main分支上進行提交並推送，就會收到錯誤訊息。
! [remote rejected] main -> main (TF402455: 推送到這個分支是不允許的; 你必須使用 pull request 來更新這個分支.)- 目標
新建一個叫 feature 的分支，然後推送到遠端伺服器。
記得重置(同步一下) main 分支和遠端伺服器保持一致，不然有可能
下一次拉的時候(pull)會跟別人的提交(commit)產生衝突。- 解決方案
1. 同步本地 main 分支：
- 重置本地 main 分支以保持與遠端同步。
2. 新建分支：
- 從同步後的 main 分支創建新的功能分支。
3. 提交更改：
- 在新分支上進行修改並提交。
4. 推送新分支：
- 將新分支推送到遠端倉庫。
5. 發起 Pull Request：
- 在遠端倉庫上發起 Pull Request。
- 這確保了本地
main分支與遠端main分支同步，並且在新的功能分支上進行工作。 - 通過將功能分支推送到遠端，我們可以發起 Pull Request 來合併我們的更改至
main分支。 - 這樣可以避免直接在
main分支上進行修改，並遵循大型項目中的協作流程。
## 重置本地 main 分支：使本地 main 分支與遠端 main 分支同步。
git reset --hard o/main
## 新建一個分支：從本地的最新提交創建一個新分支。
git checkout -b feature C2
## 推送新分支到遠端：將新分支推送到遠端倉庫。
git push- 補充：鎖定 Main 分支說明
- 補充：git reset模擬工作情境
關於 origin 和其它 repo，git remote 的進階指令
1. Push main
- 確保所有分支始終保持最新並與遠端同步，並且使所有的變更都能夠被有效地整合和發布。
1. 同步遠端更新：
- 使用 git fetch 獲取遠端倉庫的最新更新。
2. 依次重新排序分支：
- 使用 git rebase 將功能分支依次重新排序到最新的遠端主分支之後。
3. 推送更新到遠端：
- 將更新推送到遠端倉庫。- 目標
希望將三個 feature branch (side1, side2, side3) 分別推送到遠端。
在推送之前，需要先同步遠端的更新並確保所有分支都基於最新的遠端 main 分支。
## 同步遠端更新，這樣可以更新本地的 origin/main 分支，使其包含最新的遠端提交 C8。
git fetch
## 在各個分支上進行 rebase，確保所有分支都基於最新的遠端 main 分支，並保持分支之間的順序。
git rebase o/main side1
git rebase side1 side2
git rebase side2 side3
git rebase side3 main
## 最後，將更新後的分支推送到遠端。
git push- 補充：push main
2. Merge with remotes
- 在選擇使用 rebase 還是 merge 時，取決於團隊協作方式和個人偏好。
* 選擇 Merge：
- 適合那些希望保留完整歷史紀錄的開發者，merge 保留所有的分支和合併訊息。
* 選擇 Rebase：
- 適合那些希望保持提交歷史簡潔的開發者，rebase 使提交歷史更加線性，便於閱讀和理解。- 目標：
上一個關卡，但這次用 merge。- 原先寫法（
合併 origin/main 分支是在合併 side1 之後進行的）
合併 origin/main 分支是在合併 side1 之後進行的。
這意味著 main 分支會包含 side1 的更改後，再合併遠端最新的 C8。
這樣確保了 main 分支在合併 side2 和 side3 分支之前已經包含了遠端的最新更改。
## 拉取遠端 main 分支的更新C8(o/main) > checkout 到本地 main 分支(C1)
git fetch
git checkout main
## 合併 side1 分支到 main 分支 > 合併 origin/main 分支
git merge side1
git merge o/main
## 依序合併 side2、side3，並推送出去
git merge side2
git merge side3
git push- 修正後（
確保每個分支的更改都在最新的 main 基礎上進行合併。）
在合併功能分支之前，先確保 main 分支是最新的，然後依次合併各個功能分支，最後推送到遠端。
先拉取並更新了 main 分支，確保它包含遠端的最新更改 C8。
然後依次合併 side1, side2, side3 分支。
這樣可以確保每個分支的更改都在最新的 main 基礎上進行合併。
## 切換到 main 分支並更新，確保包含最新的遠端提交 C8。
git checkout main
git pull
## 依序 merge 分支，最後在推送。確保每個分支的更改都在最新的 main 基礎上進行合併。
git merge side1
git merge side2
git merge side3
git push- 補充：merge & rebase 差異
3. Remote Tracking Branches
- 在Git中，
remote tracking branch是本地分支與遠端分支之間的一種特殊關係，使得Git能夠知道如何在本地和遠端之間同步變更。 - Git如何知道Local和Remote的關係
1. 在使用 pull 時：
當在本地的 main 分支上執行 git pull 時 Git 會自動從遠端分支 origin/main下載提交
並合併到本地的main分支。
這種合併行為是基於 main 分支追蹤（track）origin/main分支。
2. 在使用 push 時：
當在本地的main分支上執行 git push 時，Git 會自動將本地的提交推送到遠端 的main 分支。
這也是基於main分支追蹤origin/main分支。- 目標：
要 push 我們的 commit 到 remote 上面的 main branch。
但是我們不 checkout 到 local 的 main branch。- 錯誤：
"side is not a remote tracking branch! I don't know where to push"
沒有指定要追蹤的遠端分支，Git將不知道應該將這個分支推送到遠端的哪個分支。
因此，在執行git push命令時，會收到這樣的錯誤訊息。
- 解決方法一：在現有分支上設置追蹤（ git branch -u ）
git branch -u 來設置本地分支 side 追蹤遠端分支 origin/main。這樣，Git就會知道該將更改推送到哪個遠端分支。## 創建並切換到新的 side 分支
git checkout -b side
## 在 side 分支上進行提交
git commit
## 設置 side 分支追蹤遠端分支
git branch -u o/main side
## 拉取並重置到遠端分支
git pull --rebase- 解決方法二：在創建分支時設置追蹤（ git checkout -b ）
這樣，side分支就會追蹤遠端的origin/side分支。
## 創建一個新的本地分支side，並設置其追蹤遠端的 main 分支 o/main。
git checkout -b side o/main
git commit
git pull --rebase
git push- 補充：遠端追蹤分支
4. Git Push 的參數( git push <remote> <place> )
- 在沒有任何參數的情況下，
git push會將當前 checkout 的分支推送到它所追蹤的遠端分支。然而，也可以通過指定參數來明確指示推送的來源和目的地。可以更靈活地推送更改到遠端倉庫。
git push <remote> <place>
<remote>：指定遠端倉庫的名稱，通常默認為 origin。
<place>：指定推送的分支或者位置。- 目標
這邊要更新在 remote 上的 foo 以及 main branch。
但是 git checkout 的使用，在這個關卡中是不被允許的。
## 來源：將本地的 main 分支上的所有提交抓取下來。
## 目的地：推送到名為 origin 的遠端倉庫的 main 分支。
git push origin main
## 來源：將本地的 foo 分支上的所有提交抓取下來。
## 目的地：推送到名為 origin 的遠端倉庫的 foo 分支。
git push origin foo- 補充：Git Push的參數
5. Git push 的參數 (git push origin <source>:<destination>)
<place>參數的細節
1. 當我們使用 git push 並將 main 作為 <place> 參數時，實際上是告訴 Git 我們要更新的
提交從哪裡來（source）並且要往哪裡去（destination）。
2. 然而，有時候我們需要指定不同的來源和目標，這時候可以使用冒號來分隔 source 和
destination。- 使用冒號指定 source 和 destination
## 為了指定不同的 source 和 destination。
## 這種語法通常被稱為 colon refspec（冒號引用規範）。
## refspec 是一個表示位置的名稱，這個位置可以被 Git 辨別（例如分支名或者提交哈希）。
git push origin <source>:<destination>- 目標：
1. 將本地 foo 分支 coomit 到遠端的 main 分支。
2. 將本地 main 分支的 parent commit 到遠端的 foo 分支。
## 來源（source）：foo 分支
## 目標（destination）：main 分支
## 會將本地 foo 分支的提交推送到遠端倉庫的 main 分支。
## 如果遠端的 main 分支不存在，Git 會創建它。
## 如果存在，則會將 foo 分支的提交合併到遠端的 main 分支。
git push origin foo:main
## 來源（source）：main^，即本地 main 分支的父提交
## 目標（destination）：foo 分支
## 會將本地 main 分支的父提交推送到遠端倉庫的 foo 分支。
## 如果遠端的 foo 分支不存在，Git 會創建它。
git push origin main^:foo- 補充：Git push 延伸討論
6. Fetch 的參數
git fetch和git push的參數非常類似，僅僅是操作的方向不同：git fetch用來從遠端下載提交，而git push用來將提交上傳到遠端。
git fetch 的作用是從遠端倉庫抓取更新，不會直接將其合併到本地分支。
這些更新會被存放在本地的遠端跟踪分支中（如 origin/foo）。- 為什麼要這麼做？
1. 通常，程式設計師很少直接將抓取的提交放到本地分支，因為這樣會影響當前分支的穩定性。
2. 一般情況下，會先抓取到遠端跟踪分支，再決定如何處理這些更新，如合併或rebase。<place>參數（基本 fetch）
## 使用 git fetch 時，可以指定一個 <place> 參數來明確抓取的來源分支和本地的目標位置。
## <remote>：指定遠端倉庫的名稱，通常默認為 origin。
## <place>：指定抓取的遠端分支。
git fetch <remote> <place>
## 從遠端的 foo 分支抓取提交，放到本地的 origin/foo 分支。
git fetch origin foo- Colon Refspec（指定 source 和 destination）
## 如果希望將抓取的提交直接放到本地的某個分支，可以使用 colon refspec 語法。
## <source>：遠端分支名稱。
## <destination>：本地分支名稱。
git fetch <remote> <source>:<destination>
## 從遠端的 foo 分支抓取提交，直接放到本地的 bar 分支。
git fetch origin foo:bar- 目標：
對於兩個 fetch 的指令，我們必須要指定 source 以及 destination，注意一下視覺化的目標，
因為 commit 的 id 可以被交換！
## 原先狀態是 checkout C1 分離HEAD。而沒有指定到任何一個要處理的分支上！！
## 將遠端倉庫 origin 中的提交 C6 抓取並放到本地的 main 分支中。
git fetch origin C6:main
## 將遠端倉庫 origin 中的提交 C3 抓取並放到本地的 foo 分支中。
git fetch origin C3:foo
## 切換到本地的 foo 分支。將本地的 main 分支合併到 foo 分支中。
git checkout foo
git merge main- 錯誤：
錯誤訊息 "cannot fetch to main when checked out on main" 。
是當前已經切換到 main 分支時，不能使用 git fetch 將遠端的提交直接抓取到同一個本地分支。
這是因為這樣的操作可能會覆蓋當前分支上的更改，導致潛在的數據丟失。
## 解決方法
可以使用其他分支、臨時分支、分離HEAD，來進行這個操作，然後再將這些更改合併到main分支。補充：Git fetch命令的參數及其用法
7. 沒有 source 的情況
1. 在 git push 中，如果沒有指定 <source> 參數，Git 將會刪除遠端分支。
2. 在 git fetch 中，如果沒有指定 <source> 參數，Git 將會在本地創建一個新的分支。Push 沒有 Source 參數
- 當使用
git push並且沒有指定<source>時，Git 將會刪除遠端分支。
## Git 將會刪除遠端倉庫 origin 上的 side 分支。
git push origin :sideFetch 沒有 Source 參數
- 當使用
git fetch並且沒有指定<source>時，Git 會在本地建立一個新的分支。
## Git 將會在本地建立一個名為 bugFix 的新分支，但不會從遠端拉取任何提交到這個分支。
git fetch origin :bugFix- 目標
在本關卡中，不允許使用 branch 指令，因此你只能使用 fetch！
利用 git push 刪除一個 remote 的 branch。
並且利用 git fetch 建立一個新的 local 的 branch。
git push origin :foo ## 會刪除遠端倉庫 origin 上的 foo 分支。
git fetch origin :bar ## 在本地建立 bar 的新分支，但不會從遠端拉取任何提交到這個分支。8. Git Pull 的參數
- 前面提到使用
git pull時，首先執行git fetch，然後將抓取的提交merge 到當前分支。
git pull origin <branch>參數使用：
相當於 git fetch origin <branch> 和 git merge origin/<branch> 的組合。- 例子
git pull origin foo
##
git fetch origin foo：從遠端 origin 的 foo 分支抓取提交到本地的 origin/foo 分支。
git merge origin/foo：將抓取的提交合併到當前分支。git pull origin <source>:<destination>參數使用：
相當於git fetch origin <source>:<destination>和 git merge <destination> 的組合。- 例子
git pull origin bar:bugFix
##
git fetch origin bar:bugFix：從遠端 origin 的 bar 分支抓取提交到本地的 bugFix 分支。
git merge bugFix：將抓取的提交合併到當前分支。- 目標
需要下載一些 commit，建立一些新的 branch。
並且 merge 這些 branch 到其他的 branch 上面。- 方式一：使用 fetch 在 merge
git fetch origin C3:foo ## 從遠端倉庫 origin 中抓取提交 C3 到本地的 foo 分支。
git merge foo ## 將 foo 分支的更改合併到當前分支。
git fetch origin C2:side ## 從遠端倉庫 origin 中抓取提交 C2 到本地的 side 分支。
git merge side ## 將 side 分支的更改合併到當前分支。- 方式二：使用 git pull origin <source>:<destination>
## 從遠端倉庫 origin 中抓取提交 C3，並將其放到本地的 foo 分支，然後合併到當前分支。
git pull origin C3:foo
## 從遠端倉庫 origin 中抓取提交 C2，並將其放到本地的 side 分支，然後合併到當前分支。
git pull origin C2:side- 提交哈希並不是常見的用法。通常會指定分支來進行
git pull操作。這樣可以避免一些意外行為。
補充：git pull命令的參數
