sh vs Bash: Key Differences Explained

Bash is an enhanced version of the Bourne shell (sh) that maintains backward compatibility while adding numerous advanced features like arrays, string manipulation, and improved syntax. While sh scripts will typically run on Bash without modification, the reverse isn’t always true due to Bash’s extended functionality that isn’t POSIX-compliant. The key differences lie in Bash’s advanced scripting capabilities, interactive features, and extended command set compared to sh’s more basic but highly portable design.

Contents

• Core Compatibility and Portability
• Key Feature Differences
• Programming Considerations
• When to Use Each Shell
• Best Practices for Cross-Shell Compatibility

Core Compatibility and Portability

Bash is largely compatible with sh and incorporates useful features from the Korn shell ksh and the C shell csh, as noted by Stack Overflow contributors. This backward compatibility means that most sh scripts will run on Bash without modifications, making migration generally smooth. However, there are important distinctions to understand.

The sh script will most likely run on bash also without modifications because bash is backward compatible with sh, according to GeeksforGeeks. This compatibility stems from Bash’s design philosophy as an enhanced version of the original Bourne shell.

From a standards perspective, sh represents the POSIX Shell and Tools portion of the IEEE POSIX specification, making it the most portable scripting language that works on most POSIX/Unix/Linux systems. As GitHub’s technical notes explain, “sh (or the Shell Command Language) is a programming language described by the POSIX standard. It has many implementations (ksh88, dash, …). bash can also be considered an implementation of sh.”

Key Feature Differences

Arrays and Data Structures

One of the most significant differences is Bash’s support for arrays, which sh lacks. As demonstrated in practical examples from various sources:

# Bash syntax for arrays
my_arr=(one two three)
echo "${my_arr[1]}"  # Output: two

# sh would produce: Syntax error: arrays not supported
my_arr=(one two three)  # This fails in sh

Bash supports both indexed arrays and associative arrays, providing powerful data manipulation capabilities that simply don’t exist in sh.

Enhanced Test Syntax

Bash offers improved test syntax with double square brackets [[ ]] that provides more robust and safer condition testing:

# sh syntax (single brackets)
if [ $a -lt $b ]; then
    echo "$a is less than $b"
fi

# Bash syntax (double brackets) - more robust
if [[ $a -lt $b ]]; then
    echo "$a is less than $b"
fi

As TecAdmin explains, “in bash, you can use the double square bracket syntax [[ ]] for tests, which is more robust and safer than the single bracket syntax [ ] used in SH.”

String Manipulation and Advanced Features

Bash provides extensive string manipulation capabilities and C-style programming constructs that sh doesn’t support:

• String operations: Pattern matching, replacement, and substring extraction
• C-style loops: for((i=0;i<=3;i++)) instead of traditional for loops
• Arithmetic evaluation: Built-in arithmetic with (( )) syntax
• Brace expansion: echo {a,b,c} expands to “a b c”
• Command history: Interactive command recall and editing
• Job control: Enhanced background and foreground process management

Some Bash keywords like local, source, function, shopt, let, declare, pushd, popd, and select are not portable to sh, as noted in Stack Overflow discussions. These features make Bash significantly more powerful for complex scripting tasks.

Built-in Commands and Functions

Bash includes numerous built-in commands and functions that extend its capabilities beyond sh:

# Bash-specific built-ins
declare -A assoc_array  # Associative arrays
let "result = 5 + 3"    # Arithmetic evaluation
shopt -s nocasematch    # Shell options
pushd /tmp              # Directory stack

Programming Considerations

Syntax Differences and Gotchas

When writing scripts that need to work across different shells, several syntax differences can cause issues:

# Function definitions differ
# sh syntax (no 'function' keyword)
my_function() {
    echo "Hello from sh"
}

# Bash syntax (both work)
my_function() {
    echo "Hello from bash"
}
function my_function() {
    echo "Hello from bash with keyword"
}

As Shaun Fulton notes in Medium, “sh supports functions, but not the function keyword. Stick to the POSIX version if you’re aiming for sh compatibility. These small syntax differences can lead to major debugging headaches.”

Variable Expansion and Quoting

The $'string\nwith\tC\escapes' feature works in Bash but is not yet supported by sh on systems that strictly adhere to POSIX standards. This can cause portability issues when trying to escape special characters.

Error Handling and Exit Codes

While both shells support basic error handling, Bash provides more sophisticated options for error control and debugging, making it easier to write robust scripts.

When to Use Each Shell

Choose Bash When:

• You need advanced scripting features like arrays, functions, and string manipulation
• You’re writing scripts for Linux-specific environments where Bash is guaranteed to be available
• You want enhanced interactive features like command history and tab completion
• You need complex mathematical operations and arithmetic evaluation
• You’re working in a development environment where flexibility and advanced features are valued

According to LinuxConfig, “Use Bash when you need advanced scripting features like arrays, functions, string manipulation, and a wide range of built-in commands.”

Choose sh When:

• You need maximum portability across different Unix systems
• You’re writing scripts for embedded systems or minimal installations
• You need to ensure POSIX compliance for enterprise environments
• You’re working with older Unix systems that may not have Bash installed
• You want to avoid shell-specific features that might break in different environments

The Linux Code explains that “sh is the most widely used scripting language for POSIX/UNIX/LINUX operating system platforms. One benefit of sh is that it exists on every Unix system.”

Best Practices for Cross-Shell Compatibility

Writing Portable Scripts

To ensure your scripts work across both shells:

1. Stick to POSIX standards: Use sh-compatible syntax when portability is critical
2. Avoid Bash-specific features: Don’t use arrays, double brackets, or other Bash-only features
3. Use proper shebang: Start scripts with #!/bin/sh for maximum compatibility
4. Test thoroughly: Validate scripts on both sh and Bash environments

Conditional Shell Detection

You can detect the current shell and adjust behavior accordingly:

#!/bin/sh
# Check if we're running under Bash
if [ -n "$BASH_VERSION" ]; then
    echo "Running under Bash - advanced features available"
    # Bash-specific code here
else
    echo "Running under sh - limited features"
    # Portable code here
fi

Gradual Migration Strategy

When migrating from sh to Bash:

1. Start with sh-compatible syntax
2. Gradually introduce Bash features
3. Maintain a parallel sh version for legacy systems
4. Document Bash-specific dependencies

Sources

1. Stack Overflow - Difference between sh and Bash
2. GeeksforGeeks - Difference between sh and bash
3. Baeldung on Linux - What’s the Difference Between sh and Bash?
4. LinuxConfig - Bash sh Command: Learn the difference between Bash vs Shell
5. Tutorials Point - Difference Between sh and Bash in Linux
6. Medium - What’s the Difference Between Bash, SH, and ZSH?
7. GitHub - Difference between sh and bash
8. TecAdmin - What are the difference between SH and BASH?
9. TheLinuxCode - Comparing sh Shell vs Bash Shell: An In-Depth Look
10. LinkedIn - Difference Between sh and Bash in Linux

Conclusion

The main differences between sh and Bash boil down to compatibility, features, and portability. Bash maintains backward compatibility with sh while adding numerous advanced capabilities like arrays, enhanced syntax, and interactive features. When choosing between them, consider your target environment - use sh for maximum portability across Unix systems, and Bash when you need advanced features and are working in Linux-centric environments.

For practical shell programming, start with sh-compatible syntax when writing scripts that need to work across different systems, but don’t hesitate to leverage Bash’s powerful features when working in controlled environments. Always test your scripts on the target shells to ensure compatibility, and consider using conditional shell detection for scripts that need to adapt to different environments.

Remember that while Bash offers many conveniences, sh remains the gold standard for portability in cross-platform shell scripting. The choice ultimately depends on your specific requirements for features, compatibility, and the systems where your scripts will need to run.