- Make sure your local copy of the selected branch is updated.
- Without overwriting anything
git fetch
- If you already fetched or you are ready to overwrite your local copy, then pull
git pull
- Without overwriting anything
- Check your repo branches
- Local branches
git branch
- All branches on remote repo
git branch -r
- Both local and remote branches
git branch -a
- You can also add
-v
to make the commands explicitly verbose
- Local branches
- Create a branch and access it
- Normal way
git branch new_branch
- (2 ways)
git checkout new_branch
git switch new_branch
> Recommended option (avoidcheckout
unless necessary)
- Shortcut (2 ways)
git checkout -b new_branch
git switch -c new_branch
> Recommended option (avoidcheckout
unless necessary)
- Normal way
- Get some work done lol
- Check the status of your work
git status
- Did you mess up editing a file and want to restore it to how it was beforehand?
git restore changed_file.txt
- Add changes to staging in order to prepare your commit
- Add a single file
git add new_file.txt
- Add all changed files
git add . -p
- Add a single file
- Did you screw up? Reset the staging
git reset
- Commit
git commit -m "This is a commit message"
- Check the commit history of the branch you're in
git log
- If you wanna see some cool things with log, you can use something like this:
git log --graph --oneline --all
- Make sure you upload your commits to the remote repo! If your local branch is brand new, you must add it to the remote repo.
- New branch
git push -u origin new_branch
- Previously existing branch
git push
- New branch
- Move to another branch
git checkout another_branch
- Merge some branch into your current branch (assuming default behavior of pull is merge)
git pull branch_that_will_be_merged_into_current_branch
For more info check the GitHub Git Cheat Sheet
checkout
can be used to switch branches and/or restore working tree files, which means that you can do things like undo/restore commmits and overwrite local changes, or detach the HEAD (navigating a commit which is not the latest on its branch).
switch
is only used for switching and creating branches. It cannot discard changes to tracked files: if you've changed a tracked file and want to switch branches, you'll need to stash or commit the changes.
The following are some best practices that may be useful, taken from this blog post, as well as this tip.
- While working on a branch, if you need to pull commits from the remote repo to your local repo, use rebase instead of merge to reduce the amount of commits
git pull --rebase
- If you want to make rebasing the default behavior when doing
git pull
, do so withgit config --global --bool pull.rebase true
- Before pushing your changes to the remote repo, perform basic housekeeping (squash related commits together, rewording messages, etc)
git rebase -i @{u}
- Make sure that you've fetched all changes from the remote repo
git fetch
- Simulate a merge to see any possible conflicts:
- Do a merge with the
--no-commit
flag from the work branch.get merge --no-commit --no-ff $GOOD_BRANCH
- Examine the staged changes
git diff --cached
- Undo the merge
git merge --abort
- Do a merge with the
- Merge (do not rebase) changes from master/main into your branch, in order to update the branch with the latest features and solve any compatibility issues and/or conflicts
git merge main
git pull --merge main
- Enforce merge commit when merging feature branch into main, even if a merge commit isn't necessary (check next point for exception), in order to make it easier to see the where and when of changes. Assuming you're in main:
git merge --no-ff branch_that_will_be_merged_into_main
- Exception to point 4: if you only need to merge a single commit (typical for stuff such as bugfixes). Assuming you're in main:
git cherry-pick branch_that_only_has_a_single_commit
- Delete merged branch:
- Delete locally
git branch -d branch_that_has_been_merged
- Delete on remote repo
git push origin :branch_that_has_been_merged
- Delete locally
- Make sure you've got a local commit. You may initialize a local repo with
git init
on any project folder and making sure that it has at least one commit, or you may use an already existing local repo. - On a separate folder, run:
git clone --bare path/to/local/project project.git
- This will create a folder with name
project.git
on the folder you're running the command. - Remote repo folders use the
.git
extension as a standard. - This folder is a bare repository. It does not contain a working folder, only the git files.
- This will create a folder with name
- Move the
project.git
folder to the final destination. Ideally, a shared folder such as a networked drive that everyone has access to "locally".- You may combine steps 2 and 3 by creating the bare repo directly on the final folder.
- You should now be able to clone the repo:
git clone path/to/remote/repo/project.git
- The original repo that we bare-cloned does not have an origin repo to push to. If you want to keep using it, set up a remote like this:
git remote add origin path/to/remote/repo/project.git
- On remote folder:
mkdir my_repo cd my_repo git init --bare
- On local folder:
cd my_repo git init git remote add origin ssh://myserver/my_repo git add . git commit -m "Initial commit" git push -u origin master