GIT Terminology
Git Goals and Objectives
- Repository container: files, history, configuration managed by GIT
- Working Directory / Repository
- Three stages of GIT (Working directory, Staging area /pro commit staging area/,Commit /GIT repository – history/)
- Remote repository (GITHUB)
- Master branch
GIT Introduction
What you get from VERSION CONTROL SYSTEM
- Eliminates the need of creating multiple backups of your files
- Allows multiple people to work at the same time on a file
- Tracks changes & also who has made the changes
- Easy to switch back to folder versions as and when required
- Makes you more productive
GIT Version Control System
Version Control is the management of changes to documents, computer program, large websites and other collections of information.
- Centralized Version Control System (CVCS)
- Distributed Version Control System (DVCS)
Centralized Version Control System
- CVCS uses a central server to store all files
- It works on a single repository to which users can directly access a central server
- The central server can be local on the remote machine directly connected to each of the programmers’ workstations
Drawbacks of CVCS
- The centralized repository is not locally available
- Since everything is centralized, any case of the central server crashing or getting corrupted will result in losing the entire data of project
Distributed Version Control System
- In DVCS every contributor has a local copy or a clone of the main repository
- The developer can update their local repository with new data from the central server by an operation called “pull” and make changes to the main repository by an operation called “push” from their local repository
Advantages of DVCS
- All operations are very fast because the tool needs to access only the HDD
- A new change-set can be committed locally without manipulating the data on the main repository
- If the central server crashes at any point of the time, the data can easily be recovered from anyone of the contributor’s local repositories
What is GIT
The most widely used modern version control system in the world today is Git. Git is a mature, actively maintained open source project originally developed in 2005 by Linus Torvalds, the famous creator of the Linux operating system kernel. A staggering number of software projects rely on Git for version control, including commercial and open-source projects.
Source: https://gdgucc.blogspot.com/2017/10/what-is-git.html
Design philosophy:
- Free and open-source
- Blazingly fast
- Distributed
- Data assurance
What is GITHUB
We’ve established that Git is a version control system, similar to but better than the many alternatives available. So, what makes GitHub so special? Git is a command-line tool. However, the center around which all Git-related things revolve is the hub – GitHub.com – where developers store their projects and networks with like-minded people.
A repository (usually abbreviated to “repo”) is a location where all the files for a particular project are stored. Each project has its own repo, and you can access it with a unique URL.
Source: https://www.howtogeek.com/180167/htg-explains-what-is-github-and-what-do-geeks-use-it-for/
Git quick start
The first step is to download GIT from the link below, it is available for all operation systems: https://git-scm.com/downloads
GIT Basic start configuration
$ git config --global user.name “Your Name Here” $ git config --global user.email “email@example.com” $ git config --list (show all properties) $ git help (example: $ git help add)
First REPO and commands
Enter the folder you want to use for the project and open a terminal on it
$ git init
Commiting the first file:
$ git status $ git add file.txt | $ git add . (add all files you made changes on) $ git commit –m “a message with which you want to commit the file” $ git push origin master (explanation after)
If you want to see the changes from a certain user:
$ git log --author ”name”
GIT Workflow
Version Control system
Verify changes in GIT
$ git diff
Compare staged with repo in GIT
$git diff --staged
Delete a file
$git rm file.txt
GIT with Github
GIT – DVCS is a tool
GITHUB is
- A code hosting platform
- A central repository
- A repository hosting service
To create a central repository:
$ git pull origin master $ git clone https://github.com/user/repo $ git push origin master
Branches in Git
A branch in GIT is a pointer to commit. To create a new branch we use the following command:
$ git branch $ git branch development $ git checkout development (to switch branches) $ git branch (to check in which branch you are)
Merge branches in GIT
Get to the branch you want to merge the changes in (for example, from development to master)
$ git checkout master $ git merge development $ git push origin master (sync with github)
GIT Basics
Revers commit in GIT
$ git reset HEAD filename (HEAD - alias for the current branch ex. $git reset master|development filename) $ git reset HEAD~ filename (HEAD~ last commit reverted | HEAD~5 delete the last 5 commits from the history)
The prefered command for many cases is:
$ git revert commit_id
You can copy the commit_id from
$ git log
Delete, rename & move a file in git
$ git reset HEAD filename $ git checkout --filename $ git rm –rf directory\ (r – recursive, f – force, all in the directory) $ git commit –m “message” | $ git push origin master $ git mv filename new_filename $ git mv filename new_dir_path
Find, commit, file history
Command to verify last commit
$ git log
Get GIT abbrev commit hash
$ git log --abbrev --log
GIT oneline commit
$ git log --oneline --graph --decorate
Logs that have been executed the last day or the last 5 days
$ git log --since=“5 days ago” $ git show commit_id $ git help log
GIT Alias
GIT alias is a short way to display a results from a long command. In order to add an alias we need to add the alias at GIT global config.
$ git config --global “long_command”
Example:
$ git config global alias.history “log --all --graph --decorate --oneline”
or:
$ nano ~/gitconfig
Exclude unwanted files in GIT
$ nano .gitignore
GIT ignore pattern example:
# exclude everything except directory /* !/dir /dir/* !/dir/bar
Comparison in Git
Working directory and staging directory
$ git diff $ git diff filename
Compare working directory and repository
$ git diff HEAD (compare working directory with the last commit) $ git diff HEAD filename
Staging area and repository
$ git diff --staged HEAD $ git diff --staged HEAD filename
Compare commits in GIT
$ git diff commit_it commit_it $ git diff HEAD HEAD^ (compare the last commit and the commit previews last head -1)
Branching and merging
Verify branch
$ git branch -a
Switch GIT branches
$ git checkout
Rename branch
$ git branch -m
Delete branch
$ git branch -d (before deleting a branch, switch to another)
Merge one branch to another
$ git merge
Example (first move to master):
$ git merge development
GIT Merge VS GIT Rebase
GIT Merge
GIT merge to create a new “merge commit” in the development branch that ties together the histories of both branches, giving you a branch structure that looks like a graph.
Impact: in this case, the development branch will have an extraneous merge commit every time you need to incorporate upstream changes. If the master is very active this can pollute your development branch history.
GIT Rebase
As an alternative to merging, you can rebase the development branch into the master branch
$ git checkout development_branch $ git rebase master
This moves the entire development branch to begin at the top of the master branch, effectively incorporating all of the new commits in the master. Instead of using merge commit, re-base re-write the project history by creating brand new commits for each commit in the original branch.
Benefits: You get much cleaner project history. It also results in a perfectly linear project history.
GIT Stashing
What is GIT Stash?
When you create a stash, you are saving uncommitted changes so that you can work on other things without losing your changes.
Example: You are working on a function, but your boss wants you to do something immediately and you need to change branches. Your code is not ready for commitment and you do not want to lose your work as well… so you stash J.
$ git stash save “message of what you were doing” $ git stash list (list the changes made on stash with their id)
In order to work again on the stashed file:
$ git stash apply stash_id (example: stash@{1})
Stashing: apply vs pop
When you’re ready to finalize these saved changes, you have two options: apply or pop.
Apply will take the stashed changes, apply them to your working directory, and keep the changes saved as a stash.
$ git stash apply stash@{0}
Pop will do the exact same thing for the first two steps, but it will permanently delete the stash.
$ git stash pop (will drag the very first stash on the stash list)
Source: https://dzone.com/articles/learning-git-what-is-stashing
Stashing: drop & clear
Discard the stashed changes:
$ git stash drop stash@{0}
Discard all stashed changes:
$ git stash clear
… [Trackback]
[…] Find More Info here to that Topic: blog.neterra.cloud/en/git-github/ […]