数据类型
动态类型编程语言
- 运行时判断
静态类型的编程语言 ： Go 、C 、
- 在开发的时候，就需要给一些定义的变量赋值空间大小。C 需要自己去开辟这个空间
数据类型 ： 每种在Go语言中出现的基本数据类型，会有一个默认的空间大小。
1、布尔类型数据
布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。
package mainimport "fmt"func main() {// 定义变量var b1 bool = truevar b2 bool = false// bool类型只有两个值 true 和 falsefmt.Println(b1, b2)fmt.Printf("%T,%t\n", b1, b1)fmt.Printf("%T,%t\n", b2, b2)/*true falsebool,truebool,false*/// 比大小var a int = 1var 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 = 1var b3 boolfmt.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 mainimport "fmt"func main() {// 默认是 float64var f1 float64var f2 float32f1 = 3.14456f2 = 5fmt.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 mainimport "fmt"func main() {// 浮点数 = 符号位 + 指数位 + 尾数位 （可能会丢失，造成精度损失）var num1 float32var num2 float64num1 = -123.0000901num2 = -123.0000901fmt.Println(num1)fmt.Println(num2)// -123.00009//-123.0000901// 使用float来计算，可能导致数据不精确
}4、特殊的数字类型
package mainimport "fmt"// byte就类似uint8（0-255之间的整数，我们通常使用byte使用）
func main() {var num1 byte = 255fmt.Println(num1) // 255fmt.Printf("%T", num1) // uint8// rune int32var num2 rune = 1000000000fmt.Println(num2)fmt.Printf("%T", num2)// int 根据系统大小来的var num3 int = 100000000000000fmt.Println(num2)fmt.Printf("%T", num3)
}byte和rune 主要是为了用来和int去做区分的
5、字符串类型
字符串就是一串固定长度的字符连接起来的字符序列。 一段中文或者英文 （编码- 字符）
Go语言中，所有的字符串都是由单个 字符 连接起来的。兼容全世界文字的
拓展：了解编码表
UTF-8编码 ， 目前兼容我们绝大部分的文字和符号。
GBK编码：中国的编码表，号称兼容所有的中文汉字。
Unicode编码表 ：号称兼容了全世界的文字。
编码 “中” 本质是一个数字
package mainimport "fmt"func main() {var s strings = "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,aint32,65int32,39761*/
}6、数据类型转换
在必要以及可行的情况下，一个类型的值可以被转换成另一种类型的值。
由于Go语言不存在隐式类型转换，因此所有的类型转换都必须显式的声明： A = A(B)
package mainimport "fmt"func main() {// 浮点数转整数，直接截断，不是四舍五入// 新类型的值 = 新类型（旧类型的值）a := 5.0b := int(a)fmt.Printf("%T,%d", b, b)c := 1d := float64(c)fmt.Printf("%T,%f", d, d)// bool类型不支持类型转换// var flag bool = true// f := int(flag)
}变量的定义： var 变量名 数据类型
数据类型 是没有上限的，以上的都是基本数据类型，常用的，系统自带的，必要的。任何一个编程语言都会有。
除了这些之外，会存在一些自己开发的数据类型（数据结构都是可以自己定义的）
运算符
1、算术运算符
package mainimport "fmt"func main() {// 算术运算符 + - * / % ++ --var a int = 7var b int = 3var c int // 结果// 双元运算符，由两个变量参与运算，或者多个c = a + bfmt.Println(c)c = a - bfmt.Println(c)c = a * bfmt.Println(c)c = a / b // 除 7/3 = 2...1fmt.Println(c)c = a % b // 取模 余数 1fmt.Println(c)// 单元运算符，用自己就可以操作得出结果// 自增++ 自减--fmt.Println(a)a++ // a = a + 1 自增，在自己的基础上 + 1fmt.Println(a)a = 7a-- // a = a-1。 遍历输出一些东西（10000个数字）fmt.Println(a)}
2、关系运算符
-
大于 >
-
小于 <
-
等于 ==
-
不等于 !=
-
大于等于 > =
-
小于等于 < =
-
结果：布尔值 （对或者错）
package mainimport "fmt"func main() {var a int = 20var b int = 12fmt.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 mainimport "fmt"func main() {var a bool = truevar b bool = falsevar c bool = falsevar d bool = falsevar e bool = truefmt.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 mainimport "fmt"func main() {// 位运算,都是操作二进制var a int = 60 //0011 1100var b int = 13 //0000 1101// &fmt.Println(a & b)// 0011 1100// 0000 1101// 0000 1100// 12fmt.Println(a | b)// |// 0011 1100// 0000 1101// 0011 1101// 61// ^ 按位异或 相同为0 不同为1// 0011 1100// 0000 1101// 0011 0001// 49fmt.Println(a ^ b)// &^ 位清空，对于b上的每个数值，如果为0，则取a对应位上的数值，如果为1，则取0.// 0011 1100 a// 0000 1101 b// 0011 0000fmt.Println(a &^ b)// << 2// 0011 1100// 1111 0000fmt.Println(a << 2) // 240// >> 2// 0011 1100// 0000 1111fmt.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; 是一个指针变量 |
