Voici le numéro de version du logiciel:
"1.0", "1.0.1", "2.0", "2.0.0.1", "2.0.1"
Comment puis-je comparer cela? Supposons que l'ordre correct est:
"1.0", "1.0.1", "2.0", "2.0.0.1", "2.0.1"
L'idée est simple ...: Lisez le premier chiffre, puis le deuxième, après le troisième .... Mais je ne peux pas convertir le numéro de version en numéro flottant .... Vous pouvez également voir le numéro de version comme ce:
"1.0.0.0", "1.0.1.0", "2.0.0.0", "2.0.0.1", "2.0.1.0"
et c'est plus clair pour voir quelle est l'idée derrière ... Mais, comment le convertir en programme informatique ?? Quelqu'un a-t-il une idée sur la façon de trier cela? Je vous remercie.
javascript
sorting
Tattat
la source
la source
Réponses:
L'idée de base pour faire cette comparaison serait d'utiliser
Array.split
pour obtenir des tableaux de parties à partir des chaînes d'entrée, puis de comparer des paires de parties des deux tableaux; si les parties ne sont pas égales, nous savons quelle version est la plus petite.Il y a quelques détails importants à garder à l'esprit:
Voici le code d'une implémentation que vous pouvez utiliser directement (l' essentiel avec la documentation ):
Cette version compare les parties naturellement , n'accepte pas les suffixes de caractères et considère que "1.7" est plus petit que "1.7.0". Le mode de comparaison peut être changé en lexicographique et les chaînes de version plus courtes peuvent être automatiquement complétées à zéro en utilisant le troisième argument facultatif.
Il existe un JSFiddle qui exécute des "tests unitaires" ici ; c'est une version légèrement développée du travail de ripper234 (merci).
Remarque importante: ce code utilise
Array.map
etArray.every
, ce qui signifie qu'il ne fonctionnera pas dans les versions IE antérieures à 9. Si vous devez prendre en charge ceux-ci, vous devrez fournir des polyfills pour les méthodes manquantes.la source
semver
L'analyseur de version sémantique utilisé par npm.
$ npm installer semver
Lien de versionnage sémantique :
https://www.npmjs.com/package/semver#prerelease-identifiers
la source
la source
var len = Math.min(a_components.length, b_components.length);
les versions 2.0.1.1 et 2.0.1 seront-elles traitées comme égales?a = '7'
etb = '7.0'
retour-1
car 7.0 est plus long. Vous avez une suggestion pour ça? (console.log(compare("7", "7.0")); //returns -1
)Cette fonction de comparaison très petite, mais très rapide, prend des numéros de version de toute longueur et de toute taille de nombre par segment .
Valeurs renvoyées:
- un nombre
< 0
si a <b- un nombre
> 0
si a> b-
0
si a = bVous pouvez donc l'utiliser comme fonction de comparaison pour Array.sort ();
EDIT: Version corrigée en supprimant les zéros de fin pour reconnaître "1" et "1.0.0" comme égaux
la source
["0.0.0", "0.0", "0.4.1", "0.5", "1.0.0", "1", "1.1", "1.2.15", "1.25.4", "2", "2.5.0", "2.5.10", "2.5.10.4159", "10.5"]
où votre code sort["0.0", "0.0.0", "0.4.1", "0.5", "1", "1.0.0", "1.1", "1.2.15", "1.25.4", "2", "2.5.0", "2.5.10", "2.5.10.4159", "10.5"]
, ce qui est parfaitement le même, puisque 0.0 et 0.0.0 sont considérés comme égaux , ce qui signifie qu'il est indifférent que «0.0» soit avant «0.0.0» ou vice versa.Tiré de http://java.com/js/deployJava.js :
la source
Impossible de trouver une fonction faisant ce que je voulais ici. Alors j'ai écrit le mien. C'est ma contribution. J'espère que quelqu'un le trouvera utile.
Avantages:
Gère les chaînes de version de longueur arbitraire. «1» ou «1.1.1.1.1».
Par défaut, chaque valeur est 0 si elle n'est pas spécifiée. Ce n'est pas parce qu'une chaîne est plus longue que c'est une version plus grande. ('1' doit être identique à '1.0' et '1.0.0.0'.)
Comparez les nombres et non les chaînes. («3» <«21» doit être vrai. Pas faux.)
Ne perdez pas de temps sur des comparaisons inutiles dans la boucle. (Comparaison pour ==)
Vous pouvez choisir votre propre comparateur.
Les inconvénients:
Mon code, similaire à la réponse acceptée par Jon :
Exemples :
la source
Fonction simple et courte:
Tests:
la source
Pardonnez-moi si cette idée a déjà été visitée dans un lien que je n'ai pas vu.
J'ai eu un certain succès avec la conversion des parties en une somme pondérée comme ceci:
Ce qui a rendu les comparaisons très faciles (comparer un double). Nos champs de version ne comportent jamais plus de 4 chiffres.
J'espère que cela aide quelqu'un, car les multiples conditions semblent un peu exagérées.
la source
Voici une autre version courte qui fonctionne avec n'importe quel nombre de sous-versions, des zéros remplis et des nombres pairs avec des lettres (1.0.0b3)
Production:
0 : a = b
1 : a> b
-1 : a <b
Afficher l'extrait de code
https://jsfiddle.net/vanowm/p7uvtbor/
la source
Réponse 2017:
Code le plus simple pour les navigateurs modernes:
L'idée ici est de comparer des nombres mais sous forme de chaîne. pour que la comparaison fonctionne, les deux chaînes doivent avoir la même longueur. alors:
"123" > "99"
devenir"123" > "099"
remplissage du nombre court "fixer" la comparaison
Ici, je remplis chaque partie avec des zéros à des longueurs de 10. puis utilisez simplement une simple chaîne de comparaison pour la réponse
Exemple :
la source
compareVersion2
ce qui se passe exactement?substring
place depadStart
pour une meilleure compatibilité ievar zeros = "0000000000"; '0.2.32'.split('.').map( s => zeros.substring(0, zeros.length-s.length) + s ).join('.')
vous donnera0000000000.0000000002.0000000032
:)Vérifiez la fonction
version_compare()
du projet php.js . C'est similaire à PHPversion_compare()
.Vous pouvez simplement l'utiliser comme ceci:
la source
Ma réponse moins verbeuse que la plupart des réponses ici
la source
Bien que cette question ait déjà beaucoup de réponses, chacun promeut sa propre solution de brasserie, alors que nous avons tout un écosystème de bibliothèques testées (au combat) pour cela.
Une recherche rapide sur NPM , GitHub , X nous donnera quelques belles bibliothèques, et je voudrais en parcourir quelques-unes:
semver-compare
est une excellente bibliothèque légère (~ 230B) particulièrement utile si vous voulez trier par numéro de version, comme le retourne la méthode exposée de la bibliothèque-1
,0
ou de1
manière appropriée.Le noyau de la lib:
compare-semver
est plutôt volumineux (~ 4,4 ko gzippé), mais permet de belles comparaisons uniques comme pour trouver le min / max d'une pile de versions ou pour savoir si la version fournie est unique ou inférieure à toute autre chose dans une collection de versions.compare-versions
est une autre petite bibliothèque (~ 630B gzippée) et suit bien les spécifications, ce qui signifie que vous pouvez comparer les versions avec des indicateurs alpha / bêta et même des caractères génériques (comme pour les versions mineures / correctives:1.0.x
ou1.0.*
)Le fait est qu'il n'est pas toujours nécessaire de copier-coller du code à partir de StackOverflow, si vous pouvez trouver des versions décentes testées (à l'unité) via le gestionnaire de packages de votre choix.
la source
J'ai été confronté à un problème similaire et j'avais déjà créé une solution pour cela. N'hésitez pas à l'essayer.
Il renvoie
0
pourequal
,1
si la version estgreater
et-1
si elle estless
la source
L'idée est de comparer deux versions et de savoir quelle est la plus grosse. Nous supprimons "." et nous comparons chaque position du vecteur avec l'autre.
la source
la source
La
replace()
fonction remplace uniquement la première occurrence de la chaîne. Alors, remplaçons le.
par,
. Ensuite, supprimez tout.
et refaites le,
to.
et analysez-le pour qu'il flotte.enfin, triez-le:
la source
Consultez ce billet de blog . Cette fonction fonctionne pour les numéros de version numériques.
la source
Si, par exemple, nous voulons vérifier si la version actuelle de jQuery est inférieure à 1.8,
parseFloat($.ui.version) < 1.8 )
donnerait un résultat erroné si la version est "1.10.1", puisque parseFloat ("1.10.1") retourne1.1
. Une comparaison de chaînes serait également erronée, car elle est"1.8" < "1.10"
évaluée àfalse
.Nous avons donc besoin d'un test comme celui-ci
La fonction suivante gère cela correctement:
Voici quelques exemples:
Voir ici pour un échantillon en direct et une suite de tests: http://jsfiddle.net/mar10/8KjvP/
la source
Voici une implémentation de coffeescript adaptée à une utilisation avec Array.sort inspirée par d'autres réponses ici:
la source
J'ai écrit un module de nœud pour trier les versions, vous pouvez le trouver ici: version-sort
Caractéristiques :
N'hésitez pas à ouvrir un problème si vous avez besoin d'une autre fonctionnalité.
la source
Cela fonctionne pour les versions numériques de toute longueur séparées par un point. Il renvoie true uniquement si myVersion est> = minimumVersion, en supposant que la version 1 est inférieure à 1.0, la version 1.1 est inférieure à 1.1.0 et ainsi de suite. Il devrait être assez simple d'ajouter des conditions supplémentaires telles que l'acceptation de nombres (simplement convertir en chaîne) et hexadécimal ou rendre le délimiteur dynamique (il suffit d'ajouter un paramètre de délimiteur puis de remplacer le "." Par le paramètre)
Voici quelques tests:
Sinon, voici une version récursive
la source
Je trouve le moyen le plus simple de les comparer, je ne sais pas si c'est ce que vous voulez. lorsque j'exécute sous le code dans la console, cela a du sens, et en utilisant la méthode sort (), je pourrais obtenir le tableau trié de la chaîne de versions. il est basé sur l'ordre alphabétique.
la source
Vous pouvez utiliser
String#localeCompare
avecoptions
la source
undefined
langue ci - dessus? Comment se fait-il que vous parveniez à poster ceci pendant que je lis les autres;)undefined
est la partie locale, n'est pas utilisée ici.ne pourriez-vous pas les convertir en nombres et ensuite trier après la taille? Ajouter des 0 à ceux des nombres de <4 de longueur
joué dans la console:
plus la version est grande, plus le nombre est grand. Edit: doit probablement être ajusté pour tenir compte des séries de versions plus grandes
la source
C'est un truc sympa. Si vous avez affaire à des valeurs numériques, entre une plage de valeurs spécifique, vous pouvez attribuer une valeur à chaque niveau de l'objet version. Par exemple, "plus grandValeur" est défini ici sur 0xFF, ce qui crée une sorte de regard très "IP" sur votre versioning.
Cela gère également la gestion des versions alphanumériques (ie 1.2a <1.2b)
la source
J'aime la version de @ mar10 , bien que de mon point de vue, il y ait un risque d'utilisation abusive (il semble que ce ne soit pas le cas si les versions sont compatibles avec le document de version sémantique , mais cela peut être le cas si un "numéro de build" est utilisé ):
Le problème ici est que les sous-numéros du numéro de version sont, dans certains cas, écrits avec des zéros de fin coupés (du moins comme je le vois récemment en utilisant un logiciel différent), ce qui est similaire à la partie rationnelle d'un nombre, donc:
Le premier (ou les deux premier et deuxième) sous-numéro de version, cependant, est toujours traité comme une valeur entière à laquelle il est en fait égal.
Si vous utilisez ce type de gestion des versions, vous pouvez modifier quelques lignes dans l'exemple:
Ainsi, chaque sous-nombre sauf le premier sera comparé comme un flottant, ainsi
09
et1
deviendra0.09
et en0.1
conséquence et comparé correctement de cette façon.2054
et3
deviendra0.2054
et0.3
.La version complète est donc (crédits à @ mar10 ):
PS Il est plus lent, mais aussi possible de penser à réutiliser la même fonction de comparaison en opérant le fait que la chaîne est en fait le tableau de caractères:
la source
J'ai fait ceci basé sur l'idée de Kons, et l'ai optimisé pour la version Java "1.7.0_45". C'est juste une fonction destinée à convertir une chaîne de version en float. Voici la fonction:
La chaîne "1.7.0_45" est convertie en 1.0070000450000001 et cela suffit pour une comparaison normale. Erreur expliquée ici: Comment gérer la précision des nombres à virgule flottante en JavaScript? . Si besoin de plus de 3 chiffres sur n'importe quelle pièce, vous pouvez changer le diviseur
Math.pow(10, i * 3);
.La sortie ressemblera à ceci:
la source
J'ai eu le même problème de comparaison de versions, mais avec des versions contenant peut-être n'importe quoi (ie: séparateurs qui n'étaient pas des points, extensions comme rc1, rc2 ...).
J'ai utilisé ceci, qui divise essentiellement les chaînes de version en nombres et non-nombres, et essaie de comparer en fonction du type.
Il y a quelques hypothèses ici pour certains cas, par exemple: "1.01" === "1.1", ou "1.8" <"1.71". Il ne parvient pas à gérer "1.0.0-rc.1" <"1.0.0", comme spécifié par Semantic versionning 2.0.0
la source
Le prétraitement des versions avant le tri signifie que parseInt n'est pas appelé plusieurs fois inutilement. En utilisant Array # map similaire à la suggestion de Michael Deal, voici un tri que j'utilise pour trouver la dernière version d'un semver standard en 3 parties:
la source