So teilen Sie eine Zeichenfolge und weisen sie Variablen zu

In Python ist es möglich, einen String zu teilen und ihn Variablen zuzuweisen:

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

aber in Go scheint es nicht zu funktionieren:

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

Frage: Wie kann man eine Zeichenfolge teilen und Werte in einem Schritt zuweisen?

Zwei Schritte zum Beispiel:

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

Ausgabe:

127.0.0.1 5432

Ein Schritt zum Beispiel:

package main

import (
    "fmt"
    "net"
)

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

Ausgabe:

127.0.0.1 5432 <nil>

Da goist flexibel und Sie können Ihren eigenen pythonStil Split erstellen ...

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
}

Die IPv6-Adressen für Felder wie RemoteAddrfrom http.Requestsind wie folgt formatiert: "[:: 1]: 53343"

Funktioniert also net.SplitHostPortsuper:

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

Ausgabe ist:

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

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

Hier ist die Definition für 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) }

Es gibt mehrere Möglichkeiten, eine Zeichenfolge zu teilen:

1. Wenn Sie es vorübergehend machen möchten, teilen Sie es wie folgt auf:

_

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. Aufteilung basierend auf Struktur:

   • Erstellen Sie eine Struktur und teilen Sie diese auf

_

type ServerDetail struct {
    Host       string
    Port       string
    err        error
}

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

Verwenden Sie jetzt in Ihrem Code wie ServerDetail.HostundServerDetail.Port

Wenn Sie eine bestimmte Zeichenfolge nicht teilen möchten, gehen Sie folgendermaßen vor:

type ServerDetail struct {
    Host       string
    Port       string
}

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

und benutze wie ServerDetail.Hostund ServerDetail.Port.

Das ist alles.

Was Sie tun, ist, dass Sie eine geteilte Antwort in zwei verschiedene Variablen und Zeichenfolgen akzeptieren. Split () gibt nur eine Antwort zurück und das ist ein Array von Zeichenfolgen. Sie müssen es in einer einzelnen Variablen speichern und können dann den Teil der Zeichenfolge extrahieren, indem Sie den Indexwert eines Arrays abrufen.

Beispiel:

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

Als Randnotiz können Sie die Trennzeichen einfügen, während Sie die Zeichenfolge in Go teilen. Verwenden Sie dazu strings.SplitAfterwie im folgenden Beispiel.

package main

import (
    "fmt"
    "strings"
)

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

Golang unterstützt das implizite Entpacken eines Slice nicht (im Gegensatz zu Python) und das ist der Grund, warum dies nicht funktionieren würde. Wie in den oben angegebenen Beispielen müssten wir es umgehen.

Eine Randnotiz:

Das implizite Entpacken erfolgt für verschiedene Funktionen in go:

func varParamFunc(params ...int) {

}

varParamFunc(slice1...)