lihui_study/GO学习/day4.md

# 数据类型

Go语言中常见的数据类型有很多，例如：

- 整型，用于表示整数。
- 浮点型，用于表示小数。
- 布尔型，用于表示真/假。
- 字符串，用于表示文本信息。
- 数组，用于表示多个数据（数据集合）
- 指针，用于表示内存地址的类型。
- 切片，用于表示多个数据（数据集合）
- 字典，用于表示键值对结合。
- 结构体，用于自定义一些数据集合。
- 接口，用于约束和泛指数据类型。

## 整型

Go中的整型分为有符号和无符号两大类，有符号的包含负值，无符号不包含负值。

有符号整型：

- int8（-128 -> 127）
- int16（-32768 -> 32767）
- int32（-2,147,483,648 -> 2,147,483,647）
- int64（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807）
- int
  - 在 32 位操作系统上使用 32 位（-2,147,483,648 -> 2,147,483,647） 2**32
  - 在 64 位操作系统上使用 64 位（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,80）2**64

无符号整数：

- uint8（0 -> 255）
- uint16（0 -> 65,535）
- uint32（0 -> 4,294,967,295）
- uint64（0 -> 18,446,744,073,709,551,615）
- uint
  - 在 32 位操作系统上使用32 位（0 -> 4,294,967,295） 2**32
  - 64 位操作系统上使用 64 位（0 -> 18,446,744,073,709,551,615） 2**64

不同整型可表示的数据范围不同，我们需要根据自己的需求来选择适合的类型。

### 整型转换

```go
data := intxxx(其他整型)

var v1 int8 = 10
var v2 int16 = 18
v3 := int16(v1) + v2
fmt.Println(v3, reflect.TypeOf(v3))
```

注意：

- 地位转向高位，没问题。
- 高位转向低位，可能有问题

现象：轮回=>不会报错

```go
var v1 int16 = 130
v2 := int8(v1)
fmt.Println(v2)
输出结果为 -126
```

### 其他进制转换

### math下的数学运算模块

### 指针/nil/声明变量/new

- 声明变量
- 指针
- new 关键字
- nil 空值

为什么要有指针？

> 为了节省内存，不重复开辟空间区存储

int和*int是两种不同的数据类型

### 超大整型

使用指针的方式，即：使用new来进行创建和初始化。

```go
// 第一步：创建一个超大整型的一个对象
var v1 big.Int
var v2 big.Int

// 第二步：在超大整型对象中写入值
v1.SetInt64(9223372036854775807)
fmt.Println(v1)

v2.SetString("92233720368547758089223372036854775808", 10)
fmt.Println(v2)
```



```go
// 第一步：创建一个超大整型的一个对象
v3 := new(big.Int)
v4 := new(big.Int)

// 第二步：在超大整型对象中写入值
v3.SetInt64(9223372036854775807)
fmt.Println(v3)

v4.SetString("92233720368547758089223372036854775808", 10)
fmt.Println(v4)
```

#### 超大整形的运算

也是建议使用new的方式

## 浮点型

float类型，计算机中小数的非精确的表示方式，如：`3.14`

### float底层存储原理

1. 浮点型转换为二进制
2. 科学计数法表示
3. 存储

### decimal

第三方的包

```go
package main

import (
	"fmt"
	"github.com/shopspring/decimal"
)

func main() {

	var v1 = decimal.NewFromFloat(0.0000000000019)
	var v2 = decimal.NewFromFloat(0.29)

	var v3 = v1.Add(v2)

	var v4 = v1.Sub(v2)

	var v5 = v1.Mul(v2)

	var v6 = v1.Div(v2)
	
    fmt.Println(v3, v4, v5, v6) // 输出：0.2900000000019（也可以调用String方法）
    
    
	var price = decimal.NewFromFloat(3.4626)
	var data1 = price.Round(1) 		// 保留小数点后1位（四舍五入）
	var data2 = price.Truncate(1)	// 保留小数点后1位
	fmt.Println(data1, data2) // 输出：3.5  3.4
}
```

## 布尔类型

阿巴阿巴

## 字符串

阿巴阿巴

### 底层存储逻辑

计算机中所有的操作和数据最终都是二进制，即：1000100001011...

Go语言中的字符串是utf-8编码的序列。

## 数组

数组，定长且元素类型一致的数据集合。

- 数组的内存是连续的。
- 数组的内存地址实际上就是数组第一个元素的内存地址。
- 每个字符串的内部存储：`len` + `str`

###  可变和拷贝

可变，数组的元素可以被更改（长度和类型都不可以修改）。

注意：字符串不可以被修改。

拷贝，变量赋值时重新拷贝一份。