如何在golang中比较两个版本号字符串

Question

如何在golang中比较两个版本号字符串

29

我有两个字符串（它们实际上是版本号，可以是任何版本号）

a := "1.05.00.0156"  
b := "1.0.221.9289"

我想比较哪个更大。在golang中该怎么做？

- JVK

13个回答

13

前段时间我创建了一个版本比较库：https://github.com/mcuadros/go-version

version.CompareSimple("1.05.00.0156", "1.0.221.9289")
//Returns: 1

享受它！

- mcuadros

太棒了，谢谢！请在未来十年内不要从GitHub上删除它:D - Harald Nordgren

请注意，该库现在是只读的，并且没有积极维护（但似乎仍然可以工作）。 - Karel Bílek

11

这里提供一个通用解决方案。

package main

import "fmt"

func VersionOrdinal(version string) string {
    // ISO/IEC 14651:2011
    const maxByte = 1<<8 - 1
    vo := make([]byte, 0, len(version)+8)
    j := -1
    for i := 0; i < len(version); i++ {
        b := version[i]
        if '0' > b || b > '9' {
            vo = append(vo, b)
            j = -1
            continue
        }
        if j == -1 {
            vo = append(vo, 0x00)
            j = len(vo) - 1
        }
        if vo[j] == 1 && vo[j+1] == '0' {
            vo[j+1] = b
            continue
        }
        if vo[j]+1 > maxByte {
            panic("VersionOrdinal: invalid version")
        }
        vo = append(vo, b)
        vo[j]++
    }
    return string(vo)
}

func main() {
    versions := []struct{ a, b string }{
        {"1.05.00.0156", "1.0.221.9289"},
        // Go versions
        {"1", "1.0.1"},
        {"1.0.1", "1.0.2"},
        {"1.0.2", "1.0.3"},
        {"1.0.3", "1.1"},
        {"1.1", "1.1.1"},
        {"1.1.1", "1.1.2"},
        {"1.1.2", "1.2"},
    }
    for _, version := range versions {
        a, b := VersionOrdinal(version.a), VersionOrdinal(version.b)
        switch {
        case a > b:
            fmt.Println(version.a, ">", version.b)
        case a < b:
            fmt.Println(version.a, "<", version.b)
        case a == b:
            fmt.Println(version.a, "=", version.b)
        }
    }
}

输出：

1.05.00.0156 > 1.0.221.9289
1 < 1.0.1
1.0.1 < 1.0.2
1.0.2 < 1.0.3
1.0.3 < 1.1
1.1 < 1.1.1
1.1.1 < 1.1.2
1.1.2 < 1.2

- peterSO

你的所有测试用例都可以通过内置的strings.Compare(a, b)函数成功运行。因此，我想知道过去是否不是这种情况，或者还需要做什么额外的努力。 - Martin Niederl

4

go-semver 是一个 Go 语言的语义化版本控制库。它可以帮助您解析和比较两个语义化版本字符串。

例如：

vA := semver.New("1.2.3")
vB := semver.New("3.2.1")

fmt.Printf("%s < %s == %t\n", vA, vB, vA.LessThan(*vB))

输出为：

输出：

1.2.3 < 3.2.1 == 真

- btwiuse

4

以下是一些版本比较所使用的库：

我已经使用了 blang/semver 库。例如：https://play.golang.org/p/1zZvEjLSOAr。

 import github.com/blang/semver/v4
 
  v1, err := semver.Make("1.0.0-beta")
  v2, err := semver.Make("2.0.0-beta")
 
  // Options availabe
  v1.Compare(v2)  // Compare
  v1.LT(v2)       // LessThan
  v1.GT(v2)       // GreaterThan

- Sourabh Shinde

3

这取决于你所说的“更大”的具体含义。

一个天真的方法是：

package main

import "fmt"
import "strings"

func main() {
    a := strings.Split("1.05.00.0156", ".")
    b := strings.Split("1.0.221.9289", ".")
    for i, s := range a {
        var ai, bi int
        fmt.Sscanf(s, "%d", &ai)
        fmt.Sscanf(b[i], "%d", &bi)
        if ai > bi {
            fmt.Printf("%v is bigger than %v\n", a, b)
            break
        }
        if bi > ai {
            fmt.Printf("%v is bigger than %v\n", b, a)
            break
        }
    }
}

http://play.golang.org/p/j0MtFcn44Z

- Jeremy Wall

1

对于 a := strings.Split("1", "."); b := strings.Split("1.0.1", ".")，在最近的两个 Go 版本中，结果为 [no output]。 - peterSO

1

是的，就像我说的那样，这只是一个非常幼稚的版本。 - Jeremy Wall

2

根据Jeremy Wall的答案：

  func compareVer(a, b string) (ret int) {
            as := strings.Split(a, ".")
            bs := strings.Split(b, ".")
            loopMax := len(bs)
            if len(as) > len(bs) {
                    loopMax = len(as)
            }
            for i := 0; i < loopMax; i++ { 
                    var x, y string
                    if len(as) > i {
                            x = as[i]
                    }
                    if len(bs) > i {
                            y = bs[i]
                    }
                    xi,_ := strconv.Atoi(x)
                    yi,_ := strconv.Atoi(y)
                    if xi > yi {
                            ret = -1
                    } else if xi < yi {
                            ret = 1
                    }
                    if ret != 0 {
                            break
                    }
            }       
            return 
    }

http://play.golang.org/p/AetJqvFc3B

- fredestby

1

追求清晰简洁：

func intVer(v string) (int64, error) {
    sections := strings.Split(v, ".")
    intVerSection := func(v string, n int) string {
        if n < len(sections) {
            return fmt.Sprintf("%04s", sections[n])
        } else {
            return "0000"
        }
    }
    s := ""
    for i := 0; i < 4; i++ {
        s += intVerSection(v, i)
    }
    return strconv.ParseInt(s, 10, 64)
}

func main() {
    a := "3.045.98.0832"
    b := "087.2345"
    va, _ := intVer(a)
    vb, _ := intVer(b)
    fmt.Println(va<vb)
}

比较不同的版本需要解析，因此我认为这两个步骤应该分开进行，以使其更加稳健。

- Grzegorz Luczywo

1

在LeetCode上进行测试：https://leetcode.com/problems/compare-version-numbers/

func compareVersion(version1 string, version2 string) int {
    len1, len2, i, j := len(version1), len(version2), 0, 0
    for i < len1 || j < len2 {
        n1 := 0
        for i < len1 && '0' <= version1[i] && version1[i] <= '9' {
            n1 = n1 * 10 + int(version1[i] - '0')
            i++
        }
        n2 := 0
        for j < len2 && '0' <= version2[j] && version2[j] <= '9' {
            n2 = n2 * 10 + int(version2[j] - '0')
            j++
        }
        if n1 > n2 {
            return 1
        }
        if n1 < n2 {
            return -1
        }
        i, j = i+1, j+1
    }
    return 0
}

- GoInterface

0

import (
    "fmt"
    "strconv"
    "strings"
)


func main() {
    j := ll("1.05.00.0156"  ,"1.0.221.9289")
   fmt.Println(j)
}


func ll(a,b string) int {
    var length ,r,l int = 0,0,0
    v1 := strings.Split(a,".")
    v2 := strings.Split(b,".")
    len1, len2 := len(v1), len(v2)

    length = len2
    if len1 > len2 {
       length = len1
    }

    for i:= 0;i<length;i++ {
        if i < len1 && i < len2 {
            if v1[i] == v2[i] {
                continue
            }
        }
        r = 0
        if i < len1 {
            if number, err := strconv.Atoi(v1[i]); err == nil {
                r = number
            }
        }

        l = 0
        if i < len2 {
            if number, err := strconv.Atoi(v2[i]); err == nil {
                l = number
            }
        }

        if r < l {
            return -1
        }else if r> l {
            return 1
        }
    }

    return 0
}

- wyx

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- krab · Accepted Answer

Hashicorp提供了一个不错的解决方案 - https://github.com/hashicorp/go-version

import github.com/hashicorp/go-version
v1, err := version.NewVersion("1.2")
v2, err := version.NewVersion("1.5+metadata")
// Comparison example. There is also GreaterThan, Equal, and just
// a simple Compare that returns an int allowing easy >=, <=, etc.
if v1.LessThan(v2) {
    fmt.Printf("%s is less than %s", v1, v2)
}