Go语言拥有两大数据类型，基本数据类型和复合数据类型。

1. 数值类型

##有符号整数
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 位,64 位操作系统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 位,64 位操作系统64 位)##浮点型
float32（+- 1e-45 -> +- 3.4 * 1e38）
float64（+- 5 1e-324 -> 107 1e308）
#无float类型#复数
Go 拥有以下复数类型：
complex64 (32 位实数和虚数)
complex128 (64 位实数和虚数)复数使用 re+imI 来表示，其中 re 代表实数部分， im 代表虚数部分，I 代表根号负 1
var c1 complex64 = 5 + 10i
fmt.Printf("The value is: %v", c1)  // 输出： 5 + 10i

1.1 整型

int后面的数字代表位数，而前面的u代表无符号。Go语言中int类型的大小与具体的平台有关系，一般来说，int在32位系统中是4字节，在64位系统中是8字节，使用简短定义自动推导类型初始化一个整数，默认为int类型。

1.2 浮点型

Go语言有两种精度的浮点数 float32 和 float64，分别占4个字节和8个字节

1.3 数值类型使用注意

• 整型的零值为 0，浮点型的零值为 0.0。

• int 和 uint 在 32 位操作系统上，它们均使用 32 位（4 个字节） ，在 64 位操作系统上，它们均使用 64 位（8 个字节）。

• uintptr 的长度被设定为足够存放一个指针即可。

• 整型的零值为 0，浮点型的零值为 0.0。

• int 型是计算最快的一种类型。

• 尽可能地使用 float64，因为 math 包中所有有关数学运算的函数都会要求接收这个类型。

• Go 是强类型语言，不会进行隐式转换.。所以Go 中不允许不同类型之间的混合使用，但允许常量之间的混合使用。

2.字符串

字符串由“ ”声明，由多个字节组成，需要使用"进行转义后才能使用 \n \r \t 为特殊作用字符。

1. 字符串是 UTF-8 字符的一个序列（当字符为 ASCII 码时则占用 1 个字节，其它字符根据需要占用 2-4 个字节）
2. 字符串在Go语言内存模型中用一个2字长的数据结构表示。它包含一个指向字符串存储数据的指针和一个长度数据。
3. 字符串是一种值类型，且值不可变。所以多字符串共享同一个存储数据是安全的。
4. 切分操作 str[i:j] 会得到一个新的2字长结构，一个可能不同的但仍指向同一个字节序列(即上文说的存储数据)的指针和长度数据。字符串切分不涉及内存分配。
5. string 类型的零值为ptr为nil，len为0的字符串，即空字符串 “”
6. 获取字符串中某个字节的地址的行为是非法的，例如： &str[i]

3. 布尔

两种取值类型，true false

1. 对于布尔值的好的命名能够很好地提升代码的可读性，例如以 is 或者 Is 开头的isSorted 、 isFinished 、 isVisivle 。
2. 在格式化输出时，你可以使用 %t 来表示你要输出的值为布尔型。
3. 布尔型的值只可以是常量 true 或者 false。

4. 数据类型的转换

强制类型转换的语法 Type(value)。Type 为目标数据类型

5. 运算符

算术运算符，逻辑运算符，关系运算符，赋值运算符与Java，c++相差无几，就不多赘述了

位运算存在一些差别

6. 占位符号

占位符表示在程序中输出一行字符串时候，或者格式化输出字符串的时候使用。go内置包fmt中Printf方法可以在控制台格式化打印出用户输入的内容。fmt.Printf("%T",x)

T代表type类型，s代表字符串string，t代表布尔值，d代表十进制数字，p代表内存地址

7. 数组

数组声明的语法格式为： var 数组名称 [长度]数据类型

• 数组的长度，用内置函数 len()来获取。
• 数组的容量，用内置函数 cap()来获取。

//默认情况下 数组中每个元素初始化时候 根据元素的类型 对应该数据类型的零值，
arr1 := [3]int{1,2}
fmt.Println(arr1[2])//下标为2的元素没有默认取int类型的零值//数组创建方式1 创建时 直接将值赋到数组里
arr2 := [5]int{1,2,3,4}    //值可以少 默认是0  但是不能超过定长//在指定位置上存储值
arr3 := [5]int{1:2,3:5}//在下标为1的位置存储2，在下标为3的位置存储5
//长度可以用...代替  根据数值长度程序自动填充数值的大小
arr4 :=  [...]int{1,2,3,4}//简短声明方式
arr5 := [...]int{2:3,6:3}//在固定位置存储固定的值arr := [5]int{1,2,3,4,5}
//range方式循环数组
for index,value:=range arr{fmt.Println(index,value)
}//声明一个二维数组
var arr [3][8]int
//给二维数组赋值
arr[0]=[8]int{1,2,3,4,5,6,7,8}
//打印结果
fmt.Println(arr) // [[1 2 3 4 5 6 7 8] [0 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0]]
//也可以通过下标给指定的索引赋值
arr[1][3]=9
fmt.Println(arr) // [[1 2 3 4 5 6 7 8] [0 0 0 9 0 0 0 0] [0 0 0 0 0 0 0 0]]

8. 切片Slice

声明一个切片语法：var 切片名字 [] 数据类型

通常情况下，使用make函数来创建一个切片，切片有长度和容量，默认情况下它的容量与长度相等。所以可以不用指定容量。

//使用make函数来创建切片
slice :=make([]int,3,5)//长度为3 容量为5  容量如果省略 则默认与长度相等也为3
fmt.Println(slice)//[0,0,0] 
fmt.Println(len(slice),cap(slice))//长度3,容量5

1. 一个slice是一个数组某个部分的引用。在内存中，它是一个包含3个域的结构体：指向slice中第一个元素的指针，slice的长度，以及slice的容量。
2. 切片 s 来说该不等式永远成立： 0 <= len(s)<= cap(s)
3. 在对slice进行append等操作时，可能会造成slice的自动扩容（因为切片的底层是一个数组，数组的容量是不可变的，因此每次扩容都要产生一个新数组）:

• 首先判断，如果新申请容量（cap）大于2倍的旧容量（old.cap），最终容量（newcap）就是新申请的容量（cap）
• 否则判断，如果旧切片的长度小于1024，则最终容量(newcap)就是旧容量(old.cap)的两倍，即（newcap=doublecap）
• 否则判断，如果旧切片长度大于等于1024，则最终容量（newcap）从旧容量（old.cap）开始循环增加原来的 1/4，即（newcap=old.cap,for {newcap += newcap/4}）直到最终容量（newcap）大于等于新申请的容量(cap)，即（newcap >= cap）
  追加元素append语法 slice=append(slice,elem1,elem2)

8.1 make()与new() 的区别

make()是Go语言中的内置函数，主要用于创建并初始化slice切片类型，或者map字典类型，或者channel通道类型数据。他与new方法的区别是。new用于各种数据类型的内存分配，在Go语言中认为他返回的是一个指针。指向的是一个某种类型的零值。make 返回的是一个有着初始值的非零值。

基本的区别是 new(T) 返回一个 *T ，返回的这个指针可以被隐式地消除引用 。而 make(T, args) 返回一个普通的T.

8.2 切片删除

由于切片没有删除方法，因此我们需要通过切片的属性进行删除，例如：

slice:=[]int{1,2,3,4}   
i := 2      // 要删除的下标为2
slice = append(slice[:i], slice[i+1:]...) // 删除中间1个元素
fmt.Println(slice)  //结果[1 2 4]

参考文章：
https://juejin.cn/book/6844733833401597966/section/6844733833477111821