GIT is a distributed version control
system for tracking changes in source code during any development.
Here each developer has their code on their local system. Whenever
they want they can push the code into Github or Git Server
Initially files when created are in
workspace area. To add them to staging we use “ git add
-a or git add . Or git add
<filename> “
commands. When the files are in Staging or index area means that
they are ready to commit. Once the files are in Staging area, they
can be put into local repository using “git commit <file1> -m
“comment about the committee” . So the files are into
local repository.
Git repository is a folder or
directory which is initialized using "git init" command which
creates a '.git' sub-directory which has all the elements to track
the code changes.
Series of commits is called a branch.
A branch is a collection of directories and files. Default branch
is master. When we create a branch from master, all code will be
copied to the new branch and there we do required modifications
like feature1 and if everything is
fine, we can merge it back to master or continue as separate
branch.
GIT Workflow:
Typically git workflow starts adding a file to the working copy.
Then move it to staging index using git add <file.txt> and
then commit changes using git commit -m <about this commit>
Add/Edit a File (Working copy)
git add <file.name> (Staging Index)
commit -m (Repository)
Hash
Values#
How git refers to each commit or changes made to a repository or
sets of changes made to a repository. Change sets are snapshots
those are the changes made.
checksum algorithms convert data into a simple number
same data always equals same checksum
data integrity is fundamental
changing data would change checksum
Git uses SHA-1 hash algorithm to create checksums
its a 40 character hexa string which is a commit ID which we can
see in git log.
Each commit number is mapped to a snapshot as discussed above.
also each commit has parent, author and message details along.
The
HEAD pointer:
point to a commit. Point to tip of the current branch in
repository.
last state of repo, what was last checked out
points to parent of next commit
HEAD is like tape recorder head. Wherever head is recording starts
from there. As same in git, if we commit changes, HEAD is at
current repo and this HEAD is the parent for next commit. Means
changes will start from here till next commit. so head is always
point to recent commit.
there is a file in each repo in .git\HEAD. if we display the file,
it displays refs/heads/master. If we go to that path, and
display master, it gives the commit ID which is head.
Making
changes to files:
go to current working copy direcotry
git status
git status gives us the difference between working directory,
staging Index and repository.
If add new files and execute git status, it displays new files
which are added and asks to add them to staging o commit changes
to repository.
so git status is a very good command to know what are the changes
we made from last commit and what are at staging Index and what
are at working copy.
git
diff:
Gives the difference
git diff <file name> gives changes made to pirticualr file.
git diff --staged [ in earlier versions(>1.7), its git diff
--cached ]
git diff by default gives changes made to your working directory.
It doesnt list the changes from staging. To get the differences
made to staging, use the command git diff --staged.
git
rm <file
to be deleted> => git remove a file
======
If we delete a file from the working directory, we need to tell
git to delete it from repo also using git rm command. If we
directly use git rm to delete a file, it deletes permenantly
without moving it to trash. Instead of “git rm”, if we delete a
file using linux rm command, we can get that file back using “git
checkout <filename>”
Git rm is equal to rm <file> and commit -am <commit
message>.
Git rm will delete file from working directory, staging area and
local repo. So it can’t be restored or recovered.
Moving
and Renaming Files:
Renaming: there are two ways to do this. First is do it from
operating system and tell git to remove the old file. Second way
is directly from git using git mv original.file newnamed.file
If we use mv command to rename a file, it will delete the existing
file and creates a file with new name. So when we check the
status, it says the file is deleted from working directory and a
new file is added to working directory. So we need to add these to
staging and then we have to commit.
So to overcome the above complex issue, we can use git mv command.
It will directly renames the file and adds the file to the
staging. So only commit is enough in this case.
tracked
and untracked files:
Untracked files are just files created in working directory. when
you say "git status", these files are shown in RED Color means
they were not yet added to Staging.
Tracked files are the files added to Staging using "git add
<file(s)>
git commit --amend --reset-author is the command to fix the author
issues.
git push --set-upstream origin master
Working
with a Real Project:
git init in new directory where repo is initialized
git add .
git commit
git diff
git status
git log
git commit -am <Add to staging and commit using single
command>
Undoing
Changes:
git can undo changes made to our working directory or staging
directory.
git status
file has been modified
git diff = shows what has changed
git checkout index.html
git checkout <fileto be restored>
git checkout <branchname>
git checkout -- index.html => -- represents to stay on current
branch and restore file index.html.
how to undo changes to staging index.
===================================
undo staging..
git reset HEAD <filename> to unstage.
Undoing
commits to repository:
git commit ammed -m "revert last commit"
How
to undo changes from a previous commit:
Find the HASH from git log in which you made changes to that
pirticular file or branch and execute git checkout <commit
code/SHA> -- <file/branch name>
git checkout <
git revert <commit code/SHA>
Git
ignore:
If we are developing, there are some unwanted files generated. For
example, If we are developing a ‘C/C++” program, lot of obj files
will be generated. If we want omit them adding to index area or
local repository, we have two option. One is we can implement the
same at system level using “/etc/gitignore” file or at directory
level, you can create a file under directory like “.gitignore”.
Include the files which you want to ignore like
*.php
*.log
*.obj
*.exe
!index.php => as we gave *.php to ignore, but want to override
the file index.php with “!” Mark .
[abc].php
Now git add . And git commit -m “git ignore file added”
Delete
Git Log History:
It will be in 3 ways. They are soft, mix and Hard type of removal
** git reset —soft <SHA1 Commit code>. => files
will be removed from local repository
** git reset —mix <SHA1 Commit code> =>
files will be removed from staging area and local repository
** git reset —hard <SHA1 Commit code> => files will
be removed from working directory, staging area and local
repository.
So we must take care while working with git reset command, as it
will also remove the files related to the commits. So when we do a
reset, HEAD will point to the <SHA1 commit code>. Prior to
the SHA1 commit code will be deleted.
GIT PUSH ISSUES:
permission Denied to push:
1. change git remote using:
git remote add origin
git@github.com:vjrid8/atozit.in.git
2. If there are any previous wrong git remote URLs, remove them
using:
git remote rm
3. Now generate the key pair on your system using
ssh-keygen
-t rsa and this will create a key pair like id_rsa and
id_rsa.pub in your ~/.ssh folder. copy contents of id_rsa.pub and
paste them in the SSH and GPG keys section on your github account
by clicking new SSH key.
4. Now you will be able to push the code to github.com
"git remote -v " command displays remote URLS
GITIGNORE:
How to ignore files in the git working directory from git?
create a file in working directory with name ".gitignore" and add
the files to it.
.gitignore file will ignore blank lines in it and comments can be
added by prefixing # in the file
include files that you want to ignore line by line as below:
file1.txt
*.txt
!
project.txt => exception from *.txt to leave this
project.txt
folder/
