✨✨ 欢迎大家来到景天科技苑✨✨

🎈🎈 养成好习惯，先赞后看哦~🎈🎈

🏆 作者简介：景天科技苑

🏆《头衔》：大厂架构师，华为云开发者社区专家博主，阿里云开发者社区专家博主，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

<code>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

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

定义整形变量，超过范围会报错，定义的时候不报错，运行的时候报错

<code>package main

import "fmt"

func main() {

// 定义的时候超过限制是不会报错的，但是在运行时发生了错误 expected 'package', found 'EOF'

// 计算只能存放固定大小的值。

// 我们在定义这个类型的时候，系统给了我们一个空间

var a int = 666666666666666666666663333333333

fmt.Println(a)

}

<code>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 ，也是一个空间的大小。

<code>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)

}

验证：浮点数计算时不精确的

<code>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

<code>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)

}

转义字符

常见的转义字符

<code>package main

import "fmt"

func main() {

// 特殊的字符 转义字符 \n

// \n 换行

fmt.Println("hello\nworld")

// \b backspace 删除上一个字符

fmt.Println("hello\bworld")

// \t Tab

fmt.Println("hello\tworld")

}

多行输入使用 ``

多行文本

<code>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)

布尔类型不支持类型转换

<code>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)

}