Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency.
git offers:
- Performance
- Security
- Flexibility
- The basic performance characteristics of Git are very strong in comparison with many alternatives. The algoritms implemented inside git take advantage of deep konwlegde about common attributes of real source code file trees.
- Git is not fooled by the names of the files when determining what the storage and version history of the file tree should be, instead Git focuses on the file content itself. The object format of Git's repository files uses a combination of delta encoding (storing content differences), compression and explicitly stores directory contents and version metadata objects.
- Being distributed enables significant performance benefits as well.
- Git has been designed with the integrity of managed source code as a top priority.
- All object in the git repository are secured with a crytographically secure hasing algorithm (SHA1)
- You can sure you have an authetic content history of your source code
- Git is flexible in several respects: in support for various kinds of nonlinear development workflows, in its efficiency in both small and large projects and in its compatibility with many existing systems and protocols.
- Was created by Linux Torvalds
- Git is different to github
- Keep track of changes
- Coordinate the work of several people or work teams
- Working directory: It is a copy of a version of the project. These files are taken from the compressed database in the .git directory and placed on disk so that you can use or modify them.
- Stanging area: It is the place where the changes are temporarily saved, to later be permanently saved in the repository, sometimes it is called "Index"
- .git (local repository) : is where the change history of our files is stored, metadata and the object database are stored, it is the most important part of git
- gitk - tool for show git graphically
- Git is a VCS
- Save only the changes made in any file or project making clear
- where did they?
- where did they run?
- who did it?
- We can travel back in time to review changes made in the past to the git repository
- List all configurations
git config --list or git config -l
- Configure name that come out in commits.
git config --global user.name "Alejo"
- Configure email
git config --global user.email [email protected]
- Color frame for commands.
git config --global color.ui true
- In order to disable SSL certificates and download the project locally.
git config --global http.sslVerify false
- To allow downloading with proxy problems.
git config --global --unset http.proxy
- To change the editor when you need to enter information.
git config --global core.editor "code --wait"
- To remove configured parameters.
git --global --unset-all core.editor
- To remove an specific parameter.
git --global --unset-all user.name "Name user"
- Change a global configuration.
git config --global --replace user.name "Modified name"
Provides a description about the command to use
git help config <command>
We start GIT in the folder where the project is:
git init <repository-name>
This command create a hidden folder called .git (local repository) where the project's atomic change log will be saved and create a space in RAM called stanging area
These commands are to observe how the files and commits are behaving in our work environment
git status It allows me to know the status of files and folders
git status
States for files
- Untracket: The file does not live in git, only on the disk (it is only in the working directory)
- Unstaged: These are files that git has records of its changes but they are out of date.
- Staged: Files that have been sent staged with git add
- Tracket: The files live inside the repository are updated and have no pending changes
- Modified: means that you have modified the file but have not yet confirmed them to your database
- Committed: files that are safely stored in your database
git show shows all the changes we have made, this includes the lines we have changed, when and who made those changes
git show
git log It allows us to see the complete history of a file
See all files
git log
See an specify file
git log <file-name>
Allows you to see the commits and mergers graphically
git log --all --online --decorate
git log --all --oneline --graph
Save log into a file
git log > log-name.txt
Look for the commits that fulfill as is what is written in quotes
git log --grep "Example"
Look for commits that comply regardless of upper or lower case
git log --grep "Example" -i
look for commits by an specific author.
git log --author "name_author"
add
Send your file to stanging area where it is temporarily saved before being sent to the repository, move a file from untracked or unstaged to staged
git add <file>
Add all the files for the commit (. refers to the folder where is located ./).
git add .
git add -A
- add all files with the specified extension for example (.txt).
git add *.txt
- add all the files inside a directory and with a specific extension.
git add src/*.txt
- add all the files inside a directory.
git add src/
commit
send the file to the repository committing the changes made and leaving a user message when adding -m (move the files from working directory to local repository)
git commit -m "Message for commit"
This commando combenes add and commit (It will only work if the files have already been previously applied a git add): git add + git commit
git commit -am "Message"
- Add to the last commit, this is not shown as a new commit in the logs. A new message can be specified.
git commit --amend -m "Text that identifies why the commit was made"
It allows us to see the difference between one version and another specifically, to obtain the IDs (SHA1) of your commits you use the git log command, git will give you the response with the changes made between the two commits (recommended to put the oldest commit at the beginning, since git takes the former as the older of the two)
Compare working directory with stanging area
git diff
git diff commit1 commit2
git diff <tag1> <tag2>
When you create your repository in your working folder, a main branch called master is created by default (this name can be modified)
it can be seen as the linear map of the commits you have made to the file
Branches are the way to make changes in our project without affecting the workflow of the main branch, this is because we want to work in a very specific part of the application or because we simply want to experiment
The HEAD header represents the branch and the commit of that branch where we are working, by default this header will appear in the last commit of our main branch,
branch
Create a branch
git branch <name-branch>
List all branches
git branch -l
Another way for list all branches
git show-branch --all
List branches and show the last commit
git branch -v
Rename branch
git branch -m <old-name-branch> <new-name-branch>
Delete a branch
git branch -d <branch-name>
Delete without asking.
git branch -D <name-branch>
Move all existing changes in your master branch to the new main branch
git branch -M <main>
allows you to see remote branches on your server
git branch -r
shows you local and remote branches
git branch - a
You use checkout to create a new branch from the commit you want of your master branch, this branch serves you to make experiments, changes or repair errors in your main code without affecting it
Change the branche.
git checkout <name-branch>
git checkout <branch> <file>
creates a branch and positions itself on it
git checkout -b <branch-name>
Create a branch based on one online.
git checkout -b <new-local-branch-name> origin/branch-name
Allows you to go back to any previous version without deleting the file's history
git checkout <commit-id>
Removes a file from HEAD and sets it to not working.
git checkout -- <file>
To join the changes between branches, merge is used, in this way the two branches will be joined to form a single
- Join the branch
git merge <name-banch>
it should be noted that there may be conflicts between the branches
If you "want to go back in time" and go back to a previous version of your file you can use git reset
git reset Allows you to go back in time without being able to go back to the future
Ways to use git reset:
- delete all the registration information that we have even what is in stanging area
reset hard
- delete all the registration information that we have even what is in stanging area
git reset --hard
- starting from commit-id, remove all future commits to it and does not and keep changes in stanging are or in working directory
git reset <commit-id> --mixed
reset soft
- delete the changes you have made to your file but what is in stanging remains there, give you the possibility to apply the changes later.
git reset --soft
- starting from commit-idX, remove all future commits to it and keep all those changes in the stanging area
git reset <commit-id> --soft
reset mixed
- match the local repository to the working directory
git reset --mixed
- starting from commit-id, remove all future commits to it and keep all those changes in the working directory
git reset <commit-id> --mixed
reset HEAD
- move the changes from stanging area to unstaged, the last changes are kept, the repository still has the file with the changes made in the commit
git reset --HEAD
To recover the SHA1 lost by a reset.
git reflog
Remove a file from the repository.
git rm <file>
Return form the stangin area to working directory (delete file from stanging)
git rm --cached <file>
It allows removing a commit from one branch and putting it in another, this can happen when changes are added to a branch that were not due, but to avoid losing those changes, use that command.
git cherry-pick <SHA1>
-
git rm
just delete files (either from stanging or from the workind directory -
git reset
send you to old versions and delete files, history and records
We obtain a copy of the master or main branch from the remote repository to the working directory and create the database of all the historical files in the local repository, leaving it stanging clean and ready to be used
It allows us to send the changes to the remote server or repository
Upload to repository.
git push origin <branch-name>
Upload a tag.
git push --tags
Upload the tags from master to origin.
git push origin master --tags
Send from a local branch to a remote branch.
git push origin <branch-local>:<branch-remote>
Remove remote branch
git push origin -- delete <name-branch>
It is used to bring updates from the remote server and save them in our local repository (in case there are, of course)
git fetch
It is used to combine the latest changes from the remote server and our working directory, it is used in conjunction with the git fetch command
The git merge command allows us to create a new commit with the combination of two branches (the branch where we are when we execute the command and the branch that we indicate after the command).
Create a new commit in the master branch by combining the branch-name changes:
git checkout master
git merge <branch-name>
if we have made a merge with a branch with which we did not want
git reset --merge HEAD
Join git fetch and git merge, basically used to fetch updates from the remote server by saving them to our local repository, and merge the latest changes from the remote server into our working directory
Check for new changes and update the repository.
git pull origin <nameBranch>
this way we can have an updated copy of our project stored on the remote server
if we want to connect the github repository with our local repository we must execute the following:
- Add remote repository.
git remote add origin <url-github>
- List the repositories.
git remote -v
- Change the remote.
git remote set-url origin <url>
- Delete repository.
git remote rm <name/origin>
- Show all remote branches.
git remote show origin
- Clean up all removed branches.
git remote prune origin
The tags allow us to assign versions to the commits with the most important or significant changes in our project.
Show a list of all tags.
git tag
Create a new tag.
git tag -a <version-or-name> - m "This is the version X"
create a new tag and assign it to a commit:
git tag -a <name-tag> <id-commit>
delete a tag in the local repository:
git tag -d <name-tag>
list the tags of our local repository:
git tag
list the tags of our local repository with the HASH:
git show-ref --tags
post a tag to the remote repository
git push origin --tags
delete a tag from the remote repository:
git tag -d <name-tag> and
git push origin :refs/tags/name-tag
Download remote form a fork
git remote add upstream <url>
Merge with master from a fork we can use
git pull upstream <branch>
When we need to go back in time because we delete a line of code but we don't want to go to another branch because it would give us an error since we have to pass that "bad change" that we made in a scenario, we can use git stash to return the previous change we made.
git stash is typical when we are changes that do not deserve a branch or do not deserve a rebase if we are not simply testing something and then you want to quickly revert to your previous version which is correct.
The git stash command saves the current staging job to a list designed to be temporary called Stash, so that it can be retrieved in the future.
git stash
list stash
git stash list
remove all items from stash:
git stash clear
We can put a message in the stash, in order to differentiate them in git stash list in case we have several elements in the stash. This with:
git stash save "message"
To retrieve the last changes from the stash to your staging area use the command:
git stash pop
To apply changes to a specific stash and remove it from the stash:
git stash pop stash@{<num_stash>}
To resume the changes of a specific position of the Stash you can use the command:
git stash apply stash@{<num_stash>}
Where the <num_stash> you get it from the git stash list
Sometimes we create files when we are doing our project that are not really part of our working directory, that should not be added and we know it.
To know which files we are going to delete we type
git clean --dry-run
To delete all the listed files (which are not folders) we type
git clean -f
The rebases are used when we work with branches this makes the branches catch up with the master without affecting it.
This command allows you to take one or more commits from another branch without having to do a complete merge. Thus, thanks to cherry-pick, we could apply the commits related to our functionality in our master branch without having to do a merge.
Join the current branch with the master, this cannot be seen as a merge.
git rebase
When a conflict occurs you don't give the following options:
When we resolve conflicts --continue continue the rebase sequence where it paused.
git rebase --continue
Skip the conflict and go your way.
git rebase --skip
Returns everything at the beginning of the rebase.
git reabse --abort
To rebase a specific branch.
git rebase <nameBranch>
Sometimes we do a commit, but it turns out that we didn't want to send it because something else was missing. We use git commit --amend, and what it will do is that the changes we made will be added to the previous commit.
git commit --ammend
used to see the commits made by different people in order with all the data if we add "-c" it looks a little better
git blame "filename"
it shows me the name of the people collaborating and the commits made by each one of them
git shortlog
shows me the names and the amount in numbers of the commits they made
git shortlog -sn
shows even deleted commits
git shortlog -sn --all
same as above but skips counting merges
git shortlog -sn -all --no-merges