git merge --abort

git remote show origin

git config --global credential.helper cache

> git add
Moves changes from the working directory to the staging area.
This gives you the opportunity to prepare a snapshot before committing it to the official history.
> git branch
This command is your general-purpose branch administration tool.
It lets you create isolated development environments within a single repository.
> git checkout
In addition to checking out old commits and old file revisions, git checkout is also the means to navigate existing branches.
Combined with the basic Git commands, it’s a way to work on a particular line of development.
> git clean
Removes untracked files from the working directory.
This is the logical counterpart to git reset, which (typically) only operates on tracked files.
> git clone
Creates a copy of an existing Git repository.
Cloning is the most common way for developers to obtain a working copy of a central repository.
> git commit
Takes the staged snapshot and commits it to the project history.
Combined with git add, this defines the basic workflow for all Git users.
> git commit --amend
Passing the --amend flag to git commit lets you amend the most recent commit.
This is very useful when you forget to stage a file or omit important information from the commit message.
> git config
A convenient way to set configuration options for your Git installation.
You’ll typically only need to use this immediately after installing Git on a new development machine.
> git fetch
Fetching downloads a branch from another repository, along with all of its associated commits and files.
But, it does not try to integrate anything into your local repository.
This gives you a chance to inspect changes before merging them with your project.
> git init
Initializes a new Git repository.
If you want to place a project under revision control, this is the first command you need to learn.
> git log
Lets you explore the previous revisions of a project.
It provides several formatting options for displaying committed snapshots.
> git merge
A powerful way to integrate changes from divergent branches.
After forking the project history with git branch, git merge lets you put it back together again.
> git pull
Pulling is the automated version of git fetch.
It downloads a branch from a remote repository, then immediately merges it into the current branch.
This is the Git equivalent of svn update.
> git push
Pushing is the opposite of fetching (with a few caveats).
It lets you move a local branch to another repository, which serves as a convenient way to publish contributions.
This is like svn commit, but it sends a series of commits instead of a single changeset.
> git rebase
Rebasing lets you move branches around, which helps you avoid unnecessary merge commits.
The resulting linear history is often much easier to understand and explore.
> git rebase -i
The -i flag is used to begin an interactive rebasing session.
This provides all the benefits of a normal rebase, but gives you the opportunity to add, edit, or delete commits along the way.
> git reflog
Git keeps track of updates to the tip of branches using a mechanism called reflog.
This allows you to go back to changesets even though they are not referenced by any branch or tag.
> git remote
A convenient tool for administering remote connections.
Instead of passing the full URL to the fetch, pull, and push commands, it lets you use a more meaningful shortcut.
> git reset
Undoes changes to files in the working directory.
Resetting lets you clean up or completely remove changes that have not been pushed to a public repository.
> git revert
Undoes a committed snapshot.
When you discover a faulty commit, reverting is a safe and easy way to completely remove it from the code base.

git branch -r

git clone
git fetch
git pull
git commit
git push

git code . //Open vs code
git status //Show file status
git status -s //show short file status
git add <filename> //Add the particular file to staging area
git add . //Add all the file to the staging area
git commit --amend //Add these changes to the last commit (will have to use vim editor)
git commit -m "message" //Commit the files in the staging area
git commit -am "message" //Will commit without adding the file to the staging area
git checkout --<filename> //will restore the file from the last commit
git checkout -f //All the files will be replaced with last commit
git checkout -b <branch name> //Create a branch
git branch	//To see the branches
git branch -d <branch name>	//To delete a branch
git branch -v	//will show the branch and its last commit
git branch --merged	//will show the branches that are merged
git branch --no-merged	//will show the branches that are not merged
git merge <branch name>	//while in a branch you can merge another branch
git log //Show all the commits
git log -n //n can be replaced by any number "will show last n commits"
git log -p //Will show detailed discription of the commits
git log -p -n //use of n is similar as described above
git log --stat //will show short detailing of the commits
git log --stat -n //use of n is similar as described above
git log --since=n.days //commit of last n days/weeks/months "days can be replaced by weeks,months"
git rm --cached <filename> //will remove to file from the tracking area
git rm -rf //will uninitialized the current repository
git rm <filename> //will delete the file
git mv <Present filename> <The filename after the change> //to Rename the file
git clone <URL> //Cloning a repository in the current folder
git clone <URL> foldername //Cloning the repository in the given folder name (Folder will be created by itself)
git config --global alias. <new name> 'old command' //while create an alias command for the given command
git remote	//Show all the name of remote repository
git remote -v	//Show all the path (fetch/push) of the remote repository
git remote add <name> url	//Add a remote repository
git remote rm <name>	//To remove a remote
git push <remote name> <branch name>	//To push a branch to remote repository
git push <remote name> <branch name>:<branch name you want to have in the remote repository>
git reset HEAD	//To move to a previous commit
More commands can be found on this website
//website https://git-scm.com/docs/git-log

#git initialization ==>
git init // initialize the folder to git
#git stagging commands ==>
//stagges every thing
git add --all
//stagges every thing as well
git add -A
//stagges every thing as well
git add . **best practice**
// stagges only the directory file
git add to/the/directry.exemple
// stagges every thing with the extension .js
git add * .js
// show changes of files and files which are stagged
git status
// to rollback from the stagging
git reset
// to rollback from the stagging with deleted files
git reset --hard
#git commiting commands ==>
//to commit changes (comments are highly recommended)
git commit -m 'comment as you want'
// to rollback from commit
git reset HEAD~
//to get back to a commit
git checkout {hash-code}
(to check the hash code type git log --oneline)
Exp: git checkout 59f733b
// to get a single file
git checkout {hash-code} to/the/directry.extension
(to check the hash code type git log --oneline)
Exp: git checkout 59f733b script.js
#git branching ==>
// info of branches
git branch
//creat new branch
git branch {name}
Exp: git branch secondry
//to switch branc
git checkout {branch name}
Exp: git checkout secondry
//merge the branch where you are with other one
git merge {branch name} -m 'comment'
#git remote version controlling ==>
//to add origin to the git
git remote add origin {link}
//to clone a repository
git clone origin {branch name}
//push changes
git push origin {branch name}
//pull a branch
git pull origin {branch name}

echo "# New-Projects" >> README.md
git init
git add README.md
git commit -m "first commit"
git branch -M main
git remote add origin https://github.com/hussainbabar/New-Projects.git
git push -u origin main

git init
git add README.md
git commit -m "first commit"
git branch -M main
git remote add origin [email protected]:xyz/reponame.git
git push -u origin main