第2章：基本数据类型

基本数据类型【数值型、字符型、布尔型、字符串】

数值型【整数类型、浮点类型】

整数类型【有符号整数类型、无符号整数类型、其他整数类型】

== 存放整数值的类型，默认值为 0==

【1】有符号整数类型：

类型 | 有无符号 | 占用储存空间 | 表数范围
int8 | 有 | 1 字节 | -27~27-1（-128~127）
int16 | 有 | 2 字节 | -215~215-1（-32768~32767）
int32 | 有 | 4 字节 | -231~231-1（-2147483648~2147483647）
int64 | 有 | 8 字节 | -263~263-1

【2】无符号整数类型：

类型 | 有无符号 | 占用储存空间 | 表数范围
uint8 | 无 | 1 字节 | 0~255
uint16 | 无 | 2 字节 | 0~216-1
uint32 | 无 | 4 字节 | 0~231-1
uint64 | 无 | 8 字节 | 0~263-1

【3】其他整数类型：

类型 | 有无符号 | 占用储存空间 | 表数范围

int

有

32 位系统占 4 字节

64 位系统占 8 字节

-231~231-1

-263~263-1

uint

无

32 位系统占 4 字节

64 位系统占 8 字节

0~232-1

0~264-1

rune | 有 | 等价 int32 | -231~231-1
byte | 无 | 等价 uint8 | 0~255

浮点类型

== 存放小数值的类型，默认值为 0==

类型 | 占用储存空间 | 表数范围
float32 | 4 字节 | -3.403E38~3.403E38
float64 | 8 字节 | -1.798E308~1.798E308

golang默认的浮点类型是float64

字符型

Golang中没有专门的字符类型，若要存储单个字符，一般使用byte来保存

ASCII 表：

汉字字符底层对应的是Unicode码值，byte类型会溢出，所以可以用int

UTF-8 编码表 :

点击此处查表

== 总结：Golang 的字符对应使用的是 UTF-8 编码（Unicode 是对应的字符集，UTF-8 是其中的一种编码方案）==

转义字符：

布尔型

== 只允许取值 true 和 false 的类型，默认值为 false==

布尔类型又叫 bool 类型，占 1 个字节，适用于逻辑运算，一般用于程序流程控制

字符串

== 一串固定长度的字符连接起来的字符序列，默认值为 ""==

1、如果字符串没有特殊字符，用双引号""表示；如果字符串没有特殊字符，用反引号``表示

Copy
package main

import "fmt"

func main() {
var str1 string = "abc"
fmt.Println(str1)
var str2 string = `a\b\c`
fmt.Println(str2)
}

2、字符串的拼接以及注意事项：

Copy
package main

import "fmt"

func main() {
var str1 string = "abc" + "def"
str1 += "xyz"
fmt.Println(str1)
//字符串拼接过长想换行，每行一定要以加号结尾
var str2 string = "abc" + "abc" + "abc" +
"abc" + "abc" + "abc" +
"abc" + "abc" + "abc" +
"abc" + "abc" + "abc" +
"abc" + "abc" + "abc"
fmt.Println(str2)
}

基本数据类型之间的转换

Go语言不同类型的变量之间赋值需要显式转换，并且只有显式转换（强制转换）

Copy
package main

import "fmt"

func main() {
var n1 int = 100
//var n2 float32 = n1 这样无法转换，必须显式转换
var n2 float32 = float32(n1)
fmt.Println(n1)
fmt.Println(n2)
//int64转换成int8时，编译不会出错，但是数据会溢出，类似于把很大的物件往很小的容器里装
var n3 int64 = 888888
var n4 int8 = int8(n3)
fmt.Println(n4) //输出56
}

基本数据类型与 string 的转换

== 开发过程中，我们经常需要将基本数据类型转换为 string , 或者将 string 转换为基本数据类型 ==

方式一

fmt.Sprintf("%参数"，表达式)，需要参数和表达式的类型匹配

Copy
package main

import "fmt"

func main() {
var n1 int = 15
var n2 float32 = 5.5
var n3 bool = true
var n4 byte = 'A'
var m1 string = fmt.Sprintf("%d", n1)
fmt.Printf("m1的数据类型是：%T, %q", m1, m1)
fmt.Println()
var m2 string = fmt.Sprintf("%f", n2)
fmt.Printf("m2的数据类型是：%T,%q", m2, m2)
fmt.Println()
var m3 string = fmt.Sprintf("%t", n3)
fmt.Printf("m3的数据类型是：%T,%q", m3, m3)
fmt.Println()
var m4 string = fmt.Sprintf("%c", n4)
fmt.Printf("m4的数据类型是：%T,%q", m4, m4)
}

运行结果

Copy
m1的数据类型是：string, "15"
m2的数据类型是：string,"5.500000"
m3的数据类型是：string,"true"
m4的数据类型是：string,"A"

方式二

使用strconv包的函数

Copy
package main

import (
"fmt"
"strconv"
)

func main() {
var n1 int = 15
//第一个参数必须转int64，第二个参数指定是多少进制
var m1 string = strconv.FormatInt(int64(n1), 10)
fmt.Printf("m1的数据类型是：%T, %q", m1, m1)
fmt.Println()
var n2 float64 = 5.5
//第二个参数'f'（-ddd.dddd），第三个参数保留小数点后几位，第四个参数指定浮点类型
var m2 string = strconv.FormatFloat(n2, 'f', 9, 64)
fmt.Printf("m2的数据类型是：%T,%q", m2, m2)
fmt.Println()
var n3 bool = true
var m3 string = strconv.FormatBool(n3)
fmt.Printf("m3的数据类型是：%T,%q", m3, m3)
fmt.Println()
}

运行结果

Copy
m1的数据类型是：string, "15"
m2的数据类型是：string,"5.500000000"
m3的数据类型是：string,"true"

== 总结：重点使用方式一 ==

string 类型转换为基本类型

使用 strconv 包的函数

Copy
package main

import (
"fmt"
"strconv"
)

func main() {
//string---->bool
var n1 string = "true"
var m1 bool
//ParseBool函数返回值有两个(value bool, err error)
//value是得到的布尔类型的数据，err是出现的错误，err可以用_直接忽略
m1, _ = strconv.ParseBool(n1)
fmt.Printf("m1的数据类型是：%T, %v", m1, m1)
fmt.Println()
//string---->int64
var n2 string = "55"
var m2 int64
//第二个参数指定几进制，第三个参数指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64
m2, _ = strconv.ParseInt(n2, 10, 64)
fmt.Printf("m2的数据类型是：%T, %v", m2, m2)
fmt.Println()
//string---->float
var n3 string = "8.8"
var m3 float64
//第二个参数指定了期望的接收类型，32是float32（返回值可以不改变精确值的赋值给float32），64是float64
m3, _ = strconv.ParseFloat(n3, 64)
fmt.Printf("m3的数据类型是：%T, %v", m3, m3)
fmt.Println()
//注意：一定要确保 st ring 类型够能够转换成有效的数据，比如我们可将 "123" 转换成一个整数，但是不能将 一个 “Hello” 转换为整数，否则会变成转换后的类型的默认值
var n4 string = "golang"
var m4 bool
m4, _ = strconv.ParseBool(n4)
fmt.Printf("m4的数据类型是：%T, %v", m4, m4)
fmt.Println()
var n5 string = "golang"
var m5 int64
m5, _ = strconv.ParseInt(n5, 10, 64)
fmt.Printf("m5的数据类型是：%T, %v", m5, m5)
}

运行结果

Copy
m1的数据类型是：bool, true
m2的数据类型是：int64, 55
m3的数据类型是：float64, 8.8
m4的数据类型是：bool, false
m5的数据类型是：int64, 0