在 Go 中，Go提供了丰富的内置类型和自定义类型，Go内置类型分为基本类型和引用类型两种，其中基本类型包括布尔型、整型、浮点型、复数类型(complex type)和字符串类型，引用类型包括指针、数组、切片、映射、管道和函数类型。以下将对内置类型的基本数据类型进行介绍，对于引用类型将在后面章节逐一进行讲解。

基本数据类型

布尔类型

布尔类型用于表示真或假。在 Go 中，布尔类型的取值只有两个：true 和 false。布尔类型通常用于条件语句和逻辑运算。

下面是一个例子，展示了如何声明和使用布尔类型：

func main() {
   var b1 bool = true
   var b2 bool = false
   fmt.Println(b1)
   fmt.Println(b2)
}

在上面的代码中，我们声明了两个布尔变量 b1 和 b2，并将它们分别初始化为 true 和 false。最后，我们使用 fmt.Println() 函数打印出这些布尔变量的值。

整数类型

Go 中的整数类型用于表示整数值。Go 支持多种整数类型，包括有符号整数类型和无符号整数类型。有符号整数类型用于表示正数、负数和零，而无符号整数类型只能表示非负数（即零和正数）。

下面是 Go 中的各种整数类型及其表示范围：

其中，int 和 uint 的具体字节大小取决于运行环境。

下面是一个例子，展示了如何声明和使用整数类型：

func main() {
   var a int = 123
   var b uint = 456
   fmt.Println("a is", a)
   fmt.Println("b is", b)
}

在上面的代码中，我们声明了一个有符号整数变量 a 和一个无符号整数变量 b，并将它们分别初始化为 123 和 456。最后，我们使用 fmt.Println() 函数打印出这些整数变量的值。

浮点类型

Go 中的浮点类型用于表示实数（即带小数点的数值）。Go 支持两种浮点类型：float32 和 float64。其中，float32 占用 4 个字节，而 float64 占用 8 个字节。

下面是一个例子，展示了如何声明和使用浮点类型：

func main() {
   var f1 float32 = 3.1415926
   var f2 float64 = 2.718281828459045
   fmt.Println("f1 is", f1)
   fmt.Println("f2 is", f2)
}

在上面的代码中，我们声明了一个 float32 类型的浮点变量 f1 和一个 float64 类型的浮点变量 f2，并将它们分别初始化为 3.1415926 和 2.718281828459045。最后，我们使用 fmt.Println() 函数打印出这些浮点变量的值。

复数类型

复数类型（complex type）用于表示实数和虚数的和。一个复数的值包括两个浮点数，一个表示实数，一个表示虚数。Go 中的 complex64 类型和 complex128 类型分别用于表示包含 float32 类型和 float64 类型的复数。

复数的标准表示形式为 a + bi，其中 a 表示实部，b 表示虚部，i 是一个不等于 0 的虚数单位。在 Go 中，虚数单位用常量 i 来表示。

Go 中的 complex 类型由一个实数和一个虚数构成。以下是一个复数类型的示例：

var c complex64 = 3.14 + 2.718i
fmt.Println(c) // 输出 (3.14+2.718i)

可以通过实部和虚部分别初始化一个复数：

var c1 complex64 = complex(3.14, 2.718)
fmt.Println(c1) // 输出 (3.14+2.718i)

还可以使用内置函数 real() 和 imag() 获取一个复数的实部和虚部：

var c2 complex64 = 1 + 2i
fmt.Println(real(c2)) // 输出 1
fmt.Println(imag(c2)) // 输出 2

复数的加、减、乘、除和取模等运算也在 Go 中得到了支持。示例如下：

var c1 complex64 = 1 + 2i
var c2 complex64 = 3 + 4i

// 加法
fmt.Println(c1 + c2) // 输出 (4+6i)

// 减法
fmt.Println(c1 - c2) // 输出 (-2-2i)

// 乘法
fmt.Println(c1 * c2) // 输出 (-5+10i)

// 除法
fmt.Println(c1 / c2) // 输出 (0.44+0.08i)

// 取模
fmt.Println(cmplx.Abs(c1)) // 输出 2.236068

需要注意的是，complex 类型和 float32、float64 类型不能直接进行运算。如果需要进行运算，需要将其转换为相同类型。

var f1 float64 = 3.14
var c1 complex64 = 1 + 2i

// 报错，无法进行运算
// fmt.Println(f1 + c1)

// 将 c1 转换为 float64 类型
fmt.Println(f1 + float64(real(c1))) // 输出 4.14

字符串类型

Go 中的字符串类型用于表示文本。字符串是一系列 Unicode 字符的序列，其中每个字符占用 1 个或 2 个字节。字符串是不可变的，即一旦创建，就不能修改它的值。

下面是一个例子，展示了如何声明和使用字符串类型：

func main() {
   var s1 string = "hello"
   var s2 string = "world"
   fmt.Println(s1 + " " + s2)
}

在上面的代码中，我们声明了两个字符串变量 s1 和 s2，并将它们分别初始化为 "hello" 和 "world"。最后，我们使用字符串拼接符 + 将这两个字符串拼接在一起，并使用 fmt.Println() 函数打印出拼接后的结果。

字符类型

Go 中的字符类型用于表示 Unicode 字符。字符类型的值是一个 Unicode 码点，它通常用单引号括起来。

下面是一个例子，展示了如何声明和使用字符类型：

func main() {
   var c1 rune = 'a'
   var c2 rune = '中'
   fmt.Printf("c1 is %c, its Unicode code point is %d\n", c1, c1)
   fmt.Printf("c2 is %c, its Unicode code point is %d\n", c2, c2)
}

在上面的代码中，我们声明了两个字符变量 c1 和 c2，并将它们分别初始化为 'a' 和 '中'。最后，我们使用 fmt.Printf() 函数打印出这些字符变量的值及其对应的 Unicode 码点。

类型转换

Golang 中，类型转换可以将一个数据类型转换为另一个数据类型。类型转换的格式如下：

var a int = 10
var b float64 = float64(a)

其中，a 是 int 类型，b 是 float64 类型。float64(a) 将 a 转换为 float64 类型。

需要注意的是，不同类型之间的转换必须显示进行，不能隐式转换。

另外，转换可能会导致精度损失和溢出等问题。例如将 float64 类型转换为 int 类型时，可能会导致小数部分被丢弃。

var a float64 = 3.14
var b int = int(a)
fmt.Println(b) // 输出 3

类型断言

类型断言用于提取接口类型的实际值，并判断其是否属于指定的类型。类型断言的格式如下：

var x interface{}
x = "hello world"
s, ok := x.(string)
if ok {
   fmt.Println(s)
}

其中，x 是一个空接口类型，可以存储任意类型的值。在类型断言中，通过 x.(string) 将 x 转换为 string 类型。如果 x 存储的值确实是 string 类型，则返回值 s 为 x 的实际值，并将 ok 设为 true。如果 x 存储的值不是 string 类型，则返回值 s 为 nil，并将 ok 设为 false。

需要注意的是，如果使用错误的类型进行类型断言，会导致程序崩溃。因此，在进行类型断言时，通常会使用 if 语句和 ok 变量来判断实际值是否属于指定的类型。

var x interface{}
x = "hello world"
i, ok := x.(int)
if ok {
   fmt.Println(i)
} else {
   fmt.Println("类型断言失败")
}

除了上述格式外，还有一种特殊的类型断言格式：

switch v := x.(type) {
case string:
   fmt.Println("字符串类型：", v)
case int:
   fmt.Println("整数类型：", v)
default:
   fmt.Println("未知类型")
}

在这种格式中，x 是一个空接口类型，v 是一个临时变量，用于存储 x 的实际值。type 是一个关键字，用于指定需要判断的类型。在 switch 语句中，根据 x 的实际类型执行相应的代码块。如果实际类型不属于任何一个 case，就执行 default 代码块。

感兴趣的小伙伴欢迎留言交流！！！