我想将字符串xxxxx：yyyyy：zzz.aaa.bbb.cc：dd：ee：ff解析为Golang中的结构，如何使用多个定界符"："和"。"来实现。

我想将字符串" xxxxx：yyyyy：zzz.aaa.bbb.cc：dd"拆分为以下结构类型

1
2
3
4
5
6
7
8
9
type Target struct {
    Service string
    Type    string
    Domain  string
    Plan    string
    Host    string
    Region  string
    Other   string
}

以便

1
2
3
4
5
6
7
Service = xxxxx
Type = yyyyy
Domain = zzzz
Plan = aaa
Host = bbb
Region = cc
Other = dd
  • 请举一个更完整的例子。 这实际上与任何其他语言相同，但是没有看到要分配给它的内容，无法完全回答您的问题。 基本的事情是，一方面分裂，另一方面分裂。
  • 抱歉，我想将字符串" xxxxx：yyyyy：zzz.aaa.bbb.cc：dd"拆分为以下结构类型示例Struct {服务字符串类型字符串域字符串计划字符串主机字符串区域字符串其他字符串}这样的服务 = xxxxx类型= yyyyy域= zzzz计划= aaa主机= bbb区域= cc其他= dd

您可以使用

1
strings.FieldsFunc(input, Split)

在The Go Playground上尝试一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package main

import (
   "fmt"
   "strings"
)

func main() {
    input := `xxxxx:yyyyy:zzz.aaa.bbb.cc:dd:ee:ff`
    a := strings.FieldsFunc(input, Split)
    t := Target{a[0], a[1], a[2], a[3], a[4], a[5], a[6]}
    fmt.Println(t) // {xxxxx yyyyy zzz aaa bbb cc dd}
}
func Split(r rune) bool {
    return r == ':' || r == '.'
}

type Target struct {
    Service string
    Type    string
    Domain  string
    Plan    string
    Host    string
    Region  string
    Other   string
}

输出：

1
{xxxxx yyyyy zzz aaa bbb cc dd}

您可以使用正则表达式分割字符串

1
2
3
4
5
6
import"regexp"

func splitWord(word string) []string {
    array := regexp.MustCompile("[\\\\:\\\\,\\\\.\\\\s]+").Split(word, -1)
    return array
}

您可以使用此函数，该函数可以将字符串分成多个符文：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import"fmt"
import"strings"

func SplitAny(s string, seps string) []string {
    splitter := func(r rune) bool {
        return strings.ContainsRune(seps, r)
    }
    return strings.FieldsFunc(s, splitter)
}

func main() {
    words := SplitAny("xxxxx:yyyyy:zzz.aaa.bbb.cc:dd:ee:ff",".:")
    fmt.Println(strings.Join(words,""))
}

输出：

1
xxxxx yyyyy zzz aaa bbb cc dd ee ff

甚至只用一行代码：

1
words := strings.FieldsFunc(s, func(r rune) bool { return strings.ContainsRune(" .:", r) })

这是一个通用函数，它将字符串作为一组符文分割。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
func Splitter(s string, splits string) []string {
    m := make(map[rune]int)
    for _, r := range splits {
        m[r] = 1
    }

    splitter := func(r rune) bool {
        return m[r] == 1
    }

    return strings.FieldsFunc(s, splitter)
}

func TestSplit() {
    words := Splitter("orange apple-banana"," -")
}

好的。 这不是一个非常优雅的解决方案，但它至少应该可以帮助您入门并适合您所给出的特定示例。 实际上，您可能想要添加一些错误处理或稍微推广一下逻辑，以使用更广泛的输入。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
type Target struct {
    Service string
    Type string
    Domain string
    Plan string
    Host string
    Region string
    Other string
}

func main() {
    input := `xxxxx:yyyyy:zzz.aaa.bbb.cc:dd:ee:ff`
    t := Target{}
    tokens := strings.Split(input,":")
    t.Service = tokens[0]
    t.Type = tokens[1]
    subtokens := strings.Split(tokens[2],".")
    t.Domain = subtokens[0]
    t.Plan = subtokens[1]
    t.Host = subtokens[2]
    t.Region = subtokens[3]
    t.Other = tokens[3]
    fmt.Printf("%v", t)
}

这里的工作示例；
https://play.golang.org/p/57ZyOfdbvo

  • 只是为他输入了sudo代码。 不想用丑陋的代码回答这个问题，这是一个可以自己学习的宝贵经验。
  • @NathanHyland是的，可能有点太包容了。 值得庆幸的是，有向下投票功能可以帮助平衡情况：)