【Go】Go语言中的基本数据类型与类型转换

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

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

🏆 作者简介：景天科技苑

🏆《头衔》：大厂架构师，华为云开发者社区专家博主，阿里云开发者社区专家博主，CSDN全栈领域优质创作者，掘金优秀博主，51CTO博客专家等。

🏆《博客》：Python全栈，Golang开发，PyQt5和Tkinter桌面开发，小程序开发，人工智能，js逆向，App逆向，网络系统安全，数据分析，Django，fastapi，flask等框架，云原生K8S，linux，shell脚本等实操经验，网站搭建，数据库等分享。

所属的专栏： Go语言开发零基础到高阶实战
景天的主页： 景天科技苑

文章目录

• go数据类型
• • 布尔数据类型
  • [整形 int](#整形 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)

}