splitting version string until found

Sort of went down the rabbit hole on this one:

package main

import (
	"fmt"
)

type apps []app

type app struct {
	version string
}

type releases []release

type release struct {
	name     string
	platform string
}

func main() {

	var versions releases
	versions = append(versions, release{name: "apple", platform: "3.14.15"})
	versions = append(versions, release{name: "orange", platform: "3.14.15.13"})
	versions = append(versions, release{name: "pear", platform: "3.14.19"})

	var test apps
	test = append(test, app{version: "3.14.15.5.123.2"}) // should map to apple
	test = append(test, app{version: "3.14.15.13.123"})  // should map to orange
	test = append(test, app{version: "3.14.15.19.12"})   // should map to pear

	for _, r := range test {
		fmt.Printf("Version %s is called: %s\n", r.version, "?")
	}

}

I'm trying to achieve the following output:

Version 3.14.15.5.123.2 is called: apple
Version 3.14.15.13.123 is called: orange
Version 3.14.15.19.12 is called: pear

I was thinking some sort of string search, slice, search, slice loop until i could find a match? is there an easier way?

You have to find the longest prefix in the releases type. For this you can implement a func like this one:

package main

import (
	"fmt"
	"strings"
)

type apps []app

type app struct {
	version string
}

type releases []release

type release struct {
	name     string
	platform string
}

func (r releases) FindName(version string) string {
	result := ""
	max := 0
	for _, release := range r {
		if strings.HasPrefix(version, release.platform) {
			if max < len(release.platform) {
				max = len(release.platform)
				result = release.name
			}
		}
	}
	return result
}

func main() {

	var versions releases
	versions = append(versions, release{name: "apple", platform: "3.14.15"})
	versions = append(versions, release{name: "orange", platform: "3.14.15.13"})
	versions = append(versions, release{name: "pear", platform: "3.14.19"})

	var test apps
	test = append(test, app{version: "3.14.15.5.123.2"}) // should map to apple
	test = append(test, app{version: "3.14.15.13.123"})  // should map to orange
	test = append(test, app{version: "3.14.19.12"})      // should map to pear

	for _, r := range test {
		fmt.Printf("Version %s is called: %s\n", r.version, versions.FindName(r.version))
	}

}

If you need to make so many lookups, then you can build an index and search in it. This way a search would take optimally maximum O(n) where n is the length of the version you are searching.

package main
import (
"fmt"
"sort"
"strings"
)
type apps []app
type app struct {
version string
}
type releases []release
type release struct {
name     string
platform string
}
var index map[string]string
func BuildIndex(r releases) {
sort.Slice(r, func(i, j int) bool { return r[i].platform < r[j].platform })
index = make(map[string]string)
for _, release := range r {
s := ""
for _, rn := range release.platform {
s += string(rn)
if strings.HasSuffix(s, ".") {
continue
}
if _, found := index
展开收缩
; !found {
index
展开收缩
 = release.name
}
}
}
}
func FindInIndex(v string) string {
for {
if name, found := index[v]; found {
return name
}
v = v[:len(v)-1]
if v == "" {
break
}
}
return ""
}
func main() {
var versions releases
versions = append(versions, release{name: "apple", platform: "3.14.15"})
versions = append(versions, release{name: "orange", platform: "3.14.15.13"})
versions = append(versions, release{name: "pear", platform: "3.14.19"})
BuildIndex(versions)
var test apps
test = append(test, app{version: "3.14.15.5.123.2"}) // should map to apple
test = append(test, app{version: "3.14.15.13.123"})  // should map to orange
test = append(test, app{version: "3.14.19.12"})      // should map to pear
for _, r := range test {
fmt.Printf("Version %s is called: %s\n", r.version, FindInIndex(r.version))
}
}