Begin to use

Create a git repository in the root directory of your project
git init

# No project code
cdGit init projectCreate a folder in the current directory with the same name as the project name
cd project
Copy the code

Git alias

Git can alias common commands to improve terminal use efficiency

git config --global alias.co checkout
git config --global alias.unstage 'reset HEAD --'
git config --global alias.visual '! gitk'Execute external command +!Copy the code

Add the file to the staging area

git add . Keep track of all files in the current directory
git add fileA fileB # trace fileA and fileB files
git add -u Add changes to all traced files to the staging area
Copy the code

Git tag

Git is tagged for a commit. Tagging is usually carried out with the release. Through Git tagging, we can more conveniently carry out version checking and rollback operations, which is also a very important link.

Git tag // Lists existing tags git tag -l'v1.8.5'Git tag-a v1.4-m git tag-a v1.4-m git tag-a v1.4-m'message'Git show [hash] git tag v1.4 / / git lightweight tag tag - a v1.2 9 fceb02 / / for a commit tagging * * * * * * * * * * * * * * * * * * to share, ******************** git push will not push tags to remote repositories git push Origin v1.5 // Tags must show push git psuh Origin --tags // Push all * * * * * * * * * * * * * * * * * * * check out * * * * * * * * * * * * * * * * * * * * git checkout/tag / / check out a tag / / will be in a state of separation head pointer, and submit at this time do not belong to any branch, If you need to modify the new branch git checkout - b version2 v2.0.0 / / on a particular tag to create a new branch of * * * * * * * * * * * * * * * * * * delete the tag * * * * * * * * * * * * * * * * * * * * * * git tag - d V1.4 Git Push Origin: Refs /tags/ V.14Copy the code

Branches are a very important concept for Git, and we often create new branches on top of the main branch for our own development or bug fixes. We then wait for development to be completed and verified before merging our new features or bug changes into the main repository by merging branches

git branch branchName

git branch -v # Look at local branches

git log--oneline --decorate // Check the objects that each branch refers to. git checkout branchName git checkout -b branchName gitlog--oneline -- class --graph --all // Outputs the submit history, the direction of each branch, and the matching of project branches. A Git branch is essentially a file that contains the checksum of the object in question (a sha-1 value string of length 40). Git branch -d branchName Git branch -d branchName Git merge branchName Branch merge automatically selects a commit as a common ancestor as the base branch conflict for merge: 1. Use Git merge --abort to force the merge, and use Git add fileName to flag resolved conflicts. Git branch --merged or git branch --no-merged displays merged or unmerged branches. Use git branch -d branchName to delete branches that have not been merged. Git branch -m oldName newNameCopy the code

View the version repository

Compare differences between versions

With git’s git diff command, you can compare any file between two commits.

Git diff j f b d u key control page flip g g first line, last line 3g jump to third line/or? + keyword up to down, down to up search, highlighted is matching n next n on the previous input H help document q exit

git diff   # Workspaces and staging areas.

git diff --cached / git diff staged  Staging area and version libraryGit diff -- file name# Specific file differences can be multiple files

git diff masterA materB  # Compare any two branches

git diff [old-commit] [new-commit-id] -- fileName  Git compares the difference between any two commits
Copy the code

File operations

Rename file

Git mv file_from file_to equals mv file_from file_to git rm file_from git add file_toCopy the code

Storage code

Git Stash is used when additional tasks are inserted after code changes are made to the workspace and repository and we need to temporarily store the contents of the existing workspace and repository

git stash

Git stash list git stash apply // The files that have been temporarily stored are not re-temporarily stored git stash apply --index Stash @{2} stash@{2} // drop stash stash pop // reapply and drop stash branch branchName // Create a new branch from the latest stash, // Git stash save noteContent But you can add the git stash clear // to clean up all the git stash show stash@{2} // to see how stash differs from the current oneCopy the code

Cancel the operation

Git reset HEAD <file>... // Cancel temporary storage. Git checkout -- <file>Copy the code

Restores the staging area to the workspace

Cancel workspace change git checkout — fileName

Code back

• Git reset HEAD file name, not all
• Overwrite the old version of the staging area back:Git checkout -- file name
• Back in the day:
  • Between Repository and Stage,commit reset
  • Between workspace Working and staging,add checkout
  • Git reset HEAD~ ~
  • Git rest –mixed(default) HEAD~
    • Move the HEAD pointer to point to the previous snapshot
    • Roll back the snapshot pointed to after HEAD is moved to the staging area
  • git rest –soft HEAD~
    • Move the HEAD point to the previous snapshot (undo a bad commit)
  • Git rest –hard HEAD~
    • Move the HEAD pointer to point to the previous snapshot
    • Roll back the snapshot pointed to after HEAD is moved to the staging area
    • Restore the files in the staging area to the working directory
  1. Move the HEAD point (–soft)
  2. Mix the snapshot into the staging area ([–mixed], default)
  3. Restore staging area to working directory (–hard)
  • Rollback specified snapshot, specify the first few :git reset ID
  • Roll back a file in a snapshot
    • Git reset Snapshot version file name/path
    • Git reset Specifies the snapshot version ID

Git pull and Git Fetch

The same place:

• Git Fetch and Git pull are both ways to update code from a remote server

Different place

• It is equivalent to obtaining the latest version from remote to local, and does not automatically merge
• Git fetch + git merge

Git fetch & Git pull [Article from Shell Technology]

collaboration

Multiplayer collaboration, no forced submission, no base change.

Some people change the file name, others change the content of the file based on the original file name.

Git merges automatically. Git handles this very well, not necessarily with other version controls.

git chery-pick

Git cheese-pick copies a commit to the current branch. After cheese-pick, for historical purposes, Auther is the original commiter for the commit, but the commiter is itself. If you make changes to your code, you may need to change the auth to your own with a Git commit. For example, apply the BRANch1 commit1 commit to the Branch2 branch.

1. Use git log to see the hash of the commit that needs to be applied to the new branch.
2. Switch to the branch2git chery-pick [commit1hash]Can automatically submit

Chery -pick parameters:

• Git cheese-pick-nAutomatic submission can be avoided.
• Git cheese-pick-eYou can edit the COMMIT information.
• Similar to Git Rebase, when you encounter a conflict,git cherry-pick --continue.git cherry-pick --abort.git cherry-pick --quit.

Git hooks

Git hooks allow you to trigger scripts to perform certain Git operations, such as verifying that your commit message meets requirements, running unit tests in your code to ensure code quality before pushing it to a remote location, and so on.

Verify the Commit message with git hooks

Git reset –hard HEAD^

Accidentally we have to code back to the last version, find the lost code. Implementation steps:

1. Git reflog to find the commit hash that we accidentally deleted.
2. Use cheese-pick to retrieve it

Change git commit history

Git Rebase makes it easy to make changes to your commit history. Making changes to the committed history can cause conflicts in the code that need to be resolved. Changing git commit history is a very dangerous operation. The changed branch cannot be directly pushed to the remote repository, so it must be pushed forcibly. If the branch involves **** multi-person collaboration, special attention should be paid to avoid unnecessary trouble.

We have developed new features based on the Master branch. First, we cut off a new branch called Feature1 to develop new features. After a week, we completed the development. Within this week, other colleagues also carried out normal development and finished online, and joined the Master branch. At this point, we need to apply the master changes made by other colleagues to our Feature1 branch within a week. This can be achieved by merging branches and rebasing. By rebasing, our Git submission history will be aligned in a straight line. The obvious difference between this and merging branches is that merging branches mixes our multiple commits with the master’s change of commit within the week, depending on the time, whereas using base changes makes our commit order come after those commits on the master. Rebasing operations can cause conflicts.

#Using merge branches
git merge master

#Use rebase
git rebase master
Copy the code

Split commit with git rebase

Blog.csdn.net/weixin_3373… Implementation steps:

1. git rebase -i [commit-hash]
2. An editor window will appear in which all of our commits will appear. The status of the commit to be split will be changed to E to save the edited content.
3. Git Rebse stays at the commit that needs to be split.
4. Use git reset HEAD^ to undo the commit that needs to be split.
5. Look at the current status, at which point we can add as many commits as we want.
6. Git rebase –continue after we play commit. At this point we have successfully modified the commit record

Select the Revised version

Refer to the log

Git reflog looks at the reference log. Whenever a HEAD point changes, Git stores this information in the reference log. Git show HEAD@{5} git show master@{yesterday} see which commit this branch pointed to yesterday. Useful only for data that is still in the reference log. Git log -g displays reference log information similar to git log output format. Branch references only exist in the local repository, new clones reference log is empty

Submit the interval

git logmaster.. Experiment looks at commits that exist in the Experiment branch but not in the Master branch. gitlogorigin/master.. HEAD views the content to be pushed to the remote end.Copy the code

Git defaults it to HEAD

At three o ‘clock

Git log master… Git log –left-right master… experiment

Temporary and untemporary files

What is in Git

• The HEAD file stores the current branch. Direct editing works just as well as switching branches
• Config file storage, the config for this file
• The refs folder heads branch tags store the hash value, and the hash value in tags refers to commit
• The objects folder and the files in the folder form a hash value. Git cat-file is a tree. Git cat-file -p HSDH git cat-file -p HSDH git cat-file -p HSDH

git cat-file -t hash  The # command displays the content, type, and size of a repository object. I'll use -p for the content
Copy the code

Commit Tree blobs are three core objects. Any file that has the same file content is a unique BLOB

Detached HEAD

Changes are not made based on a branch, so a commit made on a split header pointer during a branch switch may be garbage removed by Git. If you consider the change important, be sure to tie the change to the branch. Git checkout [commitHash] is essentially working without a branch, so you can do development and commit. If you switch to a new branch, changes that are not associated with the branch may be garbage removed by Git. You want to make changes to the branch. Git checkout -b new-branch-name Git prompts you to build a branch for a commit that has already been committed. Git Branch can take advantage of this feature and, when discarded, simply switch to another branch.

Four, use the problem induction

Git branch -a is also available locally after the remote branch is deleted

To solve the www.cnblogs.com/taohuaya/p/…

Git remote show origin git remote show origin Git remote prune origin [branch] git remote prune originCopy the code

Merge Two unrelated branches

git merge -allow-unrelated-histories master orogin/master

Commit changes to some lines of the file to the staging area

This operation requires the patch parameter to git add

1. Step 1: Run git add –patch to open a terminal interface

# Run this command directly
git add --patch

Or use this to open the interface and select Patch
git add -i
Copy the code

2. Step 2: Select the required content. In the interactive interface, Git will list all our current changes one by one and provide commands for us to operate, roughly as follows

warning: LF will be replaced by CRLF in package-lock.json.
The file will have its original line endings in your working directory
warning: LF will be replaced by CRLF in package.json.
The file will have its original line endings inyour working directory diff --git a/666.js b/666.js index e69de29.. 8ea67d4 100644 -- a/666.js +++ b/666.js @@ -0,0 +1,65 @@ +console.log(1) +console.log(2) +console.log(3) Stage this hunk [y,n,q,a,d,e,?] ?Copy the code

The first current change is shown and several operations are provided for this change [y,n,q,a, D,e,?]. (The number of operations here is not certain, there may be other, this need not remember, directly enter to check the instructions, more familiar with)

Stage this hunk [y,n,q,a,d,j,J,k,K,g,/,s,e,?] ? y - stage this hunk n -do not stage this hunk
q - quit; do not stage this hunk or any of the remaining ones
a - stage this hunk and all later hunks in the file
d - do not stage this hunk or any of the later hunks in the file
g - select a hunk to go to
/ - search for a hunk matching the given regex
j - leave this hunk undecided, see next undecided hunk
J - leave this hunk undecided, see next hunk
k - leave this hunk undecided, see previous undecided hunk
K - leave this hunk undecided, see previous hunk
s - split the current hunk into smaller hunks
e - manually edit the current hunk
? - print help

Copy the code

We just type in a command for each change to the file, and we can decide whether or not to store that change in the staging area. Commands can be simply divided into two groups and two special ones.

Y - temporary storage of this block N - No temporary storage of this block Q - Exit; Do not temporarily store the remaining blocks including this block A - temporarily store this block and all blocks following this file D - do not temporarily store this block and all blocks following this file g - select and jump to a block / - search for blocks matching the given regular expression J - Temporarily undecided, Go to the next undecided block J - undecided, go to a block K - Undecided, go to the next undecided block K - undecided, go to the next undecided block S - Split the current block into smaller blocks e - Manually edit the current block? - Output helpCopy the code

Except for e, all the others are easy to understand. When we select E yes, we will enter a text editor interface, which is roughly as follows

# Manual hunk edit mode -- see bottom for a quick guide.@ @ - 0, 0 + 1,65 @ @ + console. The log (1) - the console. The log (2) + the console. The log (3)# -- -- --
# To remove '-' lines, make them ' ' lines (context).
# To remove '+' lines, delete them.
# Lines starting with # will be removed.
#
# If the patch applies cleanly, the edited hunk will immediately be
# marked for staging.
# If it does not apply cleanly, you will be given an opportunity to
# edit again. If all lines of the hunk are removed, then the edit is
# aborted and the hunk is left unchanged.
Copy the code

• Rows deleted from changes are preceded by “-” criteria. If you don’t want to commit the change to staging, just change the “-” to “”.
• Lines added to changes are preceded by a “+”. If you don’t want to commit the change to staging, just comment it out by adding a # before the “+”
• Save the configuration and exit.

If there are multiple file changes in the current workspace, step 2 is repeated for each file until all files have been processed and exit automatically. You can use git diff –cached to see if your git add is correct. We can also directly use graphical software to operate, such as Sourcetree. Related links:

• www.v2ex.com/t/322122
• Use Git add-p to organize patch

The local branch is associated with the remote branch

Remote branch association allows you to perform git push without explicitly specifying the remote branch. Application scenarios

• Disassociate when you change the name of a local branch
• To omit entering the remote branch before the new branch is pushed for the first time

#To view
git branch -vv

#Establishes the association between the current branch and the remote branch
git branch -u origin/master
#You can do that
git branch --set-upstream-to origin/master

#Disassociate the local branch from the remote branch
git branch --unset-upstream

Copy the code

git subtree

Windows with git

1. Try to use Gitbash for Git on Windows instead of using CMD, which has no command prompt and is not friendly when editing messages (such as commit messages).
2. For our operations at gitbash, gitbash records command operations (last 500 commands) in the.bash_history file in the home directory of the currently logged user.
3. The vim configuration file we used in gitbash is the.viminfo file in the home directory of the currently logged in user.
4. If we use the user name and password to log in to GitHub/Gitee, we may fail to log in when we change the password or enter the wrong password for many times. In this case, we need to manually delete our login credentials. To do this, open the control panel \ User Account \ credentials manager, select Web credentials, and delete the GitHub tie we just entered.

Git learning resources recommendation

• Pro Git electronic edition
• Practice web git command, the game is in the form of: https://learngitbranching.js.org
• Git Flight Rules (Flight Rules) : https://github.com/k88hudson/git-flight-rules
• Code cloud Git information (very recommended, especially comprehensive) : https://gitee.com/all-about-git
• Geek Time’s play with Git Three Swordsmen, lecturing Su Ling (head of Ctrip code Platform)

article

• “Memo” 60+Git common command lines
• Three years of Experience with Git & FAQ sorting
• This is the real Git — branch merge
• Git new commands switch and restore