基本类型

Go 内置了以下基本类型：

  • 布尔
    • bool
  • 字符串
    • string
  • 整数
    • int ，int8 ，int16 ， int32 ，int64
    • uint ， uint8 ，uint16 ， uint32 ， ， uint64
  • 字节
    • byte ， uint8 的别名
  • Unicode
    • rune ， int32 别名
  • 浮点
    • float32 ，float64
  • 复数
    • complex64 ，complex128

/_src/tour/basic-types.go

  1. package main
  2.  
  3. import (
  4.     "fmt"
  5.     "math/cmplx"
  6. )
  7.  
  8. var (
  9.     ToBe    bool        = false
  10.     MaxInt  uint64      = 1 << 64 -1
  11.     z       complex128  = cmplx.Sqrt(-5 +12i)
  12. )
  13.  
  14.  
  15. func main() {
  16.     fmt.Printf("Type: %T Value: %v\n", ToBe, ToBe)
  17.     fmt.Printf("Type: %T Value: %v\n", MaxInt, MaxInt)
  18.     fmt.Printf("Type: %T Value: %v\n", z, z)
  19. }

例子展示了几种不同类型变量的用法。注意到，跟 import语句 一样，变量申明可以批量写到一个代码块里。

一般来说，int 、 uint 以及 uintptr 类型在 32 位机器上是 32 位长；在 64 位机器上则是 64 位长。需要使用整数时， int 类型是首选，除非你有特别的理由一定要用 定长 或者 无符号 类型。

零值

变量申明时没有显式赋初始值，则默认是“ 零 ”。

不同的类型有不同的“ 零 ”：

  • 对于数值类型是 0 ；
  • 对于布尔类型是 false ；
  • 对于字符串类型是 "" (空字符串)；

/_src/tour/zero.go

  1. package main
  2.  
  3. import "fmt"
  4.  
  5.  
  6. func main() {
  7.     var i int
  8.     var f float64
  9.     var b bool
  10.     var s string
  11.     fmt.Printf("%v %v %v %q\n", i, f, b, s)
  12. }

类型转换

表达式 ( expression ) T(v) 将值 v 转换成类型 T ，这就是所谓的 类型转换 ( type conversions )。

这是一些数值类型转换：

  1. var i int = 42
  2. var f float64 = float64(i)
  3. var u uint = uint(f)

或者简写成：

  1. i := 42
  2. f := float(i)
  3. u := uint(f)

跟 C 语言有所不同， Go 在不同类型之间赋值，需要显式类型转换。不信，将下面例子中 float64 和 unit 类型转换移除，看看发生什么？

/_src/tour/type-conversions.go

  1. package main
  2.  
  3. import (
  4.     "fmt"
  5.     "math"
  6. )
  7.  
  8.  
  9. func main() {
  10.     var x, y int = 3, 4
  11.     var f float64 = math.Sqrt(float64(x*x + y*y))
  12.     var z uint = uint(f)
  13.     fmt.Println(x, y, z)
  14. }

类型推理

变量类型通过右边的值推理而来。

如果申明右边的值是有类型的，那么新变量也是一样的类型：

  1. var i int
  2. j := i  // j is an int as well

如果右边只是一个数值常量，没有具体类型，那么新变量可能是 int 、float64 以及 complex128 三种类型中的一种，取决于常量的精度。

  1. i := 42             // int
  2. f := 3.142          // float64
  3. g := 0.867 + 0.5i   // complex128

接下来做个实验吧！改变例子中 v 的初始值，观察它是如何影响变量类型的：

/_src/tour/type-inference.go

  1. package main
  2.  
  3. import "fmt"
  4.  
  5.  
  6. func main() {
  7.     v := 42     // change me!
  8.     fmt.Printf("v is of type %T\n", v)
  9. }

下一步

下一节 我们一起来看看 Go 语言 常量 。

订阅更新，获取更多学习资料，请关注我们的 微信公众号 ：

../_images/wechat-mp-qrcode.png 小菜学编程

微信打赏