Bir dize nasıl bölünür ve değişkenlere atanır

Python'da bir dizeyi bölmek ve değişkenlere atamak mümkündür:

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

ama Go'da işe yaramıyor gibi görünüyor:

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

Soru: Bir dize nasıl bölünür ve bir adımda değerler atanır?

İki adım, örneğin,

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

Çıktı:

127.0.0.1 5432

Örneğin bir adım,

package main

import (
    "fmt"
    "net"
)

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

Çıktı:

127.0.0.1 5432 <nil>

Yana goesnek bir olduğunu kendi oluşturabilirsiniz pythonstil bölme ...

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
}

Gibi alanlar için IPv6 adresleri RemoteAddrgelen http.Requestolarak biçimlendirilir "[:: 1]: 53.343"

Harika net.SplitHostPortçalışıyor:

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

Çıktı:

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

İşte dizelerin tanımı.

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

Bir dizeyi bölmenin birden çok yolu vardır:

1. Geçici yapmak istiyorsanız, şu şekilde bölün:

_

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. Yapıya göre bölün:

   • Bir yapı oluşturun ve böyle bölün

_

type ServerDetail struct {
    Host       string
    Port       string
    err        error
}

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

Şimdi kodunuzu kullanın ServerDetail.HostveServerDetail.Port

Belirli bir dizeyi bölmek istemiyorsanız şu şekilde yapın:

type ServerDetail struct {
    Host       string
    Port       string
}

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

ve benzeri kullanmak ServerDetail.Hostve ServerDetail.Port.

Bu kadar.

Yaptığınız şey, iki farklı değişkente bölünmüş yanıtı kabul etmektir ve strings.Split () yalnızca bir yanıt döndürüyor ve bu bir dize dizisidir. bunu tek bir değişkene depolamanız gerekir ve sonra dizinin dizin değerini getirerek dizenin bir kısmını çıkarabilirsiniz.

misal :

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

Yan not olarak, dizeyi Go'ya bölerken ayırıcılar ekleyebilirsiniz. Bunu yapmak için, strings.SplitAfteraşağıdaki örnekte olduğu gibi kullanın .

package main

import (
    "fmt"
    "strings"
)

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

Golang, bir dilimin örtülü olarak açılmasını desteklemez (python'dan farklı olarak) ve bu nedenle işe yaramaz. Yukarıda verilen örnekler gibi, bunun da çözümü gerekir.

Bir not:

Örtük açma, hareket halindeki değişken işlevler için gerçekleşir:

func varParamFunc(params ...int) {

}

varParamFunc(slice1...)

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