如果字符串看起来像什么开始;提取;END;你可以使用的任何方法都可以得到介于两者之间的字符串：

// GetStringInBetween Returns empty string if no start string found
func GetStringInBetween(str string, start string, end string) (result string) {
    s := strings.Index(str, start)
    if s == -1 {
        return
    }
    s += len(start)
    e := strings.Index(str[s:], end)
    if e == -1 {
        return
    }
    e += s + e - 1
    return str[s:e]
}

这里所发生的是它将找到START的第一个索引，加上START字符串的长度，并返回从那里到END的第一个索引为止存在的所有内容。

在所有的编程语言中，有很多方法可以拆分字符串。
由于我不知道您特别要求的是什么，我提供了一个示例方法来从示例中获得您想要的输出。

package main

import "strings"
import "fmt"

func main() {
    initial := "<h1>Hello World!</h1>"

    out := strings.TrimLeft(strings.TrimRight(initial,"</h1>"),"<h1>")
    fmt.Println(out)
}

在上面的代码中，我们从字符串的左边修剪<h1>，从右边修剪</h1>。
正如我所说的，有数百种方法可以拆分特定的字符串，这只是一个示例。
希望对你有帮助，祝你和Golang好运：）
数据库

我改进了Jan Kardaš的答案。现在你可以找到在开始和结束处有多于1个字符的字符串。

func GetStringInBetweenTwoString(str string, startS string, endS string) (result string,found bool) {
    s := strings.Index(str, startS)
    if s == -1 {
        return result,false
    }
    newS := str[s+len(startS):]
    e := strings.Index(newS, endS)
    if e == -1 {
        return result,false
    }
    result = newS[:e]
    return result,true
}

下面是我使用正则表达式的答案。不知道为什么没有人建议这个最安全的方法

package main

import (
    "fmt"
        "regexp"
)

func main() {
    content := "<h1>Hello World!</h1>"
    re := regexp.MustCompile(`<h1>(.*)</h1>`)
    match := re.FindStringSubmatch(content)
    if len(match) > 1 {
        fmt.Println("match found -", match[1])
    } else {
        fmt.Println("match not found")
    }
    
}

Playground-https://play.golang.org/p/Yc61x1cbZOJ

在strings pkg中，您可以使用Replacer来产生巨大影响。

r := strings.NewReplacer("<h1>", "", "</h1>", "")
fmt.Println(r.Replace("<h1>Hello World!</h1>"))

开始play!

func findInString(str, start, end string) ([]byte, error) {
    var match []byte
    index := strings.Index(str, start)

    if index == -1 {
        return match, errors.New("Not found")
    }

    index += len(start)

    for {
        char := str[index]

        if strings.HasPrefix(str[index:index+len(match)], end) {
            break
        }

        match = append(match, char)
        index++
    }

    return match, nil
}

读一读strings包，看看SplitAfter函数能做什么：

var sample = "[this][is my][string]"
t := strings.SplitAfter(sample, "[")

这将生成如下所示的切片："[", "this][", "is my][", "string]"。使用进一步的函数修剪你应该得到你的解决方案。祝你好运。

func Split(str, before, after string) string {
    a := strings.SplitAfterN(str, before, 2)
    b := strings.SplitAfterN(a[len(a)-1], after, 2)
    if 1 == len(b) {
        return b[0]
    }
    return b[0][0:len(b[0])-len(after)]
}

SplitAfterN的第一次调用将原始字符串拆分为2个部分的数组除以第一个找到的after字符串，或者它将生成包含等于原始字符串的1个部分的数组。
SplitAfterN的第二次调用使用a[len(a)-1]作为输入，因为它是“数组a的最后一项“。因此，after之后的字符串或原始字符串str。输入将被拆分为2个部分的数组，除以第一个找到的before字符串，或者它将产生包含等于输入的1个部分的数组。
如果没有找到after，那么我们可以简单地返回b[0]，因为它等于a[len(a)-1]
如果找到after，它将包含在b[0]字符串的末尾，因此您必须通过b[0][0:len(b[0])-len(after)]对其进行修剪
所有字符串都区分大小写

不如这样：

func SplitBetween(str, bef, aft string) string {
    sa := strings.SplitN(str, bef, 2)
    if len(sa) == 1 {
        return ""
    }
    sa = strings.SplitN(sa[1], aft, 2)
    if len(sa) == 1 {
        return ""
    }
    return sa[0]
}

如果未找到拆分，则返回空字符串。