Pro Git, by Scott Chacon

Your Identity

The first thing you should do when you install Git is to set your user name and email address. This is important because every Git commit uses this information, and it’s immutably baked into the commits you start creating:

If you want to use a different text editor, such as Emacs, you can do the following: git config --global core.editor emacs

Checking Your Settings

If you want to check your configuration settings, you can use the git config --list command to list all the settings Git can find at that point

if you need in-person help, you can try the #git, #github, or #gitlab channels on the Libera Chat IRC server, which can be found at https://libera.chat/.

If you want to clone the repository into a directory named something other than libgit2, you can specify the new directory name as an additional argument:

That command does the same thing as the previous one, but the target directory is called mylibgit.

The main tool you use to determine which files are in which state is the git status command. If you run this command directly after a clone, you should see something like this:

Notice how you don’t have to run git add on the CONTRIBUTING.md file in this case before you commit. That’s because the -a flag includes all changed files.

To see which remote servers you have configured, you can run the git remote command

You can also specify -v, which shows you the URLs that Git has stored for the shortname to be used when reading and writing to that remote

Adding Remote Repositories

We’ve mentioned and given some demonstrations of how the git clone command implicitly adds the origin remote for you. Here’s how to add a new remote explicitly.

To add a new remote Git repository as a shortname you can reference easily, run

As you just saw, to get data from your remote projects, you can run:

Creating a New Branch What happens when you create a new branch? Well, doing so creates a new pointer for you to move around. Let’s say you want to create a new branch called testing. You do this with the git branch command:

You can easily see this by running a simple git log command that shows you where the branch pointers are pointing. This option is called --decorate.

Switching Branches To switch to an existing branch, you run the git checkout command. Let’s switch to the new testing branch: git checkout testing

This moves HEAD to point to the testing branch.

To show commit history for the desired branch you have to explicitly specify it:

git log testing

Divergent history You can also see this easily with the git log command. If you run git log --oneline --decorate --graph --all it will print out the history of your commits

It’s typical to create a new branch and want to switch to that new branch at the same time — this can be done in one operation with git checkout -b .

Create a new branch and switch to it:

The -c flag stands for create, you can also use the full flag: --create

Switch to an existing branch:

Return to your previously checked out branch:

The git branch command does more than just create and delete branches. If you run it with no arguments, you get a simple listing of your current branches:

Notice the * character that prefixes the master branch: it indicates the branch that you currently have checked out (i.e., the branch that HEAD points to).

To see the last commit on each branch, you can run

The useful --merged and --no-merged options can filter this list to branches that you have or have not yet merged into the branch you’re currently on.

To see which branches are already merged into the branch you’re on, you can run:

To see all the branches that contain work you haven’t yet merged in, you can run:

If you run git clone -o booyah instead, then you will have booyah/master as your default remote branch.

If you want to see what tracking branches you have set up, you can use the -vv option to git branch. This will list out your local branches with more information including what each branch is tracking and if your local branch is ahead, behind or both.

Git can figure out a short, unique abbreviation for your SHA-1 values. If you pass --abbrev-commit to the git log command, the output will use shorter values but keep them unique; it defaults to using seven characters but makes them longer if necessary to keep the SHA-1 unambiguous:

Interactive Staging

If you run git add with the -i or --interactive option, Git enters an interactive shell mode, displaying something like this:

You also don’t need to be in interactive add mode to do the partial-file staging — you can start the same script by using git add -p or git add --patch on the command line.

Now you want to switch branches, but you don’t want to commit what you’ve been working on yet, so you’ll stash the changes. To push a new stash onto your stack, run git stash or git stash push

To see which stashes you’ve stored, you can use git stash list:

Git Grep

Git ships with a command called grep that allows you to easily search through any committed tree, the working directory, or even the index for a string or regular expression. For the examples that follow, we’ll search through the source code for Git itself.

By default, git grep will look through the files in your working directory. As a first variation, you can use either of the -n or --line-number options to print out the line numbers where Git has found matches

you can ask git grep to summarize the output by showing you only which files contained the search string and how many matches there were in each file with the -c or --count option:

If you’re interested in the context of a search string, you can display the enclosing method or function for each matching string with either of the -p or --show-function options

If you simply want to modify your last commit message, that’s easy: git commit --amend

If, on the other hand, you want to change the actual content of your last commit, the process works basically the same way — first make the changes you think you forgot, stage those changes, and the subsequent git commit --amend **replaces** that last commit with your new, improved commit.

The official documentation can be found here: https://code.visualstudio.com/Docs/editor/versioncontrol