जाओ प्रकार अभिकथन रूपांतरण

Question

मैं इस तरह एक float64 के लिए एक पूर्णांक में बदल सकते हैं:

var a int = 10 
var b float64 = float64(a) 

के साथ दावे टाइप करने के लिए संबंध है

, प्रभावी जाओ राज्यों: 'प्रकार या तो ठोस प्रकार इंटरफ़ेस के पास होने चाहिए, या दूसरा इंटरफ़ेस प्रकार जो मान को परिवर्तित किया जा सकता है। '

इसे ध्यान में रखते

, क्यों निम्नलिखित है असफल:

func foo(a interface{}) { 
    fmt.Println(a.(float64)) 
} 

func main() { 
    var a int = 10 
    foo(a) 
} 

यह एक panic: interface conversion: interface is int, not float64 कारण बनता है।

ध्यान दें कि जाओ युक्ति का कहना है:

'इंटरफ़ेस प्रकार की एक्स एक अभिव्यक्ति है और एक प्रकार टी, प्राथमिक अभिव्यक्ति

x.(T) 

के लिए दावा है कि एक्स शून्य नहीं है और कहा कि मूल्य में संग्रहीत एक्स प्रकार टी है।

जो प्रभावी गो स्टेटमेंट का विरोध करता है लेकिन जो कुछ मैं देखता हूं उसके अनुरूप अधिक लगता है।

Answer 1

This sentence प्रभावी गो में वास्तव में भ्रमित लग रहा है। ऐसा लगता है कि लेखक उस समय structs के बारे में सोच रहा था।

The chapter on assertions in the specification बहुत स्पष्ट है:।,

एक अभिव्यक्ति के लिए इंटरफ़ेस प्रकार और एक प्रकार टी की एक्स प्राथमिक अभिव्यक्ति

एक्स (टी) का दावा है कि एक्स शून्य नहीं है और कहा कि मूल्य एक्स में संग्रहीत प्रकार टी है। नोटेशन एक्स। (टी) को एक प्रकार का दावा कहा जाता है।

दरअसल, अगर टी एक अंतरफलक प्रकार, एक्स नहीं है। (टी) का दावा है कि एक्स के गतिशील प्रकार प्रकार टी इस मामले में के समान है, टी को लागू करना चाहिए एक्स के (इंटरफेस) प्रकार ; अन्यथा प्रकार का दावा अमान्य है क्योंकि x के प्रकार के मूल्य को स्टोर करने के लिए x संभव नहीं है।टी एक इंटरफ़ेस प्रकार है, x। (टी) का दावा है कि गतिशील प्रकार x इंटरफ़ेस को लागू करता है T.

तथ्य you can convert your int to a float (और रिवर्स) का मतलब यह नहीं है कि आप दावा कर सकते हैं कि वे एक ही प्रकार के हैं।

Answer 2

प्रकार या तो ठोस इंटरफेस द्वारा आयोजित प्रकार, या एक दूसरे इंटरफ़ेस प्रकार है कि मूल्य

में बदला जा सकता हो यह मूलतः बताते चाहिए following:

package main 

import "fmt" 

type Stringer interface { 
    String() 
} 

type Byter interface { 
    Bytes() 
} 

type Stringbyter interface { 
    Stringer 
    Byter 
} 

type Polymorphic float64 

func (p *Polymorphic) String() {} 

func (p *Polymorphic) Bytes() {} 

func main() { 
    i := interface{}(new(Polymorphic)) 
    if _, ok := i.(Stringer); ok { 
     fmt.Println("i can be asserted to Stringer") 
    } 
    if _, ok := i.(Byter); ok { 
     fmt.Println("i can be asserted to Byter") 
    } 
    if _, ok := i.(Stringbyter); ok { 
     fmt.Println("i can be asserted to Stringbyter") 
    } 
    if _, ok := i.(*Polymorphic); ok { 
     fmt.Println("i can be asserted to *Polymorphic") 
    } 
    if _, ok := i.(int); ok { 
     fmt.Println("i can be asserted to int") // Never runs 
    } 
} 

int पर दावा विफल रहता है क्योंकि यह कंक्रीट प्रकार (इंटरफ़ेस प्रकार के विपरीत) wh है ich *Polymorphic स्वयं नहीं है।

Answer 3

आप केवल इंटरफ़ेस प्रकार से अंतर्निहित प्रकार पर जोर दे सकते हैं।इस मामले में int। फिर आप int से float64