एक स्ट्रिंग को कैसे विभाजित करें और इसे चर को कैसे निर्दिष्ट करें

Question

पायथन में एक स्ट्रिंग को विभाजित करना और इसे चर को सौंपना संभव है:

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

लेकिन गो में यह काम नहीं लगता:

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

प्रश्न: एक स्ट्रिंग को कैसे विभाजित करें और एक चरण में मान असाइन करें?

Comments

splittedString: = strings.Split("127.0.0.1:5432", ":")उत्तर: = splittedString[index]आप

— मोहित

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

आउटपुट:

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>

Comments

यह एक स्ट्रिंग को स्ट्रिंग की सूची में विभाजित करता है, पात्रों की सूची में नहीं।

— डोपाट्रमन

यदि हमें IPv6 पता मिल जाए तो क्या होगा?

— कद्दू सईद

@PumpkinSeed ने अभी इसे आज़माया है, और मुझे यह वापस मिल गया है err, दुर्भाग्य से: too many colons in address 2001:0db8:85a3:0000:0000:8a2e:0370:7334:(

— जेएम जेनज़ेन

Answer 2

चूंकि 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
}

Comments

यह अजगर समकक्ष से थोड़ा अलग है। आप एक चर-रिटर्न-काउंट संस्करण कैसे बनाएंगे?

— ग्रोक्स

मुझे अच्छा लगता है, लेकिन मैं इस लचीली बात को नहीं कहूंगा : D

— Pijusn

Answer 3

IPv6 जैसे क्षेत्रों के लिए पता करता RemoteAddrहैhttp.Request इस प्रारूप में उपलब्ध कर रहे हैं "[:: 1]: 53,343"

तो 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>

Answer 4

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

Comments

यहाँ एक त्रुटि है "./prog.go:12:17: अपरिभाषित: str"

— अंशु

Answer 5

स्ट्रिंग को विभाजित करने के कई तरीके हैं:

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. विभाजन पर आधारित संरचना:

   • एक संरचना बनाएं और इस तरह विभाजित करें

_

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 ।

बस इतना ही।

Comments

संरचना रूप काम नहीं करता है:./prog.go:21:4: assignment mismatch: 1 variable but net.SplitHostPort returns 3 values

— ई। एंडरसन

Answer 6

आप जो कर रहे हैं, आप दो अलग-अलग वेरिएबल्स में स्प्लिट रेस्पॉन्स स्वीकार कर रहे हैं, और स्ट्रिंग्स .plit () केवल एक रिस्पॉन्स लौटा रहा है और वह एक स्ट्रिंग ऑफ अरेंजमेंट है। आपको इसे एकल चर में संग्रहीत करने की आवश्यकता है और फिर आप किसी सरणी के इंडेक्स मूल्य को प्राप्त करके स्ट्रिंग का हिस्सा निकाल सकते हैं।

उदाहरण :

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

Answer 7

साइड नोट के रूप में, आप गो में स्ट्रिंग को विभाजित करते हुए विभाजकों को शामिल कर सकते हैं। ऐसा करने के लिए, strings.SplitAfterनीचे दिए गए उदाहरण में उपयोग करें।

package main

import (
    "fmt"
    "strings"
)

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

Answer 8

गोलंग एक टुकड़ा (अजगर के विपरीत) के अनपैकिंग का समर्थन नहीं करता है और यही कारण है कि यह काम नहीं करेगा। ऊपर दिए गए उदाहरणों की तरह, हमें इसे हल करने की आवश्यकता होगी।

एक तरफ ध्यान दें:

निहित अनपैकिंग में परिवर्तनशील कार्यों के लिए होता है:

func varParamFunc(params ...int) {

}

varParamFunc(slice1...)