如何在字符之间拆分字符串两个答案

【问题标题】：How to split string two between characters如何在字符之间拆分字符串两个
【发布时间】：2021-10-09 03:20:09
【问题描述】：

我想将一个字符串拆分为两个字符（{{ 和 }}）。

我有一个类似{{number1}} + {{number2}} > {{number3}}的字符串

我正在寻找可以返回的东西：

[number1, number2, number3]

【问题讨论】：

你试过什么？包括您的代码。你遇到了什么问题？

标签： string go split

【解决方案1】：

你可以用正则表达式试试：

s := "{{number1}} + {{number2}} > {{number3}}"

// Find all substrings in form {<var name>}
re := regexp.MustCompile("{[a-z]*[0-9]*[a-z]*}")
nums := re.FindAllString(s, -1)

// Remove '{' and '}' from all substrings
for i, _ := range nums {
    nums[i] = strings.TrimPrefix(nums[i], "{")
    nums[i] = strings.TrimSuffix(nums[i], "}")
}

fmt.Println(nums)  // output: [number1 number2 number3]

您可以在这里试验正则表达式：https://regex101.com/r/kkPWAS/1

【讨论】：

【解决方案2】：

使用正则表达式[A-Za-z]+[0-9] 并将字符串的字母数字部分过滤为字符串数组。

package main

import (
    "fmt"
    "regexp"
)

func main() {
    s := `{{number1}} + {{number2}} > {{number3}}`
    re := regexp.MustCompile("[A-Za-z]+[0-9]")
    p := re.FindAllString(s, -1)
    fmt.Println(p) //[number1 number2 number3]
}

【讨论】：

【解决方案3】：

模板解析器的难处^^

package main

import (
    "fmt"
    "strings"
    "text/template/parse"
)

func main() {

    input := "{{number1}} + {{number2}} > {{number3}}"
    out := parseit(input)
    fmt.Printf("%#v\n", out)
}

func parseit(input string) (out []string) {
    input = strings.Replace(input, "{{", "{{.", -1) // Force func calls to become variables.
    tree, err := parse.Parse("", input, "{{", "}}")
    if err != nil {
        panic(err)
    }
    visit(tree[""].Root, func(n parse.Node) bool {
        x, ok := n.(*parse.FieldNode)
        if ok {
            out = append(out, strings.Join(x.Ident, "."))
        }
        return true
    })
    return
}

func visit(n parse.Node, fn func(parse.Node) bool) bool {
    if n == nil {
        return true
    }
    if !fn(n) {
        return false
    }
    if l, ok := n.(*parse.ListNode); ok {
        for _, nn := range l.Nodes {
            if !visit(nn, fn) {
                continue
            }
        }
    }
    if l, ok := n.(*parse.RangeNode); ok {
        if !visit(l.BranchNode.Pipe, fn) {
            return false
        }
        if l.BranchNode.List != nil {
            if !visit(l.BranchNode.List, fn) {
                return false
            }
        }
        if l.BranchNode.ElseList != nil {
            if !visit(l.BranchNode.ElseList, fn) {
                return false
            }
        }
    }
    if l, ok := n.(*parse.ActionNode); ok {
        for _, c := range l.Pipe.Decl {
            if !visit(c, fn) {
                continue
            }
        }
        for _, c := range l.Pipe.Cmds {
            if !visit(c, fn) {
                continue
            }
        }
    }
    if l, ok := n.(*parse.CommandNode); ok {
        for _, a := range l.Args {
            if !visit(a, fn) {
                continue
            }
        }
    }
    if l, ok := n.(*parse.PipeNode); ok {
        for _, a := range l.Decl {
            if !visit(a, fn) {
                continue
            }
        }
        for _, a := range l.Cmds {
            if !visit(a, fn) {
                continue
            }
        }
    }
    return true
}

如果发生这种情况，您确实在操作模板字符串，但由于函数调用而未能这样做，并且您不想执行此input = strings.Replace(input, "{{", "{{.", -1) // Force func calls to become variables.

您始终可以使用类似于

的功能强制加载模板


var reMissingIdent = regexp.MustCompile(`template: :[0-9]+: function "([^"]+)" not defined`)

func ParseTextTemplateAnyway(s string) (*texttemplate.Template, texttemplate.FuncMap, error) {
    fn := texttemplate.FuncMap{}
    for {
        t, err := texttemplate.New("").Funcs(fn).Parse(s)
        if err == nil {
            return t, fn, err
        }
        s := err.Error()
        res := reMissingIdent.FindAllStringSubmatch(s, -1)
        if len(res) > 0 {
            fn[res[0][1]] = func(s ...interface{}) string { return "" }
        } else {
            return t, fn, err
        }
    }
    // return nil, nil
}

【讨论】：

【解决方案4】：

您不需要使用库。您可以创建自己的函数。

package main

const r1 = '{'
const r2 = '}'

func GetStrings(in string) (out []string) {
    var tren string
    wr := false
    f := true
    for _, c := range in {
        if wr && c != r2 {
            tren = tren + string(c)
        }
        if c == r1 {
            f = !f
            wr = f
        }
        if c == r2 {
            wr = false
            if f {
                out = append(out, tren)
                tren = ""
            }
            f = !f
        }
    }
    return
}

【讨论】：