GO学习2：基本数据类型与转换

前言

[1. 基本数据类型](#1. 基本数据类型)

[1.1 整型](#1.1 整型)

[1.1.1 分类](#1.1.1 分类)

[1.1.2 特殊整型](#1.1.2 特殊整型)

[1.1.3 unsafe.Sizeof](#1.1.3 unsafe.Sizeof)

[1.1.4 int不同长度直接的转换](#1.1.4 int不同长度直接的转换)

[1.1.5 数字字面量语法（Number literals syntax)](#1.1.5 数字字面量语法（Number literals syntax))

[1.2 浮点型](#1.2 浮点型)

[1.2.1 概述](#1.2.1 概述)

[1.2.2 golang中float精度丢失问题](#1.2.2 golang中float精度丢失问题)

[1.2.3 golang科学计数法表示符点类型](#1.2.3 golang科学计数法表示符点类型)

[1.3 布尔值](#1.3 布尔值)

[1.4 字符串](#1.4 字符串)

[1.4.1 字符串转义符](#1.4.1 字符串转义符)

[1.4.2 多行字符串](#1.4.2 多行字符串)

[1.4.3 字符串的常用操作](#1.4.3 字符串的常用操作)

[1.5 byte和rune类型](#1.5 byte和rune类型)

Go语言的字符有两种类型

[1.6 修改字符串](#1.6 修改字符串)

2.基本数据类型之间的转换

[2.1 数值类型之间的相互转换](#2.1 数值类型之间的相互转换)

[2.2 其他类型转换成string类型](#2.2 其他类型转换成string类型)

[2.2.1 sprintf把其他类型转换成string类型](#2.2.1 sprintf把其他类型转换成string类型)

[2.2.2 使用strconv包里面的几种转换方法进行转换](#2.2.2 使用strconv包里面的几种转换方法进行转换)

[2.3 string类型转换成数值类型](#2.3 string类型转换成数值类型)

[2.3.1 string类型转换成int类型](#2.3.1 string类型转换成int类型)

[2.3.2 string类型转换成float类型](#2.3.2 string类型转换成float类型)

[2.3.3 string类型转换成bool类型（意义不大）](#2.3.3 string类型转换成bool类型（意义不大）)

[2.3.4 string转字符](#2.3.4 string转字符)

[2.4 数值类型没法和bool类型进行转换](#2.4 数值类型没法和bool类型进行转换)

前言

Go语言中数据类型分为两类：

基本数据类型

复合数据类型

基本数据类型有：

整型、浮点型、布尔型、字符型

复合数据类型有：

数组、切片、结构体、函数、map、通道（channel）、接口等。

1. 基本数据类型

1.1 整型

1.1.1 分类

整型分为以下两个大类：
有符号整形 按长度分为：int8、int16、int32、int64
对应的 无符号整型 ： uint8、uint16、uint32、uint64

关于字节 ：
字节也叫 Byte ，是计算机数据的基本存储单位。 8bit( 位 )=1Byte( 字节 ) 1024Byte( 字节 )=1KB
1024KB=1MB 1024MB=1GB 1024GB=1TB 。
根据编码格式的不同，一个中文字占用的字节数也不同。

编码格式	一个中文字符占用字节	核心特点与应用场景
GB2312 / GBK 国标	2 字节	- 中国国家标准编码，专门用于处理中文； - GB2312 仅支持 6763 个常用汉字，GBK 扩展后支持 2 万 + 汉字（含生僻字）； - 主要场景：Windows 系统默认中文编码（如记事本保存为 "ANSI" 时，中文系统下实际是 GBK）、早期中文软件 / 文档。
UTF-8	3 字节（部分生僻字 4 字节）	- 国际通用的 "万国码"，可兼容全球所有语言（中文、英文、日文等）； - 设计灵活：英文占 1 字节，中文占 3 字节，极少数生僻字（如 "𪚥"）占 4 字节； - 主要场景：网页（HTML 默认编码）、数据库（如 MySQL 默认）、程序代码（如 Java/Python）、移动 APP，是当前互联网和软件开发的主流编码。
UTF-16	2 字节或 4 字节	- 另一种 Unicode 编码格式，分 "小端序（UTF-16LE）" 和 "大端序（UTF-16BE）"； - 大部分常用汉字（如 "中""国"）占 2 字节，超出基础字符集的生僻字占 4 字节； - 主要场景：Windows 系统内部处理（如记事本 "Unicode" 选项）、.NET 程序、部分文档格式（如 Office 文件）。

测试：

新建记事本，输入 1 个中文字符（如 "我"），分别用不同编码保存：

保存为 "ANSI"（中文系统 = GBK）：文件大小 2 字节；

保存为 "UTF-8"：文件大小 3 字节（若勾选 "带 BOM"，会多 3 字节标识，总 6 字节，实际字符仍占 3 字节）；

保存为 "Unicode"（UTF-16LE）：文件大小 4 字节（含 2 字节字节序标识，实际字符占 2 字节）。

1.1.2 特殊整型

注意：在使用 int 和 uint 类型时，不能假定它是 32 位或 64 位的整型，而是考虑 int 和 uint
可能在不同平台上的差异。
注意事项 ：实际项目中整数类型、切片、 map 的元素数量等都可以用 int 来表示。 在涉及
到二进制传输、为了保持文件的结构不会受到不同编译目标平台字节长度的影响，不要使
用 int 和 uint。

Go 复制代码

package main

import "fmt"

func main() {
	var num int64
	num = 123
	fmt.Printf("值为:%v 类型:%T\n", num, num) //值为:123 类型:int64
}

1.1.3 unsafe.Sizeof

unsafe.Sizeof(n1) 是 unsafe 包的一个函数，可以返回 n1 变量占用的字节数。

Go 复制代码

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var a int8 = 120
	fmt.Printf("%T\n", a) //int8
	fmt.Println(unsafe.Sizeof(a)) //1
}

1.1.4 int不同长度直接的转换

Go 复制代码

package main

import (
	"fmt"
)

func main() {
	var num1 int8
	num1 = 127
	num2 := int32(num1)
	fmt.Printf("值为:%v 类型:%T", num2, num2)//值为:127 类型:int32
}

1.1.5 数字字面量语法（Number literals syntax)

Go1.13 版本之后引入了数字字面量语法，这样便于开发者以二进制、八进制或十六进制浮点数的格式定义数字。
例如：v := 0b00101101，代表二进制的 101101，相当于十进制的 45。
v := 0o377，代表八进制的377，相当于十进制的 255.
v := 0x1p-2，代表十六进制的1除以2^2，也就是0.25。
还允许我们用 _ 来分隔数字。
v := 123_456 就等于123456
##1. 十进制

Go 复制代码

import "fmt"

func main() {
	var a int
	a = 10
	fmt.Printf("%d\n", a) //10
	fmt.Printf("%b\n", a) //1010
}

##2. 八进制以 0 开头

Go 复制代码

package main
import "fmt"

func main() {
	var a int
	a = 077
	fmt.Printf("%o\n", a)  //77
}

##3. 十六进制以0x开头

Go 复制代码

package main

import "fmt"

func main() {
	var a int
	a = 0xff
	fmt.Printf("%x\n", a) //ff
	fmt.Printf("%X\n", a)  //FF
	fmt.Printf("%d\n", a)  //255
}

1.2 浮点型

1.2.1 概述

Go 语言支持两种浮点型数：float32 和 float64。
这两种浮点型数据格式遵循 IEEE 754 标准：
float32 的浮点数的最大范围约为 3.4e38，可以使用常量定义：math.MaxFloat32。
float64 的浮点数的最大范围约为 1.8e308，可以使用一个常量定义：math.MaxFloat64。

Go 复制代码

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Printf("%f\n", math.Pi) //3.141593 默认保留 6 位小数
	fmt.Printf("%.2f\n", math.Pi) //3.14
}

Go语言中浮点数默认是float64

Go 复制代码

	num := 1.1
	fmt.Printf("值: %v --类型：%T", num, num) //值: 1.1 --类型：float64

1.2.2 golang中float精度丢失问题

几乎所有的编程语言都有精度丢失这个问题，这是典型的二进制浮点数精度损失问题，在定长条件下，二进制小数和十进制小数互转可能有精度丢失。

Go 复制代码

d := 1129.6
fmt.Println((d * 100)) //112959.99999999999

Go 复制代码

var d float64 = 1129.6
fmt.Println((d * 100)) //112959.99999999999

Go 复制代码

m1 := 8.2
m2 := 3.8
fmt.Println(m1 - m2) //期望是 4.4，但是打印出了4.3999999999999995

可以使用第三方包来解决精度损失问题：
https://github.com/shopspring/decimal

1.2.3 golang科学计数法表示符点类型

Go 复制代码

	num1 := 5.1234e2 //5.1234 * 10 的 2 次方
	num2 := 5.1234e2 //5.1234 * 10 的 2 次方 shift+alt+向下的箭头
	num3 := 5.1234e-2 //5.1234 / 10 的 2 次方 0.051234
	fmt.Println("num1=", num1, "num2=", num2, "num3=", num3) //num1= 512.34 num2= 512.34 num3= 0.051234

1.3 布尔值

Go 语言中以 bool 类型进行声明布尔型数据，布尔型数据只有 true（真）和 false（假）两个值。

注意：

布尔类型变量的默认值为 false。

Go 语言中不允许将整型强制转换为布尔型.

布尔型无法参与数值运算，也无法与其他类型进行转换。

Go 复制代码

package main

import (
	"fmt"
	"unsafe"
)

func main() {

	var a = true
	fmt.Println(a, "占用字节：", unsafe.Sizeof(a)) //true 占用字节： 1
}

1.4 字符串

Go 语言中的字符串以原生数据类型出现，使用字符串就像使用其他原生数据类型（int、bool、float32、float64 等）一样。 Go 语言里的字符串的内部实现使用 UTF-8 编码。字符串的值
为双引号(")中的内容，可以在 Go 语言的源码中直接添加非 ASCII 码字符，例如：

Go 复制代码

s1 := "hello"
s2 := "你好"

1.4.1 字符串转义符

Go 语言的字符串常见转义符包含 回车、换行、单双引号、制表符 等，如下表所示。

举个例子，我们要打印一个 Windows 平台下的一个文件路径：

Go 复制代码

//str := "D:\godemo\demo01\main.go"
fmt.Println("str := \"D:\\godemo\\demo01\\main.go\"")

1.4.2 多行字符串

Go 语言中要定义一个多行字符串时，就必须使用反引号字符：

s1 := ` 第一行
第二行
第三行
`
fmt.Println(s1)
反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。

Go 复制代码

	s1 := `"hello"
"hi"
"你好"
`
	fmt.Println(s1)
	//"hello"
	//"hi"
	//"你好"

1.4.3 字符串的常用操作

$$1. len(str)求字符串的长度

Go 复制代码

var str = "this is str"
	fmt.Println(len(str))//11

$$2. 拼接字符串

Go 复制代码

var str1 = "您好"
	var str2 = "golang"
	fmt.Println(str1 + str2) // 您好golang

	var str3 = fmt.Sprintf("%v %v", str1, str2)
	fmt.Println(str3)   //您好 golang

$$3. strings.Split 分割字符串

Go 复制代码

var str = "123-456-789"
	var arr = strings.Split(str, "-")
	fmt.Println(arr)            //[123 456 789]
	fmt.Printf("%T \n", arr)    //[]string
	fmt.Printf("%T \n", arr[0]) //string

$$4. 判断包含字符串

Go 复制代码

var str = "this is golang"
	var flag = strings.Contains(str, "golang")
	fmt.Println(flag) //true

$$5. 判断首字符尾字母是否包含指定字符

Go 复制代码

var str = "this is golang"
	var flag = strings.HasPrefix(str, "this")
	fmt.Println(flag) //true

	flag = strings.HasSuffix(str, "go")
	fmt.Println(flag) //false

$$6. 判断字符串出现的位置

Go 复制代码

	var str = "this is golang"
	var index = strings.Index(str, "is") //从前往后
	fmt.Println(index)                   //2

	index = strings.LastIndex(str, "is") //从后往前
	fmt.Println(index)      //5

$$7. Join拼接字符串

Go 复制代码

var str = "123-456-789"
var arr = strings.Split(str, "-")
	var str2 = strings.Join(arr, "*")
	fmt.Println(str2) //123*456*789

1.5 byte和rune类型

组成每个字符串的元素叫做"字符"，可以通过遍历字符串元素获得字符。字符用单引号（'）包裹起来，如：

Go 复制代码

a := 'a'
	b := 'b'
	//当我们直接输出 byte（字符）的时候输出的是这个字符对应的码值
	fmt.Println(a) //97
	fmt.Println(b) //98

	//%c 相应 Unicode 码点所表示的字符
	fmt.Printf("%c--%c\n", a, b) //a--b

字节（byte ）：是计算机中数据处理的基本单位，习惯上用大写 B 来表示 ,1B （ byte, 字节）
= 8bit （位）
字符：是指计算机中使用的字母、数字、字和符号

一个汉字占用 3 个字节一个字母占用一个字节

Go 复制代码

a := "m"
	fmt.Println(len(a)) //1
	b := "张"
	fmt.Println(len(b)) //3

Go语言的字符有两种类型

uint8 类型，或者叫 byte 型，代表了 ASCII 码的一个字符。

rune 类型，代表一个 UTF-8 字符。
当需要处理中文、日文或者其他复合字符时，则需要用到 rune 类型。rune 类型实际是一个 int32。
Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode 的文本处理更为方便，也可以使用 byte 型进行默认字符串处理，性能和扩展性都有照顾。

Go 复制代码

s := "hello 张三"
	for i := 0; i < len(s); i++ { //byte
		fmt.Printf("%v(%c) ", s[i], s[i])
	}//104(h) 101(e) 108(l) 108(l) 111(o) 32( ) 229(å) 188(¼) 160( ) 228(ä) 184(¸) 137() 
	fmt.Println()
	for _, r := range s { //rune
		fmt.Printf("%v(%c) ", r, r)
	}//104(h) 101(e) 108(l) 108(l) 111(o) 32( ) 24352(张) 19977(三) 
	fmt.Println()

因为 UTF8 编码下一个中文汉字由 3 个字节组成，所以我们不能简单的按照字节去遍历一个
包含中文的字符串，否则就会出现上面输出中第一行的结果。
字符串底层是一个 byte 数组，所以可以和[]byte 类型相互转换。字符串是不能修改的字符
串是由 byte 字节组成，所以字符串的长度是 byte 字节的长度。 rune 类型用来表示 utf8 字符，一个 rune 字符由一个或多个 byte 组成。
rune 类型实际是一个 int32

Go 复制代码

	c3 := "营"
	c4 := '营'
	fmt.Printf("C3 的类型%T--C4 的类型%T", c3, c4) //C3 的类型 string--C4 的类型 int32

1.6 修改字符串

要修改字符串，需要先将其转换成[]rune 或[]byte，完成后再转换为 string。无论哪种转换，都会重新分配内存，并复制字节数组。

Go 复制代码

func changeString() {
	s1 := "big"
	//强制类型转换
	byteS1 := []byte(s1)
	byteS1[0] = 'p'
	fmt.Println(string(byteS1))

	s2 := "白萝卜"
	runeS2 := []rune(s2)
	runeS2[0] = '红'
	fmt.Println(string(runeS2))
}

2.基本数据类型之间的转换

Go 语言中只有强制类型转换，没有隐式类型转换。

2.1 数值类型之间的相互转换

数值类型：

整型和浮点型

Go 复制代码

package main
import "fmt"
func main() {
var a int8 = 20
var b int16 = 40
var c = int16(a) + b //要转换成相同类型才能运行
fmt.Printf("值：%v--类型%T", c, c) //值：60--类型 int16
}

Go 复制代码

package main
import "fmt"
func main() {
    var a float32 = 3.2
    var b int16 = 6
    var c = a + float32(b)
    fmt.Printf("值：%v--类型%T", c, c) //值：9.2--类型 float32
}

转换的时候建议从低位转换成高位，高位转换成低位的时候如果转换不成功就会溢出，和我
们想的结果不一样。
例如：

Go 复制代码

package main
func main() {
    var a int16 = 129
    var b = int8(a) // 范围 -128 到 127
    println("b=", b) //b= -127 //错误
}

比如计算直角三角形的斜边长时使用 math 包的 Sqrt()函数，该函数接收的是 float64 类型的
参数，而变量 a 和 b 都是 int 类型的，这个时候就需要将 a 和 b 强制类型转换为 float64 类型。

Go 复制代码

var a, b = 3, 4
var c int
// math.Sqrt()接收的参数是 float64 类型，需要强制转换
c = int(math.Sqrt(float64(a*a + b*b)))
fmt.Println(c)

2.2 其他类型转换成string类型

2.2.1 sprintf把其他类型转换成string类型

注意 **：**sprintf 使用中需要注意转换的格式
int 为%d
float 为%f
bool 为%t
byte 为%c

Go 复制代码

package main
import "fmt"
func main() {
    var i int = 20
    var f float64 = 12.456
    var t bool = true
    var b byte = 'a' 
    var strs string

    strs = fmt.Sprintf("%d", i)
    fmt.Printf("str type %T ,strs=%v \n", strs, strs)//str type string ,strs=20

    strs = fmt.Sprintf("%f", f)
    fmt.Printf("str type %T ,strs=%v \n", strs, strs)//str type string ,strs=12.456000

    strs = fmt.Sprintf("%t", t)
    fmt.Printf("str type %T ,strs=%v \n", strs, strs)//str type string ,strs=true

    strs = fmt.Sprintf("%c", b)
    fmt.Printf("str type %T ,strs=%v \n", strs, strs)//str type string ,strs=a
}

2.2.2 使用strconv包里面的几种转换方法进行转换

Go 复制代码

package main
import ( 
    "fmt"
    "strconv"
)
func main() {
    //1、int 转换成 string
    var num1 int = 20
    s1 := strconv.Itoa(num1)
    fmt.Printf("str type %T ,strs=%v \n", s1, s1)

    // 2、float 转 string
    var num2 float64 = 20.113123
    /* 参数 1：要转换的值
    参数 2：格式化类型
    'f'（-ddd.dddd）、
    'b'（-ddddp±ddd，指数为二进制）、
    'e'（-d.dddde±dd，十进制指数）、
    'E'（-d.ddddE±dd，十进制指数）、
    'g'（指数很大时用'e'格式，否则'f'格式）、
    'G'（指数很大时用'E'格式，否则'f'格式）。

    参数 3: 保留的小数点 -1（不对小数点格式化）
    参数 4：格式化的类型
*/

    s2 := strconv.FormatFloat(num2, 'f', 2, 64)
    fmt.Printf("str type %T ,strs=%v \n", s2, s2)

    // 3、bool 转 string
    s3 := strconv.FormatBool(true)
    fmt.Printf("str type %T ,strs=%v \n", s3, s3)

    //4、int64 转 string
    var num3 int64 = 20

    /*第二个参数为 进制
    */
    s4 := strconv.FormatInt(num3, 10)
    fmt.Printf("类型 %T ,strs=%v \n", s4, s4)
}

2.3 string类型转换成数值类型

2.3.1 string类型转换成int类型

Go 复制代码

var s = "1234"
i64, _ := strconv.ParseInt(s, 10, 64)
fmt.Printf("值：%v 类型：%T", i64, i64)

2.3.2 string类型转换成float类型

Go 复制代码

str := "3.1415926535" 
v1, _ := strconv.ParseFloat(str, 32)
v2, _ := strconv.ParseFloat(str, 64)

fmt.Printf("值：%v 类型：%T\n", v1, v1)
fmt.Printf("值：%v 类型：%T", v2, v2)

2.3.3 string类型转换成bool类型（意义不大）

Go 复制代码

b, _ := strconv.ParseBool("true") // string 转 bool
fmt.Printf("值：%v 类型：%T", b, b)

2.3.4 string转字符

Go 复制代码

s := "hello 张三"
for _, r := range s { //rune
    fmt.Printf("%v(%c) ", r, r)
}
fmt.Println()

2.4 数值类型没法和bool类型进行转换

注意：在 go 语言中数值类型没法直接转换成 bool 类型 bool 类型也没法直接转换成数值类
型。

GO学习2：基本数据类型 与 转换

前言

1. 基本数据类型

1.1 整型

1.1.1 分类

1.1.2 特殊整型

1.1.3 unsafe.Sizeof

1.1.4 int不同长度直接的转换

1.1.5 数字字面量语法（Number literals syntax)

1.2 浮点型

1.2.1 概述

1.2.2 golang中float精度丢失问题

1.2.3 golang科学计数法表示符点类型

1.3 布尔值

1.4 字符串

1.4.1 字符串转义符

1.4.2 多行字符串

1.4.3 字符串的常用操作

1.5 byte和rune类型

Go语言的字符有两种类型

1.6 修改字符串

2.基本数据类型之间的转换

2.1 数值类型之间的相互转换

2.2 其他类型转换成string类型

2.2.1 sprintf把其他类型转换成string类型

2.2.2 使用strconv包里面的几种转换方法进行转换

2.3 string类型转换成数值类型

2.3.1 string类型转换成int类型

2.3.2 string类型转换成float类型

2.3.3 string类型转换成bool类型（意义不大）

2.3.4 string转字符

2.4 数值类型没法和bool类型进行转换

GO学习2：基本数据类型与转换