ziritrion/git.md

## git.md

      
    Raw
  

              git.md
            
          
    Basic git


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


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


Create a branch and access it

Normal way

git branch new_branch
(2 ways)

git checkout new_branch
git switch new_branch  > Recommended option (avoid checkout unless necessary)


Shortcut (2 ways)

git checkout -b new_branch
git switch -c new_branch > Recommended option (avoid checkout unless necessary)


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


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


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 vs Switch

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.
Advanced git

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 with git 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


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


Create a remote repo (local folder as remote repo)

Official method

Source

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.


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


Alternative method

Source

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