数据类型和运算符

数据类型

动态类型编程语言

• 运行时判断

静态类型的编程语言 ： Go 、C 、

• 在开发的时候，就需要给一些定义的变量赋值空间大小。C 需要自己去开辟这个空间

数据类型 ： 每种在Go语言中出现的基本数据类型，会有一个默认的空间大小。

1、布尔类型数据

布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。

package main

import "fmt"

func main() {
	// 定义变量
	var b1 bool = true
	var b2 bool = false
	// bool类型只有两个值 true 和 false
	fmt.Println(b1, b2)
	fmt.Printf("%T,%t\n", b1, b1)
	fmt.Printf("%T,%t\n", b2, b2)
	/*
		true false
		bool,true
		bool,false
	*/
    // 比大小
   var a int = 1
   var b int = 2
   // 如果  xxx  否则 xxx
   // 结果就是bool类型
   fmt.Println(a > b)
   if a > b {
      fmt.Println("a是大于b的")
      // .....
   } else {
      fmt.Println("a是小于b的")
   }

   // bool 类型的默认值 false， 规定  false  0   true = 1
   var b3 bool
   fmt.Println("bool默认值：", b3)
}

2、数字型 int

整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。

Go 也有基于架构的类型，例如：uint 无符号、int 有符号

每个数字，都是有范围的， 有的数字只能大于0

有的数字可以小于0

在计算机中，所有的东西最终都是存在内存当中的，所以我们不能无限的放置东西（数字）

序号	类型和描述
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、有符号数和无符号数的区别

• 0为分界，正负推进.......空间大小 ，空间大小是根据位来判断的 int 8 16 32 64、二进制的位，这个数据类型值的上限
• 0 + 空间大小

2、了解 二进制基本原理

3、尝试自己推算出每个整数数据类型的大小上限值。

3、浮点数

package main

import "fmt"

func main() {
	// 默认是 float64
	var f1 float64
	var f2 float32
	f1 = 3.14456
	f2 = 5
	fmt.Printf("f1=%f,f1=%T\n", f1, f1)
	fmt.Printf("f2=%f,f2=%T\n", f2, f2)
	// 保留两位小数，四舍五入
	fmt.Printf("f1=%.3f,f1=%T\n", f1, f1)
	fmt.Printf("f1=%.2f,f1=%T\n", f1, f1)

	// 浮点数是不精确的，计算机底层导致的
}

package main

import "fmt"

func main() {
	// 浮点数 = 符号位 + 指数位 + 尾数位 （可能会丢失，造成精度损失）
	var num1 float32
	var num2 float64
	num1 = -123.0000901
	num2 = -123.0000901
	fmt.Println(num1)
	fmt.Println(num2)
	// -123.00009
	//-123.0000901
	// 使用float来计算，可能导致数据不精确
}

4、特殊的数字类型

package main

import "fmt"

// byte就类似uint8（0-255之间的整数，我们通常使用byte使用）
func main() {
	var num1 byte = 255
	fmt.Println(num1)      // 255
	fmt.Printf("%T", num1) // uint8

	// rune  int32
	var num2 rune = 1000000000
	fmt.Println(num2)
	fmt.Printf("%T", num2)

	// int 根据系统大小来的
	var num3 int = 100000000000000
	fmt.Println(num2)
	fmt.Printf("%T", num3)
}

byte和rune 主要是为了用来和int去做区分的

5、字符串类型

字符串就是一串固定长度的字符连接起来的字符序列。 一段中文或者英文 （编码- 字符）

Go语言中，所有的字符串都是由单个 字符 连接起来的。兼容全世界文字的

拓展：了解编码表

UTF-8编码 ， 目前兼容我们绝大部分的文字和符号。

GBK编码：中国的编码表，号称兼容所有的中文汉字。

Unicode编码表 ：号称兼容了全世界的文字。

编码 “中” 本质是一个数字

package main

import "fmt"

func main() {
	var s string
	s = "hello"
	fmt.Printf("%T,%s\n", s, s) //string,hello

	// 单引号是字符，双引号是字符串
	v1 := "a"
	v2 := 'A'
	v3 := '魑'
	fmt.Printf("%T,%s\n", v1, v1)
	fmt.Printf("%T,%d\n", v2, v2)
	fmt.Printf("%T,%d\n", v3, v3)
	/*	string,a
		int32,65
		int32,39761*/
}

6、数据类型转换

在必要以及可行的情况下，一个类型的值可以被转换成另一种类型的值。

由于Go语言不存在隐式类型转换，因此所有的类型转换都必须显式的声明： A = A(B)

package main

import "fmt"

func main() {
	// 浮点数转整数，直接截断，不是四舍五入
    // 新类型的值 = 新类型（旧类型的值）
    
	a := 5.0
	b := int(a)
	fmt.Printf("%T,%d", b, b)

	c := 1
	d := float64(c)
	fmt.Printf("%T,%f", d, d)

	// bool类型不支持类型转换
	// var flag bool = true
	// f := int(flag)
}

变量的定义： var 变量名 数据类型

数据类型 是没有上限的，以上的都是基本数据类型，常用的，系统自带的，必要的。任何一个编程语言都会有。

除了这些之外，会存在一些自己开发的数据类型（数据结构都是可以自己定义的）

运算符

1、算术运算符

package main

import "fmt"

func main() {
   // 算术运算符 + - * / % ++ --
   var a int = 7
   var b int = 3
   var c int // 结果
   // 双元运算符，由两个变量参与运算，或者多个
   c = a + b
   fmt.Println(c)
   c = a - b
   fmt.Println(c)
   c = a * b
   fmt.Println(c)

   c = a / b // 除 7/3 = 2...1
   fmt.Println(c)
   c = a % b // 取模 余数  1
   fmt.Println(c)

   // 单元运算符，用自己就可以操作得出结果
   //  自增++  自减--
   fmt.Println(a)
   a++ // a = a + 1 自增，在自己的基础上 + 1
   fmt.Println(a)

   a = 7
   a-- // a = a-1。  遍历输出一些东西（10000个数字）
   fmt.Println(a)
   
}

2、关系运算符

• 大于 >

• 小于 <

• 等于 ==

• 不等于 !=

• 大于等于 > =

• 小于等于 < =

• 结果：布尔值 （对或者错）

package main

import "fmt"

func main() {
	var a int = 20
	var b int = 12
	fmt.Println(a > b)
	fmt.Println(a < b)
	fmt.Println(a == b)
	fmt.Println(a != b)
	fmt.Println(a >= b)
	fmt.Println(a <= b)

}

3、逻辑运算符

判断多个条件是否存在的时候，就需要逻辑

&& 与 只要有一个错，大家都是错的 false，两个都对才是对的。 多条件同时满足（与）

与（和） And 对 And 错 对 And 对（true） 错 And 对 错和错 共生！

|| 或 只要有一个对的，那么就是对的，两个都是错的，结果才是错的。（or）

或 Or 或者 对 or 错 （true） 对 or对（true） 错 or对 （true） 错or错 （错）

！如果是真的，那么为假，如果是假，则为真。

非（取反）

package main

import "fmt"

func main() {
	var a bool = true
	var b bool = false
	var c bool = false
	var d bool = false
	var e bool = true
	fmt.Println(a && b)
	fmt.Println(c && d)
	fmt.Println(a && e)
	fmt.Println(1 != 1 && e || d)
	fmt.Println(1 == 1 && e || d)
}

4、位运算符

（数的二进制来进行计算的，加密解密，一些特殊的高效运算）

Go 语言支持的位运算符如下表所示。假定 A 为60，B 为13：

运算符	描述	实例
&	按位与运算符"&"是双目运算符。都是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

package main

import "fmt"

func main() {
	// 位运算,都是操作二进制
	var a int = 60 //0011 1100
	var b int = 13 //0000 1101
	// &
	fmt.Println(a & b)
	// 0011 1100
	// 0000 1101
	// 0000 1100
	// 12

	fmt.Println(a | b)
	// |
	// 0011 1100
	// 0000 1101
	// 0011 1101
	// 61

	// ^   按位异或 相同为0  不同为1
	// 0011 1100
	// 0000 1101
	// 0011 0001
	// 49
	fmt.Println(a ^ b)

	// &^ 位清空，对于b上的每个数值，如果为0，则取a对应位上的数值，如果为1，则取0.
	// 0011 1100  a
	// 0000 1101  b
	// 0011 0000
	fmt.Println(a &^ b)

	// << 2
	// 0011 1100
	// 1111 0000
	fmt.Println(a << 2)  // 240
	
	// >> 2
	// 0011 1100
	// 0000 1111
	fmt.Println(a >> 2)  // 15
	
	// 可以理解为 左乘右除
}

5、赋值运算符

下表列出了所有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

6、其他运算符

下表列出了Go语言的其他运算符。

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