Master the Essentials of Git and GitHub in Just Minutes
What is Version Control?
Version Control, also known as source control, is the practice of tracking and managing changes to files. Version control systems are systems that record changes to a file over time so that you can record versions of it later. Some of the popular version control systems is Git which is a popular control system/software.
Now, let’s move to git…
What is git?
Git is a version-control system that is used to track changes in computer files. Git is used for tracking code changes, Tracking who made changes, and Coding Collaborations. To get started with git, you need to first go to the and download and install the software.
Okay, now let’s move to GitHub
What is GitHub?
GitHub is a code hosting platform for version control and collaboration. It lets you and others work together on projects from anywhere. For you to use GitHub, you need to go to and sign up for an account
Getting interesting right? Now, let’s move to the main business of the day
Git Work Flow
4 fundamentals of git workflow
- Working Directory
- Staging Area
- Local Repository
- Remote Repository
Now, there are three states in the file in your working directory:
It can be staged: This simply means that any updates made on your files can be staged and ready to be committed.
It can be modified: Here, we are simply saying that those changes made on the files have not yet being stored on the local repository( repo in short form).
It can be committed: Those changes you made to your files can be stored in the local repository.
I hope it is getting more interesting. Don’t worry, there is still time remaining. Let’s keep learning!
Now let’s learn the basic git commands
$ git init
This will make git to be aware of the folder.
$ git status
This will show the status of the files that are to be staged or modified.
$ git add
This will add a file that is in the working directory to the staging area.
$ git commit
What this does is to keep track of our code base. It is basically used to add all files that are staged to the local repository.
$ git push
This is used to push our code from our local machine to GitHub. Here, all the committed files in the local repository are moved to the remote repository.
$ git fetch
This is used to get files from the remote repository to the local repository.
$ git merge
This is used to get files from the local repository into the working directory.
$ git pull
This is used to get files from the remote repository into the working directory. It does the joint work of git fetch and git merge. So instead of doing git fetch and git merge, you can simply just do a git pull.
Now, let’s not make this too boring. Let’s create your first repo together with just these few steps
Step 1: Create a git hub account
Simply click on this link and create one. If you already have one, move to step two genie.
Step 2: Check if git is installed on your computer
To do this, type the following commands:
$ git -- version
If you have git already, it will show you the version you have installed.
Step 3: Set up your identity
Set your username and email address. This information is very important because whenever you make a Commit, git uses your identity (username and password) and it's immutably baked into the commits you start creating. To achieve this, you type the following commands.
$ git config –global user.name “Rose Abuba” $ git config –global user. Email “roseabuba@outlook.com $ git config --global –list # to check the data provided
Step 4: Create a repo
Create a new repository on GitHub. Move to your GitHub account and create a new repo by clicking on the new button and selecting Create Repository (you can name your repo anything you wish). After doing this, you will see a list of options for pushing a new repository or an already existing repository.
Step 5: Create a folder and file
Now, create a file and open it with any code editor of your choice. Then open your terminal. To create a file on your terminal, type the commands below.
$ touch Index.html
Step 6: Initialize git
You do this by typing the commands below
$ git init
Step 7: Staging of files for Commit
Type the following commands:
$ git add .
This adds all the files in the local repository and stages them for commit
$ git add Index.html
To add a specific file Before we commit our files, let’s check the status of our files
$ git status
Step 7: Commit changes to your git Repository
$ git commit -m "First Commit"
Add a remote origin and Push
To update the changes you have made to the main branch because it won’t be automatically updated on Git hub. All those changes are in the local Repository.
$ git remote add origin remote_repository_URL
To list connections with other repositories, type the following commands:
$ git remote -v
This will list the URLS of the remote connections you have with other repositories
Step 9: Push Changes made from your local repository to the remote repository.
Type the following command:
$ git push -u origin main #pushes changes to origin
The next thing is to refresh. If you followed the above steps, you will see that your codes have been successfully pushed to GitHub.
HI Genie! If you followed up this far, You are one step to Collaboration! People can now view your code online. All you need to do is to share your repo link and you are good to go!
Note that each time you make changes on your local repository and you want it to reflect on your Github, These following commands are the most common command flow used.
$ git add . $ git status $ git commit -m "Second Commit" $ git push -u origin main
In case you want to work with other people’s repositories on Github, you can clone their repos. To do this, type the following commands.
$ git clone remote_repository_URL
Now let’s move to collaboration
When you work with a team, That is, for example, a group of developers working on a project. Each time you make a change and push it into the main repo, your colleagues have to pull those changes that you pushed into the git repo. Simply put it this way. To keep up with updates and the latest changes on the git repo, all you need is a git pull command. To achieve this, type the following commands.
$ git pull origin main
OR
$ git fetch AND $ git merge
git pull is equilavent to git fetch and git merge
Lastly, let me teach you the basic things you need to know about Branches
$ git branch develop
This creates a new branch called the develop
$ git branch
This shows a list of branches already created
$ git checkout develop
This automatically moves to the branch develop
These are just the basic things you need to know about Git and GitHub. Stay tuned for more articles on how to use git and GitHub.
Additional resources
…And always remember, in case of fire, Do these 3 things;
Git commit
Git Push
Leave Building
Okay, Byeeeee………
The above is the detailed content of Master the Essentials of Git and GitHub in Just Minutes. For more information, please follow other related articles on the PHP Chinese website!

Hot AI Tools

Undress AI Tool
Undress images for free

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

There are three common ways to initiate HTTP requests in Node.js: use built-in modules, axios, and node-fetch. 1. Use the built-in http/https module without dependencies, which is suitable for basic scenarios, but requires manual processing of data stitching and error monitoring, such as using https.get() to obtain data or send POST requests through .write(); 2.axios is a third-party library based on Promise. It has concise syntax and powerful functions, supports async/await, automatic JSON conversion, interceptor, etc. It is recommended to simplify asynchronous request operations; 3.node-fetch provides a style similar to browser fetch, based on Promise and simple syntax

JavaScript data types are divided into primitive types and reference types. Primitive types include string, number, boolean, null, undefined, and symbol. The values are immutable and copies are copied when assigning values, so they do not affect each other; reference types such as objects, arrays and functions store memory addresses, and variables pointing to the same object will affect each other. Typeof and instanceof can be used to determine types, but pay attention to the historical issues of typeofnull. Understanding these two types of differences can help write more stable and reliable code.

In JavaScript arrays, in addition to map and filter, there are other powerful and infrequently used methods. 1. Reduce can not only sum, but also count, group, flatten arrays, and build new structures; 2. Find and findIndex are used to find individual elements or indexes; 3.some and everything are used to determine whether conditions exist or all meet; 4.sort can be sorted but will change the original array; 5. Pay attention to copying the array when using it to avoid side effects. These methods make the code more concise and efficient.

Functional programming (FP) is suitable for data immutable scenarios, emphasizing pure functions and no side effects, and is suitable for processing data transformations such as array mapping or filtering; Object-oriented programming (OOP) is suitable for modeling real-world entities, encapsulating data and behaviors through classes and objects, and is suitable for managing objects with state such as bank accounts; JavaScript supports the use of the two, and selecting appropriate paradigms according to needs to improve code quality. 1.FP is suitable for scenarios where data transformation and state remains unchanged, making it easy to test and debug. 2.OOP is suitable for modeling entities with identity and internal state, providing a good organizational structure. 3. JavaScript allows the mixing of FP and OOP, using their respective advantages to improve maintainability.

Themaindifferencebetween==and===inJavaScriptistypecoercionhandling.1.==performstypecoercion,convertingdatatypestomatchbeforecomparison,whichcanleadtounexpectedresultslike"5"==5returningtrueor[]==![]returningtrue.2.===comparesbothvalueandtyp

The filter() method in JavaScript is used to create a new array containing all the passing test elements. 1.filter() does not modify the original array, but returns a new array that meets the conditional elements; 2. The basic syntax is array.filter((element)=>{returncondition;}); 3. The object array can be filtered by attribute value, such as filtering users older than 30; 4. Support multi-condition filtering, such as meeting the age and name length conditions at the same time; 5. Can handle dynamic conditions and pass filter parameters into functions to achieve flexible filtering; 6. When using it, be careful to return boolean values to avoid returning empty arrays, and combine other methods to achieve complex logic such as string matching.

In JavaScript, check whether an array contains a certain value. The most common method is include(), which returns a boolean value and the syntax is array.includes(valueToFind), for example fruits.includes('banana') returns true; if it needs to be compatible with the old environment, use indexOf(), such as numbers.indexOf(20)!==-1 returns true; for objects or complex data, some() method should be used for in-depth comparison, such as users.some(user=>user.id===1) returns true.

Callback hell refers to nested callbacks that make the code difficult to maintain. The solution is to use Promise or async/await. 1. Promise replaces nested structures through chain calls, making the logic clear and error handling unified; 2. async/await is based on Promise, writing asynchronous code in a synchronous way to improve readability and debugging experience; 3. In actual applications, you need to pay attention to the single function responsibilities, use Promise.all in parallel tasks, correctly handle errors and avoid abuse of async/await.
