Experience of using Git for many years & FAQ collation

Configure Git

$git config --global user.name "username" $git config --global user.email "git account alias.co checkout $ git config --global alias.ss status $ git config --global alias.cm commit $ git config --global Alias. br branch $git config --global alias.rg reflog # $git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit alias.xxx $ git config --global --unset user.xxxCopy the code

git reflog

• It shows oneHEADPoints to a list of times that changed. Before you switch branches, usegit commitSubmit, and usegit resetWhen you revoke the COMMIT,HEADThe direction will change, but as you proceedgit checkout -- <filename>Revocation orgit stashWhen you do things like store files,HEADIt doesn’t change, these changes were never committed, soreflogIt doesn’t help us recover them.
• git reflogNot forever. Git cleans up “unused” objects on a regular basis. Don’t expect a commit from months ago to still be there.

Git Git

$git add. # Commit to local repository $git commit -m $git commit -u origin branchName $git commit -u origin branchName $git pull origin branchName $git merge branchName $git branch # $git branch -a # Switch branches $git checkout branchName # Temporarily save workspace file changes to the stack $git stash # Pull out files previously saved to the stack $git branch - A # Switch branches $git checkout branchName  git stash popCopy the code

add

Adds files from the workspace to the staging area

$git add [file1] [file2]... $git add. $git add. $git rm [file1] [file2]... # stop tracking specified files $git mv [file-original] [file-renamed] # git 2.0: $git add. $gti add -u $git add. Equivalent to $git add -aCopy the code

• git add . ：The object of the action is all file changes in the current directory, “.” indicates the current directory. Will monitor the workspace state tree, using it will put the workspaceAll changes submittedTo the staging area, including file content modification (modified) and new documents (new), butDeleted files are not included.
• git add -u ：The object of action is the file changes that have been tracked throughout the workspace, regardless of the current directory. Only monitorFiles that have been added(i.e.tracked file), which commits modified files (including file deletions) to the staging area.git add -uNo new documents will be submitted (untracked file). (git add --updateThe abbreviation of)
• git add -A ：The object of action is changes to all files in the “entire workspace”, regardless of the current directory. Is a combination of the above two functions (git add --all“).

commit

$git commit -m $git commit -m $git commit -m $git commit --no -- verify $git commit -n $git commit -- amend-m $git commit -- amend-m The editor does not pop up the last committed information $git commit --amend --no-editCopy the code

• git commit --amendYou can modify the contents of the last submitted file or the description of the last submitted file. I’ll use a new onecommitUpdate and replace the last committedcommit. If there’s anything in the staging area, this newcommitAny changes will be matched with the previous onecommitThe content is combined. If there is no content in the staging area, then this operation will only take the last onecommitThe message is rewritten.Never fix a commit that has already been pushed to the public repository

branch

# to check the local branch $git branch | git branch - l # to check the remote branch $git branch - r # view all branch (branch), local branch + remote # $git branch - a view all branches and to bring the latest submitted information $ $git branch -v $git branch -v $git branch -v $git branch branchname = $git branch branchname = $git branch branchname $git checkout branchname $git checkout branchname $git checkout -b aaa $git checkout -b aaa $git checkout --orphan emptyBranchName $git rm -rf. # $git brnach -d branchname $git branch -d branchname $git branch -m branchname = $git branch -m branchname = $git branch -m branchname = $git branch -m branchnameCopy the code

rebase

www.liaoxuefeng.com/wiki/896043…

Git-scm.com/book/zh/v2/…

www.jianshu.com/p/4a8f4af4e…

Juejin. Cn/post / 684490…

diff

$git diff $git diff $git diff $git diff --stat # You modify a file but do not commit it to the staging area, there will be a comparison # 2 once committed to the staging area, there will be no comparison (because the staging area has been updated). If you create a new file and don't commit it to the staging area, $git diff --cached/--staged # Git diff --cached/--staged # Git diff BranchName # Git diff branchname # Git diff branchname # Git diff HEAD # $git diff branchName $git diff branchname $git diff branchname... $git diff branchname $git diff origin/branchname... $git diff origin/branchname $git diff origin/branchname... $git diff commit1.. commit2Copy the code

tag

Often used to release versions

www.liaoxuefeng.com/wiki/896043…

$git tag v0.9 f52C633 $git tag v0.9 f52C633 $git tag -a v0.1 -m "Version 0.1 released" # git tags are not listed in chronological order, but alphabetically. $git tag # $git tag # $git tag # $git tag # $git tag # Tags created are only stored locally and are not automatically pushed to remote locations. # Therefore, mislabeled tags can be safely deleted locally. $git push origin :refs/tags/<tag > $git push origin :refs/tags/<tag >Copy the code

Version switch & Reset & Undo

• Checkout can undo workspace files, and reset can undo workspace/staging files
• Reset and checkout can work with commit or files, while Revert can only work with COMMIT

Reset,

Git reset [- hard | soft | mixed | merge | keep] [< commit > or HEAD] : Resets the current branch to the specified

or HEAD (by default, if the specified < COMMIT > is not displayed, the default is HEAD, which is the last commit), with the possibility of updating the index and working directory according to [mode]. The mode can be hard, soft, mixed, merged, or keep.

# Undo a specific file from the staging area without changing the workspace. $git reset <fileName> # resets the last commit in the staging area. $git reset = $git reset HEAD = $git reset HEAD = $git reset $git reset --hard HEAD^ # set the pointer to the current branch to commit (commit will be removed) and reset the staging area. $git reset <commit> # equivalent to $git reset --mixed <commit> # $git reset --hard <commit> $git reset --hard <commit>Copy the code

• git resetThere are many ways to use it. It can be used to remove commit snapshots, although it is commonly used to undo staging and workspace modifications. In either case, it should only be used for local modifications — you should never reset snapshots shared with other developers.
• When you use reset to roll back to a version, subsequent versions of the previous version will be garbage deleted in the next Git commit.
• When you go back to an old version and use git log to check the commit record, you will find that the previous new version record is missing. What if the next day, you want to go back to the new version? What if you cannot find the new version of commit_id?

We can usegit reflogLook at the history command so you can see the commit_id of the previous new version, and thengit reset --hard commit_idYou can go back to the new version of the code

• While you can use Git reflog to view your local history and revert to the previous version of the code, you can’t get your history commands on other computers, so it’s not secure. If your computer suddenly crashes, you can’t go back to a future version.

cherry-pick

Apply the specified commit commit to the current branch (which can be used to recover accidentally undone (revert/reset) commits)

$ git cherry-pick <commit_id> $ git cherry-pick <commit_id> <commit_id> $ git cherry-pick <commit_id>^.. <commit_id>Copy the code

git bisect

• Quickly find buggy commits
• The idea is simply to narrow down the history of code submissions in a dichotomy. The idea of “dichotomy” is to split the code history into two parts, determine whether the problem is in the first or the second half, and continue this process until it Narrows down to a single code commit.

# "end" is the most recent submission, $git bisect start [commit_id] $git bisect start HEAD commit_id # $git bisect reset = $git bisect reset = $git bisect reset = $git bisect resetCopy the code

We often encounter situations where a project at work needs to include and use another project. Maybe it’s a third-party library, or one you developed independently for multiple parent projects. Here’s the problem: you want to treat them as two separate projects, but at the same time you want to use the other in one project. If you copy code from another project into your own project, any custom changes you make will make it difficult to incorporate upstream changes. Git solves this problem with submodules that allow you to use one Git repository as a subdirectory of another. It allows you to clone another repository into your own project while keeping the commit independent.

Git submodule add [URL] [path] # clone the main project with the submodule. The default directory contains the subproject, Git submodule update # Is equivalent to git submodule init Git submodule update git submodule update Git Clone --recurse-submodules [URL]Copy the code

1. Create a local Git project and associate it with the remote repository

$Git remote add <name> <git-repo-url https://github.com/xxxxxxCopy the code

Git branch management specification

Blog.csdn.net/LitongZero/…

Juejin. Cn/post / 684490…

• In actual development, one branch per person (Personal opinion: Unless it is a large project with a large number of developers involved, the feature branch can be adopted. Otherwise, in general projects, one branch for each developer is sufficient). There is also a Develop, a test, and a Release pre-release branch.
  • Every day developers need to pull/submit branches of the latest code;
  • Test: Test branch, which is released to the test environment after developers have developed and passed the self-test.
  • Release: pre-release branch, after the test environment passes the test, the code of the test branch will be released to the branch of the pre-release environment (this depends on whether the company supports the pre-release environment, otherwise you can not use this branch);
  • Master: online branch. After passing the pre-release environment test, the operation/test will publish the branch code to the online environment.
• General process:
  • Developers need to pull/submit the latest code to the Develop branch every day;
  • After the developer finishes the development, the integration test is started. After the test is done correctly, it is submitted to the Test branch and released to the test environment for testing by the tester.
  • After the test environment passes, it is released to the release branch for pre-release environment testing.
  • After the pre-release environment passes, publish it to the master branch and tag it.
  • If there is a bug in the online branch, the developer should create a new bug branch based on the pre-release branch (if there is no pre-release environment, use the master branch) to temporarily solve the bug and apply for merging into the pre-release branch after processing the bug. This has the advantage of not affecting the functionality in development.

What the pre-release environment does: The pre-release environment is the last test before the official release. Because in a few cases, even if the pre-release passes, there is no guarantee that the formal production environment will be 100% trouble-free; The configuration of pre-release environment, database and so on are the same as online; For some companies, the pre-release environment database is an on-line environment, while for others, the pre-release environment is a separate database. If there is no pre-release environment, if there is a problem with developing merged code, the problem will be directly published online, increasing the maintenance cost.

4.2 installation of pre – commit

npm install pre-commit --save-dev
Copy the code

4.4 Skip pre-commit and continue to commit the code

#Skip the verification
$ git commit --no-verify
$ git commit -n
Copy the code

More hooks: git-scm.com/book/zh/v2/…

If you accidentally delete someone else’s remote branch, it is useless to try to pull someone else’s branch again. It will say “already up”

At this point, you can roll back the code and pull again.

3, Fatal: refusing to merge suggested histories

After Git 2.9.2, it is not possible to merge branches that do not have the same node (branches have never been pulled and merged with each other since the repository was created). If you need to merge branches of two different nodes, do as follows:

$ git pull origin branchName --allow-unrelated-histories
$ git merge branchName --allow-unrelated-histories
Copy the code

This function is to let you do not upload the warehouse wrong, if you will add this code, then you are sure to upload. With older versions of Git, it’s very easy to upload the wrong code, and now you can see that if you upload something different, you need to add code to upload. Under normal circumstances, are the first to establish the warehouse, and then cut multiple branches, branches to pull the content of the main branch, and then their own development, if the establishment of the warehouse, each branch has no area to pull the code of the main branch, after the branches want to merge will report an error.

5. Accidentally uploaded some files to a remote Git repository/wanted to delete files from the remote repository

$git rm --cached filename $git rm --cached filenameCopy the code

If you uploaded a file to the remote repository before configuring the.gitignore file and want to delete it from the remote repository, it is useless to configure the.gitignore file because it has already been traced, but you do not want to delete the file locally and then recommit it to the remote repository. You can use the git rm –cached filename command to untrace the file, so that the next time git commits the file, it will not commit again and will be deleted from the remote repository

The HEAD pointer can point to either a branch (the default is the current branch) or a snapshot. The state of the HEAD pointer when pointing to a snapshot is called a detached state.

Git does not allow you to submit empty folders

You can add a.gitkeep file to the current directory

12,Configure multiple Git accounts on the same computer

Github.com/jawil/notes…

Git commit-am “XXX” sometimes fails to commit all changes

Git commit-am “XXX” only adds a file tracked to the staging area and commits, whereas adding a file tracked to Git management uses the git add command, which tracks the new file. After creating a file, IDEA will prompt you to add it to Git management. Then idea defaults to new file tracked.)

Blog.csdn.net/liuxiaoheng…

Segmentfault.com/a/119000001…

Segmentfault.com/a/119000001…

www.playpi.org/2019031901….

19. Git pull pulls all remote branch code into the local mirror repository

When you want to merge someone else’s branches:

• Merge BranchName if you already have someone else’s branch in your local repository (switching directly to someone else’s branch generates a branch locally), you can use merge Branchname.
• Merge Origin/BranchName if your local repository does not have someone else’s branch, merge Origin/Branchname

21. Git Stash Stores untracked files

• If we create a new file and it doesn’t workgit add .Trace the files, thengit stashIt can’t be stored

$ git stash -u
Copy the code

Git configuration $cat. git/configCopy the code

• Check whether the repository URL set in the.git/config file of the local project is the same as the link used on Github.git pushThere are two types of data protocols:ssh 和 https. If they are inconsistent, you need to switchurlAddress.

Lint-passage failed

Maybe your project name path contains a Chinese name and needs to be replaced with an English name

27,Git uses vim to open, modify, and save files

31, If two people have modified a file, one is to rename the file, the other is to modify the file content, then there will be a conflict? Git is smart enough to automatically merge these changes

If two people rename the same file, there will be a conflict that Git doesn’t handle automatically and requires the developer to resolve

www.jianshu.com/p/3719dae37…

git revert -m 1 
Copy the code

To create a branch in Git, you must have a parent node, which means you must create a branch on top of an existing branch. You cannot create an empty branch if the project has been in progress for a while. But sometimes you just need to create a blank branch.

$ git checkout --orphan emptyBranchName
Copy the code

This command generates a branch called emptyBranch that contains all the files of the parent branch. But the new branch does not point to any previous commits, because it has no history. If you commit the current content, this commit will be the first commit of the branch.

If you want an empty branch, you need to delete all the current content with git

$git rm -rf.Copy the code

Recommended reading

Do you really understand the React lifecycle

React Hooks 【 nearly 1W words 】+ project combat

React SSR: + 2 projects

Cookie, Session, Token, JWT

TS FAQ sorting (more than 60, continuously updated ing)

Pro Git (Chinese version)

git-recipes

How to use Git gracefully

How to use Git submodule development in a large project

Github API Call (v3)

www.jianshu.com/p/a0c7d0482…

Developer.github.com/v3/guides/g…