Hackernoon logoMake Your Life Easier With These Git Workflows: Part I by@johnedvard

Make Your Life Easier With These Git Workflows: Part I

image
John Edvard Reiten Hacker Noon profile picture

@johnedvardJohn Edvard Reiten

GameJammer

I will describe how to make your life easier as a programmer with these useful tips on using Git. Before reading this, I recommend that you have a basic understand on how Git works.

Essential Command Line Argument

My most used argument with git is probably

!$
. It is actually a command line argument. When you type this, the last used argument is replaced. For instance:

  • Type
    mkdir myFolder
    in the command line
  • Then type
    cd !$
    to move into the recently created folder

In the above example,

cd !$
will be translated into
mkdir myFolder
, and this is a bit simple, but think about the times you forgot to stage your files before committing:

  • git commit -m'feat: Add new kickass feature'
    , but you forgot to add the src folder
  • Then you can write
    git commit src/ !$
    , saving you from typing the whole commit message again

I know that you can press the up key,

โ†‘
, to get the previous used command, and sometimes that can be just as easy. pressing
ctrl+a
, to move the caret to the beginning of the command, and then use
alt + โ†’ 
to move one word at a time, and input
src/
where it needs to be. This is also something I use quite often.

Include Changes In the Previous Commit

I almost always catch typos, excess whitespace, or missing new lines after I make a commit. My best advice for adding these changes is to add them to the previous created commit. You don't want to mess up the git history more than you have to. Use the

--amend
to accomplish this.

  • Use
    git commit --amend
    to add your changes to the previous commit.

By default, on Mac at least, the terminal will open Vim, and you will see the previous commit message. Unless you want to add more to the message, you can type

:wq
which saves the commit message as is, and quits Vim.

But I already pushed the changes to the repository. I cannot change the commit anymore.

Don't worry. You can still amend the last commit, but you need to force push the changes to the repository. If you try to amend a commit that is already pushed to the repo, you will get an error message similar to this

! [rejected] master -> master (non-fast-forward)
error: failed to push some refs to '[email protected]

You might get a hint, telling you to pull the changes from repo, but this will create a conflict in your repository, and you need to create a new merge commit to fix it. This is not what we want. Instead, force push the changes you amended.

  • git commit --amend
    to add to the previous commit
  • git commit origin yourBranch --force
    to override the changes in the repo

Using

--force
is a bit scary, because you could loose work permanently. Use it with care, and when you are 100% sure you know what you are doing. It is a powerful command, and with great power comes great responsibility.

I Want to Undo My Previous Commit

This is somewhat the opposite of the previous section. Instead of adding changes, we want to undo them.

I make a lot of mistakes as a programmer, and one of them is committing the wrong files to the wrong branch. What do I do? I want to keep my changes, but remove them from the branch. In order to do this, we need to reset the change:

  • git reset HEAD~1 --soft
    will reset the last commit, and you keep your workspace changes. (passing
    --hard
    instead of
    --soft
    means you will discard your workspace changes)
  • Now you can change branch, and commit the changes to the correct one.

But I already pushed the changes to the repository. I cannot change the commit anymore.

Don't worry. We have a way of solving it, and it involves a force push this time as well.

  • git reset HEAD~1 --soft
    to undo the commit, but keep the changes in our workspace
  • git push origin yourBranch --force
    to change the git history in our repo
  • Now you can change branch, and commit the workspace changes.

Summary

  • !$
    replaced with last used argument
  • git commit --amend
    append changes to the previous commit
  • git reset HEAD~1
    undo the latest commit
  • --soft
    keep workspace changes
  • --hard
    discard workspace changes
  • --force
    overwrite existing code in repository

Tags

Join Hacker Noon

Create your free account to unlock your custom reading experience.