Comparing Dot-Separated Version Strings in Bash: Pure Bash Implementation vs. External Tools

Background and Challenges of Version Comparison

In software deployment, system administration, and development operations, version number comparison is a common requirement. Dot-separated version strings (e.g., 2.4.5, 2.8, 2.4.5.1) need to be compared according to semantic versioning specifications, but Bash lacks native support. Main challenges include: handling inconsistent segment counts, semantics of leading zeros (e.g., 1.01 vs. 1.1), and compatibility with special formats (e.g., double dots 1..0).

Pure Bash Implementation

Based on the best answer, the vercomp function provides a solution without external dependencies. Its core logic is as follows:

#!/bin/bash
vercomp () {
    if [[ $1 == $2 ]]
    then
        return 0
    fi
    local IFS=.
    local i ver1=($1) ver2=($2)
    # Fill empty fields in ver1 with zeros
    for ((i=${#ver1[@]}; i<${#ver2[@]}; i++))
    do
        ver1[i]=0
    done
    for ((i=0; i<${#ver1[@]}; i++))
    do
        if [[ -z ${ver2[i]} ]]
        then
            # Fill empty fields in ver2 with zeros
            ver2[i]=0
        fi
        if ((10#${ver1[i]} > 10#${ver2[i]}))
        then
            return 1
        fi
        if ((10#${ver1[i]} < 10#${ver2[i]}))
        then
            return 2
        fi
    done
    return 0
}

Key technical points of this implementation include:

1. Field Splitting and Array Conversion: By setting IFS=., version strings are split into arrays for segment-by-segment comparison.
2. Length Alignment Handling: When version numbers have different segment counts, zeros are padded to the shorter array through loops (e.g., 2.4 is treated as 2.4.0), ensuring fair comparison.
3. Numerical Comparison: The 10#${ver1[i]} syntax interprets each field as a decimal number, avoiding octal misinterpretation due to leading zeros (e.g., 08).
4. Return Value Design: The function returns 0 for equality, 1 if the first argument is greater, and 2 if the second is greater, following Unix conventions.

The accompanying test function testvercomp validates correctness by reading test cases, covering edge cases and special formats:

testvercomp () {
    vercomp $1 $2
    case $? in
        0) op='=';
        1) op='>';
        2) op='<';
    esac
    if [[ $op != $3 ]]
    then
        echo "FAIL: Expected '$3', Actual '$op', Arg1 '$1', Arg2 '$2'"
    else
        echo "Pass: '$1 $op $2'"
    fi
}

Simplified GNU sort-Based Approach

If the system supports GNU coreutils 7 or later, the sort -V (version sort) option can be used for simpler comparison. Answer 2 provides two implementations:

First, by capturing sorted results:

verlte() {
    [  "$1" = "`echo -e "$1\n$2" | sort -V | head -n1`" ]
}

verlt() {
    [ "$1" = "$2" ] && return 1 || verlte $1 $2
}

Second, using sort -C silent check mode, directly judging by exit status:

verlte() {
    printf '%s\n' "$1" "$2" | sort -C -V
}

verlt() {
    ! verlte "$2" "$1"
}

This method can be extended for range checking:

ver_between() {
    # Arguments: min, actual, max
    printf '%s\n' "$@" | sort -C -V
}

Advantages include concise code and leveraging mature tools, but it depends on specific GNU versions and may be unavailable on older systems (e.g., Ubuntu Jaunty).

Other Alternative Solutions

Debian-Specific Tool: In Debian-based systems, dpkg --compare-versions <first> <relation> <second> can be used directly. This tool is designed for package management and supports rich comparison operators.

AWK Numerical Conversion: Convert version numbers to fixed-format integers via AWK for comparison:

function version { echo "$@" | awk -F. '{ printf("%d%03d%03d%03d\n", $1,$2,$3,$4); }'; }

This method pads each field to three digits (e.g., 2.4.5 becomes 2004005), supporting up to four segments but with limited extensibility and potential overflow.

Direct Sorting Example: For simple sorting needs, printf '2.4.5\n2.8\n2.4.5.1\n' | sort -V directly provides an ordered list.

Solution Comparison and Selection Recommendations

Selection should consider: system environment (availability of GNU tools), version complexity (segment count, special characters), performance requirements (AWK may be faster for frequent comparisons), and maintainability (pure Bash is easier to debug).

Practical Application Example

Checking if curl version meets minimum requirements in a script:

if ! printf '7.18\n%s\n' "$(curl -V | grep -io "[0-9][0-9a-z.-]*" | head -n1)" | sort -V -C; then
  echo "Error: curl version is older than 7.18!"
else
  echo "curl version is at least 7.18."
fi

This example combines version extraction (regex matching) and sorting comparison, demonstrating integrated application in real scenarios.

Conclusion

Version comparison in Bash requires selecting appropriate solutions based on specific needs. The pure Bash implementation offers maximum compatibility and control, suitable for general scripts; the GNU sort approach is most concise and efficient in supported environments; specialized tools (e.g., dpkg) are optimal on specific platforms. Understanding the core mechanisms—whether array operations, sorting algorithms, or numerical conversion—helps make correct technical decisions in complex scenarios. Through the code examples and comparative analysis in this article, readers should be able to flexibly apply these techniques to solve version management problems in actual operations.