Remember before

Git is most commonly used code management tool, in the actual work we will encounter some problems on the git, will make us at a loss, so the summary, the following are common scenarios and the problems in the work, if you want to learn about other aspects of git exotic curiosity-a solution looking can refer to other articles, such as have not welcome pointed out


To use Git, you must be in a repository. There are two ways to create a repository

Git clone: git clone: git clone: git clone: git clone: git clone: git clone: git clone: git clone: git clone: git clone: git clone: git clone: git clone: git clone

  • Workspace: Workspace is the area of your cloned code directory where you add and modify code
  • The staging area: the staging area is in your repository. When you use Git Add, Git will put your workspace changes into the staging area
  • Local branch: When you use Git commit, this command commits code from the staging area to a local branch

The first two are understandable, but let’s look at the third, the local branch

Git Clone -b develop…

Clone a specified branch of a remote

The local branch

Remote branches are also cloned along with the repository

The red is the remote branch, so what is the green master, which is the local branch that tracks the active branch in the remote repository, and is created by Git itself

Creating a repository

You can use git clone to create a local repository. You can use git init to create a local repository. This command is called git init. If our Git client is github and you create a private repository, see the photo below

Step 1: Git init initializes the repository

Step 2: Git Add. put all changes in the staging area

Git Remote Add Origin XXXXXX

Git push -u Origin master -u origin master -u origin master -u Origin master

!!!!! If the third step accidentally associated with the wrong, you can use the following command to cancel the association

git remote remove origin

Common commands

After introducing some git concepts above, I will now focus on git common commands and scenarios

Git status: Check the status of the workspace

Git Add: Put your workspace changes in the staging area

Git commit -m “: commit changes in the staging area to a branch of the local library

Git branch: Check the current branch

Git checkout: switch branches

Git log: Check the commit records

Scenario 1

One of the most important commands in Git is to go back when you have changed the code and use git add. Later, you find that there is something wrong with the changed file and you want to change it back. At this time, you can directly modify it once and then go to git add. Once is fine, but if you git add. And git commit -m ”; Git reset –hard HEAD^

HEAD: symbolic reference to the current checked out record, which by default points to the latest commit

HEAD^ : ^ means the last one, and this command means the last commit

HEAD~2: ~ lets you specify a number. This command specifies how many times to roll back

–hard: –hard: –hard. Once you add –hard, you can go back to the last commit, but your workspace will have to be changed completely.

Scenario 2

Another important scenario in Git is code rollback. When a bug suddenly appears, but you don’t know when the bug was committed, you can use Git checkout 123AA

Git checkout is usually used to switch branches, but if you use this command on the current branch and specify the hash value for the commit, git checkout separates the HEAD from the current branch (by default, the HEAD is the same as the current branch, so the current branch always has an *). So the HEAD points to the other commit, and your current branch code, which the HEAD points to, can be rolled back using this feature

Scenario 3

There are two types of code merge: One is Git merge Bug, which means that the current branch merges the Bug branch. The advantage of this merge mode is that the Bug branch and the current branch are independent, which can track the history of the commit well, but it will make the code line more complicated. Look at the following diagram

The second way to merge branches is git Rebase. Rebase is essentially taking a list of commit records from the bug branch, “copying” them, and dropping them one by one on the master branch. The advantage of Rebase is that it creates a more linear commit history. If only Rebase was allowed, the commit history of the code base would be very clear. Git rebase master moves the current branch commit to the master branch

The important thing to notice here is that the master branch is not new, bugFix is, unlike the merge, and you need to update the master

git checkout master

git rebase bugFix

Or git rebase bugFix Master

Scenario 4

For example, we have a release branch and a Develop branch, we submit a function on the Develop branch, but the product temporarily says that it also wants to send it, so what should we do? Can we directly copy the Develop code? Can we have a simpler method

git checkout release

git cherry-pick C4

This command is to take a branch commit, and put a copy of it in the current branch, and C4 is the hash value of a commit, and it’s usually just to bring in the other branch commit, remember only the C4 commit

Scenario 5

Whether it’s rollback or code undo, you need to know the hash value of the commit, so you use git log, sometimes it’s a little complicated because it’s all hash, but if the commit message is bad and you don’t know which one it is, then you can use git tag to type a tag, Use to set the ID of a particular submission, quickly switch to this submission

Git tag -a 3.0.8 -m ‘3.0.8 commit ‘

-a: Adds a label

3.0.8: Label name,

-m: indicates the description of the label

Git Tags View all the tags

Git push Origin pushes a local tag

Git Push Origin –tags push all successful tags to remote locations

Remote operation

Now let’s talk about git remote operations

git fetch

This command pulls the remote branch code from the remote repository to the remote branch of the local library, as shown in the following picture

After the git fetch is executed, the O /master branch is updated (this is the local remote branch), but the local master branch is not updated. To update the local master, you need to perform git merge O /master

git pull

Git pull = git fetch + Git merge o/master

git push

This command pushes local changes to the branch of the remote repository, and it’s worth explaining that git push without any parameters depends on a git configuration called pusw. default. The default value depends on what version of Git you’re using, so it’s a good idea to check this configuration before pushing.

Git push

We push to the local master branch without any parameter because git knows which branch is associated with the remote repository (explained below).

Git push 2

If you don’t know, for example, I create a local branch, modify the code, and directly git push, what will happen

“Git push origin source:target” “git push origin :target” “git push origin :target” “git push origin :target” “git push origin :target” “git push origin :target

Source: indicates the local branch

Target: indicates the remote branch

Since you are now in the test branch, you can simply ignore the source.

Git push origin test = git push origin test = git push origin test = git push origin test = git push origin test (Another way is to create it directly on a Git client such as Github and then disassociate it, as explained below.)


If I push the git branch directly to the local master branch, it will push the code to the remote master branch. Is it because the name of master O /master is similar

The correlation between master and o/master is determined by the branch’s “Remote Tracking” property. The master is set to track O /master — this means that the master branch is given a push destination and a pull and merge destination. You may be wondering how this property is set on the master branch. You didn’t specify this property with any command. Well, Git automatically sets this property for you when you clone your repository. When you clone, Git creates a remote branch (such as O /master) in the local repository for each branch in the remote repository. Then create a local branch that tracks the active branch in the remote repository. By default, this local branch is named master.

Set your own association

The above association is set by git default, so can we set it ourselves? Yes

git checkout -b develop origin/develop

This command creates a local develop branch and associates it with the develop branch of the remote library. This branch will behave as if it were a remote branch. This is how we pull the remote branch, and it will not merge

git branch -u origin/develop develop

This method also creates a Develop branch and associates the Develop branch with the remote library. This is also a way to pull the remote branch without merging it

git fetch origin foo

Git fetch and git pull have the same parameters as git push, but the value of the origin target is reversed. What does the above code mean

He will pull the remote foo branch code to the local remote branch, if there is no local remote repository branch, he will also create a local remote branch.

Git fetch Origin bar will create a local branch o/bar, but you can switch to the Git checkout bar on top of the bar

When you perform git checkout bar, git will automatically create a local branch of the bar you see

Git fetch Origin bar:bar if you want to see it from the start, you have to put the two parameters together

git pull origin target:source

Git pull is the same as git fetch, but it helps you merge it! Merge! Merge!

git pull origin develop:develop = git fetch origin develop:develop + git merge develop

It creates the develop branch locally and will help you merge the develop branch with the current branch. If you operate on the master branch, it will help you merge the develop branch with the master branch

Pay attention to

git pull origin develop = git fetch origin develop + git merge o/develop

When the command is an argument, it creates an o/develop but it also merges, so if you use the git pull command, it will help you merge. Git fetch origin develop