day02 go的数据类型和运算符

前言

• 动态语言类型
• 自动开辟数据空间，自动识别数据类型 python
• 静态语言类型
• 开辟内存空间，定义数据类型 c，java，go

go 语言中的数据类型

/*
	- go 基本数据类型：
		- 布尔类型
		- 数值类型
			- 整型  :
				- 有符号：int,int8,int16,int32,int64.
				- 无符号：uint,uint8,uint16,uint32,uint64
			- 浮点型
				- float32,float64
				- 复数：complex
		- 字符串类型
	- 派生数据类型
		- 指针 *
		- 数组 array
		- 结构体 struct
		- 通道 channel
		- 切片 slice
		- 函数 func
		- 接口 interface
		- Map
*/

code

// 1. 布尔类型
	var b1 bool
	var b2 bool
	b1 = true
	b2 = false
	fmt.Println(b1, b2)

	// f fmt.Printf 格式化输出 ： %d 整数, %s 字符串，%p 内存地址, %T 数据类型，%t布尔类型数据结果 ,%f 浮点数据
	fmt.Printf("布尔类型数据的整数结果：b1=%T,%t\n", b1, b1)
	fmt.Printf("布尔类型数据的整数结果：b2=%T,%t\n", b2, b2)

	// 布尔默认值 ： false = 0 , true = 1
	var b3 bool
	fmt.Println(b3)

	// 2. 整数类型,不能超过该数据类型的长度
	var i1 int8
	i1 = 10
	fmt.Println(i1)
	//i1 = 1000 // 超出 int8 的范围。 cannot use 1000 (untyped int constant) as int8 value in assignment (overflows)
	fmt.Println(i1)

	//var i2 uint8
	//i2 = -100 // cannot use -100 (untyped int constant) as uint8 value in assignment (overflows)
	//fmt.Println(i2)

	// 3. 浮点型，默认保留 小数点后 六位
	var f1 float32
	f1 = -19999
	fmt.Printf("%T,%f\n", f1, f1)
	fmt.Println(f1)
	f1 = 3.14
	fmt.Printf("%T,%f\n", f1, f1)
	fmt.Println(f1)

	// 保留小数点后3位. 格式化输出：%.3f，超出的位数四舍五入
	var f2 float32
	f2 = 3.1415926
	fmt.Printf("%.3f\n", f2) // 3.142。自动四舍五入

	// float32 和 float64 精度不一样. 默认使用 float64
	var f3 float32 = -123.0000901
	var f4 float64 = -123.0000901
	fmt.Println(f3, f4) // -123.00009 -123.0000901

	// 4. 特殊数字类型 无符号
	// byte类型. byte == uint8
	var byte1 byte = 255
	fmt.Println(byte1)
	fmt.Printf("%T\n", byte1) // uint8 类型

	// rune类型 rune == int32
	var rune1 rune = 1000000000
	fmt.Println(rune1)
	fmt.Printf("%T\n", rune1) // int32 类型

	// int 默认根据系统位数来定义
	var int1 int = 1000
	fmt.Println(int1)
	fmt.Printf("%T\n", int1) // int 类型

	// 5. 字符串类型. go中字符串由字符组成。  go 默认使用utf-8编码类型
	var str0 string
	str0 = "Hello Word"
	fmt.Printf("%T %s \n", str0, str0) // string 类型

	var str1 string
	str1 = "go 语言学习中" // 空格隔开中文，英文不隔开
	fmt.Println(str1)

	//  单引号：字符 字符的本质是整形数值类型数据.  双引号：string类型
	s1 := 'A'
	s2 := "A"
	fmt.Println(s1, s2)           // 65, A
	fmt.Printf("%T,%T\n", s1, s2) // int32,string

	// 转义字符： \ 转义符号： \n 换行， \b 删除上一个字符，\t tab
	fmt.Println("hello\nword")
	fmt.Println("hello\bword")
	fmt.Println("hello\tword")

	// 反 转义字符
	fmt.Println("\\n")
	fmt.Println("\"")

	// 多行文本 使用 反引号 : ``
	s3 := `go 多行文本`
	fmt.Println(s3)

	// 6. 数值类型转换. 格式：新类型的值=新类型(旧类型的值).
	// int 转换为 float
	var v1 int
	v1 = 1
	v2 := float64(v1)
	fmt.Printf("%T,%d\n", v1, v1)
	fmt.Printf("%T,%.3f\n", v2, v2)

	// float 转换为 int
	c := 12
	d := float64(c)
	fmt.Printf("%T,%.3f\n", d, d)
	fmt.Printf("%T,%d\n", c, c)

	// 布尔类型 不支持转换

数值型

序号	类型和描述
1	uint8 无符号 8 位整型 (0 到 255)
2	uint16 无符号 16 位整型 (0 到 65535)
3	uint32 无符号 32 位整型 (0 到 4294967295)
4	uint64 无符号 64 位整型 (0 到 18446744073709551615)
5	int8 有符号 8 位整型 (-128 到 127) 0
6	int16 有符号 16 位整型 (-32768 到 32767)
7	int32 有符号 32 位整型 (-2147483648 到 2147483647)
8	int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

转义字符

运算符

/*
		运算符
			- 算数运算符
				- 取模 %
				- 加减乘除
				- ++ , -- 自增/自减
			- 赋值运算符
				- = 赋值运算符
				- += 加等于
				- -= 减等于
				- /= 处等于
				- *= 乘等于
			- 逻辑运算符
				- 与 &&， 或 || ，非 !
				- ! 取反运算符
			- 位运算符。 加密解密常用。 基于二进制数据计算
				- & 对比位置。相同位置位比较，两个为1就是1
				- | 对比位置。相同位置比较，一个为1就是1
				- >> 右移。
				- << 左移
				- ^ 相异或
				- &^ 位清空。 a &^ b。 为：0，取a上的数值。 为:1 ，取0（二进制）

			- 关系运算符
				- 大于>，小于<，等于==,不等于!=，大于等于>=，小于等于<= .
			- 其他运算符
				- & 取地址
				- * 指针符号


*/

code

// 取模
	c := 7 % 2
	fmt.Println(c)

	// 取反
	b := true
	fmt.Println(!b)

	// 位运算
	// &
	aa := 1              //二进制001
	bb := 5              //二进制101
	fmt.Println(aa & bb) // 1
	// ｜
	fmt.Println(aa | bb) // 5
	// >> 右
	fmt.Println(bb >> 1) // 2. 101 右移动1位。 10 = 2
	fmt.Printf("%b\n", bb>>1)
	// << 左
	fmt.Println(bb << 1) // 10. 101 左移动1为。 1010 = 10
	fmt.Printf("%b\n", bb<<1)

	println()

	AA := 60 // 二进制：0011 1100
	BB := 13 // 二进制：0000 1101
	// &  0000 1100
	fmt.Println(AA & BB) // 12
	res1, _ := strconv.ParseInt("00001101", 2, 64)
	fmt.Println("二进制转十进制：", res1)

	// ｜ 0011 1101
	fmt.Println(AA | BB) // 61
	res2, _ := strconv.ParseInt("00111101", 2, 64)
	fmt.Println("二进制转十进制：", res2)

	// ^ 按位异或.  位置相同为0，不同为1。 0011 0001
	fmt.Println(AA ^ BB) // 0011 0001
	res3, _ := strconv.ParseInt("00110001", 2, 64)
	fmt.Println("二进制转十进制：", res3)

	// &^ 位清空。 a &^ b。 为：0，取a上的数值; 为:1 ，取0（二进制）
	fmt.Println(AA &^ BB) // 0011 0000
	res4, _ := strconv.ParseInt("00110000", 2, 64)
	fmt.Println("二进制转十进制：", res4)

	// >> 左移 几位
	fmt.Println(AA << 2) // 二进制：0011 1100  ---->  1111 0000
	res5, _ := strconv.ParseInt("11110000", 2, 64)
	fmt.Println("二进制转十进制：", res5)

	// << 右移 几位
	fmt.Println(AA >> 2) // 二进制：0011 1100  ---->  0000 1111
	res6, _ := strconv.ParseInt("00001111", 2, 64)
	fmt.Println("二进制转十进制：", res6)

位运算符 图解

运算符	描述	实例
&	按位与运算符"&"是双目运算符。都是1结果为1，否则是0	(A & B) 结果为 12, 二进制为 0000 1100
|	按位或运算符"|"是双目运算符。 都是0结果为0，否是是1	(A | B) 结果为 61, 二进制为 0011 1101
^	按位异或运算符"^"是双目运算符。 不同则为1，相同为0	(A ^ B) 结果为 49, 二进制为 0011 0001
&^	位清空，a &^ b，对于b上的每个数值，如果为0，则取a对应位上的数值，如果为1，则取0.	(A &^ B) 结果为 48, 二进制为 0011 0000
<<	左移运算符"<<"是双目运算符。左移n位就是乘以2的n次方。 其功能把"<<"左边的运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。	A << 2 结果为 240 ，二进制为 1111 0000
>>	右移运算符">>"是双目运算符。右移n位就是除以2的n次方。 其功能是把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数。	A >> 2 结果为 15 ，二进制为 0000 1111

go 中的数据类型图

赋值运算符

运算符	描述	实例
=	简单的赋值运算符，将一个表达式的值赋给一个左值	C = A + B 将 A + B 表达式结果赋值给 C
+=	相加后再赋值	C += A 等于 C = C + A
-=	相减后再赋值	C -= A 等于 C = C - A
*=	相乘后再赋值	C *= A 等于 C = C * A
/=	相除后再赋值	C /= A 等于 C = C / A
%=	求余后再赋值	C %= A 等于 C = C % A
<<=	左移后赋值	C <<= 2 等于 C = C << 2
>>=	右移后赋值	C >>= 2 等于 C = C >> 2
&=	按位与后赋值	C &= 2 等于 C = C & 2
^=	按位异或后赋值	C ^= 2 等于 C = C ^ 2
|=	按位或后赋值	C |= 2 等于 C = C | 2

其他运算符

运算符	描述	实例
&	返回变量存储地址	&a; 将给出变量的实际地址。
*	指针变量。	*a; 是一个指针变量