如何定义自定义字母顺序来比较和排序 Go 中的字符串？

从现在开始，努力学习吧！本文《如何定义自定义字母顺序来比较和排序 Go 中的字符串？》主要讲解了等等相关知识点，我会在golang学习网中持续更新相关的系列文章，欢迎大家关注并积极留言建议。下面就先一起来看一下本篇正文内容吧，希望能帮到你！

在将其标记为重复之前，请先阅读底部

我希望能够按字母顺序对字符串数组（或基于一个字符串值的结构切片）进行排序，但基于自定义字母表或 unicode 字母。

大多数时候，人们建议使用支持不同预定义语言环境/字母的整理器。 （请参阅 java 的答案），但是对于这些语言环境包中不可用的罕见语言/字母表该怎么办？

我想要使用的语言在 golangs 整理支持和可用的语言列表中不可用，因此我需要能够定义自定义字母表或顺序用于排序的 unicode 字符/符文。

其他人建议先将字符串翻译成英语/ascii 可排序字母表，然后再对其进行排序。这就是这个用 javascript 完成的解决方案或这个用 ruby 完成的解决方案中的类似问题所建议的。 但是肯定有一种更有效的方法可以用 go 来做到这一点。

是否可以在 go 中创建一个使用自定义字母/字符集的 collat​​or？这就是 func newfromtable 的用途吗？

看来我应该能够使用重新排序功能，但看起来这尚未在该语言中实现？源代码显示：

func Reorder(s ...string) Option {
    // TODO: need fractional weights to implement this.
    panic("TODO: implement")
}

如何在 go 中定义用于比较和排序字符串的自定义字母顺序？

解决方案

事先注意：

以下解决方案已被清理和优化，并在此处作为可重用库发布：github.com/icza/abcsort。

使用 abcsort，对字符串切片进行自定义排序（使用自定义字母表）非常简单：

sorter := abcsort.new("bac")

ss := []string{"abc", "bac", "cba", "ccc"}
sorter.strings(ss)
fmt.println(ss)

// output: [ccc bac abc cba]

按结构体字段之一对结构体切片进行自定义排序如下：

type person struct {
    name string
    age  int
}

ps := []person{{name: "alice", age: 21}, {name: "bob", age: 12}}
sorter.slice(ps, func(i int) string { return ps[i].name })
fmt.println(ps)

// output: [{bob 12} {alice 21}]

原答案如下：

我们可以实现使用自定义字母表的自定义排序。我们只需要创建适当的 less(i, j int) bool 函数，sort 包将完成剩下的工作。

问题是如何创建这样的 less() 函数？

让我们从定义自定义字母表开始。方便的方法是创建一个 string，其中包含自定义字母表中的字母，从最小到最大枚举（排序）。例如：

const alphabet = "bca"

让我们根据这个字母表创建一个地图，它将告诉我们自定义字母表中每个字母的重量或顺序：

var weights = map[rune]int{}

func init() {
    for i, r := range alphabet {
        weights[r] = i
    }
}

^{（注意：上述循环中的 i 是字节索引，而不是 rune 索引，但由于两者都是单调递增，因此两者都适合符文权重。）}

现在我们可以创建 less() 函数。为了获得“可接受的”性能，我们应该避免将输入 string 值转换为字节或符文切片。为此，我们可以从 utf8.DecodeRuneInString() 函数调用 help，该函数对 string 的第一个 rune 进行解码。

所以我们逐个符文进行比较。如果两个符文都是自定义字母表中的字母，我们可以使用它们的权重来告诉它们如何相互比较。如果至少有一个符文不是来自我们的自定义字母表，我们将回退到简单的数字符文比较。

如果 2 个输入字符串开头的 2 个符文相等，我们将继续处理每个输入字符串中的下一个符文。我们可以通过对输入字符串进行切片来执行此操作：对它们进行切片不会进行复制，它只是返回一个指向原始字符串数据的新字符串头。

好吧，现在让我们看看这个 less() 函数的实现：

func less(s1, s2 string) bool {
    for {
        switch e1, e2 := len(s1) == 0, len(s2) == 0; {
        case e1 && e2:
            return false // both empty, they are equal (not less)
        case !e1 && e2:
            return false // s1 not empty but s2 is: s1 is greater (not less)
        case e1 && !e2:
            return true // s1 empty but s2 is not: s1 is less
        }

        r1, size1 := utf8.decoderuneinstring(s1)
        r2, size2 := utf8.decoderuneinstring(s2)

        // check if both are custom, in which case we use custom order:
        custom := false
        if w1, ok1 := weights[r1]; ok1 {
            if w2, ok2 := weights[r2]; ok2 {
                custom = true
                if w1 != w2 {
                    return w1 < w2
                }
            }
        }
        if !custom {
            // fallback to numeric rune comparison:
            if r1 != r2 {
                return r1 < r2
            }
        }

        s1, s2 = s1[size1:], s2[size2:]
    }
}

让我们看看这个 less() 函数的一些简单测试：

pairs := [][2]string{
    {"b", "c"},
    {"c", "a"},
    {"b", "a"},
    {"a", "b"},
    {"bca", "bac"},
}
for _, pair := range pairs {
    fmt.printf("\"%s\" < \"%s\" ? %t\n", pair[0], pair[1], less(pair[0], pair[1]))
}

输出（在 Go Playground 上尝试）：

"b" < "c" ? true
"c" < "a" ? true
"b" < "a" ? true
"a" < "b" ? false
"bca" < "bac" ? true

现在让我们在实际排序中测试这个 less() 函数：

ss := []string{
    "abc",
    "abca",
    "abcb",
    "abcc",
    "bca",
    "cba",
    "bac",
}
sort.slice(ss, func(i int, j int) bool {
    return less(ss[i], ss[j])
})
fmt.println(ss)

输出（在 Go Playground 上尝试）：

[bca bac cba abc abcb abcc abca]

同样，如果性能对您很重要，您不应该使用 sort.Slice()，因为它必须在幕后使用反射，而是创建您自己的切片类型来实现 sort.Interface，并且在您的实现中，您可以告诉如何在不使用反射的情况下执行此操作使用反射。

它可能是这样的：

type custstrslice []string

func (c custstrslice) len() int           { return len(c) }
func (c custstrslice) less(i, j int) bool { return less(c[i], c[j]) }
func (c custstrslice) swap(i, j int)      { c[i], c[j] = c[j], c[i] }

当您想使用自定义字母表对字符串切片进行排序时，只需将切片转换为 custstrslice，这样它就可以直接传递给 sort.Sort()（此类型转换不会复制切片或其元素，它只是更改类型信息）：

ss := []string{
    "abc",
    "abca",
    "abcb",
    "abcc",
    "bca",
    "cba",
    "bac",
}
sort.sort(custstrslice(ss))
fmt.println(ss)

上面的输出再次（在 Go Playground 上尝试）：

[bca bac cba abc abcb abcc abca]

一些注意事项：

默认字符串比较按字节比较字符串。也就是说，如果输入字符串包含无效的 utf-8 序列，则仍将使用实际字节。

我们的解决方案在这方面有所不同，因为我们解码符文（我们必须这样做，因为我们使用自定义字母表，其中我们允许符文不一定映射到 utf-8 编码中的字节 1 到 1）。这意味着如果输入不是有效的 utf-8 序列，则行为可能与默认顺序不一致。但如果您的输入是有效的 utf-8 序列，这将执行您期望的操作。

最后一点：

我们已经了解了如何对字符串切片进行自定义排序。如果我们有一个结构体切片（或结构体指针切片），排序算法（less()函数）可能是相同的，但是在比较切片的元素时，我们必须比较元素的字段，不是结构元素本身。

假设我们有以下结构：

type person struct {
    name string
    age  int
}

func (p *person) string() string { return fmt.sprint(*p) }

^{（添加了 string() 方法，因此我们将看到结构的实际内容，而不仅仅是它们的地址...）}

假设我们要使用 person 元素的 name 字段对 []*person 类型的切片应用自定义排序。所以我们简单地定义这个自定义类型：

type personslice []*person

func (p personslice) len() int           { return len(p) }
func (p personslice) less(i, j int) bool { return less(p[i].name, p[j].name) }
func (p personslice) swap(i, j int)      { p[i], p[j] = p[j], p[i] }

仅此而已。其余的都是一样的，例如：

ps := []*person{
    {name: "abc"},
    {name: "abca"},
    {name: "abcb"},
    {name: "abcc"},
    {name: "bca"},
    {name: "cba"},
    {name: "bac"},
}
sort.sort(personslice(ps))
fmt.println(ps)

输出（在 Go Playground 上尝试）：

[{bca 0} {bac 0} {cba 0} {abc 0} {abcb 0} {abcc 0} {abca 0}]

使用 table_test.go [1] 作为起点，我得出以下结论。这 真正的工作是由 builder.add [2] 完成的：

package main

import (
   "golang.org/x/text/collate"
   "golang.org/x/text/collate/build"
)

type entry struct {
   r rune
   w int
}

func newcollator(ents []entry) (*collate.collator, error) {
   b := build.newbuilder()
   for _, ent := range ents {
      err := b.add([]rune{ent.r}, [][]int{{ent.w}}, nil)
      if err != nil { return nil, err }
   }
   t, err := b.build()
   if err != nil { return nil, err }
   return collate.newfromtable(t), nil
}

结果：

package main
import "fmt"

func main() {
   a := []entry{
      {'a', 3}, {'b', 2}, {'c', 1},
   }
   c, err := newCollator(a)
   if err != nil {
      panic(err)
   }
   x := []string{"alfa", "bravo", "charlie"}
   c.SortStrings(x)
   fmt.Println(x) // [charlie bravo alfa]
}

1. https://github.com/golang/text/blob/3115f89c/collate/table_test.go
2. https://pkg.go.dev/golang.org/x/text/collate/build#Builder.Add

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。