一、基本数据类型

1.数值类型

有符号整数
  • 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

2.布尔类型

  • bool

3.字符及字符串

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

4.字节

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

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

  1.     //整型
  2.     var v1 = 123
  4.     //浮点型
  5.     var v2 = 3.14
  7.     //字符
  8.     var v3 = '我'
  10.     //字符串
  11.     var v4 = "我是fun"
  13.     //布尔值
  14.     var v5 = false
  16.     //格式化打印
  17.     fmt.Printf("v1变量的类型为%T,值为%v\n", v1, v1)
  18.     fmt.Printf("v1变量的类型为%T,值为%v\n", v2, v2)
  20.     fmt.Printf("v1变量的类型为%T,字符序号为%v，字符为%c，十六进制为%x ，二进制位%b\n ", v3, v3, v3, v3, v3)
  22.     fmt.Printf("v1变量的类型为%T,值为%v\n", v4, v4)
  23.     fmt.Printf("v1变量的类型为%T,值为%v\n", v5, v5)
  25.     //Output:
  26.     //v1变量的类型为int,值为123
  27.     //v2变量的类型为float64,值为3.14
  28.     //v3变量的类型为int32,字符序号为25105，字符为我，十六进制为6211 ，二进制位110001000010001
  29.     //v4变量的类型为string,值为我是fun
  30.     //v5变量的类型为bool,值为false

二、变量

1.变量声明及赋值

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

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

2.多个变量一并声明、赋值

  1. var a,b int32 //一次声明两个同类型变量
  2. var c,d int32 = 4,5 //一次声明两个同类型变量并赋值
  4. e,f := "aaa",123 //冒等一次赋值两变量，可不同类型
  7. //可将var提取出来
  8. var (
  9.     a int64
  10.     b string
  11. )

三、常量

  1.     //声明常量
  2.     const PI = 3.14
  4.     //声明多个常量
  5.     const (
  6.         LightSpeed  = 30 * 10000
  7.         earthCircle = 40000
  8.     )
  10.     //使用iota定义常量
  11.     const (
  12.         MONDAY = iota + 1
  13.         /*自动延用排头兵的表达式，但iota逐一递增*/
  14.         TUESDAY
  15.         WEDNESDAy
  16.         THURSDAY
  17.         FRIDAY
  18.         SATURDAY
  19.         SUNDAY
  20.     )
  22.     const (
  23.         USA = (iota + 1) * 1000
  24.         CHINA
  25.         RUSSIA
  26.         BRITAIN
  27.         FRANCE 
  28.     )
  30.     fmt.Println(MONDAY, TUESDAY, WEDNESDAy, THURSDAY, FRIDAY, SATURDAY, SUNDAY)
  31.     fmt.Println(USA, CHINA, RUSSIA, BRITAIN, FRANCE)
  34.     Output:
  35.     1 2 3 4 5 6 7
  36.     1000 2000 3000 4000 5000

四、枚举

  1. //这种写法可以让值为整数类型，但打印输出为字符串*/
  2. type Gender int
  4. func (g Gender) String() string {
  5.     return []string{"Male", "Female", "Bisexual"}[g]
  6. }
  8. const (
  9.     //男的
  10.     Male = iota
  11.     //女的
  12.     Female
  13.     //二椅子
  14.     Bisexual
  15. )

五、类型转换

类型转换要点

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

基本语法结构：

  1. resultOfType := Type(expression)

示例：

  1. //相互兼容的数值类型转换
  2. var a int = 1
  3. var b float64 = 3.1415
  5. aa := float64(a)
  6. bb := int(b)
  8. fmt.Printf("a: Type=%T，Value=%v\n", a, a)
  9. fmt.Printf("aa: Type=%T，Value=%v\n", aa, aa)
  10. fmt.Printf("b: Type=%T，Value=%v\n", b, b)
  11. fmt.Printf("bb: Type=%T，Value=%v\n", bb, bb)
  12. //a: Type=int，Value=1
  13. //aa: Type=float64，Value=1
  14. //b: Type=float64，Value=3.1415
  15. //bb: Type=int，Value=3
  17. //相互兼容的非数值类型转换
  18. var s string = "Go语言基础"
  19. sBytes := []byte(s)
  20. sUnit := []uint8(s)
  21. sRunes := []rune(s)
  23. fmt.Printf("s: Type=%T，Value=%v\n", s, s)
  24. fmt.Printf("sBytes: Type=%T，Value=%v\n", sBytes, sBytes)
  25. fmt.Printf("sUnit: Type=%T，Value=%v\n", sUnit, sUnit)
  26. fmt.Printf("sRunes: Type=%T，Value=%v\n", sRunes, sRunes)
  28. //s: Type=string，Value=Go语言基础
  29. //sBytes: Type=[]uint8，Value=[71 111 232 175 173 232 168 128 229 159 186 231 161 128]
  30. //sUnit: Type=[]uint8，Value=[71 111 232 175 173 232 168 128 229 159 186 231 161 128]
  31. //sRunes: Type=[]int32，Value=[71 111 35821 35328 22522 30784]
  34. //非兼容类型转换,使用strconv标准包，可实现字符串和数值类型的转换，以下示例为整型转换，其他可参考该包提供的方法：
  35. //整型转字符串
  36. var i = 1
  37. s = strconv.Itoa(i)
  38. fmt.Printf("i: Type=%T，Value=%v\n", i, i)
  39. fmt.Printf("s: Type=%T，Value=%v\n", s, s)
  40. //i: Type=int，Value=1
  41. //s: Type=string，Value=1
  43. //字符串转整型
  44. var ss = "34"
  45. ii, err := strconv.Atoi(ss)
  46. if err != nil {
  47.     fmt.Println("Atoi is equivalent to ParseInt(s, 10, 0), converted to type int")
  48. }
  50. fmt.Printf("ss: Type=%T，Value=%v\n", ss, ss)
  51. fmt.Printf("ii: Type=%T，Value=%v\n", ii, ii)
  52. //ss: Type=string，Value=34
  53. //ii: Type=int，Value=34