• git随记

    git status 查看文件状态

    git status -s 比较简洁的查看文件状态。如下代表此文件是新建的，没有被git跟踪的文件：

    1. $ git status -s
    2. ?? abc.txt

    git add abc.txt 将abc添加到暂存区。后再次git status -s

    1. $ git status -s
    2. A  abc.txt

    git reset 将暂存区的文件取消暂存。后再次git status -s ，暂存区的文件会变为未跟踪

    git commit 将暂存区的文件修改提交到本地仓库。git commit -m "abc" abc.txt ，再次查看状态就没了。

    git rm abc.txt 删除本地工作区里的文件，其实本地仓库里仍然还有这个文件，此时git push origin HEAD:dev 仍然能提交至远程仓库。

    1. git rm abc.txt
    2. git status
    3. deleted:    abc.txt

    查看远程仓库

    1. $ git remote
    2. origin

    添加远程仓库，用于向本地仓库添加一个新的远程仓库引用（通常是一个 URL）。这样，你就可以从该远程仓库拉取（fetch）或推送（push）更改。
    运行 git remote add < shortname> < url> 添加一个新的远程 Git 仓库，同时指定一个可以引用的简写

    1. git remote add myRemote http://xxx.xxx.1xx.226:906x/cc/haizhou.git
    2.  
    3. $ git remote -v
    4. myRemote        http://xx.xx.xx.226:9066/cc/haizhou.git (fetch)
    5. myRemote        http://xx.xx.xx.226:9066/cc/haizhou.git (push)
    6. origin  http://xx.xx.xx.226:9066/cc/haizhou.git (fetch)
    7. origin  http://xx.xx.xx.226:9066/cc/haizhou.git (push)
    8.

    移除无效的远程仓库

     git remote rm myRemote

    从远程仓库中抓取与拉取
    git fetch 是从远程仓库获取最新版本到本地仓库，不会自动merge

    git pull 是从远程仓库获取最新版本并merge到本地仓库

    **注意：**如果当前本地仓库不是从远程仓库克隆，而是本地创建的仓库，并且仓库中存在文件，此时再从远程仓库拉取文件的时候会报错（fatal: refusing to merge unrelated histories ），解决此问题可以在git pull命令后加入参数–allow-unrelated-histories
    当执行git中的“git pull origin master –allow-unrelated-histories”命令时，会出现“ couldn’t find remote ref –allow-unrelated-histories”的错误，
    输入如下命令即可解决：
    git pull --rebase origin master

    将本地分支与远程分支关联：

    git branch --set-upstream-to origin/master master

    推送到远程仓库
    当你想分享你的代码时，可以将其推送到远程仓库。 命令形式：git push [remote-name] [branch-name]

    1. git push origin HEAD:dev
    2.  
    3. 这个命令的含义是将当前分支（HEAD）的内容推送到远程的 dev 分支。这里的 HEAD:dev 是一个引用规范（refspec），它告诉 Git 从 HEAD（即当前分支）获取内容，并将其推送到远程的 dev 分支。这个命令非常有用，特别是当你想要将一个分支的内容推送到另一个远程分支时，而这两个分支在本地可能有不同的名称。
    4.  
    5. 如果你想要将本地的 main 分支推送到远程仓库的 main 分支上，你可以执行以下命令：
    6.  
    7. git push origin main
    8.  
    9. 如果你想要将本地的 feature-branch 分支推送到远程仓库的 develop 分支上（注意这里分支名不同），你可以使用引用规范（refspec）来指定：
    10.  
    11. git push origin feature-branch:develop

    查看分支

    • 列出所有本地分支
      git branch
    • 列出所有远程分支
      git branch -r
    • 列出所有本地分支和远程分支
      git branch -a
    1. $ git branch -r
    2.   origin/HEAD -> origin/main
    3.   origin/dev
    4.   origin/main
    5. -----------------------------
    6. $ git branch
    7.   main
    8. * origin/dev
    9. -----------------------------
    10. $ git branch -a
    11.   main
    12. * origin/dev
    13.   remotes/origin/HEAD -> origin/main
    14.   remotes/origin/dev
    15.   remotes/origin/main

    origin/HEAD -> origin/main 

    表示远程仓库 origin 的 HEAD 当前指向 main 分支。这意味着当你从 origin 拉取代码时，默认情况下会拉取 main 分支的更新。

     创建分支

    在主分支上：

    1. $ git branch myBranch
    2.  
    3. $ git branch
    4. * main
    5.   myBranch
    6.   origin/dev

    引用远程分支：

    1. #先看远程分支上有啥分支，看之前可以git pull一下
    2. $ git branch -r
    3.   origin/HEAD -> origin/main
    4.   origin/dev
    5.   origin/hello
    6.   origin/main
    7.   origin/myBranch
    8.  
    9. #这条命令会创建一个名为 hello 的新本地分支，并将其设置为跟踪 origin/hello。之后你就可以在这个新的本地分支上进行工作，并通过 git push 和 git pull 与远程的 dev 分支同步更改。
    10. #然后创建一个远程分支的引用 如：
    11. #-b: 这个参数表示“branch”（分支），并告诉 git checkout 命令你想要创建一个新的分支。
    12. $ git checkout -b hello origin/hello
    13. Switched to a new branch 'hello'
    14. Branch 'hello' set up to track remote branch 'hello' from 'origin'.
    15.  
    16. $ git branch
    17. * hello
    18.   main
    19.   myBranch
    20.   origin/dev
    21.  
    22. #远程分支可以多次被引用 只需要本地分支名字不一样就行
    23. $ git checkout -b MyHello origin/hello
    24. Switched to a new branch 'MyHello'
    25. Branch 'MyHello' set up to track remote branch 'hello' from 'origin'.

    切换分支：

    1. #只是单独的切换本地分支
    2. $ git checkout myBranch
    3. Switched to branch 'myBranch'
    4.  
    5. # 创建本地分支 且引用远程分支时候也会切换
    6. $ git checkout -b dev origin/dev

    引用本地分支：

    1. git checkout -b haizhou_dev main
    2.  
    3. 注意如下两种写法：
    4. git checkout -b hello master:
    5. 这个命令会基于 master 分支来创建一个名为 hello 的新分支，并立即切换到这个新分支 hello。也就是说，hello 分支会包含 master 分支在那一刻的所有提交历史，并且你将会在新的 hello 分支上开始工作。
    6. git checkout -b hello:
    7. 这个命令会基于当前所在的分支（无论这个分支是什么）来创建一个名为 hello 的新分支，并立即切换到这个新分支。例如，如果你当前在 feature-x 分支上，那么 hello 分支就会包含 feature-x 分支在那一刻的所有提交历史，并且你将会在新的 hello 分支上开始工作。
    8. 简单来说，master 在第一个命令中指定了新分支的起始点（即基于哪个分支来创建新分支），而在第二个命令中，起始点是隐式的，即当前所在的分支。

    推送至远程仓库分支

    1. $ git push origin myBranch
    2. Total 0 (delta 0), reused 0 (delta 0), pack-reused 0
    3. remote:
    4. remote: To create a merge request for myBranch, visit:
    5. remote:   http://xxxxxxxx:9066/cc/haizhou/-/merge_requests/new?merge_request%5Bsource_branch%5D=myBranch
    6. remote:
    7. To http://116.63.139.226:9066/dongbinbin/haizhou.git
    8.  * [new branch]      myBranch -> myBranch

    删除分支

    1. #删除本地分支
    2. $ git branch -d hello
    3. Deleted branch hello (was 14109a7).
    4.  
    5. #删除远程分支
    6. $ git push origin --delete hello
    7. To http://xxxxxx.06:9066/cc/haizhou.git
    8.  - [deleted]         hello
    9.  
    10. #注意，删除本地分支的时候，如果本地分支引用了远程分支还没merged，会报如下提示：
    11. $ git branch -d MyHello
    12. warning: deleting branch 'MyHello' that has been merged to
    13.          'refs/remotes/origin/hello', but not yet merged to HEAD.
    14. Deleted branch MyHello (was 3ffe4d3).

    分支合并merge,本地分支间的合并：

    比如，我在本地分支MyHello开发完一个功能后，先要把MyHello合并到本地的master分支，然后再推到远程仓库。先从MyHello分支切换到master分支，使用checkout命令，接下来用merge命令来进行分支间的合并。

    #git merge 用于合并分支的更改。
    #git push 用于将本地的更改推送到远程仓库。

    1. #切换到主分支
    2. $ git checkout main
    3. Switched to branch 'main'
    4. Your branch is up to date with 'origin/main'.
    5.  
    6.  
    7. #将MyHello合并到主分支
    8. $ git merge MyHello
    9. Updating 18c5cd7..14109a7
    10. Fast-forward
    11.  hello.txt | 0
    12.  1 file changed, 0 insertions(+), 0 deletions(-)
    13.  create mode 100644 hello.txt
    14.  
    15. #主分支提交到远程
    16. $ git push
    17. Total 0 (delta 0), reused 0 (delta 0), pack-reused 0
    18. To http://xxxxxxx:9066/cc/haizhou.git
    19.    18c5cd7..14109a7  main -> main
    20.  
    21.

    git如何解决merge冲突？

     假如有一个主分支master,上面有个文件 a.txt 。

    1.主分支编辑a.txt内容第一行加上一行master 1,并提交这个分支。

    2.在此分支上git checkout -b new_branch为master做一个新分支(这个命令会让new_branch拥有master分支在那一刻的所有提交历史，并且你将会在新的 new_branch 分支上开始工作)，然后我们编辑这个a.txt，第二行写上文字new branch 1，然后也对a.txt进行提交。

    3.我们再次切换至master分支，再次编辑这个a.txt, 此时master分支上仍然还只有一行，我们同样在a.txt第二行写上文字master 2。

    4.那么此时，master分支的第二行和new_branch的第二行就冲突了，如果我们想在master分支去合并new_branch分支，这时候会报分支冲突。

    那我们应该怎么处理呢？首先，我们在master分支上打开这个文件，然后保留主分支master和子分支new_branch需要合并的内容，然后对这个文件进行提交就行了。如果我们在合并分支的时候发现冲突了，我们此时不想进行合并，那么我们只需要执行git merge --abort 就会撤销此次合并。因为如果我们不撤销冲突的话， 我们没法切换别的分支。

    还有一种情况没法切换分支，如果当前我们的代码已经做了修改，我们放任不管去切换别的分支也是没法切换的，此时我们可以使用 git stash 将它们暂存（stash）起来，以确保在切换分支时不会丢失这些更改，或者是我们先把修改的代码进行提交。如果你不想保留对 a.txt 的本地更改，并且想要简单地丢弃它们以便切换分支，你可以这样做git checkout -- a.txt  ，这会恢复 a.txt 文件到上次提交的状态  。

    如果遇到冲突了，我们感觉自己改动的那部分代码不重要，如果我们想先合并被人的代码到自己的分支怎么办呢？可以使用这个命令：git checkout --theirs   也就是接受人家的，自己的放弃不要了，不过你得确认自己的变动的部分真的不想要了。

    对于meger：

    • 特点：
      • Git会自动尝试合并两个分支的代码。
      • 如果合并过程中有冲突，需要手动解决冲突并提交修改后的代码。
      • Merge会创建一个合并提交，保留了分支的整个历史记录。

    合并代码还有另外一种方式Rebase

    Rebase可以将当前分支的代码rebase到其他分支上，实现合并的效果。比如将new_branch上的a.txt合并到主分支master上。在git图上就是没有分叉了，变成一条线了

    • 特点：
      • Git会将目标分支（如master）的提交应用到当前分支（如feature）上。
      • 然后将当前分支（feature）移动到目标分支（master）的最新提交之后。
      • 如果合并过程中有冲突，同样需要手动解决冲突并提交修改后的代码。
      • Rebase能保持提交的线性，更适合在提交历史较为清晰时使用。

    总结：

    • merge和rebase都是Git中用于合并代码的方式，但它们在处理合并的方式和结果上有所不同。
    • merge会创建一个新的合并提交，而rebase则会改变当前分支的提交历史，使其看起来像是直接在目标分支上提交的一样。

    git stash命令

    这个命令可以将，本地工作区和暂存区的代码先保存起来，为啥要这样呢？

    有两种情况：

    1.你本地的主分支A开发告一段落了，你切了个B分支干新的活，你在当前B分支干活正爽，结果说你主分支上出bug了需要紧急修复，你不得不放下手头里的活切到A分支上去修复代码，可是这个时候直接切git是不会让你切的，因为你还有一堆变更未提交的文件还在B分支上，要么你提交（但是没做完提交有点不合理），要么你就用git stash先将当前B分支的代码存起来，等改完A分支上的代码后切回B再取回来用（git stash pop：恢复并删除 stash 。git stash apply：恢复不删除stash）。

    2.你还没提交代码的时候，要拉代码，这时候git也不会让你拉，你也只能把当前代码stash后再拉代码。

    分支回滚远程代码

    1.git reset

    1. #找到版本号
    2. $ git log
    3. #当前版本号
    4. commit 76ba27012bab81ec56b84eef085355f4f318f9e9 (HEAD -> main, origin/main, origin/HEAD)
    5. #上一次的版本号
    6. commit 14109a7c0cedc775070f73d6737a418b505db9d0 (origin/hello, MyHello)
    7.  
    8. # 设置要回退到的版本号
    9. $ git reset --hard 14109a7c0cedc775070f73d6737a418b505db9d0
    10. HEAD is now at 14109a7 hello
    11.  
    12. #提交更改  注意 main主分支有的时候会受保护，主分支强制推送会不成功
    13. $ git push -f  origin HEAD:hello
    14. Total 0 (delta 0), reused 0 (delta 0), pack-reused 0
    15.  
    16. #git push origin HEAD:hello 这句话啥意思呢
    17. origin: 这是远程仓库的别名。当你使用 git clone 命令克隆一个仓库时，Git 会自动将远程仓库命名为 origin（除非你指定了不同的名字）。之后，你可以使用 git remote 命令来查看或修改远程仓库的别名。
    18. HEAD:hello: 这部分指定了要推送的本地分支和远程分支的对应关系。
    19. HEAD: 通常表示当前检出的分支。也就是说，这条命令将会推送当前分支的更改。
    20. hello: 这是远程仓库上的目标分支名。这条命令的意思是将本地当前分支（由 HEAD 指定）的更改推送到远程仓库的 hello 分支。
    21. 所以，整体来说，git push origin HEAD:hello 这条命令的意思是：“将当前分支的更改推送到名为 origin 的远程仓库的 hello 分支上。”
    22. 如果远程仓库的 hello 分支不存在，Git 将会尝试创建一个新的 hello 分支，并将本地分支的更改推送到这个新分支上。如果 hello 分支已经存在，并且你没有使用 --force 选项，Git 将会尝试合并这些更改（如果可能的话），否则它会拒绝推送并给出一个错误消息。

    git这个log啥意思：commit debcf712367aacb535be3a8867d988eaa1e6539c (HEAD -> new_branch, master)

    • HEAD: 在Git中，HEAD 是一个特殊的指针，它指向当前检出的提交（也就是你当前所在的分支的最新提交）。这里显示 HEAD 指向 new_branch 分支上的这个提交，说明你现在正位于 new_branch 分支上。
    • -> new_branch: 这部分指示 new_branch 分支指向这个提交。换句话说，new_branch 的最新提交就是这个 debcf71。
    • , master: 逗号后的 master 表示 master 分支也指向这个提交。这通常意味着 new_branch 和 master 分支在这一点上是相同的，也就是说它们共享相同的提交历史，直到这个提交。

    从这段输出中，我们可以得出以下结论：

    1. 你当前位于 new_branch 分支上。
    2. new_branch 分支和 master 分支都指向同一个提交 debcf712367aacb535be3a8867d988eaa1e6539c。

    如果你在这个状态下在 new_branch 上做了新的提交，new_branch 将会向前移动，而 master 仍然会指向这个旧的提交，除非你也显式地在 master 上做了提交或合并了 new_branch 到 master。

    2.git revert

    revert操作，适用于撤销某一版本，而保留该版本之后的其他版本提交。适用场景：例如某需求先后进行过第一、第二、第三次版本提交之后发现第二个版本有问题，需要撤销第二个版本的操作，同时保留第三次版本的提交，可使用git revert操作。

    比如创建三个文件1.txt,2.txt,3.txt，分次推送后，再撤销第一次的，如下操作可见第一次的那个1的文件没了。

    1. #查看日志
    2. $ git log
    3. commit 8df77d747472bc9545d6847b6f2278f00ebf5773
    4. Author: admin 
    5. Date:   Thu May 30 15:57:05 2024 +0800
    6.  
    7.     3
    8.  
    9. commit 8cd63ad98cea08782a94ade57837e79ad211ebf6
    10. Author: admin 
    11. Date:   Thu May 30 15:56:51 2024 +0800
    12.  
    13.     2
    14.  
    15. commit 148cdf939d95fc47ab94a026d68dc883f788f075
    16. Author: admin 
    17. Date:   Thu May 30 15:56:01 2024 +0800
    18.  
    19.     1
    20.  
    21. #只撤回第一次的那个1.txt
    22. $ git revert -n 148cdf939d95fc47ab94a026d68dc883f788f075
    23.  
    24. #推送到远程
    25. $ git push origin HEAD:hello

  • 相关阅读:
    【愚公系列】2022年07月 Go教学课程 023-Go容器之列表
    JS选择框全选效果（从入门到优化）
    面试官：Redis基本命令有哪些，Redis怎么实现分布式锁？
    Canvas 指纹追踪技术
    加速CI构建，实现高效流水线——CloudBees CI发布工作区缓存功能
    express学习40-多人管理31数据分页2
    IOS卡在更新进度界面处理办法
    MySQL数据库增删改查进阶（联合查询聚合查询）
    做交互设计都有哪些需要掌握的思维方式
    MATLAB算法实战应用案例精讲-【图像处理】机器视觉（基础篇）（五）
  • 原文地址：https://blog.csdn.net/weixin_43970625/article/details/139323271