03 Go 元素：基本数据类型、变量、常量及类型转换

• int //根据系统，32系统就是int32,64位系统就int64
• int8 // [-128,127]
• int16 //[-32768,32767]
• int32 //[-2147483648,2147483647]
• int64 //[-9223372036854775808,9223372036854775807]

• uint //与rune互为别名，
• uint8 //[0,255]
• uint16 //[0,65535]
• uint32 //[0,4294967295]
• uint64 //[0,18446744073709551615]

-uintptr //一个可以恰好容纳指针值的无符号整数类型（32系统为uint32，64位系统为uint64）

• fload32
• fload64

• complex64
• complex128

• bool

• rune //字符类型，uint32别名，go默认用utf8编码，最长utf8编码的字符为4字节，所以采用无符号位的unit32表示字符, (rune == uint32 == [4]byte == 32Bit)
• string //字符串类型，默认utf8编码通常与字节切片互转[]byte

• byte //这种类型在go编程中很常见，其官方包很多数值传输都使用字节切片[]byte

如没声明类型，go会自动识别：

    //整型
	var v1 = 123

	//浮点型
	var v2 = 3.14

	//字符
	var v3 = '我'

	//字符串
	var v4 = "我是fun"

	//布尔值
	var v5 = false

	//格式化打印
	fmt.Printf("v1变量的类型为%T,值为%v\n", v1, v1)
	fmt.Printf("v1变量的类型为%T,值为%v\n", v2, v2)

	fmt.Printf("v1变量的类型为%T,字符序号为%v，字符为%c，十六进制为%x ，二进制位%b\n ", v3, v3, v3, v3, v3)

	fmt.Printf("v1变量的类型为%T,值为%v\n", v4, v4)
	fmt.Printf("v1变量的类型为%T,值为%v\n", v5, v5)
	
	//Output:
	//v1变量的类型为int,值为123
    //v2变量的类型为float64,值为3.14
    //v3变量的类型为int32,字符序号为25105，字符为我，十六进制为6211 ，二进制位110001000010001
    //v4变量的类型为string,值为我是fun
    //v5变量的类型为bool,值为false

与其他语言不同，Go的类型声明是后置的

var a int64  //变量类型声明
var b fload64 = 3.14 //变量预赋值
c := “aaa” //未声明变量使用冒等自动类型赋值
a = 2 //已声明变量可直接等号赋值

var a,b int32 //一次声明两个同类型变量
var c,d int32 = 4,5 //一次声明两个同类型变量并赋值

e,f := "aaa",123 //冒等一次赋值两变量，可不同类型


//可将var提取出来
var (
    a int64
    b string
)

    //声明常量
	const PI = 3.14

	//声明多个常量
	const (
		LightSpeed  = 30 * 10000
		earthCircle = 40000
	)
	
    //使用iota定义常量
    const (
    	MONDAY = iota + 1
    	/*自动延用排头兵的表达式，但iota逐一递增*/
    	TUESDAY
    	WEDNESDAy
    	THURSDAY
    	FRIDAY
    	SATURDAY
    	SUNDAY
    )
    
    const (
    	USA = (iota + 1) * 1000
    	CHINA
    	RUSSIA
    	BRITAIN
    	FRANCE 
    )
    
    fmt.Println(MONDAY, TUESDAY, WEDNESDAy, THURSDAY, FRIDAY, SATURDAY, SUNDAY)
	fmt.Println(USA, CHINA, RUSSIA, BRITAIN, FRANCE)

    
    Output:
    1 2 3 4 5 6 7
    1000 2000 3000 4000 5000

//这种写法可以让值为整数类型，但打印输出为字符串*/
type Gender int

func (g Gender) String() string {
	return []string{"男", "女", "保密"}[g]
}

const (
	//男的
	Male = iota
	//女的
	Female
	//保密
	Secrecy
)

// Use It
change := Gender(Male).String()
fmt.Println(change)
// 男

类型转换要点

• 相互兼容的不同类型可以相互转换，如数值类型之间（可能发生精度丢失）、非数值类型之间（字符、字节）
• 非兼容类型转换需要标准包支持，如数值和非数值类型之间的转换

基本语法结构：

resultOfType := Type(expression)

示例：

//相互兼容的数值类型转换
var a int = 1
var b float64 = 3.1415

aa := float64(a)
bb := int(b)

fmt.Printf("a: Type=%T，Value=%v\n", a, a)
fmt.Printf("aa: Type=%T，Value=%v\n", aa, aa)
fmt.Printf("b: Type=%T，Value=%v\n", b, b)
fmt.Printf("bb: Type=%T，Value=%v\n", bb, bb)
//a: Type=int，Value=1
//aa: Type=float64，Value=1
//b: Type=float64，Value=3.1415
//bb: Type=int，Value=3

//相互兼容的非数值类型转换
var s string = "Go语言基础"
sBytes := []byte(s)
sUnit := []uint8(s)
sRunes := []rune(s)

fmt.Printf("s: Type=%T，Value=%v\n", s, s)
fmt.Printf("sBytes: Type=%T，Value=%v\n", sBytes, sBytes)
fmt.Printf("sUnit: Type=%T，Value=%v\n", sUnit, sUnit)
fmt.Printf("sRunes: Type=%T，Value=%v\n", sRunes, sRunes)

//s: Type=string，Value=Go语言基础
//sBytes: Type=[]uint8，Value=[71 111 232 175 173 232 168 128 229 159 186 231 161 128]
//sUnit: Type=[]uint8，Value=[71 111 232 175 173 232 168 128 229 159 186 231 161 128]
//sRunes: Type=[]int32，Value=[71 111 35821 35328 22522 30784]


//非兼容类型转换,使用strconv标准包，可实现字符串和数值类型的转换，以下示例为整型转换，其他可参考该包提供的方法：
//整型转字符串
var i = 1
s = strconv.Itoa(i)
fmt.Printf("i: Type=%T，Value=%v\n", i, i)
fmt.Printf("s: Type=%T，Value=%v\n", s, s)
//i: Type=int，Value=1
//s: Type=string，Value=1

//字符串转整型
var ss = "34"
ii, err := strconv.Atoi(ss)
if err != nil {
	fmt.Println("Atoi is equivalent to ParseInt(s, 10, 0), converted to type int")
}

fmt.Printf("ss: Type=%T，Value=%v\n", ss, ss)
fmt.Printf("ii: Type=%T，Value=%v\n", ii, ii)
//ss: Type=string，Value=34
//ii: Type=int，Value=34