浅谈Go类型转换之间的那些事

var s string = "AB"
fmt.Println(reflect.TypeOf(s[0]))
for _, v := range s {
   fmt.Println(reflect.TypeOf(v))
}

var v interface{} = 1
var s uint8 = 1

temp1 := int(s)
temp2 := v.(int)

fmt.Println(temp1,temp2)

uint8(byte) uint16 uint32 uint64 int int8 int16 int32(rune) int64 bool string
float32 float64 complex64 complex128

//也是命名类型
type MyBool bool

slice map chan function interface struct pointer

type MyInt int
func CustomType() {
   var i MyInt = 2
   var j int = 1
   j = i
   i = j
   fmt.Println(i == j)
}

//输出MyInt int
fmt.Println(reflect.TypeOf(i), reflect.TypeOf(j))
//输出int int
fmt.Println(reflect.TypeOf(i).Kind(), reflect.TypeOf(j).Kind())

type MyM struct {
   i int64
}
type MyN struct {
   j int32
}
func TestStruct() {
   n := MyN{j: 10}
   var m MyM
   m = MyM(n)
  fmt.Println(n,m)
}

type MyInt int
type I MyInt
type Ints []int
type MyInts []MyInt
type M map[string]string
type CustomM M

reflect.TypeOf(variable).Kind()

// byte is an alias for uint8 and is equivalent to uint8 in all ways. It is
// used, by convention, to distinguish byte values from 8-bit unsigned
// integer values.
type byte = uint8

// rune is an alias for int32 and is equivalent to int32 in all ways. It is
// used, by convention, to distinguish character values from integer values.
type rune = int32

var r rune = 'c'
var b byte = 1
fmt.Println(reflect.TypeOf(r).Kind()) //int32
fmt.Println(reflect.TypeOf(b).Kind()) //uint8

//相比定义一个类型多了一个=号
type alaisInt64 = int64

//这个转换时类型不同，也不兼容，所以编译报错
s := "ab"
i := int(s)

//这个转换类型不同，但兼容，所以OK
var j int8 = 1
m := int(j)

//这个转换是失败的，系统会检测到类型不匹配，直接panic
var k interface{} = "s"
l := k.(int)
//但我们可以通过一个参数来判断,只有f为true时，才会转换成功
l,f := k.(int)
//这个转换是成功的
p,f := k.(string)

//这个转换没有任何问题，都OK
var i int8 = 123
var j int16 = int16(i)
//这个转换会丢失精度，从高位转低位
var m int64 = 128
var n int8 = int8(m) //n的结果是-128，因为int8能表达的最大值是127，最小值是-128，

var s1,s2 string = "AbcD","1234"
//转字节
bs1 := []byte(s1); bs2 := []byte(s2)

//字节数组转字符串
s11 := string(bs1); s22 := string(bs2)
//单个字节转字符串
ss := string(bs1[0])
fmt.Println(s11, s22, ss)

//s2转数字 ,err 表示是否能转换成功，比如s1就会转换失败
i, err := strconv.Atoi(s2)
//数字转字符串
s := strconv.Itoa(i)

//字符串转字符数组
runes := []rune(s1)

//字符数组转字符串
ss1 := string(runes)
//单个字符转字符串
ss2 := strconv.QuoteRune(runes[0])

//字符转字节
bss := make([]byte, 0)
bss = strconv.AppendQuoteRune(bss, runes[0])
fmt.Println(err, s, ss1, ss2, runes[0], bss, string(bss))
//除开rune和byte底层的类型的区别，在使用上，
//rune能处理一切的字符，而byte仅仅局限在ascii

//整形转字节
x := int32(68)
bytesBuffer := bytes.NewBuffer([]byte{})
binary.Write(bytesBuffer, binary.BigEndian, x)
//字节转整形
var y int32
binary.Read(bytesBuffer, binary.BigEndian, &y)

//由接口类型转换为具体的类型
var i interface{} = 1
t, f := i.(int)
if f { //转换成功
   fmt.Println(t)
} else {//转换失败
   fmt.Println(reflect.TypeOf(i).Kind(), reflect.TypeOf(i))
}