总结了golang中结构体， 字符串 ，各种int类型的相互转换方式

 //string转成int：
int, err := strconv.Atoi(string)
//string转成int64：
int64, err := strconv.ParseInt(string, 10, 64)
//int转成string：
string := strconv.Itoa(int)
//int64转成string：
string := strconv.FormatInt(int64,10)  

总结了golang中结构体， map 转 byte 之间的相互转换方式

 map1 := make(map[string]interface{})
 map1["1"] = "hello"
 map1["2"] = "world"
 // map to []byte
 str, err := json.Marshal(map1)
 if err != nil {
 fmt.Println(err)
 }
 // byte to map
 map2 := make(map[string]interface{})
 err = json.Unmarshal(str, &map2)
 if err != nil {
 fmt.Println(err)
 }
 fmt.Println("json to map ", map2)
 fmt.Println("The value of key1 is", map2["1"])  

float, bool 和 string 之间的相互转换方式

 s := strconv.FormatBool(true)
fmt.Println(reflect.TypeOf(s)) //string
fmt.Println(s) //true
a, _ := strconv.ParseBool(s)
fmt.Println(reflect.TypeOf(a)) //bool
fmt.Println(a) //true
s1 := strconv.FormatFloat(13.1415, 'E', -1, 64)
fmt.Println(reflect.TypeOf(s1)) //string
fmt.Println(s1) //1.31415E+01
s2, _ := strconv.ParseFloat(s1,64)
fmt.Println(reflect. Type Of(s2)) //float64
fmt.Println(s2) //13.1415  

断言

类型断言被用于检查接口类型变量所持有的值是否实现了期望的接口或者具体的类型。

类型断言的语法定义如下：

PrimaryExpression.(Type)

PrimaryExpression 可以在 Go 语言规范 中找到，并且它可以是标识符，特定索引的数组元素，切片等等。

Type 既可以是类型标识符，也可以是类型字面量，比如：

 type I interface {
   walk()
   quack()
}

type S  struct {}

func (s S) walk() {}
func (s S) quack() {}

var i I
i = S{}
fmt.Println(i.(interface {
    walk()
}))
PrimaryExpression 必须是接口类型，否则就会产生一个编译时错误：
type I interface{
   walk()
  quack()
}

type S struct{}  

S{}.(I) // 无效类型断言：S{}.(I)(操作符左边的 S 并不是个接口类型)

动态类型

变量除了有静态类型外（变量声明中的类型），接口变量还有动态类型。就是在当前接口类型变量中设置的一种类型的值。在程序执行的过程当中，接口类型的变量具有相同的静态类型，但是其动态类型会随着其实现的接口不同，而其值也会随之改变。

 type I interface {
walk()
}

type A struct{}

func (a A) walk() {}

type B struct{}

func (b B) walk() {}

func main() {
var i I
i = A{} // i 的动态类型是 A
fmt.Printf("%T\n", i.(A))
i = B{} // i 的动态类型是 B
fmt.Printf("%T\n", i.(B))
}  

接口类型

如果 T 来自 v.(T) 是一个接口类型，这样的断言检查，可以用来检测 v 的动态类型是否实现了接口 T：

 type I interfacce {
    walk()
}

type J interface {
   quack()
}

type K interface {
   bark()
}

type S struc{}

func (s S) walk() {}

func (s S) quack() {}

func main() {
var i I
i = S{}
  fmt.Printf("%T\n", i.(J))
  fmt.Printf("%T\n", i.(K)) // panic: 接口转换: main.S 不是 main.K: 缺少方法 bark
}  

非接口类型

如果 T 来自 v.(T) 不是接口类型，这样断言检查动态类型 v 是否与 T 类型相同：

 type I interface {
  walk()
}

type A struct{}

func (a A) walk() {}

type B struct{}

func (b B) walk() {}

func main() {
var i I
i = A{}
   fmt.Printf("%T\n", i.(A))
   fmt.Printf("%T\n", i.(B)) // panic: 接口转换: main.I 是 main.A, 不是 main.B
}  

在非接口类型情况下进行类型传递就必须实现接口 I，如果不满足这个要求的话就会在编译时被捕获：

 type C struct{}
fmt.Prinf("%T\n", i.(C))  

输出：

impossible type assertion: C does not implement I (missing walk method)

不要 panic

在上述情况下，当断言不能成立时，运行时 panic 将会被触发。为了优雅的处理错误，这里有特殊的形式来赋值或者初始化：

 type I interface {
   walk()
}
type A struct {
   name string
}
func (a A) walk() {}
type B struct {
   name string
}
func (b B) walk() {}
func main() {
var i I
i = A{name: "foo"}
valA, okA := i.(A)
  fmt.Printf("%#v %#v\n", valA, okA)
valB, okB := i.(B)
   fmt.Printf("%#v %#v\n", valB, okB)
}
输出：
main.A{name:"foo"} true
main.B{name:""} false  

当断言不成立时，第一个值将会作为测试类型的零值

总结 ：在使用GO语言时候，总会遇到类型转换，各种场景下的转换，GO存在4中类型转换分别是断言，强制，隐式，显式。