Three Methods to Execute Commands from Text Files in Bash

Introduction

In Linux system administration and daily development work, there is often a need to execute a series of commands in batch. When these commands exist in text file format, how to execute them efficiently becomes a common technical requirement. Based on relevant Q&A data from Stack Overflow, this article systematically explores three main execution methods and provides in-depth analysis of their technical principles and best practices.

Method 1: Creating Executable Shell Scripts (Best Practice)

This is the most recommended approach and the highest-rated solution in the Q&A data. The core of this method involves converting text files into executable shell scripts.

First, create a script file containing the commands. Suppose we have a file named commands.txt with the following content:

sudo apt-get update
sudo apt-get upgrade -y
sudo systemctl restart apache2

To convert it into an executable script, follow these steps:

1. Create the script file and add the shebang line:

#!/bin/bash
sudo apt-get update
sudo apt-get upgrade -y
sudo systemctl restart apache2

The shebang line (#!/bin/bash) specifies the interpreter for the script, which is the standard beginning of shell scripts.

chmod +x scriptname.sh

This command uses the chmod utility to add execution permissions to the script file. The +x parameter indicates adding execute permission, which is necessary for running the script.

./scriptname.sh

Here, ./ represents the current directory, which is the common way to execute executable files in the current directory.

The advantages of this method include:

• Clear execution permission control
• Support for complex script logic (such as conditional statements, loops, etc.)
• Facilitates version control and reuse
• Aligns with Unix/Linux best practices

Method 2: Direct Execution Using Bash Interpreter

The second method is more direct, using the Bash interpreter to execute commands from text files. This approach does not require setting file execution permissions.

Execute with the following command:

bash example.txt

Or using the more generic sh:

sh example.txt

The execution mechanism of this method is: the Bash interpreter reads the file content and then interprets and executes it line by line. The main differences from the first method are:

• No shebang line required
• No execution permissions needed
• A new Bash process is started for each execution

It is important to note that if the file contains operations like environment variable settings, these changes will not affect the current shell environment because the commands are executed in a child process.

Method 3: Using the source Command

The third method uses the source command (or its shorthand form .) to execute commands from files.

Execute with the following command:

source example.txt

Or using the shorthand:

. example.txt

The unique aspect of this method is that commands are executed in the current shell environment, not in a child process. This means:

• Modifications to environment variables directly affect the current shell
• No execution permissions required
• Higher execution efficiency (no new process created)

However, this also introduces potential risks: if commands in the file have side effects (such as modifying important environment variables), they may cause unexpected impacts on the current shell environment.

Technical Comparison and Analysis

To better understand the differences between these three methods, we can compare them from several dimensions:

Security Considerations

When executing commands from text files of untrusted sources, special attention must be paid to security:

1. Always inspect file content to ensure no malicious commands are present
2. Exercise particular caution with commands requiring sudo privileges
3. Consider using set -e to make scripts exit immediately upon encountering errors
4. For production environments, Method 1 is recommended with appropriate permission controls

Practical Application Example

Suppose we need to automate a web server deployment task. We can create a comprehensive script:

#!/bin/bash

# System Update
sudo apt-get update
sudo apt-get upgrade -y

# Install Required Software
sudo apt-get install -y apache2 mysql-server php libapache2-mod-php

# Configure Firewall
sudo ufw allow 'Apache Full'

# Start Services
sudo systemctl start apache2
sudo systemctl enable apache2

# Verify Installation
echo "Installation complete, verifying service status..."
systemctl status apache2 --no-pager

This example demonstrates how to organize multiple related commands into a complete automation script, showcasing the advantages of Method 1.

Conclusion

This article has thoroughly explored three main methods for executing commands from text files in Bash. While each method has its applicable scenarios, creating executable shell scripts (Method 1) is the most recommended approach due to its maintainability, security, and alignment with best practices. In practical applications, the appropriate method should be selected based on specific needs: Method 2 for simple temporary tasks, Method 3 for configuration tasks requiring current shell environment impact, and Method 1 prioritized for complex automation tasks and production environment deployments.

Understanding the technical principles and differences of these methods helps Linux users and developers manage systems and automate tasks more efficiently and securely. With the proliferation of DevOps and automated operations, mastering these fundamental yet important skills has become increasingly crucial.