गो

Question

में एकाधिक रिटर्न मानों पर रूपांतरण/प्रकार का दावा करने का बेवकूफ तरीका गो में एकाधिक रिटर्न मान डालने का बेवकूफ तरीका क्या है?

क्या आप इसे एक ही पंक्ति में कर सकते हैं, या आपको नीचे दिए गए उदाहरण में अस्थायी चर का उपयोग करने की आवश्यकता है?

package main 

import "fmt" 

func oneRet() interface{} { 
    return "Hello" 
} 

func twoRet() (interface{}, error) { 
    return "Hejsan", nil 
} 

func main() { 
    // With one return value, you can simply do this 
    str1 := oneRet().(string) 
    fmt.Println("String 1: " + str1) 

    // It is not as easy with two return values 
    //str2, err := twoRet().(string) // Not possible 
    // Do I really have to use a temp variable instead? 
    temp, err := twoRet() 
    str2 := temp.(string) 
    fmt.Println("String 2: " + str2) 


    if err != nil { 
     panic("unreachable") 
    } 
} 

वैसे, यह casting कहा जाता है जब यह इंटरफेस के लिए आता है?

i := interface.(int) 

Answer 1

आप इसे एक ही पंक्ति में नहीं कर सकते हैं। आपका अस्थायी परिवर्तनीय दृष्टिकोण जाने का तरीका है।

वैसे, क्या यह इंटरफेस की बात आती है जब इसे कास्टिंग कहा जाता है?

इसे वास्तव में type assertion कहा जाता है। एक प्रकार डाली रूपांतरण अलग है:

var a int 
var b int64 

a = 5 
b = int64(a) 

Answer 2

template.Must एक बयान में केवल पहले वापसी मान लौटने के लिए मानक पुस्तकालय का दृष्टिकोण है। आपके मामले के लिए इसी तरह किया जा सकता है:

func must(v interface{}, err error) interface{} { 
    if err != nil { 
     panic(err) 
    } 
    return v 
} 

// Usage: 
str2 := must(twoRet()).(string) 

must का उपयोग कर आप मूल रूप से कहना है कि उसमें कोई त्रुटि हो कभी नहीं करना चाहिए, और अगर वहाँ है, तो कार्यक्रम नहीं (या कम से कम नहीं होना चाहिए) ऑपरेटिंग रख सकते तक , और बदले में घबराएगा।

Answer 3

func silly() (interface{}, error) { 
    return "silly", nil 
} 

v, err := silly() 
if err != nil { 
    // handle error 
} 

s, ok := v.(string) 
if !ok { 
    // the assertion failed. 
} 

लेकिन अधिक होने की संभावना क्या आप वास्तव में चाहते हैं की तरह एक यह एक प्रकार स्विच का उपयोग करने के लिए, यह है:

switch t := v.(type) { 
case string: 
    // t is a string 
case int : 
    // t is an int 
default: 
    // t is some other type that we didn't name. 
} 

जाओ शुद्धता के बारे में वास्तव में एक से अधिक यह terseness के बारे में है।

Answer 4

या बस एक ही है, तो में: कलाकारों का ख्याल

if v, ok := value.(migrater); ok { 
    v.migrate() 
} 

जाओ लगेगा अगर खंड के अंदर और आप casted प्रकार के गुणों का उपयोग करते हैं।