Ever been daunted by writing Bash scripts or using the terminal? Many developers prefer to use the graphical user interface (GUI) to navigate their files and applications on their computers. With Bash, developers on macOS and Linux operating systems (OS) can do lots of computer processes right from the terminal without ever having to use their mouse or the keyboard for interaction.

In this lesson, you'll learn how to write simple Bash scripts and how you can 10X your productivity efficiently.

## What is Bash?

Bash, also known as Bourne Again Shell, is an interactive shell or command line interpreter popular with UNIX users. Therefore, what is a shell? A shell (command interpreter) is an interface between the user and the kernel. It is an executable text file that contains shell commands and other specific programming structures.

Some examples of shells include:

* Bourne
* Bash (Bourne Again Shell)
* Z Shell
* C Shell

Now, when do you use a Shell?
Bash scripting gives the user the power and control over the OS in the following ways:

* Monitoring the system
* Data backup and restoring
* Creating an alert system
* User administration and many more

Another use case of the CLIs is they can handle editing, creating, and deleting multiple files with one command. It is also possible to automate the everyday task and fetch web pages from the internet using the curl command.

If you do a task repeatedly, Bash can make such a task over within the shortest timeframe. Let's get started.

## Creating Variables in Bash

Like in any other programming language, the Linux environment variables are constants for a memory location where a value is stored for the configuration and manipulation of the system and displaying additional system information based on the stored value.

Also, remember that Bash is a weakly typed programming language that doesn't allow you to define any data type in the variable declaration.

An example of the format of a variable is `<NAME>=<VALUE>`

**Declare variables in Bash**
To begin, let's start with writing some essential variables.

\
```bash
web_url="https://github.com/the-collab-lab"
distro="Kali Linux"
```

\
**Call a variable**
The way to call a declared variable in Bash is by using the echo command to print out the variable as an output. Run this command:

\
```bash
# referencing the value of the variable
echo $blog_post_url

# OR 

echo ${blog_post_url}
```

\
If you decide you no longer need or want to remove the variable, run this command:

\
```bash
unset <name-of-the-variable>

# for example

unset blog_post_url
```

## Environment Variables

These are standard global environment variables present in a UNIX Shell. Sometimes environment variables are regarded as exported variables.

* env : Listing all environment variables
* export: creating a new variable for the user
* printenv: Viewing the environment variables using the print command
* read: getting user input

## View the Environment Variables

The env and printenv commands do similar things as they are responsible for allowing us to see the list or print all environment variables present. Type this in your terminal:

\
```bash
env

# OR

printenv
```

\
**Result**:

\
 ![env variables](https://cdn.hackernoon.com/images/7FHeR383huUAovH1GLgM3KFQYh12-2023-03-11T09:26:09.945Z-clf3ri0pn00040bs6eb8v6z1b)

To view each of the environment variables using the print command, run:

\
```bash
printenv HOME // the env for HOME user directory

printenv SHELL PWD SESSION_MANAGER // print more than one environment variable
```

## Create an Environment Variable

Using the export command, we can set a variable for the Linux environment variable. The rule of thumb when setting an environment variable is it is temporary.

\
```bash
export IP="80.0.0.1"

# Changing the path
export PATH=$PATH:~/script
```

\
To make this permanent, open and modify the .bashrc file. It is a hidden file; create one if it is not in your home directory. Add the previous export command.

\
Run this command:

\
```bash
vim ~/.bashrc
```

\
 ![variables](https://cdn.hackernoon.com/images/7FHeR383huUAovH1GLgM3KFQYh12-2023-03-11T09:26:09.953Z-clf3ri0pt00050bs6btr9eywe)

Edit this file and add the variable. Doing this will ensure the command is available for use by the system.

Since we are using Vim to edit the file, to exit and save the file, type **:wq**

To save the changes in the .bashrc file, run this command:

\
```bash
source ~/.bashrc
```

## How to Read User Input

Getting user input in Bash is possible, like in JavaScript, Python, and other programming languages, using the read command to get the value from the user and print the output.

In your terminal, run this command:

\
```bash
read name
```

\
The command waits for the user to type their name in the terminal. Afterwards, type this command to get the user input:

\
```bash
echo $name // teri
```

\
Also, you can pass in multiple variable names with the `read` command like this:

\
```bash
read name age city
```

\
Like the previous, you need to enter the result of the variable with spaces in between them:

\
 ![bash command](https://cdn.hackernoon.com/images/7FHeR383huUAovH1GLgM3KFQYh12-2023-03-11T09:26:09.954Z-clf3ri0pu00060bs693u81z6n)

Not supplying the read command with a variable name, the stored command read is stored as a pre-defined variable called `$REPLY`. Run this command:

\
```bash
read

// type your message as the program waits for you

echo $REPLY // result of the message
```

\
**Displaying a message with the read command**
To display a message to the user, include the `-p` flag with the read command, including the variable name after the display message:

\
```bash
read -p "Enter your IP address: " ip
echo $ip
```

\
**Hide sensitive information**
The read command is versatile as it can also hide sensitive information from displaying in the terminal as you type. To achieve this, run this command with the **-s** command:

\
```bash
read -s -p "Enter password: " passwd
echo $passwd
```

## Creating Your First Script with Bash

Running bash script helps with automation and makes the life of developers easier.

For this example, we will create bash scripts that create a new folder, print out a message within the file, list the folder structure, and ultimately read the file by displaying the message in the file.

Create a folder in your home directory using the terminal, of course, and navigate into the folder.

\
```bash
mkdir scripts

cd scripts
```

\
Using Vim, run this command to create the file for the script with the **.sh** extension:

\
```bash
vim file_script.sh
```

\
To enable the insert mode, press the `i` button.

Copy and paste these lines of code:

\
```bash
#!/bin/bash

mkdir -p dir1
echo "hello, bash world! writing my first script" > dir1/file.txt
tree .
cat dir1/file.txt
```

\
At the top of the file, the “shebang” denoted by **#!** instructs the operating system to run the script with the **/bin/bash** executable.

\
Save and exit the interactive shell with this command **:wq**. Before then, ensure to press the esc key.

Since shell scripts are executable files, you need permission to run this file from the owner with this command:

\
```bash
chmod 700 name-of-file

chmod 700 file_script.sh
```

\
Also, you can use this command as well to enable all users to run the script:

\
```bash
chmod +x file_script.sh
```

\
Before running the script and seeing the action, install the `tree` command:

\
```bash
// on macOS using brew
brew install tree

// on Ubuntu
sudo apt install tree
```

\
The `tree` installation will display directories as trees.

\
Now, let’s run the script using path:

\
```bash
# relative path
./file_script.sh
```

\
Alternatively, you can use the absolute path to run the bash script from the specified folder:

\
```bash
/home/teri/Desktop/scripts/file_script.sh
```

\
Also, you can run it with the bash keyword:

\
```bash
bash file_script.sh
```

\
If you run it with the absolute path or the bash keyword, you do not need to grant permission to the executable script.

\
Finally, to make the script executable from any path and folder in the terminal, edit the .bashrc file and include this:

\
```bash
export PATH="$PATH:~/Desktop/scripts"
```

\
Save and quit the **.bashrc** file by pressing the esc key and using the :wq. Also, save the changes of the **.bashrc** file with **source \~/.bashrc**.

\
Now, run only the file name from anywhere in the home directory, and the script file will execute.

The result of the program should look something like this:

\
 ![bash program](https://cdn.hackernoon.com/images/7FHeR383huUAovH1GLgM3KFQYh12-2023-03-11T09:26:09.954Z-clf3ri0pu00070bs6bzj6caoa)

## Conclusion

The Bash CLI is a tool every developer, regardless of expertise or experience, should use daily to make you productive and do fun things only with the terminal. Think of using Bash as a way to use your computer without the beautiful graphical user interface.

2022 - HackerNoon Contributor of the Year - Data Visualization

2022 - HackerNoon Contributor of the Year - Frontend

2022 - HackerNoon Contributor of the Year - Heroku

2022 - HackerNoon Contributor of the Year - Javascript

2022 - No No No Nodejs

2022 - Remote Work Warrior

Portfolio

Nominated for 2022 - HackerNoon Contributor of the Year - Data Visualization

Nominated for 2022 - HackerNoon Contributor of the Year - Heroku

Nominated for 2022 - HackerNoon Contributor of the Year - Javascript

Nominated for 2022 - HackerNoon Contributor of the Year - Frontend

Nominated for 2022 - Remote Work Warrior

Nominated for 2022 - No No No Nodejs

Too Long; Didn't Read

Web Development & Ecommerce Writing Contest

How to use Bash

How to use Bash

Too Long; Didn't Read

@terieyenike

RELATED STORIES