How to Use sh for Basic Shell Scripting: A Beginner's Guide

Liam OliviaNovember 8, 2024

0 78 5 minutes read

How to Use sh for Basic Shell Scripting: A Beginner’s Guide

Shell scripting is a powerful tool in Unix-like operating systems that allows users to automate repetitive tasks, perform complex operations, and manage systems more efficiently. The sh shell, often referred to as the Bourne shell, is one of the oldest and simplest shell environments used for basic scripting. This guide will walk you through the basics of shell scripting using sh, providing examples and best practices along the way.

Whether you’re a system administrator, developer, or Linux enthusiast, learning shell scripting will enhance your ability to automate tasks and simplify command-line workflows.

What is Shell Scripting?

A shell script is essentially a text file containing a series of commands that the shell interprets and executes. It’s a program written for the shell, a command-line interpreter that allows you to interact with your operating system.

The sh shell, specifically, is widely available on most Unix-based systems and serves as the foundation for many other shells like bash and dash. Using sh for shell scripting offers a basic and portable way to write scripts that can run across different systems.

Step 1: Writing Your First Shell Script

Creating a Shell Script File

To begin writing a shell script, you’ll need a text editor and a terminal. Popular text editors like Vim, Nano, or even graphical ones like Visual Studio Code can be used to write your script.

Let’s create a simple shell script:

Open your terminal.
Create a new file with a .sh extension, which indicates a shell script. For example:

touch myscript.sh

Open this file in a text editor. If you’re using Nano, you can do this with:

nano myscript.sh

Writing the Script

The first line of any shell script should be the shebang (#!), which tells the system what interpreter to use to run the script. For sh scripts, this will look like:

#!/bin/sh

This specifies that the script should be interpreted using the sh shell.

Now, let’s add a simple command to print “Hello, World!” to the terminal:

#!/bin/sh
echo “Hello, World!”

Save and exit the text editor (in Nano, you can press Ctrl + X to exit, then Y to confirm saving).

Running the Script

Before running your script, you need to make it executable. You can do this with the chmod

chmod +x myscript.sh

Now, run the script by typing:

./myscript.sh

You should see the output:

Hello, World!

Congratulations! You’ve written and executed your first shell script.

Step 2: Variables in Shell Scripts

Variables are used to store data in shell scripts, which can then be referenced and manipulated throughout the script. Defining a variable in sh is simple, and you do not need to specify the data type.

Defining and Using Variables

Here’s an example of defining and using a variable in a shell script:

#!/bin/sh

name=”Alice”
echo “Hello, $name!”

In this script, we assign the value “Alice” to the name variable, and then reference it using the $ symbol. When you run the script, the output will be:

Hello, Alice!

User-Defined Variables

You can also prompt the user to input values that will be stored in variables. For example:

#!/bin/sh

echo “Enter your name: ”
read user_name
echo “Hello, $user_name!”

When this script runs, it will prompt the user for their name and then print a greeting using that input.

Step 3: Conditional Statements

Like most programming languages, shell scripting allows for conditional execution using if statements. This is useful when you need to perform different actions based on user input or system conditions.

Basic `if` Statement

Here’s a simple example of an if statement:

#!/bin/sh

echo “Enter a number: ”
read number

if [ $number -gt 10 ]
then
echo “The number is greater than 10.”
else
echo “The number is less than or equal to 10.”
fi

In this script, we prompt the user to input a number, and then use an if statement to check whether the number is greater than 10. The -gt operator stands for “greater than.”

Logical Operators

Shell scripts support various logical operators for conditions:

-eq: Equal to
-ne: Not equal to
-lt: Less than
-le: Less than or equal to
-ge: Greater than or equal to

For example, to check if two numbers are equal:

if [ $num1 -eq $num2 ]

You can also chain conditions using elif (else if) for multiple checks.

Step 4: Loops in Shell Scripts

Loops allow you to repeat a block of code multiple times, which is useful for iterating through lists, processing files, or automating repetitive tasks.

`for` Loop

A for loop in a shell script works similarly to loops in other languages. Here’s an example that prints numbers from 1 to 5:

#!/bin/sh

for i in 1 2 3 4 5
do
echo “Number: $i”
done

This loop will output:

Number: 1
Number: 2
Number: 3
Number: 4
Number: 5

You can also use a for loop to iterate through files in a directory:

#!/bin/sh

for file in /path/to/directory/*
do
echo “File: $file”
done

`while` Loop

A while loop continues to execute as long as the condition provided remains true. For example:

#!/bin/sh

counter=1

while [ $counter -le 5 ]
do
echo “Counter: $counter”
counter=$((counter + 1))
done

This will output:

Step 5: Functions in Shell Scripts

Functions allow you to encapsulate and reuse code within your shell script. Defining and using functions in sh is straightforward.

Defining a Function

Here’s a simple function that prints a message:

#!/bin/sh

greet() {
echo “Hello, World!”
}

greet

When you run this script, it will call the greet function and print the message.

Functions with Arguments

You can also pass arguments to functions. Here’s an example:

#!/bin/sh

greet() {
echo “Hello, $1!”
}

greet “Alice”

In this script, we pass the argument “Alice” to the greet function, and it uses $1 to reference the first argument. The output will be:

Hello, Alice!

Step 6: Input and Output Redirection

Input and output redirection allows you to redirect the output of commands to files or input data from files.

Redirecting Output

To redirect the output of a command to a file, use the > operator:

#!/bin/sh

echo “This will be written to a file.” > output.txt

This will write the text to a file named output.txt. To append output to an existing file, use >>:

Redirecting Input

You can also redirect input from a file using the < operator. For example:

#!/bin/sh

while read line
do
echo “Line: $line”
done < input.txt

This script reads each line from input.txt and prints it.

Step 7: Permissions and Best Practices

Script Permissions

When writing shell scripts, you need to ensure that your script has execute permissions. This can be done using the chmod command, as mentioned earlier:

chmod +x myscript.sh

This will make the script executable.

Best Practices

Use comments: Add comments to your script using the # symbol to explain what your code does.
# This script prints “Hello, World!”

Check for errors: Always test your scripts thoroughly to ensure they handle errors gracefully.

if [ $? -ne 0 ]; then
echo “An error occurred.”
fi

Use meaningful variable names: Choose variable names that make it easy to understand what they represent.

Conclusion

Shell scripting with sh offers a simple yet powerful way to automate tasks, manage files, and interact with the system. By mastering basic commands, loops, conditionals, and functions, you can create scripts that streamline your workflow and reduce manual effort.

With this guide, you now have the knowledge to create your own sh shell scripts, automate repetitive tasks, and start exploring more advanced scripting techniques. Happy scripting!

Post Views: 115