Comment comparer deux chaînes de caractères en dot séparés format de version de Bash?

Si vous avez coreutils-7 (dans Ubuntu Karmic mais pas Jaunty) puis votre sort commande doit avoir un -V option (version sorte que vous pouvez utiliser pour faire la comparaison:

verlte() {
[  "$1" = "`echo -e "$1\n$2" | sort -V | head -n1`" ]
}
verlt() {
[ "$1" = "$2" ] && return 1 || verlte $1 $2
}
verlte 2.5.7 2.5.6 && echo "yes" || echo "no" # no
verlt 2.4.10 2.4.9 && echo "yes" || echo "no" # no
verlt 2.4.8 2.4.10 && echo "yes" || echo "no" # yes
verlte 2.5.6 2.5.6 && echo "yes" || echo "no" # yes
verlt 2.5.6 2.5.6 && echo "yes" || echo "no" # no

GNU tri a une option pour elle:

printf '2.4.5\n2.8\n2.4.5.1\n' | sort -V

donne:

2.4.5
2.4.5.1
2.8

C'est plus de 4 champs dans la version.

$ function ver { printf "%03d%03d%03d%03d" $(echo "$1" | tr '.' ' '); }
$ [ $(ver 10.9) -lt $(ver 10.10) ] && echo hello  
hello

Vous pouvez récursive split sur . et de comparer, comme indiqué dans l'algorithme suivant, pris de ici. Il renvoie 10 si les versions sont les mêmes, 11 si la version 1 est supérieure à la version 2 et 9 de l'autre.

#!/bin/bash
do_version_check() {
[ "$1" == "$2" ] && return 10
ver1front=`echo $1 | cut -d "." -f -1`
ver1back=`echo $1 | cut -d "." -f 2-`
ver2front=`echo $2 | cut -d "." -f -1`
ver2back=`echo $2 | cut -d "." -f 2-`
if [ "$ver1front" != "$1" ] || [ "$ver2front" != "$2" ]; then
[ "$ver1front" -gt "$ver2front" ] && return 11
[ "$ver1front" -lt "$ver2front" ] && return 9
[ "$ver1front" == "$1" ] || [ -z "$ver1back" ] && ver1back=0
[ "$ver2front" == "$2" ] || [ -z "$ver2back" ] && ver2back=0
do_version_check "$ver1back" "$ver2back"
return $?
else
[ "$1" -gt "$2" ] && return 11 || return 9
fi
}    
do_version_check "$1" "$2"

Source

si c'est juste sur le point de savoir si une version est inférieure à une autre, je suis venu vérifier si sort --version-sort de modifier l'ordre de mes chaînes de version:

    string="$1
$2"
[ "$string" == "$(sort --version-sort <<< "$string")" ]

Ici est une simple Bash fonction qui n'utilise pas les commandes externes. Il fonctionne pour la version chaînes qui ont jusqu'à trois les parties numériques en eux - moins de 3 est très bien. Il peut facilement être étendu pour plus. Elle met en œuvre =, <, <=, >, >=, et != conditions.

#!/bin/bash
vercmp() {
version1=$1 version2=$2 condition=$3
IFS=. v1_array=($version1) v2_array=($version2)
v1=$((v1_array[0] * 100 + v1_array[1] * 10 + v1_array[2]))
v2=$((v2_array[0] * 100 + v2_array[1] * 10 + v2_array[2]))
diff=$((v2 - v1))
[[ $condition = '='  ]] && ((diff == 0)) && return 0
[[ $condition = '!=' ]] && ((diff != 0)) && return 0
[[ $condition = '<'  ]] && ((diff >  0)) && return 0
[[ $condition = '<=' ]] && ((diff >= 0)) && return 0
[[ $condition = '>'  ]] && ((diff <  0)) && return 0
[[ $condition = '>=' ]] && ((diff <= 0)) && return 0
return 1
}

Voici le test:

for tv1 in '*' 1.1.1 2.5.3 7.3.0 0.5.7 10.3.9 8.55.32 0.0.1; do
for tv2 in 3.1.1 1.5.3 4.3.0 0.0.7 0.3.9 11.55.32 10.0.0 '*'; do
for c in '=' '>' '<' '>=' '<=' '!='; do
vercmp "$tv1" "$tv2" "$c" && printf '%s\n' "$tv1 $c $tv2 is true" || printf '%s\n' "$tv1 $c $tv2 is false"
done
done
done

Un sous-ensemble de la sortie du test:

<snip>
* >= * is true
* <= * is true
* != * is true
1.1.1 = 3.1.1 is false
1.1.1 > 3.1.1 is false
1.1.1 < 3.1.1 is true
1.1.1 >= 3.1.1 is false
1.1.1 <= 3.1.1 is true
1.1.1 != 3.1.1 is true
1.1.1 = 1.5.3 is false
1.1.1 > 1.5.3 is false
1.1.1 < 1.5.3 is true
1.1.1 >= 1.5.3 is false
1.1.1 <= 1.5.3 is true
1.1.1 != 1.5.3 is true
1.1.1 = 4.3.0 is false
1.1.1 > 4.3.0 is false
<snip>

• Fonction V - pur bash solution, pas de utilitaires externes requis.
• Prend en charge = == != < <= > et >= (lexicographique).
• Facultatif de la queue de la lettre de comparaison: 1.5a < 1.5b
• Longueur inégale comparaison: 1.6 > 1.5b
• Lit de gauche à droite: if V 1.5 '<' 1.6; then ....

<>

# Sample output
# Note: ++ (true) and __ (false) mean that V works correctly.
++ 3.6 '>' 3.5b
__ 2.5.7 '<=' 2.5.6
++ 2.4.10 '<' 2.5.9
__ 3.0002 '>' 3.0003.3
++ 4.0-RC2 '>' 4.0-RC1

<>

function V() # $1-a $2-op $3-$b
# Compare a and b as version strings. Rules:
# R1: a and b : dot-separated sequence of items. Items are numeric. The last item can optionally end with letters, i.e., 2.5 or 2.5a.
# R2: Zeros are automatically inserted to compare the same number of items, i.e., 1.0 < 1.0.1 means 1.0.0 < 1.0.1 => yes.
# R3: op can be '=' '==' '!=' '<' '<=' '>' '>=' (lexicographic).
# R4: Unrestricted number of digits of any item, i.e., 3.0003 > 3.0000004.
# R5: Unrestricted number of items.
{
local a=$1 op=$2 b=$3 al=${1##*.} bl=${3##*.}
while [[ $al =~ ^[[:digit:]] ]]; do al=${al:1}; done
while [[ $bl =~ ^[[:digit:]] ]]; do bl=${bl:1}; done
local ai=${a%$al} bi=${b%$bl}
local ap=${ai//[[:digit:]]} bp=${bi//[[:digit:]]}
ap=${ap//./.0} bp=${bp//./.0}
local w=1 fmt=$a.$b x IFS=.
for x in $fmt; do [ ${#x} -gt $w ] && w=${#x}; done
fmt=${*//[^.]}; fmt=${fmt//./%${w}s}
printf -v a $fmt $ai$bp; printf -v a "%s-%${w}s" $a $al
printf -v b $fmt $bi$ap; printf -v b "%s-%${w}s" $b $bl
case $op in
'<='|'>=' ) [ "$a" ${op:0:1} "$b" ] || [ "$a" = "$b" ] ;;
* )         [ "$a" $op "$b" ] ;;
esac
}

Code Expliqué

Ligne 1: Définir des variables locales:

• a, op, b - comparaison des opérandes et l'opérateur, c'est à dire, "3.6" > "3.5" une.
• al, bl - lettre de queues de a et b, initialisé à la queue de l'élément, c'est à dire, "6" et "5a".

Les lignes 2, 3: à Gauche-garniture chiffres de la queue, des articles ainsi que des lettres sont de gauche, le cas échéant, c'est à dire, "" et "un".

Ligne 4: Droit de la garniture de lettres de a et b quitter la séquence numérique des éléments comme des variables locales ai et bi, c'est à dire, "3.6" et "3.5".
Exemple Notable: "4.01-RC2" > "4.01-RC1" les rendements de l'ia="4.01" al="-RC2" et bi="4.01" bl="-RC1".

Ligne 6: Définir des variables locales:

• ap, bp - de zéro à droite-rembourrages pour ai et bi. Commencez par garder l'inter-élément de points, dont le nombre est égal au nombre d'éléments de a et b respectivement.

Ligne 7: Puis ajouter "0" après chaque point de faire de rembourrage masques.

Ligne 9: variables Locales:

• w - largeur de l'objet
• fmt - format de printf, pour être calculé
• x - temporaire
• Avec IFS=. bash divise les valeurs de la variable à '.'.

Ligne 10: Calculer w, le maximum de la largeur de l'objet, qui sera utilisé pour aligner les éléments de comparaison lexicographique. Dans notre exemple, w=2.

Ligne 11: Créer le printf alignement format en remplaçant chaque caractère de $a.$b avec %${w}s, c'est à dire, "3.6" > "3.5 un" produit "%2s%2s%2s%2s".

Ligne 12: "printf v un" définit la valeur de la variable a. C'est l'équivalent de a=sprintf(...) dans de nombreux langages de programmation. Soulignons ici que, par l'effet de la FI=. les arguments de printf divisé en éléments individuels.

Avec la première printf éléments de a sont à gauche-collier avec des espaces tout assez "0" des éléments sont ajoutés à la fin de bp pour s'assurer que la chaîne résultante a peuvent être utilement comparé à un formatées de la même manière b.

Noter que nous append bp - pas ap à ai parce que ap et bp peuvent avoir des durées différentes, de sorte que cette résultats dans a et b ayant des longueurs égales.

Avec la deuxième printf on ajoute la lettre partie al à a avec rembourrage suffisant pour permettre une comparaison significative. Maintenant a est prêt pour la comparaison avec b.

Ligne 13: la Même que pour la ligne 12, mais pour b.

Ligne 15: Split comparaison entre non-intégré (<= et >=) et intégré dans les opérateurs.

Ligne 16: Si l'opérateur de comparaison est <= puis testez pour a<b or a=b - respectivement >= a<b or a=b

Ligne 17: Test intégré des opérateurs de comparaison.

<>

# All tests
function P { printf "$@"; }
function EXPECT { printf "$@"; }
function CODE { awk $BASH_LINENO'==NR{print " "$2,$3,$4}' "$0"; }
P 'Note: ++ (true) and __ (false) mean that V works correctly.\n'
V 2.5    '!='  2.5      && P + || P _; EXPECT _; CODE
V 2.5    '='   2.5      && P + || P _; EXPECT +; CODE
V 2.5    '=='  2.5      && P + || P _; EXPECT +; CODE
V 2.5a   '=='  2.5b     && P + || P _; EXPECT _; CODE
V 2.5a   '<'   2.5b     && P + || P _; EXPECT +; CODE
V 2.5a   '>'   2.5b     && P + || P _; EXPECT _; CODE
V 2.5b   '>'   2.5a     && P + || P _; EXPECT +; CODE
V 2.5b   '<'   2.5a     && P + || P _; EXPECT _; CODE
V 3.5    '<'   3.5b     && P + || P _; EXPECT +; CODE
V 3.5    '>'   3.5b     && P + || P _; EXPECT _; CODE
V 3.5b   '>'   3.5      && P + || P _; EXPECT +; CODE
V 3.5b   '<'   3.5      && P + || P _; EXPECT _; CODE
V 3.6    '<'   3.5b     && P + || P _; EXPECT _; CODE
V 3.6    '>'   3.5b     && P + || P _; EXPECT +; CODE
V 3.5b   '<'   3.6      && P + || P _; EXPECT +; CODE
V 3.5b   '>'   3.6      && P + || P _; EXPECT _; CODE
V 2.5.7  '<='  2.5.6    && P + || P _; EXPECT _; CODE
V 2.4.10 '<'   2.4.9    && P + || P _; EXPECT _; CODE
V 2.4.10 '<'   2.5.9    && P + || P _; EXPECT +; CODE
V 3.4.10 '<'   2.5.9    && P + || P _; EXPECT _; CODE
V 2.4.8  '>'   2.4.10   && P + || P _; EXPECT _; CODE
V 2.5.6  '<='  2.5.6    && P + || P _; EXPECT +; CODE
V 2.5.6  '>='  2.5.6    && P + || P _; EXPECT +; CODE
V 3.0    '<'   3.0.3    && P + || P _; EXPECT +; CODE
V 3.0002 '<'   3.0003.3 && P + || P _; EXPECT +; CODE
V 3.0002 '>'   3.0003.3 && P + || P _; EXPECT _; CODE
V 3.0003.3 '<' 3.0002   && P + || P _; EXPECT _; CODE
V 3.0003.3 '>' 3.0002   && P + || P _; EXPECT +; CODE
V 4.0-RC2 '>' 4.0-RC1   && P + || P _; EXPECT +; CODE
V 4.0-RC2 '<' 4.0-RC1   && P + || P _; EXPECT _; CODE

Voici un autre pur bash solution sans appels externes:

#!/bin/bash
function version_compare {
IFS='.' read -ra ver1 <<< "$1"
IFS='.' read -ra ver2 <<< "$2"
[[ ${#ver1[@]} -gt ${#ver2[@]} ]] && till=${#ver1[@]} || till=${#ver2[@]}
for ((i=0; i<${till}; i++)); do
local num1; local num2;
[[ -z ${ver1[i]} ]] && num1=0 || num1=${ver1[i]}
[[ -z ${ver2[i]} ]] && num2=0 || num2=${ver2[i]}
if [[ $num1 -gt $num2 ]]; then
echo ">"; return 0
elif
[[ $num1 -lt $num2 ]]; then
echo "<"; return 0
fi
done
echo "="; return 0
}
echo "${1} $(version_compare "${1}" "${2}") ${2}"

Et il est encore plus simple solution, si vous êtes sûr que les versions en question ne contiennent pas de zéros après le premier point:

#!/bin/bash
function version_compare {
local ver1=${1//.}
local ver2=${2//.}
if [[ $ver1 -gt $ver2 ]]; then
echo ">"; return 0
elif    
[[ $ver1 -lt $ver2 ]]; then
echo "<"; return 0
fi 
echo "="; return 0
}
echo "${1} $(version_compare "${1}" "${2}") ${2}"

Cela fonctionne pour quelque chose comme 1.2.3 vs 1.3.1 vs 0.9.7, mais ne fonctionne pas avec
1.2.3 vs 1.2.3.0 ou 1.01.1 vs 1.1.1

J'ai mis en place encore un autre comparateur de fonction. Celui-ci avait deux exigences: (i) je ne voulais pas la fonction pour échouer en utilisant return 1 mais echo à la place; (ii) que nous récupérons des versions à partir d'un dépôt git version "1.0" doit être plus grand que "1.0.2", ce qui signifie que "1.0" vient de tronc.

function version_compare {
IFS="." read -a v_a <<< "$1"
IFS="." read -a v_b <<< "$2"
while [[ -n "$v_a" || -n "$v_b" ]]; do
[[ -z "$v_a" || "$v_a" -gt "$v_b" ]] && echo 1 && return
[[ -z "$v_b" || "$v_b" -gt "$v_a" ]] && echo -1 && return
v_a=("${v_a[@]:1}")
v_b=("${v_b[@]:1}")
done
echo 0
}

N'hésitez pas à commenter et suggérer des améliorations.

Je suis venu à travers et résolu ce problème, ajouter un autre (et plus court et plus simple) de réponse...

Première note, étendu shell comparaison a échoué comme vous le savez peut-être déjà...

    if [[ 1.2.0 < 1.12.12 ]]; then echo true; else echo false; fi
false

À l'aide de la tri -t'.'-g (ou tri -V tel que mentionné par kanaka) pour commander des versions et bash simple comparaison de chaînes de caractères, j'ai trouvé une solution. Le fichier d'entrée contient des versions dans les colonnes 3 et 4 qui je veux comparer. Ce parcourt la liste de l'identification d'un match, ou si l'un est plus grand que l'autre. Espérons que cela peut toujours aider ceux qui cherchent à le faire à l'aide de bash aussi simple que possible.

while read l
do
#Field 3 contains version on left to compare (change -f3 to required column).
kf=$(echo $l | cut -d ' ' -f3)
#Field 4 contains version on right to compare (change -f4 to required column).
mp=$(echo $l | cut -d ' ' -f4)
echo 'kf = '$kf
echo 'mp = '$mp
#To compare versions m.m.m the two can be listed and sorted with a . separator and the greater version found.
gv=$(echo -e $kf'\n'$mp | sort -t'.' -g | tail -n 1)
if [ $kf = $mp ]; then 
echo 'Match Found: '$l
elif [ $kf = $gv ]; then
echo 'Karaf feature file version is greater '$l
elif [ $mp = $gv ]; then
echo 'Maven pom file version is greater '$l
else
echo 'Comparison error '$l
fi
done < features_and_pom_versions.tmp.txt

Grâce à Barry blog pour le genre d'idée...
ref: http://bkhome.org/blog/?viewDetailed=02199

Comment à ce sujet? Semble fonctionner?

checkVersion() {
subVer1=$1
subVer2=$2
[ "$subVer1" == "$subVer2" ] && echo "Version is same"
echo "Version 1 is $subVer1"
testVer1=$subVer1
echo "Test version 1 is $testVer1"
x=0
while [[ $testVer1 != "" ]]
do
((x++))
testVer1=`echo $subVer1|cut -d "." -f $x`
echo "testVer1 now is $testVer1"
testVer2=`echo $subVer2|cut -d "." -f $x`
echo "testVer2 now is $testVer2"
if [[ $testVer1 -gt $testVer2 ]]
then
echo "$ver1 is greater than $ver2"
break
elif [[ "$testVer2" -gt "$testVer1" ]]
then
echo "$ver2 is greater than $ver1"
break
fi
echo "This is the sub verion for first value $testVer1"
echo "This is the sub verion for second value $testVer2"
done
}
ver1=$1
ver2=$2
checkVersion "$ver1" "$ver2"

Voici un autre pur bash version, nettement plus petite que la accepté de répondre. Il vérifie uniquement si une version est inférieure ou égale à une "version", et il va vérifier alphanumérique séquences de manière lexicographique, qui donne souvent de mauvais résultat ("snapshot" n'est pas plus tard que la "libération", pour donner un exemple courant). Il fonctionne parfaitement pour la majeur/mineur.

is_number() {
case "$BASH_VERSION" in
3.1.*)
PATTERN='\^\[0-9\]+\$'
;;
*)
PATTERN='^[0-9]+$'
;;
esac
[[ "$1" =~ $PATTERN ]]
}
min_version() {
if [[ $# != 2 ]]
then
echo "Usage: min_version current minimum"
return
fi
A="${1%%.*}"
B="${2%%.*}"
if [[ "$A" != "$1" && "$B" != "$2" && "$A" == "$B" ]]
then
min_version "${1#*.}" "${2#*.}"
else
if is_number "$A" && is_number "$B"
then
[[ "$A" -ge "$B" ]]
else
[[ ! "$A" < "$B" ]]
fi
fi
}

Ici est un pur Bash solution qui prend en charge les révisions (par exemple, '1.0-r1'), basé sur la réponse postée par Dennis Williamson. Il peut facilement être modifié pour prendre en charge des trucs comme "- RC1 " ou de l'extrait de la version à partir d'une chaîne plus complexes, par modification de l'expression régulière.

Pour plus de détails concernant la mise en œuvre, veuillez vous référer aux commentaires de code et/ou activer le inclus le code de débogage:

#!/bin/bash
# Compare two version strings [$1: version string 1 (v1), $2: version string 2 (v2)]
# Return values:
#   0: v1 == v2
#   1: v1 > v2
#   2: v1 < v2
# Based on: https://stackoverflow.com/a/4025065 by Dennis Williamson
function compare_versions() {
# Trivial v1 == v2 test based on string comparison
[[ "$1" == "$2" ]] && return 0
# Local variables
local regex="^(.*)-r([0-9]*)$" va1=() vr1=0 va2=() vr2=0 len i IFS="."
# Split version strings into arrays, extract trailing revisions
if [[ "$1" =~ ${regex} ]]; then
va1=(${BASH_REMATCH[1]})
[[ -n "${BASH_REMATCH[2]}" ]] && vr1=${BASH_REMATCH[2]}
else
va1=($1)
fi
if [[ "$2" =~ ${regex} ]]; then
va2=(${BASH_REMATCH[1]})
[[ -n "${BASH_REMATCH[2]}" ]] && vr2=${BASH_REMATCH[2]}
else
va2=($2)
fi
# Bring va1 and va2 to same length by filling empty fields with zeros
(( ${#va1[@]} > ${#va2[@]} )) && len=${#va1[@]} || len=${#va2[@]}
for ((i=0; i < len; ++i)); do
[[ -z "${va1[i]}" ]] && va1[i]="0"
[[ -z "${va2[i]}" ]] && va2[i]="0"
done
# Append revisions, increment length
va1+=($vr1)
va2+=($vr2)
len=$((len+1))
# *** DEBUG ***
#echo "TEST: '${va1[@]} (?) ${va2[@]}'"
# Compare version elements, check if v1 > v2 or v1 < v2
for ((i=0; i < len; ++i)); do
if (( 10#${va1[i]} > 10#${va2[i]} )); then
return 1
elif (( 10#${va1[i]} < 10#${va2[i]} )); then
return 2
fi
done
# All elements are equal, thus v1 == v2
return 0
}
# Test compare_versions [$1: version string 1, $2: version string 2, $3: expected result]
function test_compare_versions() {
local op
compare_versions "$1" "$2"
case $? in
0) op="==" ;;
1) op=">" ;;
2) op="<" ;;
esac
if [[ "$op" == "$3" ]]; then
echo -e "\e[1;32mPASS: '$1 $op $2'\e[0m"
else
echo -e "\e[1;31mFAIL: '$1 $3 $2' (result: '$1 $op $2')\e[0m"
fi
}
echo -e "\nThe following tests should pass:"
while read -r test; do
test_compare_versions $test
done << EOF
1            1            ==
2.1          2.2          <
3.0.4.10     3.0.4.2      >
4.08         4.08.01      <
3.2.1.9.8144 3.2          >
3.2          3.2.1.9.8144 <
1.2          2.1          <
2.1          1.2          >
5.6.7        5.6.7        ==
1.01.1       1.1.1        ==
1.1.1        1.01.1       ==
1            1.0          ==
1.0          1            ==
1.0.2.0      1.0.2        ==
1..0         1.0          ==
1.0          1..0         ==
1.0-r1       1.0-r3       <
1.0-r9       2.0          <
3.0-r15      3.0-r9       >
...-r1       ...-r2       <
2.0-r1       1.9.8.21-r2  >
1.0          3.8.9.32-r   <
-r           -r3          <
-r3          -r           >
-r3          -r3          ==
-r           -r           ==
0.0-r2       0.0.0.0-r2   ==
1.0.0.0-r2   1.0-r2       ==
0.0.0.1-r7   -r9          >
0.0-r0       0            ==
1.002.0-r6   1.2.0-r7     <
001.001-r2   1.1-r2       ==
5.6.1-r0     5.6.1        ==
EOF
echo -e "\nThe following tests should fail:"
while read -r test; do
test_compare_versions $test
done << EOF
1            1            >
3.0.5-r5     3..5-r5      >
4.9.21-r3    4.8.22-r9    <
1.0-r        1.0-r1       ==
-r           1.0-r        >
-r1          0.0-r1       <
-r2          0-r2         <
EOF
echo -e "\nThe following line should be empty (local variables test):"
echo "$op $regex $va1 $vr1 $va2 $vr2 $len $i $IFS"