Getting Started with Bash Scripting for Web Developers
Tags: webdev, automation, shell, productivity
Published: 2019-01-22 22:40:32

---
published: true
title: Getting Started with Bash Scripting for Web Developers
date: "2019-01-22T22:40:32.169Z"
template: "post"
draft: false
slug: "/posts/intro-to-bash/"
category: "Tutorials"
canonical_url: https://blog.ekohordan.com/posts/intro-to-bash
tags: 
  - "Web development"
  - "Automation"
  - "Shell"
  - "Productivity"
description: "Shell scripting unlocks a great deal of productivity for web developers. This article gives a quick primer on using shell scripting to automate mundane tasks"
---

Web developers are constantly seeking ways to increase their efficiency, and one key way to do that is to automate, at least to an extent, most mundane and repetitive tasks that constitute our daily activities. One tool that can help with that and requires no overhead to begin to use and leverage upon is Bash Scripting.

This article aims to get you started with Bash. My aim is to highlight its potential to be an addition to your workflow as a developer.

As might be obvious from the preceding statements, I'll assume that you have a bit of familiarity with software development, you know what Git and Github are and at least know what a terminal is.

Having said that what you will need in order to follow along with this tutorial includes:

- A terminal (Linux or Mac)
- A text editor

If you have these, we can begin.

## Introduction

### What is Bash and Bash Scripting
Bash stands for Bourne Again Shell and it is a command processor or interpreter in which a user can type in executable commands. A Bash script, on the other hand, is, simply put, a collection of Bash commands.

![terminal](https://thepracticaldev.s3.amazonaws.com/i/ucqm6qmeidhtb3ljrqap.png)

### A simple hello world script

Let us begin with a simple hello world script.
In Bash, the construct for printing out something to the terminal(console) is the `echo` keyword. It is the equivalent of `console.log` in JavaScript which simply prints out the arguments supplied to it.

In order to make our first script we need to create a simple file called `hello_world.sh`.

```bash
$ touch hello_world.sh
```

To begin with our hello world script we would create a Bash command in our script which we can run and execute. Open the `hello_world.sh` file in your text editor and enter the following

```bash
  #!/bin/bash

  echo "Hello world"
```

### Making an executable

In order to run this script, we would need to make it an executable file. If you list out the files in the current directory using `ls -al`, the `hello_world.sh` file we created would be listed with the following properties similar to what is shown below

![list-files](https://thepracticaldev.s3.amazonaws.com/i/jac4js3e9gjgcuw765ld.png)

The `-rw-r--r--` section shows that the current user only has `r`ead and `w`rite permissions on that file.

In order to execute this script run the following command to add execute permissions for the current user.

```bash
$ chmod 755 hello_world.sh
```

Run `ls -al` once more to see the current permissions and you should see something similar to this. The `x` showing that the current user has execute permissions for this file.

![list-executable](https://thepracticaldev.s3.amazonaws.com/i/0a7bileat5amyhunenvu.png)

### Running the script

In order to execute our Hello world script just run `./hello_world.sh` in the current directory. This Bash script simply prints out the string "Hello world" to the terminal when it is executed.

Exciting right? 🚀🔥

What if we could make this function take in an argument and print out that argument instead. And if no argument is provided it can just print out a default "Hello world" greeting.

We will update the script to handle receiving and use of arguments.

### Bash Scripting Basics

#### Command line parameters

We can pass arguments to our script by supplying them in front of the call to our script. So let's say we wanted to execute our script and pass an argument (e.g a name) to it, we can do it as follows

![hello-param](https://thepracticaldev.s3.amazonaws.com/i/jjxjw8atrmjip6xfpty1.png)

Executing our script this way passes the string of characters "Jane" to our script. However, we currently have no way of using this parameter in our current script.

Command line arguments are usually supplied to the running script as a list of arguments represented by `$1` for the first argument, `$2` for the second and so on.

So in our case above, we can update our script to accept a name and print out a "Hello" greeting along with the name. Edit your `hello_world.sh` file and replace it with the following:

```bash
  #!/bin/bash

  echo "Hello" $1
```

Executing `./hello_world.sh Jane` should print out the expected result

![hello-jane](https://thepracticaldev.s3.amazonaws.com/i/gjs7zh8s7xhx4fmw1wt5.png)

#### if...else conditionals

Now we have our script printing the greeting with a provided name. If you run the script without any arguments you will notice it just prints out "Hello". We can extend its functionality by making use of conditionals within Bash. A simple if...else statement would do.

Update your script to the following:

```bash
  #!/bin/bash

  if [ $1 ]; then
    echo "Hello" $1
  else
    echo "Hello World"
  fi
```

With the above, we are checking if a command line argument was supplied to the script and then we print the greeting with the argument, otherwise we print "Hello World". Run it a few times to verify this.

### A more practical Bash script

Now I understand you can't do much with just a "Hello World" script, so we will try to build a script you can actually use.

For this, we will look to solve a problem that I think developers have in their daily activity, which is cloning a Github repository and changing directory into the newly cloned repository in one single step.

Create a new file in a folder of your choice called `clone_repo.sh`. Add execute permissions to the file by running `chmod 755 clone_repo.sh`

Enter the following into it

```bash
  #!/bin/bash

  echo "Initializing git clone $1"

  git clone $1

  basename=$(basename $1)
  folder_name=${basename%.*}

  echo "Changed directory to $folder_name"
  cd $folder_name
  exec bash
```

What the above script does is fairly obvious. Firstly we print out a message saying notifying the beginning of the git clone. Then we run the actual git clone command. (Note this script assumes you already have git installed in your environment).

Next, we make use of <a href="https://en.wikipedia.org/wiki/Basename" target="_blank">basename</a> which is a standard Unix program to get the last name from the provided Github URL ignoring any trailing slashes. The next line only sanitizes it in order to get the correct pathname in cases where the Github URL also has a `**.git` extension at the end e.g `https://github.com/ceoehis/reactive-weather.git`.

After obtaining the correct folder name we notify the user with where we are with the set up via another `echo` statement and then issue a command to `cd` or change directory into the folder name.

The final line is a call to execute the current Bash instance at the end of our script in order for the `cd` command to take effect on the parent shell. This is because Bash scripts are usually run in a subshell and cannot change the working directory of the parent shell. This means that the effect of the `cd` command would ordinarily not affect the parent shell. In order to have the `cd` command take effect on the parent shell, we need to `exec`ute the child Bash instance in the script as above.

Finally, we need to execute this script and pass a Github repository as an argument.

```bash
$ ./clone_repo.sh https://github.com/ceoehis/reactive-weather.git
```
![clone-repo](https://thepracticaldev.s3.amazonaws.com/i/spqr2wb7572j684mvyr1.png)

Voila! The repo was cloned successfully and the resulting directory became the current working directory, thanks to our script. 🔥💪🏽

Our demo script can be improved upon in a few ways. See if you can improve the user experience for this script by handling potential errors, and maybe even prompting a user with the correct usage information for cases when they don't supply a Github URL.

The possibilities with shell scripting are endless, from printing names to the console to automating several tasks. This tutorial is a primer to get you started with basic Bash constructs and scripts. You can find more resources in the links below.

[Shell Scripting tutorial](https://www.shellscript.sh/)
[Bash for beginners](https://linuxconfig.org/bash-scripting-tutorial-for-beginners)

_Thanks for reading. This article was originally posted on my [blog](https://blog.ekohordan.com/posts/intro-to-bash/)_