✨✨ 欢迎大家来到景天科技苑✨✨
🎈🎈 养成好习惯，先赞后看哦~🎈🎈
🏆 作者简介：景天科技苑
🏆《头衔》：大厂架构师，华为云开发者社区专家博主，阿里云开发者社区专家博主，CSDN全栈领域优质创作者，掘金优秀博主，51CTO博客专家等。
🏆《博客》：Python全栈，Golang开发，PyQt5和Tkinter桌面开发，小程序开发，人工智能，js逆向，App逆向，网络系统安全，数据分析，Django，fastapi，flask等框架，云原生K8S，linux，shell脚本等实操经验，网站搭建，数据库等分享。所属的专栏：Go语言开发零基础到高阶实战
景天的主页：景天科技苑
文章目录
- go数据类型
- 布尔数据类型
- 整形 int
- 浮点型
- 验证：浮点数计算时不精确的
- 特殊的数字类型
- 字符串类型
- 转义字符
- go数据类型转换
go数据类型
Go语言是一种静态类型、编译型语言，它提供了丰富的数据类型用于处理各种数据。
在Go中，数据类型主要分为两大类：基本数据类型和派生数据类型。值类型包括整型、浮点型、布尔型、字符串等，而派生数据类型则包括指针、数组、结构体、函数、切片、映射、通道和接口等。本文将通过实际案例详细讲解Go语言中的基本数据类型及其用法。
布尔数据类型
布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。
bool的默认值是false
package main
import "fmt"
func main() {
// bool类型，只有两个值 true 和 false。 对和错
// 定义变量 bool 布尔类型的定义 与 int、string 都是Go语言中基本数据类型。
var b1 bool
var b2 bool
b1 = true
b2 = false
// f 格式化输出 %d 整数 %s 字符串 %p内存地址 %T 类型 %t bool值
fmt.Printf("b1=%T,%t\n", b1, b1)
fmt.Printf("b2=%T,%t\n", b2, b2)
// 比大小
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)
}
整形 int
整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。
Go 也有基于架构的类型，例如：uint 无符号、int 有符号
每个数字，都是有范围的， 有的数字只能大于0
有的数字可以小于0
在计算机中，所有的东西最终都是存在内存当中的，所以我们不能无限的放置东西（数字）
定义整形变量，超过范围会报错，定义的时候不报错，运行的时候报错
package main
import "fmt"
func main() {
// 定义的时候超过限制是不会报错的，但是在运行时发生了错误 expected 'package', found 'EOF'
// 计算只能存放固定大小的值。
// 我们在定义这个类型的时候，系统给了我们一个空间
var a int = 666666666666666666666663333333333
fmt.Println(a)
}
package main
import "fmt"
func main() {
// 定义的时候超过限制是不会报错的，但是在运行时发生了报错
// 计算只能存放固定大小的值。
// 我们在定义这个类型的时候，系统给了我们一个空间
//var a int64 = 666666666666666666666663333333333
//fmt.Println(a)
var i1 int8 // (-128 到 127)
i1 = -100
fmt.Println(i1)
//i1 = 1000
//fmt.Println(i1)
// 由于系统现在空间都很大，默认都使用 int64 int。
// 二进制的8位 00000000
// 二进一 01
// 00000000
// 0 0
// 1 1
// 2 10
// 3 11
// 4 100
// 0~255
// 00000000 - 11111111
// int16 0000000000000000 - 1111111111111111
// int32 00000000000000000000000000000000 - 11111111111111111111111111111111
// int64
// >0 无符号数+ 有符号数 + -
// 定义这个变量的时候，空间大小已经被这个数据类型确定了。
var i2 uint8 // 0 ~ 255
i2 = 255
fmt.Println(i2)
}
浮点型
浮点型用于表示有小数部分的数。Go语言提供了float32和float64两种浮点型，分别占用32位和64位存储空间。
默认情况下，Go语言中的浮点字面量被当作float64类型。
浮点数 float ：float32 float64 ，也是一个空间的大小。
package main
import "fmt"
// 浮点数 float ，默认是 float64 ，32
func main() {
// 浮点数是不精确的,计算机底层导致的 0 1、浮点数、复数，没办法做到精确计算
var f1 float64
f1 = 3.16
var f2 float32
f2 = 5
fmt.Println(f1)
// // 默认的 float 类型，都是保留了6位小数
// 浮点数的格式化输出 %f ，都是保留了6位小数,保留2位或者3位怎么实现
// .3 保留3位小数 其余类推
// 如果小于了当前保留的位数，四舍五入
fmt.Printf("%T,%.1f\n", f1, f1)
fmt.Printf("%T,%f", f2, f2)
}
验证：浮点数计算时不精确的
package main
import "fmt"
func main() {
// 浮点数 ； 符号位 + 指数位 + 尾数位（存储过程中,可能会丢失，造成精度损失）。
// float64 的空间 > float32
var num1 float32 = -123.0000901
var num2 float64 = -123.0000901
fmt.Println(num1)
fmt.Println(num2)
// 结论：
// 1、使用float来计算，可能导致数据不精确。
// 2、float64的精度>float32， go语言中，浮点数默认使用的是float64
}
特殊的数字类型
byte 就是uint8
rune 就是int32
package main
import "fmt"
// byte
func main() {
// 别名uint8是byte，十分常用
// byte = uint8 （0-255之间的整数，我们通常使用byte来定义） uint8
var num1 byte = 255
fmt.Println(num1)
fmt.Printf("%T\n", num1)
// 不经常用 rune int32
var num2 rune = 1000000000
fmt.Println(num2)
fmt.Printf("%T\n", num2)
// int、系统大小来的，32位 32、64默认是64
// 软件跑在32位系统上是不兼容的
var num3 int = 100000
fmt.Println(num3)
fmt.Printf("%T\n", num3)
}
64位的操作系统是可以兼容32位的、32为不能跑64位的软件。 寻址空间。
字符串类型
字符串就是一串固定长度的字符连接起来的字符序列。 一段中文或者英文 （编码- 字符）
Go语言中，所有的字符串都是由单个 字符 连接起来的。兼容全世界文字的，Go语言默认用的是utf-8编码
UTF-8编码 ， 目前兼容我们绝大部分的文字和符号。
GBK编码：中国的编码表，号称兼容所有的中文汉字。
Unicode编码表 ：号称兼容了全世界的文字。
编码 中 本质是一个数字
Go语言中，所有的字符串都是由单个 字符 连接起来的
Go语言中，单引号是字符、双引号才是 string 类型
字符本质是整型
package main
import "fmt"
func main() {
var str string
str = "Hello,World"
fmt.Printf("%T,%s\n", str, str)
// H E L L O , W O R L D
// Go语言中，所有的字符串都是由单个 字符 连接起来的。
// 单引号是字符、双引号才是 string 类型
// 字符本质是整型
v1 := 'A'
v2 := "A"
fmt.Printf("%T,%d\n", v1, v1)
fmt.Printf("%T,%s\n", v2, v2)
v3 := '景'
fmt.Printf("%T,%d\n", v3, v3)
}
转义字符
常见的转义字符
package main
import "fmt"
func main() {
// 特殊的字符 转义字符 \n
// \n 换行
fmt.Println("hello\nworld")
// \b backspace 删除上一个字符
fmt.Println("hello\bworld")
// \t Tab
fmt.Println("hello\tworld")
}
多行输入使用 ``
多行文本
package main
import "fmt"
func main() {
// 特殊的字符 转义字符 \n
// \n 换行
fmt.Println("hello\nworld")
// \b backspace 删除上一个字符
fmt.Println("hello\bworld")
// \t Tab
fmt.Println("hello\tworld")
// 转义，就是可以将特殊转义符号或者一些符号打印出来 \
// ` ` 可以通过它来定义一些长字符串，可以换行输入
fmt.Println(`\\n
sadad
asd
a
sd
asda
sd
asda`)
}
go数据类型转换
在必要以及可行的情况下，一个类型的值可以被转换成另一种类型的值。
由于Go语言不存在隐式类型转换，因此所有的类型转换都必须显式的声明： A = A(B)
布尔类型不支持类型转换
package main
import "fmt"
// 类型转换
func main() {
// 数据类型转换在Go中就一个格式
// 新类型的值 = 新类型（旧类型的值）
// 高位向低位转 （int64 int32 int16）
// 浮点数转整数，截断，只保留整数部分
a := 5.9 // float
b := int(a) // b 就是int类型的a = 5
fmt.Printf("%T,%.1f\n", a, a)
fmt.Printf("%T,%d\n", b, b)
c := 1
d := float64(c)
fmt.Printf("%T,%d\n", c, c)
fmt.Printf("%T,%f\n", d, d)
// 布尔类型转换，布尔类型 是不支持类型转换的。
//var flag bool = true
//f := int(flag)
}
