Git基础使用

2024-06-12 1687阅读

目录

  • 附录:Git常用命令
  • 一、起步
    • ⑴下载安装git
    • ⑵配置git
    • ⑶Git帮助
    • ⑷Git概念
    • 二、Git基础
      • ⑴获取Git仓库
        • ①创建一个新的Git仓库并推送到GitHub
        • ②克隆一个已存在的Git仓库
        • ⑵查看状态、跟踪文件
          • ①查看状态
          • ②跟踪文件
          • ③精简显示状态
          • ④查看已暂存和未暂存的修改
          • ⑶提交文件
            • ①将暂存区内容提交到Git目录
            • ②跳过暂存区提交
            • ⑷移除文件
              • ①在工作区手动移除文件
              • ②从Git仓库中移除文件
                • ㈠从Git仓库和工作区中同时移除对应文件
                • ㈡移除Git仓库的文件,保留工作区的文件
                • ③从暂存区移除文件
                  • ㈠从暂存区移除指定文件
                  • ㈡从暂存区移除所有文件
                  • ⑸撤销操作
                    • ①修改提交的说明
                    • ②撤销对文件的修改
                    • ⑹查看提交历史
                    • ⑺回退版本
                    • ⑻远程仓库
                      • ①查看远程仓库
                      • ②添加远程仓库
                      • ③从远程仓库抓取
                        • ㈠从远程仓库中获得数据
                        • ㈡本地修改与上游修改有冲突时的抓取数据
                        • ④推送到远程仓库
                        • ⑤重命名、移除远程仓库
                        • ⑼忽略文件(.gitignore)
                        • ⑽标签
                        • 三、分支
                          • ⑴创建分支
                          • ⑵切换分支
                          • ⑶创建分支并切换到该分支
                          • ⑷合并分支
                          • ⑸删除分支
                          • ⑹查看分支
                          • ⑺遇到冲突时的分支合并
                            • 文档

                              链接: Git•Documentation

                              附录:Git常用命令

                              • 文章

                                链接: 《Git常用命令》

                                一、起步

                                ⑴下载安装git

                                • 步骤
                                  1. 进入Git官网

                                    链接:Git

                                  2. 下载Git:

                                    点击【Downloads】

                                    Git基础使用

                                    选择对应系统版本

                                    Git基础使用

                                    Git基础使用

                                  3. 安装Git:

                                    运行应用程序

                                    Git基础使用

                                    根据提示,进行对应操作

                                    Git基础使用

                                    Git基础使用

                                    Git基础使用

                                  ⑵配置git

                                  • 步骤

                                    1.打开 Git Bash(安装Git时默认设置的,一般鼠标右键点击桌面空白处打开)

                                    Git基础使用

                                    2.输入Git命令

                                    配置用户名和邮件地址

                                    #配置用户名
                                    $ git config --global user.name "xm"
                                    #配置邮件地址
                                    $ git config --global user.email xm@163.com
                                    

                                    查看配置

                                    #列出配置
                                    $ git config -l
                                    #或
                                    $ git config --list
                                    #查看所有的配置及配置所在文件
                                    $ git config -l --show-origin
                                    #查看全局配置及配置所在文件
                                    $ git config --global -l --show-origin
                                    #查看系统配置及配置所在文件
                                    $ git config --system -l --show-origin
                                    #查看本地仓库配置及配置所在文件
                                    $ git config --local -l --show-origin
                                    

                                    示例:

                                    Git基础使用

                                    Git基础使用

                                    • 说明

                                      命令名称:git config (获取和设置仓库或全局选项)

                                      语法:

                                      ❶ git config [] []

                                      ❷ git config [] [–show-origin] -l | --list

                                      参数:

                                      从不同的文件读取或写入:

                                      –system($(prefix)/etc/gitconfig)

                                      –global(~/.gitconfig)

                                      –local(.git/config)

                                      ❷ –show-origin

                                      用来源类型和实际来源对所有查询到的配置选项的输出进行扩充。

                                      ❸ -l | --list

                                      列出配置文件中设置的所有变量,以及它们的值。

                                      ⑶Git帮助

                                      ①查看常用命令

                                      $ git -h
                                      #或
                                      $ git --help
                                      #或
                                      $ git help
                                      

                                      示例:

                                      Git基础使用

                                      ②查看手册页

                                      (比如 git -h config ,会调出 git config 的手册页)

                                      $ git -h 
                                      #或
                                      $ git --help 
                                      #或
                                      $ git help 
                                      

                                      ③查看参数选项

                                      (比如 git config -h ,查看 git config 的参数选项)

                                      $ git  -h
                                      

                                      ④查看 git 手册页

                                      $ git help git
                                      

                                      (备注:

                                      语法中的符号:

                                      Git基础使用

                                      尖括号,指示占位符文本。 要将其替换为所描述项的内容。(比如 git ,要替换成 git add 或 git init 等)

                                      [ ] 中括号,用中括起来表示可选项。(比如 [-h | --help] [-C ] 括在括号[ ]中,它们都是可选的)

                                      | 垂直条分隔, 表示只能从列出的值集中选择一个值。(比如 [-v | --version],选择其中的一个)

                                      ⑷Git概念

                                      Git是分布式版本控制系统。

                                      客户端每一次的克隆操作,都是一次对代码仓库的完整备份,包括完整的历史记录。

                                      Git的状态:已提交(committed)、已修改(modified)、已暂存(staged)。

                                      Git项目的几个阶段:

                                      Git基础使用

                                      二、Git基础

                                      ⑴获取Git仓库

                                      ①创建一个新的Git仓库并推送到GitHub

                                      • 文章

                                        链接: 《GitHub生成SSH密钥,使用SSH进行连接》

                                        ②克隆一个已存在的Git仓库

                                        将存储库克隆到新目录

                                        $ git clone 
                                        
                                        • 示例
                                          1. 切换到指定文件夹
                                          cd  
                                          

                                          Git基础使用

                                          (或在文件夹下打开Git Bash)

                                          1. 找到要克隆的链接库

                                            (比如:链接:GitHub•libgit2

                                          点击仓库的【Code】 -> 选择【SSH】->复制链接

                                          Git基础使用

                                          1. 克隆仓库

                                            Git基础使用

                                          ⑵查看状态、跟踪文件

                                          • 说明
                                            一般显示
                                            未跟踪UntrackedGit基础使用
                                            未修改UnmodifiedGit基础使用
                                            已修改ModifiedGit基础使用
                                            未暂存UnstagedGit基础使用Git基础使用
                                            已暂存StagedGit基础使用

                                            ①查看状态

                                            $ git status
                                            

                                            ②跟踪文件

                                            ㈠跟踪指定文件

                                            跟踪指定文件,并将该文件放入暂存区;

                                            把已跟踪、且已修改的文件放入暂存区;

                                            把有冲突的文件标记为已解决状

                                            $ git add 
                                            

                                            ㈡跟踪所有文件

                                            $ git add .
                                            
                                            • 示例
                                              1. 新建一个文件;

                                                运行 git status (查看状态),提示 Untracked(未跟踪)

                                                Git基础使用

                                              2. 运行 git add (跟踪文件);

                                                查看状态,提示 Changes to be committed

                                              在 Changes to be committed 这行下面,说明是已暂存状态

                                              Git基础使用

                                              1. 修改已跟踪的文件;

                                                查看状态,提示 Changes not staged for commit

                                              在 Changes not staged for commit 这行下面,说明已跟踪文件的内容发生了变化,但未加入暂存区

                                              Git基础使用

                                              1. 运行 git add (将文件加入暂存区)

                                                Git基础使用

                                              2. 再修改文件;

                                                查看状态,发现文件同时出现在暂存区和非暂存区

                                                Git基础使用

                                              运行了 git add 之后又作了修改的文件,需要重新运行 git add 把最新版本重新暂存起来

                                              Git基础使用

                                              ③精简显示状态

                                              $ git status -s
                                              #或
                                              $ git status --short
                                              

                                              精简状态下的符号含义:

                                              符号含义备注
                                              左边是暂存区状态,右边是工作区状态
                                              M在暂存区中修改红色:未在暂存区,已修改;绿色:在暂存区,已修改
                                              A添加到暂存区
                                              D从暂存区中删除红色:未在暂存区,已删除;绿色:在暂存区,已删除
                                              ??新增的未跟踪的

                                              示例:

                                              Git基础使用

                                              D(红色):

                                              Git基础使用

                                              D(绿色):

                                              Git基础使用

                                              ④查看已暂存和未暂存的修改

                                              ㈠查看未暂存的文件工作区和暂存区的变化

                                              $ git diff
                                              

                                              ㈡查看已暂存文件与最后一次提交的文件差异

                                              $ git diff --staged
                                              #或
                                              $ git diff --​cached
                                              

                                              示例:

                                              Git基础使用

                                              Git基础使用

                                              ⑶提交文件

                                              ①将暂存区内容提交到Git目录

                                              提交(使用给定的作为提交消息)

                                              $ git commit -m 
                                              

                                              示例:

                                              Git基础使用

                                              ②跳过暂存区提交

                                              提交(把所有已经跟踪过的文件暂存起来一并提交,跳过 git add 步骤)

                                              $ git commit -a -m 
                                              

                                              示例:

                                              Git基础使用

                                              ⑷移除文件

                                              要从Git中移除某个文件,就必须要从已跟踪文件清单中移除(确切地说,是从暂存区移除),然后提交

                                              ①在工作区手动移除文件

                                              (手动移除文件后,运行 git rm 记录移除,在下次提交时,文件就不纳入版本管理了)

                                              $ git rm 
                                              

                                              示例:

                                              Git基础使用

                                              ②从Git仓库中移除文件

                                              ㈠从Git仓库和工作区中同时移除对应文件
                                              $ git rm -f 
                                              

                                              示例:

                                              Git基础使用

                                              ㈡移除Git仓库的文件,保留工作区的文件
                                              $ git rm --cached 
                                              

                                              Git基础使用

                                              ③从暂存区移除文件

                                              ㈠从暂存区移除指定文件
                                              $ git reset HEAD 
                                              
                                              ㈡从暂存区移除所有文件
                                              $ git reset HEAD .
                                              

                                              示例:

                                              git reset HEAD

                                              Git基础使用

                                              git reset HEAD .

                                              Git基础使用

                                              ⑸撤销操作

                                              • 文档

                                                链接: GitLab•文档中心•Git•Git 撤销

                                                链接: Vim documentation: help

                                                ①修改提交的说明

                                                $ git commit --amend
                                                

                                                这个命令会将暂存区中的文件提交。如果上次提交后没有作任何修改(比如在上次提交后马上执行了此命令), 那么你所修改的只是提交信息。

                                                文本编辑器启动后,可以看到之前的提交信息。 编辑后保存会覆盖原来的提交信息。

                                                • 示例

                                                  运行 git commit -m 提交信息后,想要修改提交的 信息

                                                  1. 运行 git commit --amend

                                                    Git基础使用

                                                  2. 出现提示,输入 E

                                                    Git基础使用

                                                  3. 进入编辑器界面,可以看到之前的提交信息

                                                    Git基础使用

                                                  4. 输入 i (进入插入模式INSERT)

                                                    Git基础使用

                                                  5. 编辑完成,按键盘 Esc 键(退出插入模式INSERT,返回正常模式)

                                                    Git基础使用

                                                  6. 输入 :wq ->回车。

                                                    (备注:

                                                    w(保存);

                                                    q (关闭本窗口)

                                                    Git基础使用

                                                    (新的提交信息覆盖原来的提交信息)

                                                    Git基础使用

                                                  ②撤销对文件的修改

                                                  ㈠撤销对指定文件的修改

                                                  $ git checkout -- 
                                                  

                                                  ㈡撤销对所有文件的修改

                                                  $ git checkout .
                                                  

                                                  指的是对已提交的文件的修改,然后撤销,撤销以后,可以将它还原成上次提交时的样子。Git 会用最近提交的版本覆盖掉它

                                                  示例:

                                                  git checkout .

                                                  Git基础使用

                                                  git checkout –

                                                  Git基础使用

                                                  ⑹查看提交历史

                                                  ①显示提交历史

                                                  $ git log
                                                  

                                                  ②显示提交历史(最近数量的提交历史)

                                                  (比如 git log -2 显示最近2次的提交历史)

                                                  $ git log -数量
                                                  

                                                  ③显示提交历史(按行显示+简写/完整哈希值)

                                                  #按行显示提交历史(简写哈希值)
                                                  $ git log --oneline
                                                  #按行显示对应数量的提交历史(简写哈希值)
                                                  $ git log -数量 --oneline
                                                  #按行显示提交历史(完整哈希值)
                                                  $ git log --pretty=oneline
                                                  #按行显示对应数量的提交历史(完整哈希值)
                                                  $ git log -数量 --pretty=oneline
                                                  

                                                  ④显示提交历史(简略统计信息)

                                                  $ git log --stat
                                                  

                                                  ⑤查看历史状态(定制记录的显示格式)

                                                  $ git log --pretty=format:"%H - %s, %cd"
                                                  

                                                  表格: git log --pretty=format 常用的选项

                                                  选项说明
                                                  %H提交的完整哈希值
                                                  %h提交的简写哈希值
                                                  %T树的完整哈希值
                                                  %t树的简写哈希值
                                                  %P父提交的完整哈希值
                                                  %p父提交的简写哈希值
                                                  %an作者名字
                                                  %ae作者的电子邮件地址
                                                  %ad作者修订日期(可以用 --date=选项 来定制格式)
                                                  %ar作者修订日期,按多久以前的方式显示
                                                  %cn提交者的名字
                                                  %ce提交者的电子邮件地址
                                                  %cd提交日期
                                                  %cr提交日期(距今多长时间)
                                                  %s提交说明

                                                  ⑺回退版本

                                                  查看提交历史

                                                  $ git log --oneline
                                                  

                                                  指定版本

                                                  $ git reset --hard 提交的哈希值
                                                  

                                                  重新查看提交历史

                                                  $ git log --reflog --oneline
                                                  

                                                  重新指定版本

                                                  $ git reset --hard 提交的哈希值
                                                  

                                                  示例:

                                                  Git基础使用

                                                  再次回到 525e7bf 的版本

                                                  Git基础使用

                                                  ⑻远程仓库

                                                  ①查看远程仓库

                                                  ㈠查看远程仓库的名字

                                                  $ git remote
                                                  

                                                  ㈡查看远程仓库使用的Git保存的简写与其对应的URL

                                                  $ git remote -v
                                                  

                                                  ㈢查看某个远程仓库(比如 git remote show origin)

                                                  $ git remote show 
                                                  

                                                  ②添加远程仓库

                                                  添加一个新的远程Git仓库

                                                  $ git remote add  
                                                  

                                                  使用 git clone 克隆的仓库,自动添加为远程仓库并默认以 “origin” 为简写

                                                  ③从远程仓库抓取

                                                  ㈠从远程仓库中获得数据
                                                  $ git pull
                                                  

                                                  git pull 命令通常会从最初克隆的服务器上抓取数据并自动尝试合并到当前所在的分支

                                                  示例:

                                                  Git基础使用

                                                  :q(关闭本窗口)

                                                  Git基础使用

                                                  ㈡本地修改与上游修改有冲突时的抓取数据
                                                  • 说明

                                                    当本地修改与上游的修改不冲突时,运行 git pull 。

                                                    有些情况下,本地修改与上游修改有冲突,而 git pull 拒绝覆盖你的修改。

                                                    在这种情况下可以选择:

                                                    ❶保留本地修改(把进度保存起来,执行一次拉取,然后再解开)

                                                    $ git pull
                                                     ...
                                                    文件 xxx 不是最新的,无法合并。
                                                    $ git stash
                                                    $ git pull
                                                    $ git stash pop
                                                    

                                                    ❷不保留本地修改(远程代码覆盖本地)

                                                    $ git reset --hard
                                                    $ git pull origin main
                                                    
                                                    • 说明

                                                      命令名称:git stash(将变化藏在一个脏工作区中)

                                                      语法:

                                                      ❶ git stash list

                                                      ❷ git stash pop

                                                      参数:

                                                      ❶ list

                                                      列出你目前拥有的储藏目录。

                                                      ❷ pop

                                                      从贮藏库列表中移除一个单一的贮藏状态,并将其应用于当前工作区状态之上。

                                                      命令名称:git reset (重置当前HEAD到指定的状态)

                                                      语法:

                                                      ❶ git reset --hard

                                                      参数:

                                                      ❶ –hard

                                                      重置暂存区和工作区。工作区中自 以来对跟踪文件的任何更改都会被丢弃。 任何妨碍写入跟踪文件的未跟踪文件或目录都会被删除。

                                                      示例:

                                                      git stash;

                                                      git stash list;

                                                      git stash pop

                                                      Git基础使用

                                                      git reset --hard

                                                      Git基础使用

                                                      ④推送到远程仓库

                                                      ㈠首次推送(比如 git remote -u origin main)

                                                      $ git push -u  
                                                      

                                                      ㈡推送

                                                      $ git push
                                                      

                                                      当命令行没有用 参数指定推送位置时,会参考当前分支的 branch.*.remote 配置来决定推送位置。 如果配置丢失,则默认为 “origin”。

                                                      Git基础使用

                                                      (一般远程仓库有了新的推送内容)必须先抓取远程仓库合并进工作后再推送(先运行 git pull ,…,再运行 git push)

                                                      ㈢推送分支到远程仓库(比如 git push origin main(推送main分支到origin远程仓库))

                                                      $ git push  
                                                      

                                                      ㈣删除远程分支

                                                      $ git push  --delete 
                                                      

                                                      示例:

                                                      Git基础使用

                                                      Git基础使用

                                                      Git基础使用

                                                      ⑤重命名、移除远程仓库

                                                      ㈠重命名远程仓库

                                                      $ git remote rename  
                                                      

                                                      ㈡移除远程仓库

                                                      $ git remote remove 
                                                      #或
                                                      $ git remote rm 
                                                      

                                                      示例:

                                                      Git基础使用

                                                      ⑼忽略文件(.gitignore)

                                                      • 说明

                                                        .gitignore 文件可以让一些不需要Git追踪的文件不被跟踪

                                                        格式
                                                        以 # 开头的一行为注释
                                                        所有空行或者以 # 开头的行都会被Git忽略
                                                        匹配模式可以以(/)开头防止递归(如果只想将其限制在目录中,而不限制在其子目录中,可以在模式前加上斜线(/))
                                                        (比如 /a.txt 模式可匹配当前目录的 a.txt 但不匹配 sub/a.txt )
                                                        匹配模式可以以(/)结尾指定目录
                                                        (比如 sub/ 忽略模式,忽略任何目录下名为 sub 的文件夹)
                                                        要忽略指定模式以外的文件或目录,可以在模式前加上叹号(!)取反(任何被先前模式排除的匹配文件都将被重新包含。如果文件的父目录已被排除,则无法重新包含该文件)
                                                        (比如 忽略了 *.txt,!a.txt 忽略模式,跟踪所有的 a.txt,即便在前面忽略了 *.txt 文件)
                                                        可以使用标准的 glob 模式匹配,它会递归地应用在整个工作区中
                                                        (glob 模式:
                                                        星号(*)匹配零个或多个任意字符(比如模式 a.* 匹配名称以 a. 开头的任何文件或目录);

                                                        [abc] 匹配任何一个列在方括号中的字符 (比如匹配一个 a,或匹配一个 b,或匹配一个 c);

                                                        问号(?)只匹配一个任意字符;

                                                        如果在方括号中使用短划线分隔两个字符, 表示所有在这两个字符范围内的都可以匹配(比如 [0-9] 表示匹配所有 0 到 9 的数字);
                                                        使用两个星号(**)表示匹配任意中间目录,比如 a/**/z 可以匹配 a/z 、 a/b/z 或 a/b/c/z

                                                        … )

                                                        • 示例
                                                          1. 创建 .gitignore 文件

                                                            Git基础使用

                                                          2. 定义匹配模式

                                                          忽略模式匹配当前目录及子目录

                                                          Git基础使用

                                                          在模式前加上斜线(/)(匹配模式限制在目录中,而不限制在其子目录中)

                                                          Git基础使用

                                                          以(/)结尾指定目录(比如 sub/ 忽略模式,忽略任何目录下名为 sub 的文件夹)

                                                          Git基础使用

                                                          在模式前加上叹号(!)取反(忽略指定模式以外的文件或目录)

                                                          (任何被先前模式排除的匹配文件都将被重新包含。如果文件的父目录已被排除,则无法重新包含该文件)

                                                          Git基础使用

                                                          星号(*)匹配零个或多个任意字符(比如模式 a.* 匹配名称以 a. 开头的任何文件或目录)

                                                          Git基础使用

                                                          问号(?)只匹配一个任意字符

                                                          Git基础使用

                                                          [abc] 匹配任何一个列在方括号中的字符 (比如匹配一个 a,或匹配一个 b,或匹配一个 c)

                                                          Git基础使用

                                                          如果在方括号中使用短划线分隔两个字符, 表示所有在这两个字符范围内的都可以匹配(比如 [0-9] 表示匹配所有 0 到 9 的数字)

                                                          Git基础使用

                                                          ⑽标签

                                                          • 说明

                                                            ①列出已有标签

                                                            $ git tag
                                                            

                                                            ②创建标签

                                                            ㈠创建轻量标签

                                                            (比如 git tag v1.0 )

                                                            $ git tag 
                                                            

                                                            ㈡创建附注标签

                                                            (比如 git tag -a v1.1 -m “version 1.1” )

                                                            $ git tag -a  -m 
                                                            

                                                            ③查看标签

                                                            $ git show 
                                                            

                                                            ④推送标签到远程仓库

                                                            ㈠推送指定标签

                                                            $ git push origin 
                                                            

                                                            ㈡推送所有不在远程仓库的标签到远程仓库

                                                            $ git push origin --tags
                                                            

                                                            ⑤删除标签

                                                            ㈠删除本地标签

                                                            $ git tag -d 
                                                            

                                                            ㈡删除远程标签

                                                            $ git push origin --delete 
                                                            
                                                            • 示例

                                                              Git基础使用

                                                              此时在远程仓库可以查看推送的标签

                                                              Git基础使用

                                                              Git基础使用

                                                              Git基础使用

                                                              此时在远程仓库查看标签已被删除

                                                              Git基础使用

                                                              Git基础使用

                                                              三、分支

                                                              • 说明

                                                                ⑴创建分支

                                                                ( git branch 命令是创建一个新分支,不会自动切换到新分支中去)

                                                                $ git branch 分支名
                                                                

                                                                ⑵切换分支

                                                                $ git checkout 目标分支名
                                                                

                                                                ⑶创建分支并切换到该分支

                                                                $ git checkout -b 分支名
                                                                

                                                                ⑷合并分支

                                                                $ git merge 需要合并进来的的分支名
                                                                

                                                                ⑸删除分支

                                                                ①删除分支

                                                                $ git branch -d 分支名
                                                                

                                                                ②删除分支(不管其合并状态如何,也不管它是否指向一个有效的提交)

                                                                $ git branch -D 分支名
                                                                

                                                                ⑹查看分支

                                                                ①列出所有的分支列表(分支前有 * 代表当前所在分支(当前 HEAD 指针所指向的分支))

                                                                $ git branch
                                                                

                                                                HEAD 指向当前所在的分支

                                                                示例:

                                                                Git基础使用

                                                                ②列出已经合并到当前分支的分支

                                                                $ git branch --merged
                                                                

                                                                ③列出尚未合并到当前分支的分支

                                                                $ git branch --no-merged
                                                                
                                                                • 示例
                                                                  1. git clone 克隆一个仓库;

                                                                    运行 git remote -v(查看远程仓库)

                                                                    Git基础使用

                                                                  2. 切换到项目目录
                                                                  3. 运行 git checkout -b 分支名(创建分支并切换到该分支);

                                                                    在工作区修改内容;

                                                                    运行 git add 或 git add .(加入暂存区);

                                                                    运行 git commit -m (提交);

                                                                    运行 git push origin fenzhi1 (将fenzhi1分支推送到远程仓库origin)

                                                                    Git基础使用

                                                                  本地的分支并不会自动与远程仓库同步—必须显式地推送分支

                                                                  此时在远程仓库可以看到推送的分支

                                                                  Git基础使用

                                                                  1. 运行 git checkout main (切换到main分支);

                                                                    运行 git merge fenzhi1 (合并分支);

                                                                    运行 git push(推送更改)

                                                                    Git基础使用

                                                                    此时在远程仓库可以看到fenzhi1分支和main分支更改的内容

                                                                    Git基础使用

                                                                    Git基础使用

                                                                  ⑺遇到冲突时的分支合并

                                                                  • 示例

                                                                    (比如有时候在两个不同的分支中,对同一个文件的同一个部分进行了不同的修改,合并时提示出现冲突)

                                                                    1. 运行 git merge 分支名 (合并分支)时,提示出现冲突

                                                                      Git基础使用

                                                                    2. 解决冲突

                                                                      比如在vscode中打开冲突的文件,选择不同的更改方式,更改后保存

                                                                      Git基础使用

                                                                      Git基础使用

                                                                      Git基础使用

                                                                    3. 运行 git add (将文件标记为冲突已解决)

                                                                    解决了所有文件里的冲突后,对每个文件使用 git add 命令来将其标记为冲突已解决。 一旦暂存这些原本有冲突的文件,Git

                                                                    就会将它们标记为冲突已解决。

                                                                    Git基础使用

                                                                    1. 运行 git status 来确认所有的合并冲突都已被解决;

                                                                      运行 git commit -m 提交

                                                                      Git基础使用

VPS购买请点击我

免责声明:我们致力于保护作者版权,注重分享,被刊用文章因无法核实真实出处,未能及时与作者取得联系,或有版权异议的,请联系管理员,我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明:本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度,360,搜狗等多加搜索引擎自动关键词搜索配图,如有侵权的图片,请第一时间联系我们,邮箱:ciyunidc@ciyunshuju.com。本站只作为美观性配图使用,无任何非法侵犯第三方意图,一切解释权归图片著作权方,本站不承担任何责任。如有恶意碰瓷者,必当奉陪到底严惩不贷!

目录[+]