git学习经验_save main.cpp

git

git init 初始化

git status 查看当前状态

git add xxx 将文件加到缓存区

git commit -m "1add readme.txt " 提交，并添加注释

git restore --stage readme.txt 将readme.txt文件 从缓存区删除

git diff readme.txt 比对

持久化就是存起来

当想要看历史版本 提交的记录：
git log 多行显示
git log --pretty=oneline 一行显示

回滚， 到以前的版本
git reset --hard HEAD^^ 一个^就是回滚一个版本
不会删除版本

查看HEAD的走过的版本： 倒叙看
git reflog

8d1faef (HEAD -> master) HEAD@{0}: reset: moving to HEAD^^
e3fe9be HEAD@{1}: commit: 333
9d36c7a HEAD@{2}: commit: 222
8d1faef (HEAD -> master) HEAD@{3}: commit (initial): add readme.txt
acs@c0d8b4682d85:~/project$ 

七位是个历史版本编号， 通过以下命令可以回滚到该版本
git reset --hard 9d36c7a

1
2
3
4
5
6
7
8
9

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6Ln01qRQ-1632726426470)(_v_images/20210920155514611_8121.png)]

将所有修改的文件加到暂存区
git add .

从最初起点到当前结点路径 就是当前状态
git log 历史记录各个版本

git restore readme.txt
把工作区中 相对于 暂存区中 修改过的内容删掉了。
即: git add .后，又做了修改， 通过git restore readme.txt 来删掉修改的内容，保留着暂存区中的内容。
就是将工作区的修改 回滚到暂存区存的内容， 如果暂存区没有内容，则表示Head头节点回滚到最后一次的结点。

如果暂存区中的内容也不想用，要回滚到暂存区(staged)之前的怎么办呢?
用 git restore --staged readme.txt

再用 git status查看状态

acs@c0d8b4682d85:~/project$ git restore --staged readme.txt                     
acs@c0d8b4682d85:~/project$                                                     
acs@c0d8b4682d85:~/project$ git status                                          
On branch master                                                                
Changes not staged for commit:                                                  
  (use "git add <file>..." to update what will be committed)                    
  (use "git restore <file>..." to discard changes in working directory)
        modified:   readme.txt  

1
2
3
4
5
6
7
8
9

git restore readme.txt后，即删掉暂存区中的

acs@c0d8b4682d85:~/project$ git restore readme.txt
acs@c0d8b4682d85:~/project$ git status
On branch master
nothing to commit, working tree clean
acs@c0d8b4682d85:~/project$ cat readme.txt 
11112221
2222
3333
1
2
3
4
5
6
7
8

即工作区中的内容已经回滚到 暂存区修改之前了。

acs@c0d8b4682d85:~/project$ touch main.cpp
acs@c0d8b4682d85:~/project$ git status
On branch master
Untracked files:
  (use "git add <file>..." to include in what will be committed)
        main.cpp

nothing added to commit but untracked files present (use "git add" to track)
1
2
3
4
5
6
7
8
9

On branch master 当前分支

acs@c0d8b4682d85:~/project$ git commit -m "add main.cpp"
[master a7dd630] add main.cpp
1
2

commit 就是把暂存器staged 持久化

 
acs@c0d8b4682d85:~/project$ git commit -m "save main.cpp"
[master e7b02e6] save main.cpp
1
2
3

可以只存一个main.cpp 当一个分支
通过 git restore readme.txt 来回滚掉 修改过的readme.txt

删除文件

在工作区本地(git init的目录)删除文件后，也可添加到暂存区(staged) ，同步到commit
例如：
在本地工作区，删除了rm a.txt b.txt
git add a.txt b.txt 添加到暂存区
git add不是创建的意思， 是把操作添加到暂存区

git restore --staged a.txt 把a文件的修改从暂存区删掉，
这时，是可以通过git 回滚 你不小心删除的文件的
git restore a.txt这时，你之前删掉的a文件就回滚回来了。

acs@c0d8b4682d85:~/project$ git add a.txt b.txt
acs@c0d8b4682d85:~/project$ git stataus
git: 'stataus' is not a git command. See 'git --help'.

The most similar command is
        status
acs@c0d8b4682d85:~/project$ 
acs@c0d8b4682d85:~/project$ git status
On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        deleted:    a.txt
        deleted:    b.txt

acs@c0d8b4682d85:~/project$  git restore --stage a.txt 
acs@c0d8b4682d85:~/project$ git status
On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        deleted:    b.txt

Changes not staged for commit:
  (use "git add/rm <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        deleted:    a.txt

acs@c0d8b4682d85:~/project$ ls
main.cpp  readme.txt
acs@c0d8b4682d85:~/project$ git restore a.txt
acs@c0d8b4682d85:~/project$ ls
a.txt  main.cpp  readme.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

如果删掉后，持久化了(commit) , 也是可以回滚回来的， 通过回滚到上一个历史版本即可。

[1]+  Stopped                 git log


acs@c0d8b4682d85:~/project$ 
acs@c0d8b4682d85:~/project$ 
acs@c0d8b4682d85:~/project$ 
acs@c0d8b4682d85:~/project$ 
acs@c0d8b4682d85:~/project$ git reset --hard  a3f20a3
HEAD is now at a3f20a3 a.txt b.txt
acs@c0d8b4682d85:~/project$ 
acs@c0d8b4682d85:~/project$ 
acs@c0d8b4682d85:~/project$ ls
a.txt  b.txt  main.cpp  readme.txt
1
2
3
4
5
6
7
8
9
10
11
12
13

git log 时，已经看不到路径后的点了， 但是通过git reflog可以看到后边的结点.

acs@c0d8b4682d85:~/project$ git reflog
a3f20a3 (HEAD -> master) HEAD@{0}: reset: moving to a3f20a3
8c78dd3 HEAD@{1}: commit: delete a.txt b.txt
a3f20a3 (HEAD -> master) HEAD@{2}: commit: a.txt b.txt
e7b02e6 HEAD@{3}: commit: save main.cpp
a7dd630 HEAD@{4}: commit: add main.cpp
8c25450 HEAD@{5}: reset: moving to 8c25450
8d1faef HEAD@{6}: reset: moving to HEAD
8d1faef HEAD@{7}: reset: moving to HEAD
8d1faef HEAD@{8}: reset: moving to 8d1faef
e3fe9be HEAD@{9}: reset: moving to e3fe9be
8c25450 HEAD@{10}: commit: readme.txt
9d36c7a HEAD@{11}: reset: moving to 9d36c7a
8d1faef HEAD@{12}: reset: moving to HEAD^^
e3fe9be HEAD@{13}: commit: 333
9d36c7a HEAD@{14}: commit: 222
8d1faef HEAD@{15}: commit (initial): add readme.txt
acs@c0d8b4682d85:~/project$ 
acs@c0d8b4682d85:~/project$ 
acs@c0d8b4682d85:~/project$ git reset --hard 8c78dd3
HEAD is now at 8c78dd3 delete a.txt b.txt
acs@c0d8b4682d85:~/project$ 
acs@c0d8b4682d85:~/project$ ls
main.cpp  readme.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

管理版本的话，不用用到云端，本地就可以，以上的git 全是在本地。

这些版本可以放到代码托管平台上去。

步骤1：
注册完成后，创建项目，不勾选默认初始化文件。
自己配置，

1. 用户设置，配置SSH密钥
   在 服务器中家目录的 .ssh/路径下，cat id_rsa.pub 显示公钥， 不配置是无法用github 或者gitlab的

2. 如果自己本地已经初始化过.git仓库，则只需要将本地的仓库同步到github上即可，将本地的仓库与远程目录对应起来
   也叫推送现有文件夹

git remote add origin git@git. .com:xxx/project_0.git
将本地的仓库与远程目录对应起来

3. git push -u origin master 推送当前文件夹 当前分支，master
   将本地的推送到了远端服务器上。
4. 在服务器端就很容易看到了 历史 历史版本。
   云端操作容易，可以作为浏览代码的一个工具。

迁移项目到新的服务器上

rm project/ -rf 都删掉
通过clone把云端版本库拷贝到本地

1. 复制 ssh克隆地址
   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lKgchsD9-1632726426475)(_v_images/20210924154119497_13119.png)]
2. git clone git@git. .com:Cubbyz/project_0.git

现在查看本地，会发现克隆下来了。
但是引用分支记录git reflog没有了,有的是下载的分支内容，所有节点。
这样大大的好处是，不怕本地误删除了，云端上有。

分支

默认都在主分支 master
云端(origin)创建了与本地完全一样的版本库。

如果是个人开发，可以主分支开发；
若是团队开发，一般不会在主分支上开发。一般开辟一个新分支。

新分支，是一个趋向，通过git commit后才会创建出来结点。
git checkout -b dev创建一个新分支 dev
git branch查看当前分支

acs@c0d8b4682d85:~/project_0$ git checkout -b dev                                    
Switched to a new branch 'dev'                                                       
acs@c0d8b4682d85:~/project_0$ git branch                                            
* dev                                                                                
  master                                                                             
    
1
2
3
4
5
6

各个分支是共享一个暂存区(staged)的。
commit时是看当前所在分支，将暂存区的内容加到分支后边。
切换分支 都是用的一个暂存区。

commit 持久化 到当前分支的后边。

git checkout master  // 回到master分支 将Head移动到master上
git branch 查看当前分支

1
2
3

若想将结点分支中的内容全部合并到master分支中,
git merge dev #将dev分支合并到当前分支 快速合并模式(直接将master分支指向了dev分支，没有复制)

合并完后，可以将dev分支删掉 git branch -d dev

如果有冲突，合并有问题时。 合并之前，对文件修改了，所以有冲突。
2021年9月24日 周五农历八月十八

git checkout dev2 -b dev2 创建新分支 dev2 并跳转过去
在新分支中 readme.txt添加888

vim readme.txt ...
git add .
git commit -m "888"

1
2
3
4

git checkout master 切换到原来的分支
云端版本 origin
git push -u(第一次需要-u以后不需要)：将当前分支推送到远程仓库
git push origin branch_name：将本地的某个分支推送到远程仓库

以上是把当前分支推送到云端
如何把子分支推送到云端呢？
新建dev3分支 git checkout -b dev3
直接用git push 推送新建的分支是不允许的，dev3 has no upstream branch. 云端没有此分支 ， 需要创建对应分支对应起来
git push --set-upstream origin dev3这是提示给出的命令
意思是云端没有这个分支，则创建这个分支

删除分支

要先跳到其他分支，才可以删除当前分支。

git checkout master
git branch -d dev3
git branch
git push -d origin dev3 // 可删除云端分支


// 将云端分支 与本地分支绑定到一起
git branch --setupstream-to=origin/dev4 dev4

// 将云端分支 拉下来同步到本地
git pull

// 此时有主分支master 和 子分支dev4
可以将dev4的修改同步合并到主分支
git checkout master
git merge dev4

git branch -d dev4 // 将本地dev4分支删掉
git push -d origin dev4  // 将云端dev4删掉

// 手动将本地 同步到云端  本地比云端多一个版本
git push

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

将云端的分支合并到本地
git pull origin dev5

git push 将本地同步到云端
git pull将云端同步到本地

从本地删除云端的 分支 dev3
先跳转到master 才能删除其他分支

 git push -d origin dev3
 
1
2

战略上藐视敌人，战术上重视敌人
不用害怕， 仔细理解原理

将本时刻存储 历史化没有修改,只是本地存储
将当前修改 存储到栈里。
暂存区有修改的内容， 本地又修改了，服务器挂了。存储到本地：
git stash
git stash list 查看当前栈中所有内容

多人协作

// 一台新机协作已有项目  dev
git branch 查看现在分支

git checkout -b dev 创建dev分支

git branch --set-upstream-to=origin/dev dev // 两个项目名字一致 与云端的项目绑定到一起。

git pull 拉取下来。

ok 两人可以同时合作。 如果同时修改了一个文件， 一方已经push了，则另一端需要pull拉取下来，再push上去 保持一致。
实现不同机器代码同步。

1
2
3
4
5
6
7
8
9
10
11
12

`