Go基础数据类型

布尔类型

布尔类型用于表示真假，类型名为bool，只有两个值true和false，占用一个字节宽度，0为false

var (
    isTrue bool = true
    isFalse bool = false
)

逻辑运算

(1)    与&&
只有左右两边表达式结果都为true,运算结果才为true

	fmt.Println(true && true)	//true
	fmt.Println(true && false)	//false
	fmt.Println(false && true)	//false
	fmt.Println(false && false)	//false

(2)    或||

	fmt.Println(true || true)	//true
	fmt.Println(true || false)	//true
	fmt.Println(false || true)	//true
	fmt.Println(false || false)	//false

(3)    非!

	fmt.Println(!true)	//false
	fmt.Println(!false)	//true

关系运算

	fmt.Println(true == true)	//等于==
	fmt.Println(true != true)	//不等于!=

整数类型

Go语言提供了5种有符号、5种无符号、1种指针、1种单字节、1种单个unicode字符(unicode码点)，共13种整数类型，零值均为0

类型名	字节宽度	说明&取值范围
int	与平台有关，32位系统4字节，64位系统8字节	有符号整型
uint	与平台有关，32 位系统 4 字节，64 位系统 8 字节	无符号整形
int8	1 字节	用 8 位表示的有符号整型，取值范为：[-128, 127]
int16	2字节	用 16 位表示的有符号整型，取值范围为：[-32768,32767]
int32	4字节	用 32 位表示的有符号整型，取值范围为：[-2147483648,2147483647]
int64	8字节	用 64 位表示的有符号整型，取值范围为:[-9223372036854775808,9223372036854775807]
uint8	1 字节	用 8 位表示的有符号整型，取值范为：[0, 255]
uint16	2字节	用 16 位表示的有符号整型，取值范围为：[0,65535]
uint32	4字节	用 32 位表示的有符号整型，取值范围为：[0,4294967295]
uint64	8字节	用 64 位表示的有符号整型，取值范围为:[0,18446744073709551615]
rune	4字节	Unicode 码点，取值范围同int32
byte	1 字节	字节类型，取值范围同 uint8
uintptr	与平台有关，32 位系统 4 字节，64 位系统 8 字节	指针值的无符号整型

字面量:

十进制表示法: 以 10 为基数，采用 0-9 十个数字，逢 10 进位，如：10
八进制表示法：以 8 为基数，采用 0-7 八个数字，逢 8 进位，使用 0 开头表示为八进制表示，如：010
十六进制表示法：以 16 为基数，采用 0-9 十个数字和 A-F 六个字母，逢 16 进位，使用0X 开头表示为十六进制 ，如：0X10

	// 分别打印十进制，八进制，十六进制的字面量
	fmt.Println(10, 010, 0X10)	//10 8 16

算术运算

+、-、*、/、%、++、--，注意：针对/除数不能为0，且结果依然为整数

	var n1, n2, n3 int = 1, -8, -2
	var n4 uint = 4
	// 算术运算
	fmt.Println(n1 + n2)	//-7
	fmt.Println(n1 - n2)	//9
	fmt.Println(n1 * n2)	//-8
	fmt.Println(n1 / n2)	//0 /向下取整
	fmt.Println(n1 % n2)	//1

	n3++
	n4--
	fmt.Println(n3, n4)	//-1 3

关系运算

、>=、 <、 <=、 ==、 !=

	fmt.Println(1 > 2)
	fmt.Println(1 >= 2)
	fmt.Println(1 < 2)
	fmt.Println(1 <= 2)
	fmt.Println(1 == 2)
	fmt.Println(1 != 2)

位运算

&、|、^、<<、 >>、 &^
对于负整数在计算机中使用补码进行表示，对应正整数二进制表示取反+1
针对左、右移的右操作数必须为无符号整型

二进制表示法	
	原码 正数
	反码
	补码	负数

	// 位运算
	// 2 二进制=> 0010
	// 7 二进制=> 0111
	// -2 二进制=> 1110  负整数在计算机中使用补码进行表示，对应正整数二进制表示取反+1
	fmt.Println(4 & 2)	// 0100 & 0010 => 0000
	fmt.Println(4 | 2)	// 0100 | 0010 => 0110
	fmt.Println(4 ^ 2)	// 0100 ^ 0010 => 0110
	fmt.Println(4 &^ 2)	// 0100 &^ 0010 => 0100
	fmt.Println(4 << 2)	// 0100 <<移2位 => 0001 0000
	fmt.Println(8 >> 2)	// 1000 >>移2位 => 0010

赋值运算

=、+=、-+、*=、/=、%=、&=、|=、^=、<<=、>>=

	// 赋值运算
	var n1, n2 int = 1, 2
	n1 += n2	// n1 = n1 + n2
	fmt.Println(n1)	//3
	n1 <<= n2	// n1 = n1 << n2
	fmt.Println(n1)	//12

类型转换

Go不会自动对数据类型转换，因此左、右操作数类型必须一致或int莫个字面量，可通过类型名(数据)的语法将数据转换为对应类型。需要大转小需要注意值截断和值溢出问题

不建议这种类型转换写法：大转小，有符号转无符号，无符号转有符号

// 类型转换
	var n1, n2 int = 1, 4
	fmt.Printf("%T %T %T %T %T %T\n", n1, uint(n1), n2, int(n2), uint8(n2), int64(n2))	//int uint int int uint8 int64

fmt.Printf进行格式化参数输出, 占位符:

%T    变量名类型
%b    二进制
%c    字符
%d    十进制
    %+d    表示对正整数带+符号
    %nd    表示最小占位n个宽度且右对齐
    %-nd    表示最小占位n个宽度且左对齐
    %0nd    表示最小占位n个宽度且右对齐，空字符使用0填充
%o    八进制
    %#o    带0的前缀
%x、%X 十六进制
    %#x(%#X)带0x(0X)的前缀
%U    Unicode码点
    %#U    带字符的Unicode码点
%q    带单引号的字符

// fmt打印
	var (
		n1	int = 10
		n2	int	= -10
		n3	byte = 'a'
		n4  rune = '虎'
	)
	fmt.Printf("%d %b %o %x %X %#o %#x %#X\n", n1, n1, n1, n1, n1, n1, n1, n1,)	//10 1010 12 a A 012 0xa 0XA
	fmt.Printf("|%d|%+d|%10d|%-10d|%010d|%+-10d|%+010d|\n", n1, n1, n1, n1, n1, n1, n1)	//10|+10|        10|10        |0000000010|+10       |+000000010
	fmt.Printf("%d|%+d|%10d|%-10d|%010d|%+-10d|%+010d|\n", n2, n2, n2, n2, n2, n2, n2)	//-10|-10|       -10|-10       |-000000010|-10       |-000000010
	fmt.Printf("%c %c %q %q\n", n3, n4, n3, n4)	//a 虎 'a' '虎'
	fmt.Printf("%U %#U\n", n4, n4)	//U+864E U+864E '虎'

浮点型

浮点数用于表示带小数的数字，Go提供float32和float64两种浮点类型，非精确值类型，零值0.0

主要是为了表示小数，也可细分为float32和float64两种。浮点数能够表示的范围可以从很小到很巨大，这个极限值范围可以在math包中获取，math.MaxFloat32表示float32的最大值，大约是3.4e38，math.MaxFloat64大约是1.8e308，两个类型最小的非负值大约是1.4e-45和4.9e-324。

float32大约可以提供小数点后6位的精度，作为对比，float64可以提供小数点后15位的精度。通常情况应该优先选择float64，因此float32的精确度较低，在累积计算时误差扩散很快，而且float32能精确表达的最小正整数并不大，因为浮点数和整数的底层解释方式完全不同。

类型	长度
float32	IEEE-754 32位浮点型数
float64	IEEE-754 64位浮点型数

字面量

十进制表示法：3.1415926
科学计数法：1e-5

格式

	// 浮点型
	var (
		f1 float32 = 3.1415926
		f2 float32 = 3E-3
		f3 float64 = 3.1E10
	)

算术运算

+、-、*、/、++、--
注意：针对/除数不能为0

// 浮点型-算术运算
	var (
		f1 float32 = 3.1415926
		f2 float32 = 3E-3
	)
	fmt.Println(f2)	//0.003
	fmt.Println(f1 + f2)	//3.1445925
	fmt.Println(f1 - f2)	//3.1385925
	fmt.Println(f1 * f2)	//0.009424778
	fmt.Println(f1 / f2)	//1047.1975
	f1++
	f2--
	fmt.Println(f1, f2)	//4.1415925 -0.997

关系运算

、>=、<、<=
浮动型不能进行==或者!=比较，可选择使用两个浮点数的差在一定区间内则认为相等

	// 浮点型-关系运算
	var (
		f1 float32 = 3.1415926
		f2 float32 = 3E-3
	)
	fmt.Println(f1 > f2)
	fmt.Println(f1 >= f2)
	fmt.Println(f1 < f2)
	fmt.Println(f1 <= f2)

赋值运算

=、-=、*=、/=

var (
		f1 float32 = 3.1415926
		f2 float32 = 3E-3
	)
	f1 += f1
	f2 -= f2
	fmt.Println(f1)
	fmt.Println(f2)

类型转换

Go不会自动对数据类型转换，因此左、右操作数类型必须一致或int莫个字面量，可通过类型名(数据)的语法将数据转换为对应类型。需要注意值截断和值溢出问题

var (
		f1 float32 = 3.1415926
	)

	fmt.Printf("%T %T\n", f1, float64(f1))

fmt.Printf进行格式化参数输出，占位符：

%f、%F    十进制表示法
%n.mf 表示最小占n个宽度并且最多保留m位小数
%e、%E    科学计数法表示
%g、%G    自动选择最紧凑得表示方法%e\%E和%f\%F

//  fmt.Printf打印
	var (
		f1 float32 = 3.1415926
		f3 float32 = 3E-3
	)

	fmt.Printf("%f %f %F %F\n", f1, f3, f1, f3)	//3.141593 0.003000 3.141593 0.003000
	fmt.Printf("%e %e %E %E\n", f1, f3, f1, f3)	//3.141593e+00 3.000000e-03 3.141593E+00 3.000000E-03
	fmt.Printf("%g %g %G %G\n", f1, f3, f1, f3)	//3.1415925 0.003 3.1415925 0.003
	fmt.Printf("|%5.2f| |%5.2f|\n", f1, f3)	//| 3.14| | 0.00|

复数型

Go 提供 complex64 和 complex128 两种复数类型，针对 complex64 复数的实部和虚部均使用
float32，针对 complex128 复数的实部和虚部均使用 float64

类型	长度
complex64	32位实数和虚数
complex128	64位实数和虚数

字面量

十进制表示法：1 + 2i，i*i = -1; 1为实部，2为虚部

常用函数

complex: 工厂函数，通过两个参数创建一个复数

real: 用于获取复数的实部

imag：用于获取复数的虚部

	//  复数
	var (
		c1 complex64 = 1 + 2i
		c2 complex64 = complex(3, 4)
	)

	fmt.Println(c1 + c2)	//(4+6i)
	fmt.Println(real(c1), imag(c1))	//1 2

字符串类型

Go语言内置了字符串类型，使用类型名string表示，零为空字符串""

只读的Unicode字节序列，Go语言使用UTF-8格式编码Unicode字符，每个字符对应一个rune类型。一旦字符串变量赋值之后，内部的字符就不能修改，英文是一个字节，中文是三个字节。

字面量

​ 可解析字符串：通过双引号"来创建，不包含多行，支持特殊字符转义序列

​ 原生字符串：通过反引号`来创建，包含多行，不支持特殊字符转义序列

特殊字符

	\\	反斜杠
	\'	单引号
	\"	双引号
	\a	响铃
	\b	退格
	\f	换页
	\n	换行
	\r	回车
	\t	制表符
	\v	垂直制表符
	\ooo	3个8位数字给定的八进制码点的Unicode字符(不能超过\377)
	\uhhhh	4个16位数字给定的十六进制码点的Unicode字符
	\Uhhhhhhhh	8个32位数字给定的十六进制码点的Unicode字符
	\xhh	2个8位数字给定的十六进制码点的Unicode字符

//  字符串
	var (
		s1 string = "aaa\nbbb"
		s2 string = `aaa\nbbb`
		s3 string = `aaa
							bbb`
		s4 string = "qwertyuiopasdfghjklzxcvbnm"
		s5 string = "我爱中国"
	)

	fmt.Println(s1)
	fmt.Println(s2)	//aaa\nbbb
	fmt.Println(s3)	/*aaa
													bbb*/

	fmt.Println(s4)
	fmt.Println(s5)	//我爱中国

常用操作

字符串拼接 +

关系运算符 >、>=、<、<=、==、!=

赋值运算符 +=

索引 s[index],针对只包含ascii字符的字符串

切片 s[start:end],针对只包含ascii字符的字符串

//  字符串
	var (
		s1 string = "aaa\nbbb"
		s2 string = `aaa\nbbb`
		s3 string = `aaa
							bbb`
		s4 string = "qwertyuiopasdfghjklzxcvbnm"
		s5 string = "我爱中国"
	)

	fmt.Println(s4+"aaaaaaaaaaaaaaaasssdscas")	//qwertyuiopasdfghjklzxcvbnmaaaaaaaaaaaaaaaasssdscas
	s5 += "--来自南方"
	fmt.Println(s5)	//我爱中国--来自南方
	fmt.Println(s1 == s2)	//false
	fmt.Println(s1 != s3)	//true
	fmt.Println("abc" > "abe")	//false
	fmt.Println("abc" >= "abe")	//false
	fmt.Println("abc" <= "abe")	//true

	fmt.Println(s4[0])	//索引0的ascii：113
	// 切片前包后不包
	fmt.Println(s4[:], s4[3:], s4[:8], s4[3:8])	//qwertyuiopasdfghjklzxcvbnm rtyuiopasdfghjklzxcvbnm qwertyui rtyui

常用函数

​ len 获取字符串长度(针对只包含ascii字符的字符串)

​ string 将byte或rune数组转换为字符串

使用fmt.Printf进行格式化参数输出，占位符:

%s	基本的字符串输出

%d	十进制

	//  字符串
	var (
		s1 string = "aaa\nbbb"
		s5 string = "我爱中国"
	)

	fmt.Printf("%s len %d\n", s1, len(s1))
	fmt.Printf("%s len %d\n", s5, len(s5))

类型转换

string转int：    int, err := strconv.Atoi(string)
string转int64：  int64, err := strconv.ParseInt(string, 10, 64)
int转string：    string := strconv.Itoa(int)
int64转string：  string := strconv.FormatInt(int64, 10)

枚举类型

常使用iota生成器用于初始化一系列相同规则的常量，批量声明常量的第一个常量的使用iota进行赋值，此时 iota 被重置为 0，其他常量省略类型和赋值，在每初始化一个常量则加 1

const (
	i1 int = iota
	i2
	i3 int = iota
	i4
)

func main() {
	//  枚举类型
	const (
		i5 = iota
		i6
		i7 = 7
		i8 = iota
		i9
	)

	fmt.Println(i1, i2, i3, i4, i5, i6, i7, i8, i9)	//0 1 2 3 0 1 7 3 4

}

指针类型（Pointer)

一个指针变量可以指向任何一个值的内存地址。它指向那个值的内存地址，在 32 位机器上占用 4 个字节，在 64 位机器上占用 8 个字节，并且与它所指向的值的大小无关。当然，可以声明指针指向任何类型的值来表明它的原始性或结构性；你可以在指针类型前面加上号（前缀）来获取指针所指向的内容，这里的号是一个类型更改器。使用一个指针引用一个值被称为间接引用。

当一个指针被定义后没有分配到任何变量时，它的值为 nil，表示空指针

一个指针变量通常缩写为 ptr。

符号 ““ 可以放在一个指针前，如 “intP”，那么它将得到这个指针指向地址上所存储的值；这被称为反引用（或者内容或者间接引用）操作符；另一种说法是指针转移。

对于任何一个变量 var， 如下表达式都是正确的：var == *(&var)

注意事项：
你不能得到一个数字或常量的地址，下面的写法是错误的。

//例如：
const i = 5
ptr1 := &i // error: cannot take the address of i
ptr2 := &10 // error: cannot take the address of 10

所以说，Go 语言和 C、C++ 以及 D 语言这些低级（系统）语言一样，都有指针的概念。

但是对于经常导致 C 语言内存泄漏继而程序崩溃的指针运算（所谓的指针算法，如：pointer+2，移动指针指向字符串的字节数或数组的某个位置）是不被允许的。

Go 语言中的指针保证了内存安全，更像是 Java、C# 和 VB.NET 中的引用。

因此 c = *p++ 在 Go 语言的代码中是不合法的。

指针的一个高级应用是你可以传递一个变量的引用（如函数的参数），这样不会传递变量的拷贝。指针传递是很廉价的，只占用 4 个或 8 个字节。当程序在工作中需要占用大量的内存，或很多变量，或者两者都有，使用指针会减少内存占用和提高效率。被指向的变量也保存在内存中，直到没有任何指针指向它们，所以从它们被创建开始就具有相互独立的生命周期。

另一方面（虽然不太可能），由于一个指针导致的间接引用（一个进程执行了另一个地址），指针的过度频繁使用也会导致性能下降。

指针也可以指向另一个指针，并且可以进行任意深度的嵌套，导致你可以有多级的间接引用，但在大多数情况这会使你的代码结构不清晰。

如我们所见，在大多数情况下 Go 语言可以使程序员轻松创建指针，并且隐藏间接引用，如：自动反向引用。

对一个空指针的反向引用是不合法的，并且会使程序崩溃：

package main
func main() {
    var p *int = nil
    *p = 0
}
// 结果err: panic: runtime error: invalid memory address or nil pointer dereference
// 紧急：运行时错误：无效的内存地址或nil指针取消引用

指针的使用方法：

• 定义指针变量；
• 为指针变量赋值；
• 访问指针变量中指向地址的值；
• 在指针类型前面加上*号来获取指针所指向的内容。

package main

import "fmt"

func main() {
    var a, b int = 20, 30 // 声明实际变量
    var ptra *int         // 声明指针变量
    var ptrb *int = &b
    
    ptra = &a // 指针变量的存储地址 // 取出a的地址赋值给ptra => 取引用
    
    fmt.Printf("a  变量的地址是: %x\n", &a)
    fmt.Printf("b  变量的地址是: %x\n", &b)
    
    // 指针变量的存储地址
    fmt.Printf("ptra  变量的存储地址: %x\n", ptra)
    fmt.Printf("ptrb  变量的存储地址: %x\n", ptrb)
    
    // 使用指针访问值
    fmt.Printf("*ptra  变量的值: %d\n", *ptra)  // 获取ptra内存地址中对应的存储的值 => 解引用
    fmt.Printf("*ptrb  变量的值: %d\n", *ptrb)	// 获取ptrb内存地址中对应的存储的值 => 解引用
}

数组值类型

package main

import "fmt"

func main() {
	nums := [5]int{1, 2, 3, 4, 5}
	nums2 := nums

	fmt.Println(nums, nums2)

	nums2[0] = 100
	fmt.Println(nums, nums2) // nums的[0]不受影响
    // 指针
    // 值类型
    // int, float, bool, string => 值类型
    // 赋值 原有的数据复制一份给新的变量
    // 两个变量之间没有任何联系
    // 对nums进行任何修改都不会影响nums2
    // 对nums2进行任何修改也不会影响nums
    
    var numsPoint *[5]int = &nums  // 取出nums数组地址赋值给numsPoint => 取引用
	fmt.Printf("%T\n", numsPoint)
	numsPoint[0] = 100
	fmt.Println(nums, numsPoint) // 指针影响
}