DEV Community: Elaine Iheanacho

(Outdated) Complete Git Cheat sheet

Elaine Iheanacho — Wed, 25 Sep 2024 08:20:06 +0000

Navigating the complexities of version control can be a daunting task, so understanding Git is essential for efficient and collaborative software development. Git enables you to effectively manage code and collaborate seamlessly with other developers as well as many other functions.
This Git cheat sheet is designed to be your quick reference guide, offering a concise reference for the essential commands and concepts in Git.

This is not an introductory article. You must have at least a basic knowledge of Git and GitHub before proceeding to avoid confusion.

If you happen to not be in the above category, visit my previous article, introduction to Git and GItHub, and this YouTube playlist: Git and GitHub tutorial for beginners to get started.

Git commands

Here are the most frequently used Git commands:

●Set Username:
git config __global user.name <desired username>

●Set email:
git config __global user.email <desired email>

●Go back a directory:
cd ..

●List folder content:
Ls

OR
Dir

●Create a new directory:
mkdir <directory name>

●Create a new file inside a directory:
touch <file name>

●Open a file in text editor:
texteditorname <file name>

●Delete a file:
rm <file name>

●Delete a directory:
rmdir <directory name>

●Create a repository:
Step 1:
cd <folder's full path>

Step 2:
git init

●Stage a file:
git add <file name>

●Stage all files:
git add .

●Check changed files/ files in or out of staging area:
git status

●Remove a file from staging area:
git rm __cached <file name>

●Create a commit:
git commit -m "<descriptive commit message>"

●Check commit history:
git log

For a condensed version:
git log __oneline

●Check code of an earlier commit:
git checkout <commit's ID>

●Undo a commit:
git revert <commit's ID>

●Permanently go back to a commit:
git reset <commit's ID>

Note- the code remains in our text editor just in case, so to remove them:
git reset __hard

●Create a branch:
git branch <branch name>

●Go to a branch:
git checkout <branch name>

●Create and go the branch simultaneously:
git checkout -b

●Delete a branch:
git branch -D

for merged branches:
git branch -d

●Merge a branch:
git merge <branch name>

●Remove merged branch conflict:
:wq

●Push Git files to Github:
git push <github repository URL/ github repository URL alias> <branch name>

●Give a Github repository an alias:
git remote add <alias> <github repository URL>

●Clone a Github repository into your computer:
Step 1:
cd ..

Step 2:
git clone <github repository URL>

●Check your github repository URL:
git remote -v

●Make local repository up to date with remote repository:
git pull <github repository URL/ alias> <branch name>

(Outdated) INTRODUCTION TO GIT AND GITHUB

Elaine Iheanacho — Sat, 16 Sep 2023 20:00:05 +0000

Outlines:
●What is git?
●Advantages of using git.
●What is github?
●Advantages of using github
●How does git even work?

Often, in programming, regrettable changes are made to our files. There is hesitation to experiment more with projects for fear that it might ruin what was originally planned. Reversing those changes back to the previous state might be too annoying and or time-consuming. Collaboration with other developers is stressful because file sharing can be bothersome, but not to worry, Git can fix all of that.

What exactly is Git?
According to Wikipedia, Git is a distributed version control system that tracks changes in any set of computer files, usually used for coordinating work among programmers who are collaboratively developing source code during software development.
https://en.wikipedia.org/wiki/Git#:~:text=Git%20(/%C9%A1%C9%AAt/,source%20code%20during%20software%20development.

In simpler terms, Git is a system that tracks changes to your files, allowing you to access any version of these files whenever you need. It also provides an environment that facilitates seamless collaboration with other developers on your project.
What are the advantages of using Git?
You might be thinking, "I go through my projects just fine with little to no issues, is there really a point to having Git?". There are numerous benefits you might not be aware of, a few of them are as follows:

●Low storage: It helps store all the changes made to your file in one directory(folder), enabling you to save space on your computer.
●Easy code management: Git provides a simple and effective way to manage code as it tracks all changes made to files making it easy to access any version of said file at any time.
●Encourages experimentation: By leveraging Git, you can access any file and it's previous versions, and experiment with your code without the fear of losing the information or data.
●Facilitates collaborative development: Git allows multiple developers to work on the same project with little to no issues.
●Open source: It is freely available for anyone to use as it is an open-source project.

What is Github?
According to Wikipedia, it is a platform and cloud-based service for software development and version control using Git, allowing developers to store and manage their code.
https://en.wikipedia.org/wiki/GitHub#:~:text=February%202023,store%20and%20manage%20their%20code.

In other words, github is an online platform that hosts and manages our work already saved to git.

What are the advantages of using Github?
Already having Git does not negate the need for Github, a few reasons being:
●Collaboration: It makes collaboration easier as developers are able to work on the same code at the same time.
●Easy sharing of code: Github facilitates easy sharing of code with other developers as it can host projects with the user's permission to be used by the public.
●Security: Github ensures the user's code is protected from unauthorized access with its various security features.
●Resolves issues: Github has a built-in feature that automatically tracks and resolves conflict in the code.

How does Git work?
The feature of Git used mainly by developers is the recording and storing of the changes made to their files, which sounds incredibly convenient, but how exactly does this happen? It is done by committing repositories.

A repository is the folder containing the files to be tracked by Git. It is important to note that having various repositories saved to git won't merge or disturb your projects, regardless of how many repositories you have, they will all be tracked individually.
Where the Git file resides significantly affects which files would be tracked.

In the above image, the git file is added to the main folder(project folder), so because of this, Git tracks all the items in the main folder, including the subfolder (IMG) and all the files in it.

In the above image, the git file is added to the sub folder in the project folder(Javascript), so Git only tracks the files in the subfolder. The other files, as you can see, remain untouched by Git.

A commit is a stage in your code saved to the repository that enables you to go to the saved stage whenever you please. You can think of commits as safe points in your project.

In the above image, you can think of the boxes as commits and the line passing through them as code. The four boxes are all safe points you can jump back to whenever. If you feel like you don't want your footer anymore(Added footer), you can take a step back to the safe point before then(Change all fonts), and if you end up changing your mind about the footer again, no worries! Just jump back to the 'Added footer' commit, and you can have your footer back.
There are three stages of committing: modified, staged, and committed.

Modified: This is when you've changed or added to your code since the last safe point.
Staged: By adding a file to the staging area, you choose or acknowledge a potential safe point to which you wish to be committed. Staged files are not the same as committed files; they are only files you're considering committing.
Committed: By committing a staged file, you are officially crowning your current code as a safe point you can return to at any point you please.