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

git add使用大全_git add force

作者：盐析白兔 | 2024-07-14 02:46:48

赞

踩

git add force

作用：将当前新建、修改过的文件的内容生成快照，加入到索引中，或者删除工作树中不存在的路径。

  1. git add [--verbose | -v] [--dry-run | -n] [--force | -f] [--interactive | -i] [--patch | -p]
  2. 	  [--edit | -e] [--[no-]all | --[no-]ignore-removal | [--update | -u]]
  3. 	  [--intent-to-add | -N] [--refresh] [--ignore-errors] [--ignore-missing] [--renormalize]
  4. 	  [--chmod=(+|-)x] [--] [<pathspec>…​]

演示环境 

  1. test MINGW64 /d/gitTest/add  
  2. $ git init  
  3. Initialized empty Git repository in D:/gitTest/add/.git/  
  4.   
  5. test MINGW64 /d/gitTest/add (master)  
  6. $ git status  
  7. On branch master  
  8.   
  9. No commits yet  
  10.   
  11. nothing to commit (create/copy files and use "git add" to track)  
  12.   
  13. test MINGW64 /d/gitTest/add (master)

1.git add [<pathsec>]

该指令会条件pathsec路径下的所有文件，若pathsec中含有通配符，则会添加所有符合pathsec的文件。

  1. //在当前路径下创建subpath子路径
  2. test MINGW64 /d/gitTest/add (master)
  3. $ mkdir subpath
  4. test MINGW64 /d/gitTest/add (master)
  5. $ cd subpath
  6.  
  7. //在子路径下创建A.c和B.c
  8. test MINGW64 /d/gitTest/add/subpath (master)
  9. $ echo "SubPathAFile">A.c
  10. test MINGW64 /d/gitTest/add/subpath (master)
  11. $ echo "SucPathBFile">B.c
  12.  
  13. //返回上一级路径
  14. test MINGW64 /d/gitTest/add/subpath (master)
  15. $ cd ..
  16.  
  17. //直接对路径进行暂存
  18. test MINGW64 /d/gitTest/add (master)
  19. $ git add subPath
  20. //git没有追踪到文件
  21. test MINGW64 /d/gitTest/add (master)
  22. $ git status
  23. On branch master
  24.  
  25. No commits yet
  26.  
  27. Untracked files:
  28.   (use "git add <file>..." to include in what will be committed)
  29.  
  30.         subpath/
  31.  
  32. nothing added to commit but untracked files present (use "git add" to track)
  33.  
  34. //对subpath/进行暂存
  35. test MINGW64 /d/gitTest/add (master)
  36. $ git add subPath/
  37. warning: LF will be replaced by CRLF in subPath/A.c.
  38. The file will have its original line endings in your working directory
  39. warning: LF will be replaced by CRLF in subPath/B.c.
  40. The file will have its original line endings in your working directory
  41. //追踪到subPath下的A.c和B.c文件
  42. test MINGW64 /d/gitTest/add (master)
  43. $ git status
  44. On branch master
  45.  
  46. No commits yet
  47.  
  48. Changes to be committed:
  49.   (use "git rm --cached <file>..." to unstage)
  50.  
  51.         new file:   subPath/A.c
  52.         new file:   subPath/B.c
  53. //将暂存的索引删除，并不删除A.c和B.c的文件
  54. test MINGW64 /d/gitTest/add (master)
  55. $ git rm --cached subPath/ -r
  56. rm 'subPath/A.c'
  57. rm 'subPath/B.c'
  58. //在当前路径下添加C.c文件
  59. test MINGW64 /d/gitTest/add (master)
  60. $ echo "PathC">>C.c
  61. //使用通配符，测试能否暂存到文件中子路径中的符合通配符格式的文件
  62. test MINGW64 /d/gitTest/add (master)
  63. $ git add *.c
  64. warning: LF will be replaced by CRLF in C.c.
  65. The file will have its original line endings in your working directory
  66. //结果表明不能暂存子路径中符合通配符格式的文件
  67. test MINGW64 /d/gitTest/add (master)
  68. $ git status
  69. On branch master
  70.  
  71. No commits yet
  72.  
  73. Changes to be committed:
  74.   (use "git rm --cached <file>..." to unstage)
  75.  
  76.         new file:   C.c
  77.  
  78. Untracked files:
  79.   (use "git add <file>..." to include in what will be committed)
  80.  
  81.         subpath/
  82.  
  83. //进入subpath子路径
  84. test MINGW64 /d/gitTest/add (master)
  85. $ cd subpath/
  86. //再次使用通配符进行暂存，暂存到所有符合条件的文件
  87. test MINGW64 /d/gitTest/add/subpath (master)
  88. $ git add *.c
  89. warning: LF will be replaced by CRLF in subpath/A.c.
  90. The file will have its original line endings in your working directory
  91. warning: LF will be replaced by CRLF in subpath/B.c.
  92. The file will have its original line endings in your working directory
  93.  
  94. test MINGW64 /d/gitTest/add/subpath (master)
  95. $ git status
  96. On branch master
  97.  
  98. No commits yet
  99.  
  100. Changes to be committed:
  101.   (use "git rm --cached <file>..." to unstage)
  102.  
  103.         new file:   ../C.c
  104.         new file:   A.c
  105.         new file:   B.c
  106.  
  107.

2.-n/--dry-run

作用：该指令只是用于测试文件是否存在，不会将文件暂存

  1. //先删除上一个指令生成的暂存，保证当前没有暂存（主要是为了便于理解，也可以不这么做）
  2. test MINGW64 /d/gitTest/add/subpath (master)
  3. $ git rm --cached *.c
  4. rm 'subpath/A.c'
  5. rm 'subpath/B.c'
  6. //返回上一级文件路径
  7. test MINGW64 /d/gitTest/add/subpath (master)
  8. $ cd ..
  9. //先删除上一个指令生成的暂存，保证当前没有暂存（主要是为了便于理解，也可以不这么做）
  10. test MINGW64 /d/gitTest/add (master)
  11. $ git rm --cached *.c
  12. rm 'C.c'
  13.  
  14. test MINGW64 /d/gitTest/add (master)
  15. $ git status
  16. On branch master
  17.  
  18. No commits yet
  19.  
  20. Untracked files:
  21.   (use "git add <file>..." to include in what will be committed)
  22.  
  23.         C.c
  24.         subpath/
  25.  
  26. nothing added to commit but untracked files present (use "git add" to track)
  27.  
  28.  
  29. //运行git add -n 指令
  30. test MINGW64 /d/gitTest/add (master)
  31. $ git add -n *.c
  32. warning: LF will be replaced by CRLF in C.c.
  33. The file will have its original line endings in your working directory
  34. add 'C.c'
  35.  
  36. //结果显示并没有将C.c文件暂存
  37. test MINGW64 /d/gitTest/add (master)
  38. $ git status
  39. On branch master
  40.  
  41. No commits yet
  42.  
  43. Untracked files:
  44.   (use "git add <file>..." to include in what will be committed)
  45.  
  46.         C.c
  47.         subpath/
  48.  
  49. nothing added to commit but untracked files present (use "git add" to track)
  50.  
  51. //进入subpath目录下
  52. test MINGW64 /d/gitTest/add (master)
  53. $ cd subpath/
  54. //执行git add --dry-run 指令
  55. test MINGW64 /d/gitTest/add/subpath (master)
  56. $ git add --dry-run A.c
  57. warning: LF will be replaced by CRLF in subpath/A.c.
  58. The file will have its original line endings in your working directory
  59. add 'subpath/A.c'
  60. //结果并没有将A.c暂存
  61. test MINGW64 /d/gitTest/add/subpath (master)
  62. $ git status
  63. On branch master
  64.  
  65. No commits yet
  66.  
  67. Untracked files:
  68.   (use "git add <file>..." to include in what will be committed)
  69.  
  70.         ../C.c
  71.         ./
  72.  
  73. nothing added to commit but untracked files present (use "git add" to track)
  74.  
  75. //暂存不存在的D.c文件，提示无法找到匹配文件
  76. test MINGW64 /d/gitTest/add (master)
  77. $ git add --dry-run D.c
  78. fatal: pathspec 'D.c' did not match any files
  79.  
  80. //暂存不存在的E.c文件，提示无法找到匹配文件
  81. test MINGW64 /d/gitTest/add (master)
  82. $ git add -n E.c
  83. fatal: pathspec 'E.c' did not match any files
  84.  
  85.

 3 -f/--force

作用：将.gitignore文件中忽略的文件强制添加到暂存区中，若文件没有被.gitignore文件中的规则命中，能正常暂存。

  1. //删除C.c的索引
  2. test MINGW64 /d/gitTest/add (master)
  3. $ git rm --cached C.c
  4. rm 'C.c'
  5. //查看当前分支的状态
  6. test MINGW64 /d/gitTest/add (master)
  7. $ git status
  8. On branch master
  9.  
  10. No commits yet
  11.  
  12. Untracked files:
  13.   (use "git add <file>..." to include in what will be committed)
  14.  
  15.         C.c
  16.         subpath/
  17.  
  18. nothing added to commit but untracked files present (use "git add" to track)
  19.  
  20. //添加.gitignore忽略文件，使得项目忽略*.c的文件
  21. test MINGW64 /d/gitTest/add (master)
  22. $ echo "*.c">>.gitignore
  24. test MINGW64 /d/gitTest/add (master)
  25. $ cat .gitignore
  26. *.c
  27. //再次查看当前分支的状态，发现忽略了C.c文件以及subPath/路径
  28. test MINGW64 /d/gitTest/add (master)
  29. $ git status
  30. On branch master
  31.  
  32. No commits yet
  33.  
  34. Untracked files:
  35.   (use "git add <file>..." to include in what will be committed)
  36.  
  37.         .gitignore
  38.  
  39. nothing added to commit but untracked files present (use "git add" to track)
  40.  
  41. //将文件暂存到暂存区中，失败
  42. test MINGW64 /d/gitTest/add (master)
  43. $ git add C.c
  44. The following paths are ignored by one of your .gitignore files:
  45. C.c
  46. Use -f if you really want to add them.
  47.  
  48. //使用-f参数强制暂存，成功
  49. test MINGW64 /d/gitTest/add (master)
  50. $ git add C.c -f
  51. warning: LF will be replaced by CRLF in C.c.
  52. The file will have its original line endings in your working directory
  53.  
  54. //当前分支已经检测到C.c被暂存
  55. test MINGW64 /d/gitTest/add (master)
  56. $ git status
  57. On branch master
  58.  
  59. No commits yet
  60.  
  61. Changes to be committed:
  62.   (use "git rm --cached <file>..." to unstage)
  63.  
  64.         new file:   C.c
  65.  
  66. Untracked files:
  67.   (use "git add <file>..." to include in what will be committed)
  68.  
  69.         .gitignore
  70.  
  71. //删除暂存区中的C.c的索引
  72. test MINGW64 /d/gitTest/add (master)
  73. $ git rm --cached C.c
  74. rm 'C.c'
  75.  
  76. //使用git add --force添加索引，成功
  77. test MINGW64 /d/gitTest/add (master)
  78. $ git add --force C.c
  79. warning: LF will be replaced by CRLF in C.c.
  80. The file will have its original line endings in your working directory
  81.  
  82. test MINGW64 /d/gitTest/add (master)
  83. $ git status
  84. On branch master
  85.  
  86. No commits yet
  87.  
  88. Changes to be committed:
  89.   (use "git rm --cached <file>..." to unstage)
  90.  
  91.         new file:   C.c
  92.  
  93. Untracked files:
  94.   (use "git add <file>..." to include in what will be committed)
  95.  
  96.         .gitignore
  97.  
  98. //创建一个不符合忽略规则的文件
  99. test MINGW64 /d/gitTest/add (master)
  100. $ echo "D">>D
  101. //强制将该文件暂存到暂存区中，成功
  102. test MINGW64 /d/gitTest/add (master)
  103. $ git add -f D
  104. warning: LF will be replaced by CRLF in D.
  105. The file will have its original line endings in your working directory
  106.  
  107. test MINGW64 /d/gitTest/add (master)
  108. $ git status
  109. On branch master
  110.  
  111. No commits yet
  112.  
  113. Changes to be committed:
  114.   (use "git rm --cached <file>..." to unstage)
  115.  
  116.         new file:   C.c
  117.         new file:   D
  118.  
  119. Untracked files:
  120.   (use "git add <file>..." to include in what will be committed)
  121.  
  122.         .gitignore

4.-i/--interactive

作用：通过交互式的方式，提供查看当前状态、更新索引、revert索引、追踪未索引文件、打补丁、显示差异等功能。该命令主要用在索引前有很多文件，且各文件需要添加到不同提交中的情况。

  1. //删除C.c和D的索引
  2. test MINGW64 /d/gitTest/add (master)
  3. $ git status
  4. On branch master
  5.  
  6. No commits yet
  7.  
  8. Changes to be committed:
  9.   (use "git rm --cached <file>..." to unstage)
  10.  
  11.         new file:   C.c
  12.         new file:   D
  13.  
  14. Untracked files:
  15.   (use "git add <file>..." to include in what will be committed)
  16.  
  17.         .gitignore
  18.  
  19.  
  20. test MINGW64 /d/gitTest/add (master)
  21. $ git rm --cached C.c
  22. rm 'C.c'
  23.  
  24. test MINGW64 /d/gitTest/add (master)
  25. $ git rm --cached D
  26. rm 'D'
  27.  
  28. //由于.gitignore里面的规则是*.c,所以不会提示C.c未被追踪
  29. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  30. $ git status                                                                                                                                                                  
  31. On branch master                                                                                                                                                              
  32.                                                                                                                                                                               
  33. No commits yet                                                                                                                                                                
  34.                                                                                                                                                                               
  35. Untracked files:                                                                                                                                                              
  36.   (use "git add ..." to include in what will be committed)                                                                                                              
  37.                                                                                                                                                                               
  38.         .gitignore                                                                                                                                                            
  39.         D                                                                                                                                                                     
  40.                                                                                                                                                                               
  41. nothing added to commit but untracked files present (use "git add" to track)                                                                                                  
  42.  
  43. //首先测试git add -i里面的add untracked、status以及quiet                                                                                                                                                                             
  44. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  45. $ git add -i                                                                                                                                                                  
  46.                                                                                                                                                                               
  47. *** Commands ***                                                                                                                                                              
  48.   1: status       2: update       3: revert       4: add untracked                                                                                                            
  49.   5: patch        6: diff         7: quit         8: help                                                                                                                     
  50. What now> 4                                                                                                                                                                   
  51.   1: .gitignore                                                                                                                                                               
  52.   2: D                                                                                                                                                                        
  53. Add untracked>> 1,2                                                                                                                                                           
  54. * 1: .gitignore                                                                                                                                                               
  55. * 2: D        
  56. //(输入回车)                                                                                                                                                                
  57. Add untracked>>                                                                                                                                                              
  58. warning: LF will be replaced by CRLF in D.                                                                                                                                    
  59. The file will have its original line endings in your working directory                                                                                                        
  60. added 2 paths                                                                                                                                                                 
  61.                                                                                                                                                                               
  62. *** Commands ***                                                                                                                                                              
  63.   1: status       2: update       3: revert       4: add untracked                                                                                                            
  64.   5: patch        6: diff         7: quit         8: help                                                                                                                     
  65. What now> 1                                                                                                                                                                   
  66.            staged     unstaged path                                                                                                                                           
  67.   1:        +1/-0      nothing .gitignore                                                                                                                                     
  68.   2:        +1/-0      nothing D                                                                                                                                              
  69.                                                                                                                                                                               
  70. *** Commands ***                                                                                                                                                              
  71.   1: status       2: update       3: revert       4: add untracked                                                                                                            
  72.   5: patch        6: diff         7: quit         8: help                                                                                                                     
  73. What now> 7                                                                                                                                                                   
  74. Bye.                                                                                                                                                                          
  75.  
  76. //修改D文件，测试git add -i的stauts、update以及quit                                                                                                                                                                            
  77. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  78. $ echo "2.D">>D                                                                                                                                                               
  79.                                                                                                                                                                               
  80. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  81. $ git add -i                                                                                                                                                                  
  82. warning: LF will be replaced by CRLF in D.                                                                                                                                    
  83. The file will have its original line endings in your working directory                                                                                                        
  84.            staged     unstaged path                                                                                                                                           
  85.   1:        +1/-0      nothing .gitignore                                                                                                                                     
  86.   2:        +1/-0        +1/-0 D                                                                                                                                              
  87.                                                                                                                                                                               
  88. *** Commands ***                                                                                                                                                              
  89.   1: status       2: update       3: revert       4: add untracked                                                                                                            
  90.   5: patch        6: diff         7: quit         8: help                                                                                                                     
  91.                                                                                                                  
  92. What now> 1                                                                                                                                                                   
  93. warning: LF will be replaced by CRLF in D.                                                                                                                                    
  94. The file will have its original line endings in your working directory                                                                                                        
  95.            staged     unstaged path                                                                                                                                           
  96.   1:        +1/-0      nothing .gitignore                                                                                                                                     
  97.   2:        +1/-0        +1/-0 D                                                                                                                                              
  98.                                                                                                                                                                               
  99. *** Commands ***                                                                                                                                                              
  100.   1: status       2: update       3: revert       4: add untracked                                                                                                            
  101.   5: patch        6: diff         7: quit         8: help                                                                                                                     
  102. What now> 2                                                                                                                                                                   
  103. warning: LF will be replaced by CRLF in D.                                                                                                                                    
  104. The file will have its original line endings in your working directory                                                                                                        
  105.            staged     unstaged path                                                                                                                                           
  106.   1:        +1/-0        +1/-0 D                                                                                                                                              
  107. Update>> 1                                                                                                                                                                    
  108.            staged     unstaged path                                                                                                                                           
  109. * 1:        +1/-0        +1/-0 D 
  110. //（下面回车以后才会执行update）                                                                                                                                             
  111. Update>>                                                                                                                                                                      
  112. warning: LF will be replaced by CRLF in D.                                                                                                                                    
  113. The file will have its original line endings in your working directory                                                                                                        
  114. updated 1 path                                                                                                                                                                
  115.                                                                                                                                                                               
  116. *** Commands ***                                                                                                                                                              
  117.   1: status       2: update       3: revert       4: add untracked                                                                                                            
  118.   5: patch        6: diff         7: quit         8: help                                                                                                                     
  119. What now> 7                                                                                                                                                                   
  120. Bye.                                                                                                                                                                          
  121.                                                                                                                                                                                                                                                                                                                                        
  122.                                                                                                                                                                               
  123. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  124. $ git status                                                                                                                                                                  
  125. On branch master                                                                                                                                                              
  126.                                                                                                                                                                               
  127. No commits yet                                                                                                                                                                
  128.                                                                                                                                                                               
  129. Changes to be committed:                                                                                                                                                      
  130.   (use "git rm --cached ..." to unstage)                                                                                                                                
  131.                                                                                                                                                                               
  132.         new file:   .gitignore                                                                                                                                                
  133.         new file:   D                                                                                                                                                         
  134.                                                                                                                                                                               
  135. //验证当前提交树的内容已经是update以后的内容                                                                                                                                                                              
  136. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  137. $ git write-tree                                                                                                                                                              
  138. d1d3635d12451de219be536c44fbdab6d03b53f2                                                                                                                                      
  139.                                                                                                                                                                               
  140. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  141. $ git cat-file -p d1d3635d12451de219be536c44fbdab6d03b53f2                                                                                                                    
  142. 100644 blob 064a8d8ef55dc8bf526fe49d45e93197bed1bfb7    .gitignore                                                                                                            
  143. 100644 blob d5731444010dead9489cd83fb4f65ad8fa4cf9f4    D                                                                                                                     
  144.                                                                                                                                                                               
  145. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  146. $ git cat-file -p d5731444010dead9489cd83fb4f65ad8fa4cf9f4                                                                                                                    
  147. D                                                                                                                                                                             
  148. 2.D                                                                                                                                                                           
  149.  
  150. //测试git add -i中的revert和quiet。                                                                                                                                                                              
  151. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  152. $ git add -i                                                                                                                                                                  
  153.            staged     unstaged path                                                                                                                                           
  154.   1:        +1/-0      nothing .gitignore                                                                                                                                     
  155.   2:        +2/-0      nothing D                                                                                                                                              
  156.                                                                                                                                                                               
  157. *** Commands ***                                                                                                                                                              
  158.   1: status       2: update       3: revert       4: add untracked                                                                                                            
  159.   5: patch        6: diff         7: quit         8: help                                                                                                                     
  160. What now> 3                                                                                                                                                                   
  161.            staged     unstaged path                                                                                                                                           
  162.   1:        +1/-0      nothing .gitignore                                                                                                                                     
  163.   2:        +2/-0      nothing D                                                                                                                                              
  164. Revert>> 2                                                                                                                                                                    
  165.            staged     unstaged path                                                                                                                                           
  166.   1:        +1/-0      nothing .gitignore                                                                                                                                     
  167. * 2:        +2/-0      nothing D                                                                                                                                              
  168. //(下面输入回车以后才会真正执行）
  169. Revert>>                                                                                                                                                                      
  170. rm 'D'                                                                                                                                                                        
  171. reverted 1 path                                                                                                                                                               
  172.                                                                                                                                                                               
  173. *** Commands ***                                                                                                                                                              
  174.   1: status       2: update       3: revert       4: add untracked                                                                                                            
  175.   5: patch        6: diff         7: quit         8: help                                                                                                                     
  176. What now> 7                                                                                                                                                                   
  177. Bye.                                                                                                                                                                          
  178.  
  179. //从提交树上验证文件D已经比revert
  180. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  181. $ git write-tree                                                                                                                                                              
  182. 63a1d649aaa3ec01ac6504a88a725842bfe2b6d2                                                                                                                                      
  183.                                                                                                                                                                               
  184. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  185. $ git cat-file -p 63a1d649aaa3ec01ac6504a88a725842bfe2b6d2                                                                                                                    
  186. 100644 blob 064a8d8ef55dc8bf526fe49d45e93197bed1bfb7    .gitignore 
  187.  
  188. //验证git add -i的diff和quiet                                                                                                                                                                              
  189. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  190. $ git add -i                                                                                                                                                                  
  191.            staged     unstaged path                                                                                                                                           
  192.   1:        +1/-0      nothing .gitignore                                                                                                                                     
  193.                                                                                                                                                                               
  194. *** Commands ***                                                                                                                                                              
  195.   1: status       2: update       3: revert       4: add untracked                                                                                                            
  196.   5: patch        6: diff         7: quit         8: help                                                                                                                     
  197. What now> 6                                                                                                                                                                   
  198.            staged     unstaged path                                                                                                                                           
  199.   1:        +1/-0      nothing .gitignore                                                                                                                                     
  200. Review diff>> 1                                                                                                                                                               
  201. diff --git a/.gitignore b/.gitignore                                                                                                                                          
  202. new file mode 100644                                                                                                                                                          
  203. index 0000000..064a8d8                                                                                                                                                        
  204. --- /dev/null                                                                                                                                                                 
  205. +++ b/.gitignore                                                                                                                                                              
  206. @@ -0,0 +1 @@                                                                                                                                                                 
  207. +*.c                                                                                                                                                                          
  208. *** Commands ***                                                                                                                                                              
  209.   1: status       2: update       3: revert       4: add untracked                                                                                                            
  210.   5: patch        6: diff         7: quit         8: help                                                                                                                     
  211. What now>                                                                                                                                                                     
  212. *** Commands ***                                                                                                                                                              
  213.   1: status       2: update       3: revert       4: add untracked                                                                                                            
  214.   5: patch        6: diff         7: quit         8: help                                                                                                                     
  215. What now> q                                                                                                                                                                   
  216. Bye.                                                                                                                                                                          
  217.                                                                                                                                                                               
  218.                                                                                                            
  219. //使用git add -i 中的 help                                                                                                                                                                              
  220. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  221. $ git add -i                                                                                                                                                                  
  222.            staged     unstaged path                                                                                                                                           
  223.   1:        +1/-0      nothing .gitignore                                                                                                                                     
  224.                                                                                                                                                                               
  225. *** Commands ***                                                                                                                                                              
  226.   1: status       2: update       3: revert       4: add untracked                                                                                                            
  227.   5: patch        6: diff         7: quit         8: help                                                                                                                     
  228. What now> 8                                                                                                                                                                   
  229. status        - show paths with changes                                                                                                                                       
  230. update        - add working tree state to the staged set of changes                                                                                                           
  231. revert        - revert staged set of changes back to the HEAD version                                                                                                         
  232. patch         - pick hunks and update selectively                                                                                                                             
  233. diff          - view diff between HEAD and index                                                                                                                              
  234. add untracked - add contents of untracked files to the staged set of changes                                                                                                  
  235. *** Commands ***                                                                                                                                                              
  236.   1: status       2: update       3: revert       4: add untracked                                                                                                            
  237.   5: patch        6: diff         7: quit         8: help                                                                                                                     
  238. What now> 7                                                                                                                                                                   
  239. Bye.                                                                                                                                                                          
  240.  
  241. //所有操作后.gitignore和D文件的状态                                                                                                                                                                              
  242. test  MINGW64 /d/gitTest/add (master)                                                                                                                       
  243. $ git status                                                                                                                                                                  
  244. On branch master                                                                                                                                                              
  245.                                                                                                                                                                               
  246. No commits yet                                                                                                                                                                
  247.                                                                                                                                                                               
  248. Changes to be committed:                                                                                                                                                      
  249.   (use "git rm --cached ..." to unstage)                                                                                                                                
  250.                                                                                                                                                                               
  251.         new file:   .gitignore                                                                                                                                                
  252.                                                                                                                                                                               
  253. Untracked files:                                                                                                                                                              
  254.   (use "git add ..." to include in what will be committed)                                                                                                              
  255.          D    
  256.                                                                                                                                                                    
  257.

5.--edit/-e

 作用：对比索引和当前修改的差异，并且可以编辑该差异，在退出后，保存编辑后的差异。

  1. //查看本地仓库当前状态
  2. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  3. $ git status                                                                                                                                                                  
  4. On branch master                                                                                                                                                              
  5.                                                                                                                                                                               
  6. No commits yet                                                                                                                                                                
  7.                                                                                                                                                                               
  8. Changes to be committed:                                                                                                                                                      
  9.   (use "git rm --cached ..." to unstage)                                                                                                                                
  10.                                                                                                                                                                               
  11.         new file:   .gitignore                                                                                                                                                
  12.         new file:   D                                                                                                                                                         
  13.                                                                                                                                                                               
  14. //生成一个提交                                                                                                                                                                              
  15. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  16. $ git commit -m "test for add --edit"                                                                                                                                         
  17. [master (root-commit) 65b7804] test for add --edit                                                                                                                            
  18.  2 files changed, 3 insertions(+)                                                                                                                                             
  19.  create mode 100644 .gitignore                                                                                                                                                
  20.  create mode 100644 D                                                                                                                                                         
  21.  
  22. //为D文件添加内容                                                                                                                                                                              
  23. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  24. $ echo "D --edit">>D                                                                                                                                                          
  25.  
  26. //默认会把所有修改了文件一一列出（在差异信息中增加了"D --edit"）                                                                                                                                                                              
  27. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  28. $ git add --edit                                                                                                                                                              
  29. warning: LF will be replaced by CRLF in D.                                                                                                                                    
  30. The file will have its original line endings in your working directory                                                                                                        
  31. warning: recount: unexpected line: add again                                                                                                                                  
  32.                                                                                                                                                                               
  33. //查询当前提交树的sha值                                                                                                                                                                              
  34. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  35. $ git write-tree                                                                                                                                                              
  36. 1d62f9a5257666f37811d2b0f3dfdd36b842a18e                                                                                                                                      
  37.  
  38. //查询D文件的sha值                                                                                                                                                                              
  39. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  40. $ git cat-file -p 1d62f9a5257666f37811d2b0f3dfdd36b842a18e                                                                                                                    
  41. 100644 blob 064a8d8ef55dc8bf526fe49d45e93197bed1bfb7    .gitignore                                                                                                            
  42. 100644 blob c8e0e32db807e0c7ce45cf3ef3489c13b12f502e    D                                                                                                                     
  43.  
  44. //在当前提交树下，已经增加了git add -edit中的内容                                                                                                                                                                              
  45. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  46. $ git cat-file -p c8e0e32db807e0c7ce45cf3ef3489c13b12f502e                                                                                                                    
  47. D                                                                                                                                                                             
  48. 2.D                                                                                                                                                                           
  49. D --edit                                                                                                                                                                      
  50.  
  51. //增加的内容有没有可能是通过打补丁的形式增加到了先前的提交中产生的呢？下面来验证一下                                                                                                                                                                              
  52. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  53. $ git log --oneline                                                                                                                                                           
  54. 65b7804 (HEAD -> master) test for add --edit                                                                                                                                  
  55.  
  56. //查看先前提交树的sha值                                                                                                                                                                              
  57. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  58. $ git cat-file -p 65b7804                                                                                                                                                     
  59. tree d1d3635d12451de219be536c44fbdab6d03b53f2                                                                                                                                 
  60. author xxx  1553670756 +0800                                                                                                                          
  61. committer xxx  1553670756 +0800                                                                                                                       
  62.                                                                                                                                                                               
  63. test for add --edit                                                                                                                                                           
  64.  
  65. //查找D文件的sha值                                                                                                                                                                              
  66. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  67. $ git cat-file -p d1d3635d12451de219be536c44fbdab6d03b53f2                                                                                                                    
  68. 100644 blob 064a8d8ef55dc8bf526fe49d45e93197bed1bfb7    .gitignore                                                                                                            
  69. 100644 blob d5731444010dead9489cd83fb4f65ad8fa4cf9f4    D                                                                                                                     
  70.  
  71. //显示D文件的内容  
  72. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  73. $ git cat-file -p d5731444010dead9489cd83fb4f65ad8fa4cf9f4                                                                                                                    
  74. D                                                                                                                                                                             
  75. 2.D                                                                                                                                                                           
  76.                                                                                                                                                                               
  77. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  78. $ git status                                                                                                                                                                  
  79. On branch master                                                                                                                                                              
  80. Changes to be committed:                                                                                                                                                      
  81.   (use "git reset HEAD ..." to unstage)                                                                                                                                 
  82.                                                                                                                                                                               
  83.         modified:   D                                                                                                                                                         
  84.                                                                                                                                                                               
  85.                                                                                                                                                                               
  86. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  87. $ cat D                                                                                                                                                                       
  88. D                                                                                                                                                                             
  89. 2.D                                                                                                                                                                           
  90. D --edit

6.--no-all/--ignore-removal

作用：对当前修改文件以及新建的文件生成快照，不会将被删除的文件从提交树中删除；

  1. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  2. $ git commit -m "perpare for -ingore-removal&--no-all"                                                                                                                        
  3. [master ac2f0f8] perpare for -ingore-removal&--no-all                                                                                                                         
  4.  2 files changed, 2 insertions(+)                                                                                                                                             
  5.                                                                                                                                                                               
  6. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  7. $ git status                                                                                                                                                                  
  8. On branch master                                                                                                                                                              
  9. nothing to commit, working tree clean                                                                                                                                         
  10.  
  11. //删除D文件                                                                                                                                                                              
  12. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  13. $ rm D                                                                                                                                                                        
  14.                                                                                                                                                                               
  15. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  16. $ git status                                                                                                                                                                  
  17. On branch master                                                                                                                                                              
  18. Changes not staged for commit:                                                                                                                                                
  19.   (use "git add/rm ..." to update what will be committed)                                                                                                               
  20.   (use "git checkout -- ..." to discard changes in working directory)                                                                                                   
  21.                                                                                                                                                                               
  22.         deleted:    D                                                                                                                                                         
  23.                                                                                                                                                                               
  24. no changes added to commit (use "git add" and/or "git commit -a")                                                                                                             
  25.  
  26. //增加F文件                                                                                                                                                                              
  27. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  28. $ echo "F">F                                                                                                                                                                  
  29.                                                                                                                                                                               
  30. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  31. $ git status                                                                                                                                                                  
  32. On branch master                                                                                                                                                              
  33. Changes not staged for commit:                                                                                                                                                
  34.   (use "git add/rm ..." to update what will be committed)                                                                                                               
  35.   (use "git checkout -- ..." to discard changes in working directory)                                                                                                   
  36.                                                                                                                                                                               
  37.         deleted:    D                                                                                                                                                         
  38.                                                                                                                                                                               
  39. Untracked files:                                                                                                                                                              
  40.   (use "git add ..." to include in what will be committed)                                                                                                              
  41.                                                                                                                                                                               
  42.         F                                                                                                                                                                     
  43.                                                                                                                                                                               
  44. no changes added to commit (use "git add" and/or "git commit -a")                                                                                                             
  45.                                                                                                                                                                                                                                                                                                                    
  46. //测试git add --no-all                                                                                                                                                                              
  47. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  48. $ git add --no-all .                                                                                                                                                          
  49. warning: LF will be replaced by CRLF in F.                                                                                                                                    
  50. The file will have its original line endings in your working directory                                                                                                        
  51.                                                                                                                                                                               
  52. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  53. $ git status                                                                                                                                                                  
  54. On branch master                                                                                                                                                              
  55. Changes to be committed:                                                                                                                                                      
  56.   (use "git reset HEAD ..." to unstage)                                                                                                                                 
  57.                                                                                                                                                                               
  58.         new file:   F                                                                                                                                                         
  59.                                                                                                                                                                               
  60. Changes not staged for commit:                                                                                                                                                
  61.   (use "git add/rm ..." to update what will be committed)                                                                                                               
  62.   (use "git checkout -- ..." to discard changes in working directory)                                                                                                   
  63.                                                                                                                                                                               
  64.         deleted:    D         
  65.  
  66. //查看提交树                                                                                                                                                
  67. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  68. $ git write-tree                                                                                                                                                              
  69. 28e32c408eb3ab0e46c87e1cbef83607e090485a                                                                                                                                      
  70.  
  71. //提交树中仍然有D                                                                                                                                                                              
  72. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  73. $ git cat-file -p 28e32c408eb3ab0e46c87e1cbef83607e090485a                                                                                                                    
  74. 100644 blob 6a149d370aedc2893c39d32d6b67b7dd62a37414    .gitignore                                                                                                            
  75. 100644 blob c8e0e32db807e0c7ce45cf3ef3489c13b12f502e    D                                                                                                                     
  76. 100644 blob cf84443e49e1b366fac938711ddf4be2d4d1d9e9    F                                                                                                                                                                                  
  77.  
  78. //删除F的快照                                                                                                                                                                              
  79. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  80. $ git rm --cached F                                                                                                                                                           
  81. rm 'F'                                                                                                                                                                        
  82.  
  83. //执行git add --ignore-removal                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   
  84. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  85. $ git add --ignore-removal .                                                                                                                                                  
  86. warning: LF will be replaced by CRLF in F.                                                                                                                                    
  87. The file will have its original line endings in your working directory                                                                                                        
  88.                                                                                                                                                                               
  89. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  90. $ git status                                                                                                                                                                  
  91. On branch master                                                                                                                                                              
  92. Changes to be committed:                                                                                                                                                      
  93.   (use "git reset HEAD ..." to unstage)                                                                                                                                 
  94.                                                                                                                                                                               
  95.         new file:   F                                                                                                                                                         
  96.                                                                                                                                                                               
  97. Changes not staged for commit:                                                                                                                                                
  98.   (use "git add/rm ..." to update what will be committed)                                                                                                               
  99.   (use "git checkout -- ..." to discard changes in working directory)                                                                                                   
  100.                                                                                                                                                                               
  101.         deleted:    D       
  102.  
  103. //查看提交树                                                                                                                                                    
  104. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  105. $ git write-tree                                                                                                                                                              
  106. 28e32c408eb3ab0e46c87e1cbef83607e090485a                                                                                                                                      
  107. //提交树中仍然有D                                                                                                                                                                              
  108. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  109. $ git cat-file -p 28e32c408eb3ab0e46c87e1cbef83607e090485a                                                                                                                    
  110. 100644 blob 6a149d370aedc2893c39d32d6b67b7dd62a37414    .gitignore                                                                                                            
  111. 100644 blob c8e0e32db807e0c7ce45cf3ef3489c13b12f502e    D                                                                                                                     
  112. 100644 blob cf84443e49e1b366fac938711ddf4be2d4d1d9e9    F

7. --all/-A/--no-ignore-removal

作用：对当前修改的文件、新建的文件修改快照，从提交树中删除已删除文件的索引

  1. //删除上一个实例产生的F文件快照和索引
  2. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  3. $ git rm --cached F                                                                                                                                                           
  4. rm 'F'                                                                                                                                                                        
  5. //查看当前状态                                                                                                                                                                              
  6. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  7. $ git status                                                                                                                                                                  
  8. On branch master                                                                                                                                                              
  9. Changes not staged for commit:                                                                                                                                                
  10.   (use "git add/rm ..." to update what will be committed)                                                                                                               
  11.   (use "git checkout -- ..." to discard changes in working directory)                                                                                                   
  12.                                                                                                                                                                               
  13.         deleted:    D                                                                                                                                                         
  14.                                                                                                                                                                               
  15. Untracked files:                                                                                                                                                              
  16.   (use "git add ..." to include in what will be committed)                                                                                                              
  17.                                                                                                                                                                               
  18.         F                                                                                                                                                                     
  19.                                                                                                                                                                               
  20. no changes added to commit (use "git add" and/or "git commit -a")                                                                                                             
  21. //展示当前提交树sha值                                                                                                                                                                              
  22. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  23. $ git write-tree                                                                                                                                                              
  24. 3691df535a49661cae004a0920d3780d0b8f37cb
  25.                                                                                                                                       
  26. //查询当前提交树下面的blob，有.gitignore和D的索引                                                                                                                                                                              
  27. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  28. $ git cat-file -p 3691df535a49661cae004a0920d3780d0b8f37cb                                                                                                                    
  29. 100644 blob 6a149d370aedc2893c39d32d6b67b7dd62a37414    .gitignore                                                                                                            
  30. 100644 blob c8e0e32db807e0c7ce45cf3ef3489c13b12f502e    D                                                                                                                     
  31.  
  32. //执行git add --all                                                                                                                                                                              
  33. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  34. $ git add --all                                                                                                                                                               
  35. warning: LF will be replaced by CRLF in F.                                                                                                                                    
  36. The file will have its original line endings in your working directory                                                                                                        
  37.  
  38. //当前状态发生变化：D文件快照及索引被删除、F文件被添加快照，并生成索引                                                                                                                                                                              
  39. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  40. $ git status                                                                                                                                                                  
  41. On branch master                                                                                                                                                              
  42. Changes to be committed:                                                                                                                                                      
  43.   (use "git reset HEAD ..." to unstage)                                                                                                                                 
  44.                                                                                                                                                                               
  45.         deleted:    D                                                                                                                                                         
  46.         new file:   F                                                                                                                                                         
  47.                                                                                                                                                                               
  48.                                                                                                                                                                               
  49. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  50. $ git write-tree                                                                                                                                                              
  51. c09d569b6b0c94753fd80b79cd7378d7411d070e                                                                                                                                      
  52.  
  53. //当前提交树下已经没有D文件索引，增加了F文件的索引                                                                                                                                                                             
  54. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  55. $ git cat-file -p c09d569b6b0c94753fd80b79cd7378d7411d070e                                                                                                                    
  56. 100644 blob 6a149d370aedc2893c39d32d6b67b7dd62a37414    .gitignore                                                                                                            
  57. 100644 blob cf84443e49e1b366fac938711ddf4be2d4d1d9e9    F                                                                                                                     
  58.  
  59. //检出D文件                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    test MINGW64 /d/gitTest/add (master)                                                                                                                       
  60. $ git checkout master -- D                                                                                                                                                    
  61.                                                                                                                                                                               
  62. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  63. $ git status                                                                                                                                                                  
  64. On branch master                                                                                                                                                              
  65. Changes to be committed:                                                                                                                                                      
  66.   (use "git reset HEAD ..." to unstage)                                                                                                                                 
  67.                                                                                                                                                                               
  68.         new file:   F                                                                                                                                                         
  69.                                                                                                                                                                               
  70. //删除F文件的快照和索引                                                                                                                                                                             
  71. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  72. $ git rm --cached F                                                                                                                                                           
  73. rm 'F'                                                                                                                                                                        
  74.                                                                                                                                                                               
  75. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  76. $ git status                                                                                                                                                                  
  77. On branch master                                                                                                                                                              
  78. Untracked files:                                                                                                                                                              
  79.   (use "git add ..." to include in what will be committed)                                                                                                              
  80.                                                                                                                                                                               
  81.         F                                                                                                                                                                     
  82.                                                                                                                                                                               
  83. nothing added to commit but untracked files present (use "git add" to track)                                                                                                  
  84.  
  85. //展示当前提交树sha值                                                                                                                                                                              
  86. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  87. $ git write-tree                                                                                                                                                              
  88. 3691df535a49661cae004a0920d3780d0b8f37cb                                                                                                                                      
  89.  
  90. //当前提交树中包含D和.gitignore的快照和索引                                                                                                                                                                              
  91. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  92. $ git cat-file -p 3691df535a49661cae004a0920d3780d0b8f37cb                                                                                                                    
  93. 100644 blob 6a149d370aedc2893c39d32d6b67b7dd62a37414    .gitignore                                                                                                            
  94. 100644 blob c8e0e32db807e0c7ce45cf3ef3489c13b12f502e    D                                                                                                                     
  95.                                                                                                                                                                                                                                                                                     
  96.  
  97. //查看当前状态                                                                                                                                                                              
  98. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  99. $ git status                                                                                                                                                                  
  100. On branch master                                                                                                                                                              
  101. Changes to be committed:                                                                                                                                                      
  102.   (use "git reset HEAD ..." to unstage)                                                                                                                                 
  103.                                                                                                                                                                               
  104.         new file:   F                                                                                                                                                         
  105.                                                                                                                                                                               
  106. //删除F文件的快照和索引                                                                                                                                                                              
  107. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  108. $ git rm --cached F                                                                                                                                                           
  109. rm 'F'                                                                                                                                                                        
  110.  
  111. //删除D文件                                                                                                                                                                              
  112. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  113. $ rm D                                                                                                                                                                        
  114.  
  115. //执行 git add --no-ignore-removal                                                                                                                                                                              
  116. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  117. $ git add --no-ignore-removal                                                                                                                                                 
  118. warning: LF will be replaced by CRLF in F.                                                                                                                                    
  119. The file will have its original line endings in your working directory                                                                                                        
  120.  
  121. //展示当前状态                                                                                                                                                                              
  122. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  123. $ git status                                                                                                                                                                  
  124. On branch master                                                                                                                                                              
  125. Changes to be committed:                                                                                                                                                      
  126.   (use "git reset HEAD ..." to unstage)                                                                                                                                 
  127.                                                                                                                                                                               
  128.         deleted:    D                                                                                                                                                         
  129.         new file:   F                                                                                                                                                         
  130.                                                                                                                                                                               
  131. //展示当前提交树的sha值                                                                                                                                                                             
  132. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  133. $ git write-tree                                                                                                                                                              
  134. c09d569b6b0c94753fd80b79cd7378d7411d070e                                                                                                                                      
  135.  
  136. //当前提交树包含F文件以及.gitignore文件的快照和索引                                                                                                                                                                             
  137. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  138. $ git cat-file -p c09d569b6b0c94753fd80b79cd7378d7411d070e                                                                                                                    
  139. 100644 blob 6a149d370aedc2893c39d32d6b67b7dd62a37414    .gitignore                                                                                                            
  140. 100644 blob cf84443e49e1b366fac938711ddf4be2d4d1d9e9    F                                                                                                                     
  141.  
  142. //再次检出D文件                                                                                                                                                                              
  143. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  144. $ git checkout master -- D                                                                                                                                                    
  145.  
  146. //删除F文件的快照和索引                                                                                                                                                                              
  147. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  148. $ git rm --cached F                                                                                                                                                           
  149. rm 'F'                                                                                                                                                                        
  150.  
  151. //查看检出D并删除F快照和索引后的文件树                                                                                                                                                                              
  152. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  153. $ git write-tree                                                                                                                                                              
  154. 3691df535a49661cae004a0920d3780d0b8f37cb                                                                                                                                      
  155.  
  156. //文件数中包含D文件和.gitignore文件的快照和索引                                                                                                                                                                             
  157. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  158. $ git cat-file -p 3691df535a49661cae004a0920d3780d0b8f37cb                                                                                                                    
  159. 100644 blob 6a149d370aedc2893c39d32d6b67b7dd62a37414    .gitignore                                                                                                            
  160. 100644 blob c8e0e32db807e0c7ce45cf3ef3489c13b12f502e    D                                                                                                                     
  161.  
  162. //删除D文件                                                                                                                                                                              
  163. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  164. $ rm D                                                                                                                                                                        
  165.  
  166. //执行git add -A .                                                                                                                                                                              
  167. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  168. $ git add -A .                                                                                                                                                                
  169. warning: LF will be replaced by CRLF in F.                                                                                                                                    
  170. The file will have its original line endings in your working directory                                                                                                        
  171.  
  172. //查看当前状态                                                                                                                                                                              
  173. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  174. $ git status                                                                                                                                                                  
  175. On branch master                                                                                                                                                              
  176. Changes to be committed:                                                                                                                                                      
  177.   (use "git reset HEAD ..." to unstage)                                                                                                                                 
  178.                                                                                                                                                                               
  179.         deleted:    D                                                                                                                                                         
  180.         new file:   F                                                                                                                                                         
  181.                                                                                                                                                                               
  182. //查看当前提交树的sha                                                                                                                                                                              
  183. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  184. $ git write-tree                                                                                                                                                              
  185. c09d569b6b0c94753fd80b79cd7378d7411d070e                        
  186.                                                                                                               
  187. //当前提交树包含.gitignore和F文件的快照和索引，D文件的快照和索引已经被删除                                                                                                                                                                              
  188. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  189. $ git cat-file -p c09d569b6b0c94753fd80b79cd7378d7411d070e                                                                                                                    
  190. 100644 blob 6a149d370aedc2893c39d32d6b67b7dd62a37414    .gitignore                                                                                                            
  191. 100644 blob cf84443e49e1b366fac938711ddf4be2d4d1d9e9    F     
  192.

7.--update/-u

作用：给更新的文件添加快照和索引，以及将删除文件的从提交树中删除索引和快照。但不会给新建的文件添加索引或快照。

  1. //检出上一个实例删除的D文件                                                                                                                                                                              
  2. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  3. $ git checkout master -- D                                                                                                                                                    
  4.                                                                                                                                                                               
  5. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  6. $ git status                                                                                                                                                                  
  7. On branch master                                                                                                                                                              
  8. Changes to be committed:                                                                                                                                                      
  9.   (use "git reset HEAD ..." to unstage)                                                                                                                                 
  10.                                                                                                                                                                               
  11.         new file:   F                                                                                                                                                         
  12.                                                                                                                                                                               
  13. //修改.gitignore文件                                                                                                                                                                              
  14. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  15. $ echo ".modifying">>.gitignore                                                                                                                                               
  16.                                                                                                                                                                                                                                                                                                                                                            
  17.                                                                                                                                                                               
  18. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  19. $ rm D                                                                                                                                                                        
  20.  
  21. //目前新增了F文件，删除了D文件，修改了.gitignore文件                                                                                                                                                                              
  22. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  23. $ git status                                                                                                                                                                  
  24. On branch master                                                                                                                                                              
  25. Changes to be committed:                                                                                                                                                      
  26.   (use "git reset HEAD ..." to unstage)                                                                                                                                 
  27.                                                                                                                                                                               
  28.         new file:   F                                                                                                                                                         
  29.                                                                                                                                                                               
  30. Changes not staged for commit:                                                                                                                                                
  31.   (use "git add/rm ..." to update what will be committed)                                                                                                               
  32.   (use "git checkout -- ..." to discard changes in working directory)                                                                                                   
  33.                                                                                                                                                                               
  34.         modified:   .gitignore                                                                                                                                                
  35.         deleted:    D                                                                                                                                                         
  36.                                                                                                                                                                               
  37.                                                                                                                                                                                                                                                                                                  
  38.                                                                                                                                                                               
  39. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  40. $ git rm --cache F                                                                                                                                                            
  41. rm 'F'                                                                                                                                                                        
  42.                                                                                                                                                                                                                                                                                                                                    
  43. //查看git add --update前的提交树sha值                                                                                                                                                                              
  44. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  45. $ git write-tree                                                                                                                                                              
  46. 3691df535a49661cae004a0920d3780d0b8f37cb                                                                                                                                      
  47.  
  48. //在执行git add --update之前当前提交树中包含D和.gitignore文件                                                                                                                                                                              
  49. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  50. $ git cat-file -p 3691df535a49661cae004a0920d3780d0b8f37cb                                                                                                                    
  51. 100644 blob 6a149d370aedc2893c39d32d6b67b7dd62a37414    .gitignore                                                                                                            
  52. 100644 blob c8e0e32db807e0c7ce45cf3ef3489c13b12f502e    D                                                                                                                     
  53.  
  54. //在修改了.gitignore文件、新建了F文件，删除了D文件以后执行git add --update 操作                                                                                                                                                                              
  55. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  56. $ git add --update .                                                                                                                                                          
  57. warning: LF will be replaced by CRLF in .gitignore.                                                                                                                           
  58. The file will have its original line endings in your working directory                                                                                                        
  59.  
  60. //执行后的当前状态                                                                                                                                                                              
  61. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  62. $ git status                                                                                                                                                                  
  63. On branch master                                                                                                                                                              
  64. Changes to be committed:                                                                                                                                                      
  65.   (use "git reset HEAD ..." to unstage)                                                                                                                                 
  66.                                                                                                                                                                               
  67.         modified:   .gitignore                                                                                                                                                
  68.         deleted:    D                                                                                                                                                         
  69.                                                                                                                                                                               
  70. Untracked files:                                                                                                                                                              
  71.   (use "git add ..." to include in what will be committed)                                                                                                              
  72.                                                                                                                                                                               
  73.         F                                                                                                                                                                     
  74.                                                                                                                                                                               
  75. //执行后查询当前提交树的sha值                                                                                                                                                                              
  76. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  77. $ git write-tree                                                                                                                                                              
  78. 4ed5e1cbaa6dc10291e08bae831efeebf312612e                                                                                                                                      
  79.  
  80. //查看执行后提交树包含的文件，符合预期，更新了.gitignore，删除了D文件，新增的F文件不会被add.                                                                                                                                                                            
  81. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  82. $ git cat-file -p 4ed5e1cbaa6dc10291e08bae831efeebf312612e                                                                                                                    
  83. 100644 blob 2b1ba4a62c709082820dc3cf1cc7f5d2740c6ac9    .gitignore                                                                                                            
  84.  
  85. //接下来为git add -u做准备，从最近一次提交中检出D                                                                                                                                                                          
  86. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  87. $ git checkout master -- D                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
  88.  
  89. //检出.gitignore                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         test MINGW64 /d/gitTest/add (master)                                                                                                                       
  90. $ git checkout master -- .gitignore                                                                                                                                           
  91.  
  92. //删除D文件                                                                                                                                                                            test MINGW64 /d/gitTest/add (master)                                                                                                                       
  93. $ rm D         
  94.                                                                                                                                                                
  95. //修改.gitignore                                                                                                           
  96. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  97. $ echo "Test for -U">>.gitignore                                                                                                                                              
  98.  
  99. //查看执行git add -u .之前的提交树sha值                                                                                                                                                                              
  100. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  101. $ git write-tree                                                                                                                                                              
  102. 3691df535a49661cae004a0920d3780d0b8f37cb                                                                                                                                      
  103.  
  104. //当前提交树中包含.gitignore和D的快照和索引                                                                                                                                                                              
  105. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  106. $ git cat-file -p 3691df535a49661cae004a0920d3780d0b8f37cb                                                                                                                    
  107. 100644 blob 6a149d370aedc2893c39d32d6b67b7dd62a37414    .gitignore                                                                                                            
  108. 100644 blob c8e0e32db807e0c7ce45cf3ef3489c13b12f502e    D                                                                                                                     
  109.  
  110. //执行git add -u                                                                                                                                                                              
  111. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  112. $ git add -u .                                                                                                                                                                
  113. warning: LF will be replaced by CRLF in .gitignore.                                                                                                                           
  114. The file will have its original line endings in your working directory                                                                                                        
  115.  
  116. //查看当前状态                                                                                                                                                                              
  117. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  118. $ git status                                                                                                                                                                  
  119. On branch master                                                                                                                                                              
  120. Changes to be committed:                                                                                                                                                      
  121.   (use "git reset HEAD ..." to unstage)                                                                                                                                 
  122.                                                                                                                                                                               
  123.         modified:   .gitignore                                                                                                                                                
  124.         deleted:    D                                                                                                                                                         
  125.                                                                                                                                                                               
  126. Untracked files:                                                                                                                                                              
  127.   (use "git add ..." to include in what will be committed)                                                                                                              
  128.                                                                                                                                                                               
  129.         F                                                                                                                                                                     
  130.                                                                                                                                                                               
  131. //查看执行完git add -u 之前的提交树sha值                                                                                                                                                                              
  132. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  133. $ git write-tree                                                                                                                                                              
  134. 0942488cfa25f9111d91a43b4ea9401fb00d17af                                                                                                                                      
  135.  
  136. //当前提交树中,D文件的快照和索引被删除，.gitignore修改已更新，新建文件F没有生成快照和索引                                                                                                                                                                              
  137. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  138. $ git cat-file -p 0942488cfa25f9111d91a43b4ea9401fb00d17af                                                                                                                    
  139. 100644 blob 390a9846fb6486a0edf4d9b508c67ce0a28b0ff9    .gitignore

8.-N/---intent-to-add

作用：不改变删除和修改的文件，追踪新建文件，不对新建文件生成快照和索引，此时，可以执行git diff，查看差异。

  1. //查看当前状态，.gitignore被修改,D文件被删除，F文件未追踪
  2. test MINGW64 /d/gitTest/add (master)
  3. $ git status
  4. On branch master
  5. Changes to be committed:
  6.   (use "git reset HEAD <file>..." to unstage)
  7.  
  8.         modified:   .gitignore
  9.         deleted:    D
  10.  
  11. Untracked files:
  12.   (use "git add <file>..." to include in what will be committed)
  13.  
  14.         F
  15. //执行--intent-to-add，期望的结果是应该是修改和删除的文件不变，F文件变为被追踪，但是内容没有被生成快照以及索引到提交树中
  16. test MINGW64 /d/gitTest/add (master)
  17. $ git add . --intent-to-add
  18.  
  19. //.gitignore和D文件状态不变，F文件被追踪
  20. test MINGW64 /d/gitTest/add (master)
  21. $ git status
  22. On branch master
  23. Changes to be committed:
  24.   (use "git reset HEAD <file>..." to unstage)
  25.  
  26.         modified:   .gitignore
  27.         deleted:    D
  28.  
  29. Changes not staged for commit:
  30.   (use "git add <file>..." to update what will be committed)
  31.   (use "git checkout -- <file>..." to discard changes in working directory)
  32.  
  33.         new file:   F
  34.  
  35. //查看当前提交树的sha值
  36. test MINGW64 /d/gitTest/add (master)
  37. $ git write-tree
  38. 0942488cfa25f9111d91a43b4ea9401fb00d17af
  39.  
  40. //查询当前提交树中的文件，只有.gitignore文件
  41. test MINGW64 /d/gitTest/add (master)
  42. $ git cat-file -p 0942488cfa25f9111d91a43b4ea9401fb00d17af
  43. 100644 blob 390a9846fb6486a0edf4d9b508c67ce0a28b0ff9    .gitignore
  44.  
  45. //可以执行git diff
  46. test MINGW64 /d/gitTest/add (master)
  47. $ git diff
  48. warning: LF will be replaced by CRLF in F.
  49. The file will have its original line endings in your working directory
  50. diff --git a/F b/F
  51. new file mode 100644
  52. index 0000000..cf84443
  53. --- /dev/null
  54. +++ b/F
  55. @@ -0,0 +1 @@
  56. +F
  57.  
  58. //执行diff以后不改变文件树以及其内容
  59. test MINGW64 /d/gitTest/add (master)
  60. $ git write-tree
  61. 0942488cfa25f9111d91a43b4ea9401fb00d17af
  62.  
  63.  
  64. test MINGW64 /d/gitTest/add (master)
  65. $ git cat-file -p 0942488cfa25f9111d91a43b4ea9401fb00d17af
  66. 100644 blob 390a9846fb6486a0edf4d9b508c67ce0a28b0ff9    .gitignore
  67.  
  68. //删除F追踪
  69. test MINGW64 /d/gitTest/add (master)
  70. $ git rm --cached F
  71. rm 'F'
  72.  
  73. //执行-N
  74. test MINGW64 /d/gitTest/add (master)
  75. $ git add -N .
  76.  
  77. test MINGW64 /d/gitTest/add (master)
  78. $ git status
  79. On branch master
  80. Changes to be committed:
  81.   (use "git reset HEAD <file>..." to unstage)
  82.  
  83.         modified:   .gitignore
  84.         deleted:    D
  85.  
  86. Changes not staged for commit:
  87.   (use "git add <file>..." to update what will be committed)
  88.   (use "git checkout -- <file>..." to discard changes in working directory)
  89.  
  90.         new file:   F
  91.  
  92.  
  93. test MINGW64 /d/gitTest/add (master)
  94. $ git diff
  95. warning: LF will be replaced by CRLF in F.
  96. The file will have its original line endings in your working directory
  97. diff --git a/F b/F
  98. new file mode 100644
  99. index 0000000..cf84443
  100. --- /dev/null
  101. +++ b/F
  102. @@ -0,0 +1 @@
  103. +F
  104.  
  105. test MINGW64 /d/gitTest/add (master)
  106. $ git write-tree
  107. 0942488cfa25f9111d91a43b4ea9401fb00d17af
  108.  
  109. test MINGW64 /d/gitTest/add (master)
  110. $ git cat-file -p 0942488cfa25f9111d91a43b4ea9401fb00d17af
  111. 100644 blob 390a9846fb6486a0edf4d9b508c67ce0a28b0ff9    .gitignore
  112.  
  113. //不加任何参数
  114. test MINGW64 /d/gitTest/add (master)
  115. $ git add F
  116. warning: LF will be replaced by CRLF in F.
  117. The file will have its original line endings in your working directory
  118.  
  119. //不过不能diff
  120. test MINGW64 /d/gitTest/add (master)
  121. $ git diff
  122.  
  123. test MINGW64 /d/gitTest/add (master)
  124. $ git write-tree
  125. 8e88d9a90e0b799cfa16a47c7a7ee87e5db9c06f
  126.  
  127. //F被提交到文件树中
  128. test MINGW64 /d/gitTest/add (master)
  129. $ git cat-file -p 8e88d9a90e0b799cfa16a47c7a7ee87e5db9c06f
  130. 100644 blob 390a9846fb6486a0edf4d9b508c67ce0a28b0ff9    .gitignore
  131. 100644 blob cf84443e49e1b366fac938711ddf4be2d4d1d9e9    F
  132.

9.--refresh

作用：不在暂存区中添加文件的快照，只刷新文件的状态，变成changes not staged for commit. 该参数后面的文件必须不是新建的。

  1. //查看一下当前状态，提交一波，为接下来的演示做准备
  2. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  3. $ git status                                                                                                                                                                  
  4. On branch master                                                                                                                                                              
  5. Changes to be committed:                                                                                                                                                      
  6.   (use "git reset HEAD ..." to unstage)                                                                                                                                 
  7.                                                                                                                                                                               
  8.         modified:   .gitignore                                                                                                                                                
  9.         deleted:    D                                                                                                                                                         
  10.         new file:   F                                                                                                                                                         
  11.                                                                                                                                                                               
  12.                                                                                                                                                                               
  13. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  14. $ git commit -m "ready for --refresh"                                                                                                                                         
  15. [master fbfe682] ready for --refresh                                                                                                                                          
  16.  3 files changed, 2 insertions(+), 3 deletions(-)                                                                                                                             
  17.  delete mode 100644 D                                                                                                                                                         
  18.  create mode 100644 F                                                                                                                                                         
  19.                                                                                                                                                                               
  20. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  21. $ git log --oneline --abbrev-commit --graph                                                                                                                                   
  22. * fbfe682 (HEAD -> master) ready for --refresh                                                                                                                                
  23. * ac2f0f8 perpare for -ingore-removal&--no-all                                                                                                                                
  24. * 65b7804 test for add --edit                                                                                                                                                 
  25.  
  26. //创建G文件                                                                                                                                                                              
  27. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  28. $ echo "G">>G      
  29.                                                                                                                                                            
  30. //查看当前暂存区的文件                                                                                                                                                                              
  31. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  32. $ git ls-files -s                                                                                                                                                             
  33. 100644 390a9846fb6486a0edf4d9b508c67ce0a28b0ff9 0       .gitignore                                                                                                            
  34. 100644 cf84443e49e1b366fac938711ddf4be2d4d1d9e9 0       F                                                                                                                     
  35.  
  36. //执行git add --refresh G指令，指令报找不到匹配的G文件，说明新建的文件执行--refresh不行                                                                                                                                                                              
  37. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  38. $ git add --refresh G                                                                                                                                                         
  39. fatal: pathspec 'G' did not match any files                                                                                                                                   
  40.  
  41. //修改.gitignore文件                                                                                                                                                                              
  42. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  43. $ echo "add for --ready">>.gitignore                                                                                                                                          
  44.  
  45. //查看修改完以后暂存区的情况，和修改前一样                                                                                                                                                                             
  46. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  47. $ git ls-files -s                                                                                                                                                             
  48. 100644 390a9846fb6486a0edf4d9b508c67ce0a28b0ff9 0       .gitignore                                                                                                            
  49. 100644 cf84443e49e1b366fac938711ddf4be2d4d1d9e9 0       F                                                                                                                     
  50.  
  51. //执行--refresh,应该会只刷新stat()信息，而不会生成快照并索引，该信息通过git status可以查看                                                                                                                                                                              
  52. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  53. $ git add --refresh .                                                                                                                                                         
  54.  
  55. //.gitignore文件尚未暂存（如果是执行了git add .gitignore会是什么现象呢？）                                                                                                                                                                              
  56. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  57. $ git status                                                                                                                                                                  
  58. On branch master                                                                                                                                                              
  59. Changes not staged for commit:                                                                                                                                                
  60.   (use "git add ..." to update what will be committed)                                                                                                                  
  61.   (use "git checkout -- ..." to discard changes in working directory)                                                                                                   
  62.                                                                                                                                                                               
  63.         modified:   .gitignore                                                                                                                                                
  64.                                                                                                                                                                               
  65. Untracked files:                                                                                                                                                              
  66.   (use "git add ..." to include in what will be committed)                                                                                                              
  67.                                                                                                                                                                               
  68.         G                                                                                                                                                                     
  69.                                                                                                                                                                               
  70. no changes added to commit (use "git add" and/or "git commit -a")                                                                                                             
  71.  
  72. //查看暂存区文件列表                                                                                                                                                                              
  73. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  74. $ git ls-files -s                                                                                                                                                             
  75. 100644 390a9846fb6486a0edf4d9b508c67ce0a28b0ff9 0       .gitignore                                                                                                            
  76. 100644 cf84443e49e1b366fac938711ddf4be2d4d1d9e9 0       F                                                                                                                     
  77.  
  78. //查看暂存区的.gitignore文件内容，还没有"add for --ready"                                                                                                                                                                             
  79. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  80. $ git cat-file -p 390a9846fb6486a0edf4d9b508c67ce0a28b0ff9                                                                                                                    
  81. *.c                                                                                                                                                                           
  82. new rule                                                                                                                                                                      
  83. Test for -U                                                                                                                                                                   
  84.  
  85. //检出head提交中的.gitignore，使得文件内容恢复到未修改之前。                                                                                                                                                                              
  86. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  87. $ git checkout -- .gitignore                                                                                                                                                  
  88.  
  89. //修改.gitignore                                                                                                                                                                              
  90. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  91. $ echo "add for --ready again">>.gitignore                                                                                                                                    
  92.  
  93. //将修改后的.gitignore文件提交到暂存区                                                                                                                                                                              
  94. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  95. $ git add .gitignore                                                                                                                                                          
  96. warning: LF will be replaced by CRLF in .gitignore.                                                                                                                           
  97. The file will have its original line endings in your working directory                                                                                                        
  98.  
  99. //查看暂存区文件，很显然,暂存区中的.gitignore文件已经发生了变化，sha值也变了                                                                                                                                                                              
  100. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  101. $ git ls-files -s                                                                                                                                                             
  102. 100644 b87854ff36c7c3048816f13d08b5be69227e5e62 0       .gitignore                                                                                                            
  103. 100644 cf84443e49e1b366fac938711ddf4be2d4d1d9e9 0       F                                                                                                                     
  104.  
  105. //打印文件内容为证                                                                                                                                                                              
  106. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  107. $ git cat-file -p b87854ff36c7c3048816f13d08b5be69227e5e62                                                                                                                    
  108. *.c                                                                                                                                                                           
  109. new rule                                                                                                                                                                      
  110. Test for -U                                                                                                                                                                   
  111. add for --ready again

9.--ignore-missing

作用：和--dry-run搭配使用，当路径参数中包含被忽略的路径时，会提示文件是被忽略的文件；如果参数是通配符.，即便其中含有被忽略的路径也不会打印提示。

  1. //当前有未追踪的G文件
  2. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  3. $ git status                                                                                                                                                                  
  4. On branch master                                                                                                                                                              
  5. Untracked files:                                                                                                                                                              
  6.   (use "git add ..." to include in what will be committed)                                                                                                              
  7.                                                                                                                                                                               
  8.         G                                                                                                                                                                     
  9.                                                                                                                                                                               
  10. nothing added to commit but untracked files present (use "git add" to track)                                                                                                  
  11.  
  12. //新建一个D.c文件，该命名命中了.gitignore中的*.c的规则，所以会被忽略                                                                                                                                                                              
  13. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  14. $ echo "D.c">>D.c                                                                                                                                                             
  15.                                                                                                                                                                                                                                                                                                                    
  16. //这里只会打印添加了G文件（实际上没有添加）                                                                                                                                                                              
  17. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  18. $ git add --dry-run .                                                                                                                                                         
  19. add 'G'                                                                                                                                                                       
  20.                                                                                                                                                                                                                                                                                                                                                                                                                                                              
  21. //这里只会打印添加了G文件（实际上没有添加）                                                                                                                                                                              
  22. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  23. $ git add --dry-run --ignore-missing .                                                                                                                                        
  24. add 'G'                                                                                                                                                                       
  25.                                                                                                                                                                                                                                                                                                                     
  26. //证明G文件确实没有被添加                                                                                                                                                                              
  27. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  28. $ git status                                                                                                                                                                  
  29. On branch master                                                                                                                                                              
  30. Untracked files:                                                                                                                                                              
  31.   (use "git add ..." to include in what will be committed)                                                                                                              
  32.                                                                                                                                                                               
  33.         G                                                                                                                                                                     
  34.                                                                                                                                                                               
  35. nothing added to commit but untracked files present (use "git add" to track)                                                                                                  
  36.                                                                                                                                                                                                                                                                               
  37. //尝试给D.c生成快照并添加索引，提示命中了.gitignore中的规则                                                                                                                                                                                                                                                                                                                                                          
  38. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  39. $ git add --dry-run --ignore-missing D.c                                                                                                                                      
  40. The following paths are ignored by one of your .gitignore files:                                                                                                              
  41. D.c                                                                                                                                                                           
  42. Use -f if you really want to add them.                                                                                                                                        
  43.  
  44. //使用通配符添加，不提示D.c命中规则                                                                                                                                                                              
  45. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  46. $ git add --dry-run --ignore-missing .                                                                                                                                        
  47. add 'G'                                                                                                                                                                       
  48.  
  49.                                                                                                                                                                               
  50. test MINGW64 /d/gitTest/add (master)                                                                                                                       
  51. $ git add --dry-run --ignore-missing G                                                                                                                                        
  52. add 'G'

10 --chmod=+x和--chmod=-x

作用：--chmod=+x将文件模式设置成可执行模式，--chomod-x将文件模式设置为不可执行模式，只是对索引中的文件进行模式设置，不改变磁盘文件中的模式。

  1. //创建一个H.sh可执行文件
  2. test MINGW64 /d/gitTest/add (master) 
  3. $ echo "execute">>H.sh
  4.  
  5. //不加--chmod=+x和--chmod=-x
  6. test MINGW64 /d/gitTest/add (master) 
  7. $ git add H.sh
  8. warning: LF will be replaced by CRLF in H.sh. 
  9. The file will have its original line endings in your working directory
  10.  
  11. //默认模式是100644，就是不可执行的意思
  12. test MINGW64 /d/gitTest/add (master) 
  13. $ git ls-files -s 
  14. 100644  390a9846fb6486a0edf4d9b508c67ce0a28b0ff9  0       gitignore
  15. 100644  cf84443e49e1b366fac938711ddf4be2d4d1d9e9  0       F
  16. 100644  e1b6ca64bc6cf509ed029f9f859dde07752c242e  0       H.sh
  17.  
  18. //删除索引和快照
  19. test MINGW64 /d/gitTest/add (master) 
  20. $ git rm --cached H.sh
  21. rm 'H.sh' 
  22.  
  23. //添加--chmod=+x
  24. test MINGW64 /d/gitTest/add (master) 
  25. $ git add --chmod=+x H.sh 
  26. warning: LF will be replaced by CRLF in H.sh. 
  27. The file will have its original line endings in your working directory
  28.  
  29. //H.sh的文件模式发生了变化，变成了100755，可执行文件
  30. test MINGW64 /d/gitTest/add (master) 
  31. $ git ls-files -s 
  32. 100644  390a9846fb6486a0edf4d9b508c67ce0a28b0ff9 0        .gitignore
  33. 100644  cf84443e49e1b366fac938711ddf4be2d4d1d9e9 0        F 
  34. 100755  e1b6ca64bc6cf509ed029f9f859dde07752c242e 0        H.sh
  35.  
  36. //删除快照和索引
  37. test MINGW64 /d/gitTest/add (master)     
  38. $ git rm --cached H.sh      
  39. rm 'H.sh'   
  40.  
  41. //执行--chmod=-x
  42. test MINGW64 /d/gitTest/add (master)     
  43. $ git add --chmod=-x H.sh   
  44. warning: LF will be replaced by CRLF in H.sh.       
  45. The file will have its original line endings in your working directory      
  46.  
  47. //H.sh暂存文件的模式是不可执行的模式    
  48. test MINGW64 /d/gitTest/add (master)     
  49. $ git ls-files -s   
  50. 100644  390a9846fb6486a0edf4d9b508c67ce0a28b0ff9 0       .gitignore  
  51. 100644  cf84443e49e1b366fac938711ddf4be2d4d1d9e9 0       F   
  52. 100644  e1b6ca64bc6cf509ed029f9f859dde07752c242e 0       H.sh
  53.     
  54.

11 --patch/-p/--ignore-errors

由于LZ对补丁这块还不太了解，所以没有介绍--patch/-p。--ignore-errors因为没有找到产生error的途径，所以没有介绍这个option。后续等LZ了解了以后再加相关的解释。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/822832
推荐阅读
相关标签

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

  

闽ICP备14008679号