devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

git详细讲解_git csdn

作者：AllinToyou | 2024-04-25 01:21:06

赞

踩

git csdn

目录

一.git详细介绍 

1、git起源与简介 

2、集中式与分布区别

3、集中式与分布式区别

4、git的安装

5、git的安装与版本库的创建

6、把文件添加到版本库

7、git版本回退、文件修改、撤销与删除

8、工作区和暂存区

9、git管理是修改而非文件

10、git如何撤销修改

11.git删除文件

二.git远程仓库的添加与克隆

1、如何添加远程库

2、注册https://gitee.com账号

3、在本地生成ssh密钥对

4、在gitee.com上创建新的仓库，注意不要初始化仓库

5、本地仓库和远程仓库进行同步

6、从远程库克隆

一.git详细介绍

1、git起源与简介

Linus在1991年创建了开源的Linux，Linux的代码是如何管理的呢？Linus花了两周时间自己用C写了一个分布式版本控制系统，这就是Git！

Git是目前世界上最先进的分布式版本控制系统，那什么是版本控制系统？

  • 能够记录文档的改动历史

  • 能够回滚到任意一个修改时间点

  • 能够协作编辑文件

2、集中式与分布式的区别

集中式版本控制系统，版本库是集中存放在中央服务器的，而干活的时候， 用的都是自己的电脑，所以要先从中央服务器取得最新的版本， 然后开始干活，干完活了，再把自己的工作推送给中央服务器。 中央服务器就好比是一个图书馆，你要改一本书， 必须先从图书馆借出来，然后回到家自己改，改完了，再放回图书馆。

3、集中式与分布式区别 

分布式版本控制系统根本没有“中央服务器”，每个人的电脑上都是一个完整的版本库，这样，你工作的时候，就不需要联网了，因为版本库就在你自己的电脑上。

多个人如何协作呢？比方说你在自己电脑上改了文件A，你的同事也在他的电脑上改了文件A， 这时，你们俩之间只需把各自的修改推送给对方，就可以互相看到对方的修改了。

和集中式版本控制系统相比，分布式版本控制系统的安全性要高很多， 因为每个人电脑里都有完整的版本库，某一个人的电脑坏掉了不要紧， 随便从其他人那里复制一个就可以了。 而集中式版本控制系统的中央服务器要是出了问题，所有人都没法干活了。 分布式版本控制系统通常也有一台充当“中央服务器”的电脑， 但这个服务器的作用仅仅是用来方便“交换”大家的修改， 没有它大家也一样干活，只是交换修改不方便而已。

4、git的安装

最早Git是在Linux上开发的，很长一段时间内，Git也只能在Linux和Unix系统上跑。不过，慢慢地有人把它移植到了Windows上。现在，Git可以在Linux、Unix、Mac和Windows这几大平台上正常运行了。    我用的是Centos7.5版本，首先，可以试着输入Git，看看系统有没有安装Git：

[root@server ~]# yum install -y git

安装完成后，还需要最后一步设置，在命令行输入：

  1. [root@server ~]# git config --global user.name "chao"
  2. [root@server ~]# git config --global user.email "3386785198@qq.com"
  3. [root@server ~]# git config --list
  4.

注意git config命令的--global参数，用了这个参数，表示这台机器上所有的Git仓库都会使用这个配置，当然也可以对某个仓库指定不同的用户名和Email地址。

5、git的安装与版本库的创建

      版本库又叫仓库，英文名repository ，可以简单理解成一个目录，这个目录里面的所有文件都可以被Git管理起来，每个文件的修改，删除，Git都能跟踪，以便任何时刻都可以追踪历史，或者在将来某个时刻可以 还原 

创建一个版本库非常简单，首先，选择一个合适的地方，创建一个空目录：

  1. [root@server ~]# mkdir -p /data/mygit
  2. [root@server ~]# cd /data/mygit

通过git init 命令把这个目录变成Git可以管理的仓库：

  1. [root@server mygit]# git init
  2. 初始化空的 Git 版本库于 /data/mygit/.git/
  3. [root@server mygit]# ls -a
  4. .  ..  .git

注意：初始化之后当前目录下多了一个.git的目录，这个目录是Git来跟踪管理版本库的，没事千万不要手动修改这个目录里面的文件，不然改乱了，就把Git仓库给破坏了。

6、把文件添加到版本库

请注意，所有的版本控制系统，其实只能跟踪文本文件的改动，比如TXT文件，网页，所有的程序代码等等，Git也不例外。版本控制系统可以告诉你每次的改动，而图片、视频这些二进制文件，虽然也能由版本控制系统管理，但没法跟踪文件的变化，只能把二进制文件每次改动串起来，也就是只知道图片从100KB改成了120KB，但到底改了啥，版本控制系统不知道，也没法知道。

  1. [root@server mygit]# vim readme.txt
  2. git is a version

注意：上述文件一定要放到mygit目录下（子目录也行），因为这是一个Git仓库。

下面是将文件添加到仓库和提交到仓库

  1. [root@server mygit]# git add readme.txt
  2. [root@server mygit]# git commit -m "add files readme.txt"
  3. [master（根提交） 4793fe7] add files readme.txt
  4.  1 file changed, 0 insertions(+), 0 deletions(-)
  5.  create mode 100644 readme.txt

还可以一次提交多次文件

  1. [root@server mygit]# cp /etc/hosts .
  2. [root@server mygit]# cp /etc/resolv.conf .
  3. [root@server mygit]# git add hosts resolv.conf
  4. [root@server mygit]# git commit -m "add two files"
  5. [master f6a2ae4] add two files
  6.  2 files changed, 5 insertions(+)
  7.  create mode 100644 hosts
  8.  create mode 100644 resolv.conf

7、git版本回退、文件修改、撤销与删除

修改readme.txt文件内容如下

  1. [root@server mygit]# echo "git is a version ok" > readme.txt
  2. [root@server mygit]# cat readme.txt
  3. git is a version ok
  4.  
  5. [root@server mygit]# git status
  6. # 位于分支 master
  7. # 尚未暂存以备提交的变更：
  8. #   （使用 "git add <file>..." 更新要提交的内容）
  9. #   （使用 "git checkout -- <file>..." 丢弃工作区的改动）
  10. #
  11. #    修改：      readme.txt
  12. #
  13. 修改尚未加入提交（使用 "git add" 和/或 "git commit -a"）
  14.  
  15. [root@server mygit]# git diff readme.txt
  16. diff --git a/readme.txt b/readme.txt           
  17. index 05e0843..fd78016 100644
  18. --- a/readme.txt
  19. +++ b/readme.txt
  20. @@ -1 +1 @@
  21. -git is a version
  22. +git is a version  ok
  23.  
  24. [root@server mygit]# git add readme.txt
  25.  
  26. [root@server mygit]# git status
  27. # 位于分支 master
  28. # 要提交的变更：
  29. #   （使用 "git reset HEAD <file>..." 撤出暂存区）
  30. #
  31. #    修改：      readme.txt
  32. #
  33.  
  34. [root@server mygit]#git commit -m "add ok"
  35. [master 7ebead4] add ok
  36. 1 file changed, 1 insertion(+), 1 deletion(-)
  37. [root@hd1 mygit]#
  38. [root@hd1 mygit]# git status
  39. # 位于分支 master
  40. 无文件要提交，干净的工作区
  41.  
  42. ----------------------------------------------
  43. #git 回退 首先修改readme.txt文件 
  44.  
  45. [root@server mygit]# cat readme.txt
  46. git is a version  ok
  47. git is very good
  48. [root@server mygit]# git add readme.txt
  49. [root@server mygit]# git commit -m "add a line"
  50.  
  51.  
  52. #查看修改的日志
  53. [root@server mygit]# git log
  54.  
  55. commit c46361af969cf7cac5b60f7217d1f629b616c328
  56. Author: duoduo <wmbenet@126.com>
  57. Date:   Sat Aug 7 14:25:44 2021 +0800
  58.  
  59.  
  60.     add a line
  61.  
  62.  
  63. commit 7ebead447739c2d93d59bb39df0c24777f83141a
  64. Author: duoduo <wmbenet@126.com>
  65. Date:   Sat Aug 7 14:21:51 2021 +0800
  66.  
  67.  
  68.     add ok
  69.  
  70.  
  71. commit 8f1ea6afbfe4b634bd8df9f65333ddf3dbf201e3
  72. Author: duoduo <wmbenet@126.com>
  73. Date:   Sat Aug 7 12:02:33 2021 +0800
  74.  
  75.  
  76.     add two files
  77.  
  78.  
  79. commit da2ae5b05ac02d56e9039defde163b0d8d6a5e0e
  80. Author: duoduo <wmbenet@126.com>
  81. Date:   Sat Aug 7 11:55:37 2021 +0800
  82.  
  83.  
  84.     add files readme.txt

那么如何将readme.txt 回退到上一个版本呢，首先，Git必须知道当前版本是哪个版本，在Git中，用HEAD表示当前版本，也就是最新的提交，上一个版本就是HEAD^，上上一个版本就是HEAD^^，当然往上100个版本写100个^比较容易数不过来，所以写成HEAD~100。

  1. [root@hd1 mygit]# git reset --hard HEAD^
  2. HEAD 现在位于 7ebead4 add ok
  3. [root@hd1 mygit]# cat readme.txt
  4. git is a version  ok
  5.  
  6.  
  7. [root@hd1 mygit]# git log
  8. commit 7ebead447739c2d93d59bb39df0c24777f83141a
  9. Author: duoduo <wmbenet@126.com>
  10. Date:   Sat Aug 7 14:21:51 2021 +0800
  11.  
  12.  
  13.     add ok
  14.  
  15.  
  16. commit 8f1ea6afbfe4b634bd8df9f65333ddf3dbf201e3
  17. Author: duoduo <wmbenet@126.com>
  18. Date:   Sat Aug 7 12:02:33 2021 +0800
  19.  
  20.  
  21.     add two files
  22.  
  23.  
  24. commit da2ae5b05ac02d56e9039defde163b0d8d6a5e0e
  25. Author: duoduo <wmbenet@126.com>
  26. Date:   Sat Aug 7 11:55:37 2021 +0800
  27.  
  28.  
  29.     add files readme.txt

以上可以看到我们回退到上一次的内容中了  ，这里有一个问题我想恢复到，恢复操作之前的状态怎么办？

下面是见证奇迹的时刻，c46361af969cf是部分commit的编号

  1. [root@server mygit]# git reset --hard c46361af969cf
  2. HEAD 现在位于 c46361a add a line
  3. [root@server mygit]# cat readme.txt
  4. git is a version  ok
  5. git is very good

Git的版本回退速度非常快，因为Git在内部有一个指针，如下图所示：

  

 关于回退，还有个命令

  1. [root@server mygit]# git reflog
  2. c46361a HEAD@{0}: reset: moving to c46361af969cf
  3. 7ebead4 HEAD@{1}: reset: moving to HEAD^
  4. c46361a HEAD@{2}: commit: add a line
  5. 7ebead4 HEAD@{3}: commit: add ok
  6. 8f1ea6a HEAD@{4}: commit: add two files
  7. da2ae5b HEAD@{5}: commit (initial): add files readme.txt
  8. [root@server mygit]#

8、工作区和暂存区

工作区（Working Directory）就是你在电脑里能看到的目录，比如我的mygit文件夹就是一个工作区。

工作区有个隐藏的目录 .git ，这个不算工作区，而是git的版本库。git的版本库里存了很多东西，其中最重要的就是称为stage （或者叫index）的暂存区，还有git为我们自动创建的第一个分支master，以及指向master的一个指针叫HEAD。

 前面讲了我们把文件往git版本库里添加的时候，是分两步执行的：

第一步是用git add 把文件添加进去，实际上就是把文件修改添加到暂存区；

第二步是用git commit 提交更改，实际上就是把暂存区的所有内容提交到当前分支。

可以简单理解为，需要提交文件修改通通放到暂存区，然后，一次性提交暂存区的所有修改。

9、git管理是修改而非文件

什么是修改？比如你新增加了一行，这就是修改，删除了一行，也是一个修改，更改了某些字符，也是一个修改，删了一些又增加了一些，也是一个修改，而创建一个新文件，也是一个修改。

10、git如何撤销修改

我们写代码犯错是难免的，但是git允许你犯错，因为git有撤销修改的功能，git checkout --file 可以丢弃工作区的修改：

例1：只是在工作区进行了修改，并未进行add到暂存区

  1. [root@server mygit]# echo "git 7788" >readme.txt
  2. [root@server mygit]# cat readme.txt
  3. git 7788
  4. [root@server mygit]# git status
  5. # 位于分支 master
  6. # 尚未暂存以备提交的变更：
  7. #   （使用 "git add <file>..." 更新要提交的内容）
  8. #   （使用 "git checkout -- <file>..." 丢弃工作区的改动）
  9. #
  10. #    修改：      readme.txt
  11. #
  12. 修改尚未加入提交（使用 "git add" 和/或 "git commit -a"）
  13. [root@server mygit]# git checkout -- readme.txt
  14. [root@server mygit]# cat readme.txt
  15. git is a version  ok
  16. git is very good

例2：在工作区进行了修改，并且add到了暂存区

  1. [root@server mygit]# git status
  2. # 位于分支 master
  3. 无文件要提交，干净的工作区
  4. [root@server mygit]# cat readme.txt
  5. git 7788
  6. [root@server mygit]# echo "hao xiang ku " >readme.txt
  7. [root@server mygit]# git add readme.txt
  8. [root@server mygit]#
  9. [root@server mygit]# git status
  10. # 位于分支 master
  11. # 要提交的变更：
  12. #   （使用 "git reset HEAD <file>..." 撤出暂存区）
  13. #
  14. #    修改：      readme.txt
  15. #
  16. [root@server mygit]# git reset HEAD readme.txt
  17. 重置后撤出暂存区的变更：
  18. M    readme.txt
  19. [root@server mygit]# git status
  20. # 位于分支 master
  21. # 尚未暂存以备提交的变更：
  22. #   （使用 "git add <file>..." 更新要提交的内容）
  23. #   （使用 "git checkout -- <file>..." 丢弃工作区的改动）
  24. #
  25. #    修改：      readme.txt
  26. #
  27. 修改尚未加入提交（使用 "git add" 和/或 "git commit -a"）
  28. [root@server mygit]# cat readme.txt
  29. hao xiang ku
  30. [root@server mygit]# git checkout -- readme.txt
  31. [root@server mygit]# cat readme.txt
  32. git 7788

 注意：git checkout  --  后面有空格，有空格，有空格，让这个文件回到最近一次git commit或git add时的状态。

git checkout -- file  命令中的--很重要，没有--，就变成了“切换到另一个分支”的命令，我们在后面的分支管理中会再次遇到git checkout命令。 

举例： 总结： 

场景1：当你改乱了工作区某个文件的内容，想直接丢弃工作区的修改时，用命令git checkout -- file。 

场景2：当你不但改乱了工作区某个文件的内容，还添加到了暂存区时，想丢弃修改，分两步，第一步用命令git reset HEAD <file>，就回到了场景1，第二步按场景1操作。 

11、git删除文件

命令git rm用于删除一个文件。如果一个文件已经被提交到版本库，那么永远不用担心误删，但是要小心，你只能恢复文件到最新版本，你会丢失最近一次提交后你修改的内容。

1）删除后，通过git恢复文件

  1. [root@server mygit]# rm -rf readme.txt
  2. [root@server mygit]# git status
  3. # 位于分支 master
  4. # 尚未暂存以备提交的变更：
  5. #   （使用 "git add/rm <file>..." 更新要提交的内容）
  6. #   （使用 "git checkout -- <file>..." 丢弃工作区的改动）
  7. #
  8. #    删除：      readme.txt
  9. #
  10. 修改尚未加入提交（使用 "git add" 和/或 "git commit -a"）
  11. [root@server mygit]# git checkout -- readme.txt
  12. [root@server mygit]# ls
  13. readme.txt  resolv.conf

2 ）彻底删除，需要三个步骤

  1. [root@server mygit]# rm -rf readme.txt
  2. [root@server mygit]#
  3. [root@server mygit]# git status
  4. # 位于分支 master
  5. # 尚未暂存以备提交的变更：
  6. #   （使用 "git add/rm <file>..." 更新要提交的内容）
  7. #   （使用 "git checkout -- <file>..." 丢弃工作区的改动）
  8. #
  9. #    删除：      readme.txt
  10. #
  11. 修改尚未加入提交（使用 "git add" 和/或 "git commit -a"）
  12. [root@server mygit]# git rm readme.txt
  13. rm 'readme.txt'
  14. [root@server mygit]# git status
  15. # 位于分支 master
  16. # 要提交的变更：
  17. #   （使用 "git reset HEAD <file>..." 撤出暂存区）
  18. #
  19. #    删除：      readme.txt
  20. #
  21. [root@server mygit]# git commit -m "delete readme.txt"
  22. [master fefbe0e] delete readme.txt
  23. 1 file changed, 1 deletion(-)
  24. delete mode 100644 readme.txt
  25. [root@server mygit]# git status
  26. # 位于分支 master
  27. 无文件要提交，干净的工作区
  28.

二 git远程仓库的添加与克隆
Git是分布式版本控制系统，同一个Git仓库，可以分布到不同的机器上。最早，肯定只有一台机器有一个原始版本库，此后，别的机器可以“克隆”这个原始版本库，而且每台机器的版本库其实都是一样的，并没有主次之分。
 我们可以自己搭建一台运行Git的服务器，每天24小时开机，其他每个人都从这个“服务器”仓库克隆一份到自己的电脑上，并且各自把各自的提交推送到服务器仓库里，也从服务器仓库中拉取别人的提交。
 要快速使用git，可以通过一个叫GitHub的神奇网站，从名字就可以看出，这个网站就是提供Git仓库托管服务的，所以，只要注册一个GitHub账号，就可以免费获得Git远程仓库。
由于本地Git仓库和GitHub仓库之间的传输是通过SSH加密的，所以，需要设置公钥认证机制，举例如下：
GitHub允许添加多个Key。假定你有若干电脑，你一会儿在公司提交，一会儿在家里提交，只要把每台电脑的Key都添加到GitHub，就可以在每台电脑上往GitHub推送了。
 最后友情提示，在GitHub上免费托管的Git仓库，任何人都可以看到喔（但只有你自己才能改）。所以，不要把敏感信息放进去。如果你不想让别人看到Git库，有两个办法，一个是交点保护费，让GitHub把公开的仓库变成私有的，这样别人就看不见了（不可读更不可写）。另一个办法是自己动手，搭一个Git服务器，因为是你自己的Git服务器，所以别人也是看不见的。
1）如何添加远程库
假定，现在我们在本地创建了一个Git仓库后，又想在Gitee创建一个Git仓库，并且让这两个仓库进行远程同步，这样，GitHub上的仓库既可以作为备份，又可以让其他人通过该仓库来协作，真是一举多得。私有仓库也是免费的 。

2)注册https://gitee.com账号

3）在本地生成ssh公钥私钥对

  1. [root@server mygit]# ssh-keygen
  2. Generating public/private rsa key pair.
  3. Enter file in which to save the key (/root/.ssh/id_rsa):
  4. Created directory '/root/.ssh'.
  5. Enter passphrase (empty for no passphrase):
  6. Enter same passphrase again:
  7. Your identification has been saved in /root/.ssh/id_rsa.
  8. Your public key has been saved in /root/.ssh/id_rsa.pub.
  9. The key fingerprint is:
  10. SHA256:6hwC1WNisvjI4MQMfweNH82B8a79J6kxbkSq00WNri8 root@server
  11. The key's randomart image is:
  12. +---[RSA 2048]----+
  13. |      .o.        |
  14. |     +.+ .       |
  15. |. . * * +o       |
  16. |+o = = ++ .      |
  17. |o++ . o=S        |
  18. |=o o ..++        |
  19. |.o. .o+++  .     |
  20. |    o+Eo.+o .    |
  21. |     .o++..o     |
  22. +----[SHA256]-----+
  24. [root@server mygit]# cd /root/.ssh
  25. [root@server .ssh]# ll
  26. 总用量 8
  27. -rw-------. 1 root root 1679 6月   5 18:42 id_rsa
  28. -rw-r--r--. 1 root root  393 6月   5 18:42 id_rsa.pub
  30. [root@server .ssh]# cat id_rsa.pub
  31. ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCdyhTmMNhOd6SkZAB+Kt/EldBizJ+Ks6E7syuQ23Eg/QHtLYBW/0P3NXI+40QxX9SLsPTA3CaM4VimaQLhtl0oyljC7HkczlqbtQMGyXxUpyUZgymZMTiS07pzrOMwVJ5W/oKsUA+UbOWYHvG4bfQhhs1kdMI1LAHYMYc7IBVrwE7WKjYKQUzr7ERHJGXg35Wvpezmz9iaqqiTcTdYsaSxtCJtFNBVB+RhhjTUlGB97EtJD5eaTX5wXfbdq491rqD8hfBxSOoiyR8fJti6WERU/uvOKO1Koep9ncI7mj+Fkif3T1uybj7VAkh2aeam0TjSE52vfv2i15weiyiuxcTL root@server
  32. [root@server .ssh]#

 将上面的公钥内容复制到gitee上面 

创建完毕仓库之后，gitee上有git命令的提示，我们可以参考一下这些命令

5）本地仓库和远程仓库进行同步

本地仓库和远程仓库进行关联

[root@server mygit]# git remote add origin git@gitee.com:zhang7433892/mygit.git

远程库的名字就是origin，这是Git默认的叫法，也可以改成别的

接下来我们将本地的仓库文件push上传到远程的服务器

  1. [root@server mygit]# git push -u origin master
  2. Counting objects: 20, done.
  3. Compressing objects: 100% (14/14), done.
  4. Writing objects: 100% (20/20), 1.85 KiB | 0 bytes/s, done.
  5. Total 20 (delta 0), reused 0 (delta 0)
  6. remote: Powered by GITEE.COM [GNK-6.0]
  7. To git@gitee.com:wmbenet/mygit.git
  8. * [new branch]      master -> master
  9. 分支 master 设置为跟踪来自 origin 的远程分支 master。
  10.  
  11.  
  12. 查看本地文件
  13. [root@server mygit]# ls
  14. resolv.conf

刷新页面，发现文件已经上传

我们再上传一个文件

  1. [root@server mygit]# cp /root/anaconda-ks.cfg .
  2. [root@server mygit]# git add anaconda-ks.cfg
  3. [root@server mygit]# git commit -m "add ks.cfg"
  4.  
  5. [root@server mygit]# git push origin master
  6. Counting objects: 7, done.
  7. Delta compression using up to 2 threads.
  8. Compressing objects: 100% (5/5), done.
  9. Writing objects: 100% (5/5), 1.31 KiB | 0 bytes/s, done.
  10. Total 5 (delta 1), reused 0 (delta 0)
  11. remote: Powered by GITEE.COM [GNK-6.3]
  12. To git@gitee.com:zhang7433892/mygit.git
  13.    3871dbd..d5931d1  master -> master

上面最后一个命令，因为是第二次执行，所以 -u参数就可以去掉了。

远程仓库也同步成功了

6）从远程库克隆 

前面我们讲了先有本地库，后有远程库的时候，如何进行远程关联，现在，假设我们从零开发，最好的方式就是从远程克隆

假设我们有一个项目，一般是在gitee建立一个库，每个人都从远程库克隆一份到本地 

首先我们建立一个远程仓库

将远程仓库clone到本地

  1. [root@server mygit]# cd ..
  2. [root@server data]# git clone git@gitee.com:zhang7433892/gamelife.git
  3. 正克隆到 'gamelife'...
  4. remote: Enumerating objects: 4, done.
  5. remote: Counting objects: 100% (4/4), done.
  6. remote: Compressing objects: 100% (4/4), done.
  7. remote: Total 4 (delta 0), reused 0 (delta 0), pack-reused 0
  8. 接收对象中: 100% (4/4), done.
  9.  
  10. [root@server data]# ls
  11. gamelife  mygit
  12.  
  13. [root@server data]# cd gamelife/
  14. [root@server gamelife]# ls
  15. README.en.md  README.md

 修改本地文件，并上传到远程服务器

  1. [root@server gamelife]# echo "mylife is not a game" >> README.md
  2. [root@server gamelife]# git add README.md
  3. [root@server gamelife]# git commit -m "add a line for readme"
  4. [master 5821f71] add a line for readme
  5.  1 file changed, 1 insertion(+)
  6. [root@server gamelife]# git push  origin master
  7. Counting objects: 5, done.
  8. Delta compression using up to 2 threads.
  9. Compressing objects: 100% (3/3), done.
  10. Writing objects: 100% (3/3), 324 bytes | 0 bytes/s, done.
  11. Total 3 (delta 1), reused 0 (delta 0)
  12. remote: Powered by GITEE.COM [GNK-6.3]
  13. To git@gitee.com:zhang7433892/gamelife.git
  14.    ec52338..5821f71  master -> master
请自行查看远程的仓库文件是否发生了改变 
Git支持多种协议，默认的git://使用ssh，但也可以使用https等其他协议，即可以用 https://github.com/ixdbagao/gitcode1.git这样的地址。但通过ssh支持的原生git协议速度最快。 使用https除了速度慢以外，还有个最大的麻烦是每次推送都必须输入口令，而在某些只开放http端口的公司内部可能无法使用ssh协议，此时只能用https。
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/482563
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号