The almighty terminal
The terminal at first glance may seem intimidating since you aren't presented with a fancy GUI(Graphical user interface) but once you start to get the hang of things you'll be Changing Directories faster than you could even with a gui!
Being able to properly use the terminal is a necessity for every developer! Especially when working with Node and react! This article is going to be using Git BASH for windows - which functions exactly like LINUX, and UNIX environments!
LS stands for 'List information' and will be one of the most freqently commands you'll use:
Boahs@DESKTOP /c/Sample_Directory/BoahsInfo_Git_Tutorial $ ls example_directory/ example_file.txt
What you're seeing above is the LS command being executed to print out the current contents of the directory we're in. if we use the touch command we can create a file inside the directory, and it'll show up with the ls command:
Boahs@DESKTOP /c/Sample_Directory/BoahsInfo_Git_Tutorial $ touch make_text_file.txt Boahs@DESKTOP /c/Sample_Directory/BoahsInfo_Git_Tutorial $ ls example_directory/ example_file.txt make_text_file.txt
CD stands for 'change directory' and will be used to navigate through the directories on the machine you're using. We can change the directory using an absolute path like this:
Boahs@DESKTOP /c $ cd Sample_Directory/ Boahs@DESKTOP /c/Sample_Directory $ cd BoahsInfo_Git_Tutorial/example_directory/ Boahs@DESKTOP /c/Sample_Directory/BoahsInfo_Git_Tutorial/example_directory $ ls more_example_Files.txt
The inputs we sent our terminal above ended up changing out directory from the
C:\ drive to the
Sample_Directory/ directory then we went inside
BoahsInfo_Git_Tutorial/example_directory/ using an absolute path to navigate our way there.
We can also go back to the previous directory with the
cd .. command:
Boahs@DESKTOP /c/Sample_Directory/BoahsInfo_Git_Tutorial/example_directory $ cd .. Boahs@DESKTOP /c/Sample_Directory/BoahsInfo_Git_Tutorial $ cd .. Boahs@DESKTOP/c/Sample_Directory
You can see when we input
cd .. it brought up back one directory at a time until we were inside
/Sample_Directory This is called the parent directory.
We can also change our directory to the root directory as well with
cd /, and to another user's home directory with the
cd ~(username) command. An example would be
Nano is another really popular command you'll find yourself using often. It's included in many linux distributions by default, but some users may need to install it through which done on Debian/Ubuntu with
apt install nano and for CentOS/Fedora
yum install nano
Let's try using nano to open a document inside our folders.
Boahs@DESKTOP /c/Sample_Directory/BoahsInfo_Git_Tutorial $ ls example_directory/ example_file.txt make_text_file.txt Boahs@DESKTOP /c/Sample_Directory/BoahsInfo_Git_Tutorial $ nano make_text_file.txt
Now you're inside maketextfile.txt where you can start making changes. To exit you'll simple hit
CTRL + X but wait! We forgot to save with the
CTRL + S command. Okay, saved? Now we can exit :-). Don't worry we would've been prompted a warning we hadn't saved!
When we're editing files that we use to configure applications or important system files, we'll start nano with the
-w flag. This will prevent nano from wrapping the lines that are too long to fit on your screen.
Git Clone will be used to make a clone(copy) of a repo hosted on github to a local directory on the machine you're using. When ran like this
git clone https://github.com/boahs/dont_clone_this the repo will now be inside the directory you're currently inside:
Boahs@DESKTOP /c/Sample_Directory $ git clone https://github.com/boahs/EasyIMDb.git Cloning into 'EasyIMDb'... remote: Enumerating objects: 49, done. remote: Counting objects: 100% (49/49), done. remote: Compressing objects: 100% (38/38), done. remote: Total 49 (delta 22), reused 31 (delta 10), pack-reused 0 Unpacking objects: 100% (49/49), 808.68 KiB | 3.53 MiB/s, done.
Above we just cloned one of my repos to our machine. Let's access that repo now!
Boahs@DESKTOP /c/Sample_Directory $ ls BoahsInfo_Git_Tutorial/ EasyIMDb/ Boahs@DESKTOP /c/Sample_Directory $ cd EasyIMDb/ Boahs@DESKTOP /c/Sample_Directory/EasyIMDb (master) $ ls background.js icon.png manifest.json popup.js example.gif LICENSE popup.html README.md
Now that the repo has been successfully cloned we can see all the contents it that populated it.
When we're working with a repo that's enormous or continually maintained we can shallow clone the repo:
Boahs@DESKTOP /c/Sample_Directory/BoahsInfo_Git_Tutorial $ git clone --depth 1 https://github.com/boahs/CodeWarSolutions.git Cloning into 'CodeWarSolutions'... remote: Enumerating objects: 130, done. remote: Counting objects: 100% (130/130), done. remote: Compressing objects: 100% (119/119), done. remote: Total 130 (delta 0), reused 122 (delta 0), pack-reused 0 Receiving objects: 100% (130/130), 19.61 KiB | 912.00 KiB/s, done.
Whats happening is only the most recent history of commits are being cloned because we specified the
depth 1 option.
We can use the
-branch arguement to specify a branch to clone instead of the master branch.
git clone -branch staging_branch https://github.com/boahs/CodeWarSolutions.git
The example above would only clone the staging_branch branch from the repo. This can be useful in many scenarios but one benefit I'll name is that it would save you a lot of time from downloading the
HEAD ref of the repo.
So now we'll learn how to actually initialize a repo of our own from scratch. So we'll go inside our directory
/c/Sample_Directory and execute the following:
Boahs@DESKTOP /c/Sample_Directory $ git init Initialized empty Git repository in C:/Sample_Directory/
we've just successfully added our first local repo! Now we'll type
git add to add a test file. This is used to add new code to your repo:
Boahs@DESKTOP /c/Sample_Directory (master) $ git add test.txt warning: LF will be replaced by CRLF in test.txt. The file will have its original line endings in your working directory
Above we can see we added test.txt to our repo successfully. Lets commit it now with
Boahs@DESKTOP /c/Sample_Directory (master) $ git commit -m "Our first commit! We can add a message here to explain what changes we made to the repo, or added." [master (root-commit) b2d2d66] Our first commit! We can add a message here to explain what changes we made to the repo, or added. 1 file changed, 1 insertion(+) create mode 100644 test.txt
note: in this example we're still in the master branch
Now that we've added a commit to our local repo we can give it a home on github.
- First thing we'll do is go to github
- Secondly we'll log into our account
- Thirdly we'll click + icon and hit 'new repository'
We can see
Add .gitignore: and
Add a license: we'll ignore those though for now.
- Lastly we'll hit "Create repository"
Once we've done this we'll see two sets of instructions. We're going to choose the third set "push an existing repo from the command line"
git remote add origin https://github.com/boahs/Sample_Repo.git git push -u origin master
Once we execute
git push -u orgin master we're pushing anything new we've added with the
git add command. Remember that when adding something new such as a .txt file we need to also add a commit with
git commit -m "Comment here and to actually push it up to the live repo we push it!
git pull will both
git fetch and
git merge for us. Before using the
pull command we should be positive that our local work is commited before we execute the command. If we don't we may run into a dreaded merge conflict.
We'll use git pull to our master branch (which you should never do, always make your own branch!):
Boahs@DESKTOP /c/Sample_Directory (master) $ git pull https://github.com/boahs/Sample_Repo.git master From https://github.com/boahs/Sample_Repo * branch master -> FETCH_HEAD Already up to date.
Above we can see we've pulled the branch, and merged our changes with the master branch. We can open a pull request as well by navigating through our repo to "Pull requests" and hitting "New pull request". We can now delete our branch we've merged by clicking 'closed' - We'll see our pull here, simply check it and hit 'delete branch'. Well done - We've successfully merged, and closed! The owner of the repository can now view all the commits, pull requests...etc and click 'Confirm merge' if they agree with your changes.
We've learned command line commands such as
cd to navigate our way around the terminal, and
nano to create new files. We've also learned how to create a repo and clone a repo to edit locally on our machine, and also how to clone specific branches of that repo with the
git clone command, and
git clone -branch <branch name> command. When we ran
git init inside our
C:/Sample_directory/ directory while also realizing we can
git add to add our new files/code to the repo. Well done today!