初探Golang（3）-数据类型

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 为特殊作用字符。

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

3. 布尔

两种取值类型，true false

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

一个slice是一个数组某个部分的引用。在内存中，它是一个包含3个域的结构体：指向slice中第一个元素的指针，slice的长度，以及slice的容量。
切片 s 来说该不等式永远成立： 0 <= len(s)<= cap(s)
在对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