More about Git & GitHub

Git is used for tracking changes in source code during software development.

Basic Flow

The basic workflow for using Git includes staging, committing and pushing changes.
Before a change can be committed it must be staged and to apply changes for everyone else, the changes must be pushed to the remote repository.

Basic Commands

Some commands that are likely to be used very often. 

Cloning a Repository (git clone)

To download a remote repository you can use the git clone command and provide the URL of the remote repository. The clone command is very useful because it configures the local repository.

# git clone [REPOSITORY_URL]
git clone https://github.com/apartha77/PSD-AWS-CNF.git

Staging a Change (git add)

Staging is the step that you must take before commiting a change. This enables to choose what changes are actually going to get committed. There is a few ways you stage files:

# stage all files
git add --all

# stage all files (only if you are at the root of your project)
git add .

# stage selected files: git add [FILES]
git add test1.txt test2.txt
git add *.txt

Username and Email in Git Config (git config)

Before you can commit changes to the repository you need to have your username and email configured. This can either be set in the scope of the repository you downloaded or set globally, to avoid repeating everytime you commit. 

Setting Config Globally

# git config --global user.name "[USERNAME]"
git config --global user.name "apartha77"
# git config --global user.email "[EMAIL]"
git config --global user.email "apartha77@email.com"

Setting Config Locally

# git config user.name "[USERNAME]"
git config user.name "apartha77"
# git config user.email "[EMAIL]"
git config user.email "apartha77@email.com"

Local Repository Status (git status)

This provides information about the current state of your local repository. It is very useful, how can you know what files have been staged and not staged?

git status

Commiting a Change (git commit)

When you make a commit to a Git repository, you are effectively “saving” the changes that you have staged to the repository. Commit with a message, which helps to identify the changes. 

# git commit -m "[COMMIT_MESSAGE]"
git commit -m "my initial commit"

Pushing Changes (git push)

To apply the changes made in a remote repository have to push them to that remote repository.
Only changes that have been committed will be pushed to the remote repository. We can use git push and provide the remote repository (default is origin) and remote branch to push our changes.

# git push -u [REMOTE] [REMOTE_BRANCH]
git push -u origin main

Retrieving Remote Changes

Because Git is a collaborative tool, other people could have made changes to code in the remote repository, these changes will need to be pulled down to avoid conflicts in the code.

# git pull [REMOTE] [REMOTE_BRANCH]
git pull origin main

Ignoring Files

Git segregates all files in your local repository into "tracked" (files which have been staged or committed), "untracked" (files which have not been staged) or "ignored" (files which will be ignored).
In order to make sure that Git does not track files which we don't wan to push, we need to create a .gitignore file in our repository. This file is a list of intentionally untracked files that Git should ignore.
We can use an asterisk "*" to specify which type of files should be ignored (an asterisk matches anything except a slash). If we use ".txt", Git will ignore all files that end in ".txt". A leading "*/" means match in all directories.
For example, if we use "**/test", Git will ignore a file or directory "venv" anywhere in our repository. If you have queries, do drop in your queries below.

**/test
*.txt

.settings/
target/
bin/
Other common commands are:

These are common Git commands used in various situations:

start a working area (see also: git help tutorial)
   clone             Clone a repository into a new directory
   init              Create an empty Git repository or reinitialize an existing one

work on the current change (see also: git help everyday)
   add               Add file contents to the index
   mv                Move or rename a file, a directory, or a symlink
   restore           Restore working tree files
   rm                Remove files from the working tree and from the index
   sparse-checkout   Initialize and modify the sparse-checkout

examine the history and state (see also: git help revisions)
   bisect            Use binary search to find the commit that introduced a bug
   diff              Show changes between commits, commit and working tree, etc
   grep              Print lines matching a pattern
   log               Show commit logs
   show              Show various types of objects
   status            Show the working tree status

grow, mark and tweak your common history
   branch            List, create, or delete branches
   commit            Record changes to the repository
   merge             Join two or more development histories together
   rebase            Reapply commits on top of another base tip
   reset             Reset current HEAD to the specified state
   switch            Switch branches
   tag               Create, list, delete or verify a tag object signed with GPG

collaborate (see also: git help workflows)
   fetch             Download objects and refs from another repository
   pull              Fetch from and integrate with another repository or a local branch
   push              Update remote refs along with associated objects


If you have queries, do drop in your queries below.

...HaPpY CoDiNg
Partha