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

在Python中，可以拆分字符串并将其分配给变量：

ip, port = '127.0.0.1:5432'.split(':')

但在Go中，它似乎不起作用：

ip, port := strings.Split("127.0.0.1:5432", ":")
// assignment count mismatch: 2 = 1

---

问题：如何在一个步骤中拆分字符串并赋值？

例如，两个步骤

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)
}

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

127.0.0.1 5432 <nil>

比如说一步,

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)
}

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

127.0.0.1 5432 <nil>

127.0.0.15432

由于

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
}

主程序包
进口(
“fmt”
“字符串”
“错误”
)
键入PyString字符串
func main（）{
var py PyString
py=“127.0.0.1:5432”
ip，端口，错误：=py.Split（“：”//Python样式
fmt.Println（ip、端口、错误）
}
func（py PyString）Split（str string）（string，string，error）{
s:=strings.Split（string（py），str）
如果len（s）<2{
返回“”，错误。新建（“未找到最小匹配项”）
}
返回s[0]，s[1]，零
}

来自

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>

127.0.0.15432
::1 2345 
本地主机1234

拆分字符串有多种方法：

如果要使其成为临时的，请按如下方式拆分：

_

基于结构的拆分：

• 创建一个结构并像这样拆分

_

现在在您的代码中使用

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)
}

下面是strings.Split的定义

// 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响应，strings.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", ","))
}

---

这会将字符串拆分为字符串列表，而不是字符列表。如果我们获得IPv6地址，会发生什么情况？@Pumpkinsed刚刚尝试过，我从

err

中得到了这个结果，不幸的是：

地址2001:0db8:85a3:0000:0000:8a2e:0370:7334中的冒号太多了：（@dopatraman你为什么这么说？这个问题是关于将一个字符串拆分成一个字符串列表的，不是吗？这与python的等价物有点不同。你如何制作一个可变返回计数版本？我喜欢Go，但我不会称之为灵活的：D
splittedString
：=
strings.Split（“127.0.1:5432”，“：”）
Ans:=
splittedString[index]
您可以访问splittedString的值这里有一个错误“/prog.go:12:17:undefined:str”结构表单不工作：
/prog.go:21:4:赋值不匹配：1个变量，但net.SplitHostPort返回3个值