Parsing INI Files in Shell Scripts: Core Methods and Best Practices

Introduction

In automation scripting and system configuration management, INI files serve as a lightweight structured format widely used for storing application parameters. However, Bash shell lacks a built-in INI parser, requiring developers to leverage text processing tools or creative methods for configuration reading. This article takes a typical scenario—extracting the database_version value from a parameters.ini file—as a starting point to systematically present multiple technical solutions, focusing on best practices and their underlying design logic.

Core Method: Efficient Parsing with Awk

Based on community votes and scores, the most efficient solution is using the awk command, which achieves precise extraction with a one-liner:

version=$(awk -F "=" '/database_version/ {print $2}' parameters.ini)

This command works as follows: first, -F "=" sets the field separator to the equal sign, splitting each line into key and value parts; next, the pattern /database_version/ matches lines containing the target parameter; finally, {print $2} outputs the second field, i.e., the parameter value. This method offers significant advantages: it utilizes standard Unix tools without additional dependencies; execution is fast, especially for large files; and the code is concise, easy to integrate into existing scripts. However, note that if the INI file contains spaces or comments, preprocessing may be needed, such as using grep -v "^#" to remove comment lines.

Comparative Analysis of Alternative Approaches

Beyond awk, other methods have distinct features suitable for different scenarios:

• Native Bash Parsing: Using source <(grep = parameters.ini) imports INI key-value pairs as shell variables. This approach leverages Bash's variable assignment mechanism, enabling direct access like $database_version. Yet, it has limitations: it cannot handle assignments with spaces (requiring sed for trimming), ignores section structures, and may cause parsing errors with special characters. For simple, section-less configurations, this is a quick solution.
• Advanced Sed Expressions: Such as sed -nr "/^\\[section2\\]/ { :l /^param2[ ]*=/ { s/[^=]*=[ ]*//; p; q;}; n; b l;}" file.ini, which supports section-aware extraction. This command navigates to a specific section via a loop, then matches the target parameter, making it suitable for complex INI structures. However, the syntax is obscure and maintenance-heavy.
• Dedicated Parser Functions: Like the provided cfg_parser function, which converts entire INI files to Bash variables, supporting sections and arrays. This offers maximum flexibility but involves verbose code and relies on eval, posing potential security risks; it is recommended only for scenarios requiring full parsing.
• External Tools: For example, crudini, which directly retrieves values via crudini --get parameters.ini '' database_version. Such tools simplify operations but require additional installation and may not be available in minimal environments.

Practical Recommendations and Optimizations

When choosing a solution, consider the following factors:

1. Performance Requirements: For frequent reads or large files, awk or sed generally outperform the source method, which incurs subshell overhead.
2. Configuration Complexity: If the INI contains multiple sections or special formats (e.g., arrays), consider using parser functions or enhanced sed commands; for simple key-value pairs, prioritize awk.
3. Maintainability: One-liners are easier to debug, while complex functions may hide errors. It is advisable to add error handling, such as checking file existence: if [ -f parameters.ini ]; then version=$(awk -F "=" '/database_version/ {print $2}' parameters.ini); fi.
4. Cross-Platform Compatibility: Ensure that the tools used (e.g., awk, grep) behave consistently across target systems (e.g., Linux, macOS), avoiding reliance on GNU extensions.

Example integration into a migration script:

#!/bin/sh
# Read database version
if [ -f "parameters.ini" ]; then
    DATABASE_VERSION=$(awk -F "=" '/database_version/ {gsub(/^[ \t]+|[ \t]+$/, "", $2); print $2}' parameters.ini)
    if [ -n "$DATABASE_VERSION" ]; then
        php app/console doctrine:migrations:migrate "$DATABASE_VERSION"
    else
        echo "Error: database_version parameter not found"
        exit 1
    fi
else
    echo "Error: configuration file parameters.ini does not exist"
    exit 1
fi

This script enhances robustness: it trims leading and trailing spaces from the value using gsub and verifies the parameter is non-empty.

Conclusion

Parsing INI files in Shell scripts centers on balancing efficiency, complexity, and maintainability. For most scenarios, the awk-based one-liner offers the best combination: it is fast, reliable, and easy to understand. As configuration needs evolve, more advanced approaches like section-aware sed or dedicated parsers can be gradually adopted. Developers should test these methods in their specific environments to ensure compatibility and performance, thereby building robust automation workflows. By mastering these techniques, one can effectively manage configuration data, enhancing script flexibility and reusability.