Git merge local to local branch without switching

In this blog post, we’ll explore a simple, but powerful Git command: git push . master:production. This command allows you to push changes from your master branch to your production branch locally, without having to switch between branches manually.

Let’s dive into what this command does and why it’s useful.

The Command: git push . master:production

Before we break this down, let’s first look at the command:

git push . master:production

At first glance, it might seem a bit unusual. However, it’s actually a clever way to push changes within your local repository, without needing to rely on any remotes or switching between branches. Let’s break it down:

• git push: This is the standard command to push changes to a remote repository. But when you use . (dot) instead of a remote name, you’re telling Git to push to the current repository, i.e., your local repository.
• . (dot): The dot here is shorthand for the current repository (essentially saying, “push changes to my current local repository”).
• master: This is the source branch. It’s the branch you’re currently working on and want to push from.
• production: This is the target branch where you want the changes to go. It could be another local branch, and Git will push changes from master to production locally.

What does it do?

This command is doing the following:

1. Pushes the master branch to the production branch within your local repository.
2. It does not require you to switch branches. You can stay on your master branch and still push its changes into production.

This is particularly useful in situations where you want to update one branch with changes from another, but you don’t want to deal with the hassle of switching branches or manually merging.

Why Is This Useful?

The main benefit of this command is efficiency. Imagine you’re working on a master branch, and you want to update a production branch with the latest changes. Normally, you would either:

• Switch to production, run a git merge master, and then push it.
• Use a more manual process like git cherry-pick or copying changes over.

But with git push . master:production, you can:

• Stay on your current branch (master).
• Push the changes directly to production without the need to switch branches or use additional merge commands.
• Avoid unnecessary merges or commits when you just want to sync one branch with another.

Real-World Example

Let’s say you’ve been working on the master branch, and your changes are ready to be reflected in the production branch. You want to avoid the extra overhead of switching to production and performing a manual merge. Instead, you can run:

bashCopygit push . master:production

This will apply all changes from master to production without interrupting your workflow.

Additional Notes

• Local-only: This command works only within your local Git repository. If you want to push these changes to a remote repository, you’d need to use git push origin master:production instead.
• No remote involved: This is useful in cases where you’re working on different branches locally and want to keep them in sync without pushing to a remote server.
• Simple & Clean: This one-liner keeps your Git workflow neat and clean, especially when you’re juggling multiple branches locally.

Conclusion

Git provides an array of powerful features to streamline your development process, and mastering a few simple commands like git push . master:production can make a huge difference in how you work with branches. Whether you’re managing multiple branches for different features, environments, or tasks, this simple command allows you to quickly sync branches without unnecessary context-switching.

Next time you need to push changes from one local branch to another, give this command a try and save yourself a few steps!