Golang 数据类型有哪些？

一个完整的项目需要更复杂的逻辑，不是简单的“Hello 世界”可相比的。这些逻辑通过变量、常量、类型、函数方法、接口、结构体组成，这节课我就将带你认识它们，让你的 Go 语言程序变得更加生动。

 

内置类型 值类型

    bool
    int(32 or 64), int8, int16, int32, int64
    uint(32 or 64), uint8(byte), uint16, uint32, uint64
    float32, float64
    string
    complex64, complex128
    array    -- 固定长度的数组

 

变量声明

变量代表可变的数据类型，也就是说，它在程序执行的过程中可能会被一次甚至多次修改。

在 Go 语言中，通过 var 声明语句来定义一个变量，定义的时候需要指定这个变量的类型，然后再为它起个名字，并且设置好变量的初始值。所以 var 声明一个变量的格式如下：

var 变量名 类型 = 表达式

 现在我通过一个示例来演示如何定义一个变量，并且设置它的初始值：

package main

import "fmt"

func main() {
    var i int = 10
    fmt.Println(i)
}

观察上面例子中 main 函数的内容，其中 var i int = 10 就是定义一个类型为 int（整数）、变量名为 i 的变量，它的初始值为 10

这里为了运行程序，我加了一行 fmt.Println(i)，表示打印出变量 i 的值。

这样做一方面是因为 Go 语言中定义的变量必须使用，否则无法编译通过，这也是 Go 语言比较好的特性，防止定义了变量不使用，导致浪费内存的情况；另一方面，在运行程序的时候可以查看变量 i 的结果。

通过输入 go run ch02/main.go 命令回车运行，即可看到如下结果：

$ go run ch02/main.go 
10

打印的结果是10，和变量的初始值一样。

因为 Go 语言具有类型推导功能，所以也可以不去刻意地指定变量的类型，而是让 Go 语言自己推导，比如变量 i 也可以用如下的方式声明：

var i = 10

这样变量 i 的类型默认是 int 类型。

你也可以一次声明多个变量，把要声明的多个变量放到一个括号中即可，如下面的代码所示：

var (
    j int= 0
    k int= 1
)

同理因为类型推导，以上多个变量声明也可以用以下代码的方式书写：

var (
    j = 0
    k = 1
)

这样就更简洁了。其实不止int类型，后面的float64、bool、string 等基础类型都可以被自动推导，也就是可以省略定义类型。

基础类型

---

任何一门语言都有对应的基础类型，这些基础类型和现实中的事物一一对应，比如整型对应着 1、2、3、100 这些整数，浮点型对应着 1.1、3.4 这些小数等。Go 语言也不例外，它也有自己丰富的基础类型，常用的有：整型、浮点数、布尔型和字符串，下面我就为你详细介绍。

整型

在 Go 语言中，整型分为：

• 有符号整型：如 int、int8、int16、int32 和 int64。

• 无符号整型：如 uint、uint8、uint16、uint32 和 uint64。

它们的差别在于，有符号整型表示的数值可以为负数、零和正数，而无符号整型只能为零和正数。

除了有用“位”（bit）大小表示的整型外，还有 int 和 uint 这两个没有具体 bit 大小的整型，它们的大小可能是 32bit，也可能是 64bit，和硬件设备 CPU 有关。

在整型中，如果能确定 int 的 bit 就选择比较明确的 int 类型，因为这会让你的程序具备很好的移植性。

在 Go 语言中，还有一种字节类型 byte，它其实等价于 uint8 类型，可以理解为 uint8 类型的别名，用于定义一个字节，所以字节 byte 类型也属于整型。

浮点数

浮点数就代表现实中的小数。Go 语言提供了两种精度的浮点数，分别是 float32 和 float64。项目中最常用的是 float64，因为它的精度高，浮点计算的结果相比 float32 误差会更小。

下面的代码示例定义了两个变量 f32 和 f64，它们的类型分别为 float32 和 float64。

var f32 float32 = 2.2
var f64 float64 = 10.3456
fmt.Println("f32 is",f32,,"64 is",f64)

运行这段程序，会看到如下结果：

$ go run ch02/main.go
f32 is 2.2 ,f64 is 10.3456

**特别注意：**在演示示例的时候，我会尽可能地贴出演示需要的核心代码，也就是说，会省略 package 和 main 函数。如果没有特别说明，它们都是放在main函数中的，可以直接运行。

布尔型

一个布尔型的值只有两种：true 和 false，它们代表现实中的“是”和“否”。它们的值会经常被用于一些判断中，比如 if 语句等。Go 语言中的布尔型使用关键字 bool 定义。

下面的代码声明了两个变量，你可以自己运行，看看打印输出的结果。

var bf bool =false
var bt bool = true
fmt.Println("bf is",bf,",bt is",bt)

布尔值可以用于一元操作符 !，表示逻辑非的意思，也可以用于二元操作符 &&、||，它们分别表示逻辑和、逻辑或。

字符串

Go 语言中的字符串可以表示为任意的数据，比如以下代码，在 Go 语言中，字符串通过类型 string 声明：

var s1 string = "Hello"
var s2 string = "世界"
fmt.Println("s1 is",s1,",s2 is",s2)

运行程序就可以看到打印的字符串结果。

在 Go 语言中，可以通过操作符 + 把字符串连接起来，得到一个新的字符串，比如将上面的 s1 和 s2 连接起来，如下所示：

fmt.Println("s1+s2=",s1+s2)

由于 s1 表示字符串“Hello”，s2 表示字符串“世界”，在终端输入 go run ch02/main.go 后，就可以打印出它们连接起来的结果“Hello世界”，如以下代码所示：

s1+s2= Hello世界

字符串也可以通过 += 运算符操作，你自己可以试试 s1+=s2 会得到什么新的字符串。

变量

变量简短声明

有没有发现，上面我们演示的示例都有一个 var 关键字，但是这样写代码很烦琐。借助类型推导，Go 语言提供了变量的简短声明 :=，结构如下：

变量名:=表达式

借助 Go 语言简短声明功能，变量声明就会非常简洁，比如以上示例中的变量，可以通过如下代码简短声明：

i:=10
bf：=false
s1:="Hello"

在实际的项目实战中，如果你能为声明的变量初始化，那么就选择简短声明方式，这种方式也是使用最多的。

指针

在 Go 语言中，指针对应的是变量在内存中的存储位置，也就说指针的值就是变量的内存地址。通过 & 可以获取一个变量的地址，也就是指针。

在以下的代码中，pi 就是指向变量 i 的指针。要想获得指针 pi 指向的变量值，通过*pi这个表达式即可。尝试运行这段程序，会看到输出结果和变量 i 的值一样。

pi:=&i
fmt.Println(*pi)

赋值
在讲变量的时候，我说过变量是可以修改的，那么怎么修改呢？这就是赋值语句要做的事情。最常用也是最简单的赋值语句就是 =，如下代码所示： 

i = 20
fmt.Println("i的新值是",i)

这样变量 i 就被修改了，它的新值是 20。

 基本数据类型默认值

在 go中，数据类型都有一个默认值，当程序员没有赋值时，就会保留默认值，在go中，默认值又叫零值。 

基本数据类型和后面的复杂数据类型都有默认值，默认值叫做0值。

	var a int
	var b float32
	var c float64
	var d bool
	var e string
	
fmt.Printf("a=%d,b=%f,c=%f,d=%v,e=%s",a,b,c,d,e)

a=0,b=0.000000,c=0.000000,d=false,e=
//这里%v是按照变量的值输出

常量

一门编程语言，有变量就有常量，Go 语言也不例外。在程序中，常量的值是指在编译期就确定好的，一旦确定好之后就不能被修改，这样就可以防止在运行期被恶意篡改。

常量的定义

常量的定义和变量类似，只不过它的关键字是 const。下面的示例定义了一个常量 name，它的值是“飞雪无情”。因为 Go 语言可以类型推导，所以在常量声明时也可以省略类型。

const name =  "飞雪无情"

 在 Go 语言中，只允许布尔型、字符串、数字类型这些基础类型作为常量。

iota

iota 是一个常量生成器，它可以用来初始化相似规则的常量，避免重复的初始化。假设我们要定义 one、two、three 和 four 四个常量，对应的值分别是 1、2、3 和 4，如果不使用 iota，则需要按照如下代码的方式定义：

const(
    one = 1
    two = 2
    three =3
    four =4
)

以上声明都要初始化，会比较烦琐，因为这些常量是有规律的（连续的数字），所以可以使用 iota 进行声明，如下所示：

const(
    one = iota+1
    two
    three
    four
)

fmt.Println(one,two,three,four)

你自己可以运行程序，会发现打印的值和上面初始化的一样，也是 1、2、3、4。

iota 的初始值是 0，它的能力就是在每一个有常量声明的行后面 +1，下面我来分解上面的常量：

1. one=(0)+1，这时候 iota 的值为 0，经过计算后，one 的值为 1。

2. two=(0+1)+1，这时候 iota 的值会 +1，变成了 1，经过计算后，two 的值为 2。

3. three=(0+1+1)+1，这时候 iota 的值会再 +1，变成了 2，经过计算后，three 的值为 3。

4. four=(0+1+1+1)+1，这时候 iota 的值会继续再 +1，变成了 3，经过计算后，four 的值为 4。

如果你定义更多的常量，就依次类推，其中 () 内的表达式，表示 iota 自身 +1 的过程。