如何拆分字符串并将其分配给变量

例如，两个步骤,

package main


import (
"fmt"
"strings"
)


func main() {
s := strings.Split("127.0.0.1:5432", ":")
ip, port := s[0], s[1]
fmt.Println(ip, port)
}

产出:

127.0.0.1 5432

例如，一个步骤,

package main


import (
"fmt"
"net"
)


func main() {
host, port, err := net.SplitHostPort("127.0.0.1:5432")
fmt.Println(host, port, err)
}

产出:

127.0.0.1 5432 <nil>

由于 go是灵活的，你可以创建自己的 python风格分裂..。

package main


import (
"fmt"
"strings"
"errors"
)


type PyString string


func main() {
var py PyString
py = "127.0.0.1:5432"
ip, port , err := py.Split(":")       // Python Style
fmt.Println(ip, port, err)
}


func (py PyString) Split(str string) ( string, string , error ) {
s := strings.Split(string(py), str)
if len(s) < 2 {
return "" , "", errors.New("Minimum match not found")
}
return s[0] , s[1] , nil
}

http.Request中 RemoteAddr等字段的 IPv6地址格式为“[ : : 1] : 53343”

因此，net.SplitHostPort运行得很好:

package main


import (
"fmt"
"net"
)


func main() {
host1, port, err := net.SplitHostPort("127.0.0.1:5432")
fmt.Println(host1, port, err)


host2, port, err := net.SplitHostPort("[::1]:2345")
fmt.Println(host2, port, err)


host3, port, err := net.SplitHostPort("localhost:1234")
fmt.Println(host3, port, err)
}

产出为:

127.0.0.1 5432 <nil>
::1 2345 <nil>
localhost 1234 <nil>

拆分字符串有多种方法:

1. 如果你想让它变成暂时的，那就像这样分开:

我不知道

import net package


host, port, err := net.SplitHostPort("0.0.0.1:8080")
if err != nil {
fmt.Println("Error is splitting : "+err.error());
//do you code here
}
fmt.Println(host, port)

2. 基于 struct 的拆分:

   • 创建一个 struct 并像这样拆分

我不知道

type ServerDetail struct {
Host       string
Port       string
err        error
}


ServerDetail = net.SplitHostPort("0.0.0.1:8080") //Specific for Host and Port

现在在你的代码中使用像 ServerDetail.Host和 ServerDetail.Port

如果你不想拆分特定的字符串，可以这样做:

type ServerDetail struct {
Host       string
Port       string
}


ServerDetail = strings.Split([Your_String], ":") // Common split method

像 ServerDetail.Host和 ServerDetail.Port一样使用。

仅此而已。

package main


import (
"fmt"
"strings"
)


func main() {
strs := strings.Split("127.0.0.1:5432", ":")
ip := strs[0]
port := strs[1]
fmt.Println(ip, port)
}

下面是字符串的定义

// Split slices s into all substrings separated by sep and returns a slice of
// the substrings between those separators.
//
// If s does not contain sep and sep is not empty, Split returns a
// slice of length 1 whose only element is s.
//
// If sep is empty, Split splits after each UTF-8 sequence. If both s
// and sep are empty, Split returns an empty slice.
//
// It is equivalent to SplitN with a count of -1.
func Split(s, sep string) []string { return genSplit(s, sep, 0, -1) }

你正在做的是，你正在接受两个不同的变量和字符串的分裂响应。Split ()只返回一个响应，即字符串数组。您需要将它存储到单个变量中，然后您可以通过获取数组的索引值来提取字符串的部分。

例如:

 var hostAndPort string
hostAndPort = "127.0.0.1:8080"
sArray := strings.Split(hostAndPort, ":")
fmt.Println("host : " + sArray[0])
fmt.Println("port : " + sArray[1])

Golang 不支持对一个切片进行隐式解包(不像 python) ，这就是为什么它不能工作的原因。像上面给出的例子一样，我们需要解决这个问题。

附注:

对 go 中的可变函数进行隐式解包:

func varParamFunc(params ...int) {


}


varParamFunc(slice1...)

另外，在 Go 中拆分字符串时可以包括分隔符。为此，请使用 strings.SplitAfter，如下面的示例所示。

package main


import (
"fmt"
"strings"
)


func main() {
fmt.Printf("%q\n", strings.SplitAfter("z,o,r,r,o", ","))
}

**In this function you can able to split the function by golang using array of strings**


func SplitCmdArguments(args []string) map[string]string {
m := make(map[string]string)
for _, v := range args {
strs := strings.Split(v, "=")
if len(strs) == 2 {
m[strs[0]] = strs[1]
} else {
log.Println("not proper arguments", strs)
}
}
return m
}