Mastering Shell Script Execution: A Practical Guide to Running .sh Files in Linux Efficiently

Most guides tell you to just bash script.sh — but mastering the nuances of .sh execution permissions, environments, and debugging transforms a basic command into a powerful, reliable automation skillset.

If you’ve ever peeked into the world of Linux automation, chances are you’ve encountered .sh files — shell scripts that can save you countless hours by automating repetitive tasks. But running these scripts isn’t always as straightforward as typing bash script.sh.

Understanding how to properly execute .sh files in Linux is the foundation of effective system administration and development workflows. This guide breaks down everything you need to know, from execution permissions to environment considerations and debugging, to ensure you run your shell scripts efficiently and confidently.

What is a .sh File?

A .sh file is a shell script — essentially a sequence of Linux commands stored in a plain text file. When executed, these commands run in the shell environment, automating tasks like software installation, system monitoring, or file manipulation.

Step 1: Verify Your Script’s Content

Before running any .sh file, inspect its contents to understand what it will do. Use:

cat script.sh

or open it with a text editor like nano or vim. This is a security best practice to avoid running malicious scripts.

Step 2: Set Execution Permissions

Linux protects your system by requiring the right permissions before executing files. Your script needs to have execute permission.

Check the permissions with:

ls -l script.sh

You’ll see something like:

-rw-r--r-- 1 user user 348 May 15 10:22 script.sh

Here, -rw-r--r-- means the file is readable and writable by the user but not executable.

To add execute permissions:

chmod +x script.sh

Now, ls -l will show:

-rwxr-xr-x 1 user user 348 May 15 10:22 script.sh

The x means executable.

Step 3: Run the Script — Two Common Methods

Method 1: Run with Interpreter Explicitly

Use the shell interpreter command directly:

bash script.sh

or

sh script.sh

This method doesn’t require execute permission because you are telling Bash/Shell to read and run the script file explicitly.

Method 2: Run as Executable File

If your script has execute permissions and a valid shebang line, you can run it directly:

./script.sh

• ./ means "current directory" — important because your current directory might not be in $PATH by default.
• Your script should start with a shebang, telling the system which interpreter to use. Example:

#!/bin/bash

This line (on the very first line of the script) ensures your script runs with Bash when executed directly.

Why Use Shebang?

The shebang (#!) specifies the path of the interpreter that runs the script.

Common shebang lines:

#!/bin/bash       # Run with Bash shell
#!/bin/sh         # Run with default shell, often dash on Ubuntu
#!/usr/bin/env bash  # More portable way to find Bash in the environment

Without a shebang, executing the script directly (./script.sh) might produce an error or run in an unintended shell.

Example: Creating and Running a Simple Script

1. Create a file:

nano hello.sh

2. Add the following content:

#!/bin/bash
echo "Hello, Linux world!"

3. Save and exit (Ctrl + O, Enter, Ctrl + X).

4. Make it executable:

chmod +x hello.sh

5. Run it:

./hello.sh

Output:

Hello, Linux world!

Step 4: Passing Arguments to Your Script

You can supply arguments after the script name:

./script.sh arg1 arg2

Inside your script, access them as $1, $2, etc.

Example, save to greet.sh:

#!/bin/bash
echo "Hello, $1!"

Run:

chmod +x greet.sh
./greet.sh Alice

Output:

Hello, Alice!

Step 5: Debugging Your Shell Scripts

Even simple scripts can fail unexpectedly. Use these tips to debug:

• Add set -x at the start of your script:

#!/bin/bash
set -x
# your commands here

This prints commands as they run, showing which line might cause trouble.

• Run your script with bash -x:

bash -x script.sh

• Check for syntax errors by running:

bash -n script.sh

• Insert echo statements to print variable values and checkpoints.

Step 6: Environment Considerations

• When running a script by ./script.sh, it runs in a new shell instance.
• Environment variables you set in your interactive session may not be available inside the script — and vice versa.
• To share environment variables, export them before running or source scripts:

export MY_VAR=value
./script.sh

Or source with:

source script.sh
# or
. script.sh

Using source runs the script in the current shell, making variables and functions defined inside available afterward.

Summary Cheat Sheet

Final Thoughts

Mastering how to run .sh files in Linux means much more than just issuing a command; it involves understanding how Linux handles file permissions, interpreters, environments, and debugging. By applying these concepts, you gain the power to automate reliably and streamline workflows—essential skills for any system administrator or developer working in Linux.

Ready to automate smarter? Start experimenting today by writing your own shell scripts, setting the right permissions, and running them with confidence.

If you found this guide helpful or have any questions about Linux shell scripts, drop a comment below! Happy scripting!