3.数据类型

3.1 整型

整型通常是指没有小数部分的数据。可以使用八进制、十进制、十六进制来表示。在数据前添加+、-可代表正负值。根据整型数值大小，又可以分为短整形、长整型、无符号整形等，每一种类型都有固定的数值范围。在定义整型变量，需要根据实际需求设置相应的数值范围。Go 语言中的数值范围如下所示：

数据类型	功能及范围
int	整型，大小与操作系统位数相关
int8	整型，范围-128~127
int16	整型，范围-32768~32767
int32	整型，范围--2^31 ~ 2^31-1
int64	整型，范围-2^63 ~ 2^63-1
uint	无符号整型，大小与操作系统位数相关
uint8	无符号整型,范围为 0~255
uint16	无符号整型,范围为 0~65535
uint32	无符号整型,范围为 0~2^32-1
uint64	无符号整型,范围为 0~2^64-1

在实际开发中，一般使用int和uint 设置整型的数值范围，它们的大小由实际运行操作系统的位数决定，在 32 位操作系统中，大小为4字节，64 位操作系统为8字节

3.2 浮点型

浮点型常用于存储带小数部分的数字。一个整数数值可以赋值给浮点类型，但一个整型类型不可以赋值给浮点类型。Go 语言支持float32和float64两种类型。在使用中的注意事项如下所示：

Go 语言的数据类型不支持隐形自动转换，必须显式进行转换，例如 int 和 float32，则需要转换为同一类型后才能进行运算
不同类型的浮点型不能直接计算，必须要同一类型的浮点类型才能计算，例如 float32 和 float64，也不能直接进行运算，需要转换为同一类型后才能进行运算
在浮点类型相互转换的过程中，可能会存在精度损失的情况，请务必注意

示例如下所示：

package main

import (
	"fmt"
)

func main()  {
	var a float32 = 1.1
	var b float64 = 1.2
	var c int =2
	// 将float32转换 float64
	resultA:=float64(a) + b
	fmt.Println("a+b=",resultA)
	// 将int转换为float32
    resultB:=float32(c)+a
	fmt.Println("a+c=",resultB)
}

运行结果如下所示：

a+b= 2.300000023841858
a+c= 3.1

从上面的输出结果来 1.1 + 1.2 应该等于 2.3 ，但输出结果却为 2.300000023841858。出现这种结果是因为精度丢失导致。这是因为计算机在存储数据时是以二进制形式表示，浮点数在转换为二进制时，会出现小数部分丢失，造成精度丢失。解决精度丢失最简单的办法是对浮点数小数位进行四舍五入或截取，这种办法适用于对数据精度要求不高的情况下，若对于精度要求比较高，可以引入第三方包decimal解决。

3.3 布尔类型

布尔类型只有两个值true和false，一般常用于判断，示例如下所示：

package main

import (
	"fmt"
)

func main() {
	var a, b, c int = 28, 29, 29
	if a > b {
		fmt.Println("a>b成立")
	} else if b == c {
		fmt.Println("b==c成立")
	}

	var flag bool = true
	if flag {
		fmt.Printf("flag value is %t\n", flag)
	} else if !flag {
		fmt.Printf("flag value is %t\n", flag)
	}
}

运行结果如下所示:

b==c成立
flag value is true

3.4 字符类型

3.4.1 ASCII 与 UniCode 编码

ASCII 码是美国信息交换标准编码(American Standard Code for Information Interchange),最初作为美国国家标准制定，为不同计算机在相互通信时共同遵守的英文字符编码标准，后来被国际标准化组织 ISO(International Organization for Standardization)定为国际标准，称为 ISO-646 标准。

虽然 ASCII 码可以表示英文字符，但不同的国家有不同的文字，ASCII 就无法表示了，因此便出现了 Unicode 编码方案，它为每种语言的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、平台的文本转换方案。但 Unicode 仅仅是一个字符集，规定了每个字符的二进制编码，但字符需要使用多少个字节存储则没有规定，因此出现 UTF-8、UTF-16、UTF-32 等不同的存储形式。在 Go 语言中，提供的字符类型uint8和rune分别对应字节编码 ASCII 和 Unicode 中的 UTF-8

Unicode 可以理解为一种行业标准、而 UTF-8/UTF-16/UTF-32 则相当于根据行业标准一种具体的实现方案，

在 Go 语言中，英文字符占用 1 个字节，而汉字则占用 3 个字节

3.4.2 字符类型

字符串的每个元素称为字符。在 Go 语言中有两种类型uint8和rune，详细说明如下所示：

uint8：也称为 byte 型，代表 ASCII 码的一个字符
rune：等价于 int32 类型，代表一个 UTF-8 字符。当处理非英语国家的字符时，常使用该类型，

字符可以根据实际场景需要定义为 uint8 或 rune，如未设置字符类型，则默认为rune类型，字符的赋值必须使用单引号表示且只有一个字符，示例代码如下所示：

package main

import "fmt"

func main() {
	var a byte = 's'
	var b rune = 'u'
	c := 'r'
	d := '中'
	var e rune = '国'
	// 打印各变量的类型
	fmt.Printf("a的类型为：%T\n", a)
	fmt.Printf("b的类型为：%T\n", b)
	fmt.Printf("c的类型为：%T\n", c)
	fmt.Printf("d的类型为：%T\n", d)
	fmt.Printf("e的类型为：%T\n", e)
}

运行结果如下所示：

a的类型为：uint8
b的类型为：int32
c的类型为：int32
d的类型为：int32
e的类型为：int32

3.5 字符串

字符串是数字、字母和下划线等字符组成的一串字符。多个字符可以组成一个字符串，常用于表示文本型的数据。在存储上类似于字符数组。

3.5.1 字符串定义

字符串是由多个字符组合而成，必须使用双引号或反引号进行定义，主要区别如下所示:

使用双引号表示，可以解析字符串字面量，支持转义，但不支持多行表示
使用反引号表示，支持原生的字符串字面量，不支持转义，支持多行字符串组成

示例如下：

	var name string = "I am Surpass"

	var location string = `I
						am
						in
						Shanghai`

3.5.2 字符串转义符

Go 语言支持转义字符如下所示：

转义符	功能
\t	制表符，常用于格式化排版
\n	换行符
\\	\
\"	"
\r	回车符

示例如下所示：

package main

import "fmt"

func main() {
	var a, b string
	a = "Hello,Surpass\nGood morning"
	b = `Hello,
		Surpass
		\n
		Good morning
	`
	fmt.Println("双引号：", a)
	fmt.Println("反引号：", b)
}

运行结果如下所示：

双引号： Hello,Surpass
Good morning
反引号： Hello,
		Surpass
		\n
		Good morning

3.5.3 字符串格式化

字符串格式化是指字符串引入变量，通过改变变量值从而生成不同的字符串，通常使用格式化符号%。常见的格式化符号如下所示：

格式化符号	功能
%v	适合所有类型数据，默认打印格式
%+v	对结构体，会多打印出字段名
%#v	对结构体，会有更加详细的打印
%T	打印值的数据类型
%%	打印% 本身
%b	数据以二进制格式输出
%o	数据以八进制格式输出
%d	数据以十进制格式输出
%x	数据以十六进制格式输出
%X	数据以十六进制大写字母格式输出
%U	数据以 Unicode 格式输出
%c	把 rune、byte 的整型值用字符串打印
%q	把一个整型当做 Unicode 字符输出，类似于%c，不过在字符外面多了单引号，q=quote
%e、%E	以科学计数法打印
%f、%F	数据以浮点数格式输出
%s	数据以字符串格式输出，如果是 rune 切片，则需要使用 string 强制类型转换
%p	数据以指针格式输出，且以十六进制表示
%t	数据以布尔格式输出
%g	以浮点类型打印输出

日常注意事项如下所示：

格式化符号与数学运算中的求余符号很像，需要结合使用场景来进行区分。
因 Go 语言对数据类型要求十分严格，若格式化符号与数据类型不匹配时，程序仍然能输出字符串，但格式化的数据是无法显示的，示例如下所示：

package main

import "fmt"

func main() {
    a:=112
	fmt.Printf("a is %t",a)
}

运行结果如下所示：

a is %!t(int=112)

3.5.4 字符串拼接

在日常使用过程，会遇到将多个字符串拼接到一起的情况，Go 语言提供了+、fmt.Sprintf()、strings.Join()、strings.Builder、bytes.Buffer等几种方法。示例如下所示：

package main

import (
	"bytes"
	"fmt"
	"strings"
)

func main() {
	strA := "Hello,Surpass"
	strB := ",Welcome to Shanghai"
	// 使用 + 拼接
	stringJoinResultA := strA + strB

	// 使用fmt.Sprintf()
	stringJoinResultB := fmt.Sprintf("%s%s", strA, strB)

	// 使用strings.Join()
	stringJoinResultC := strings.Join([]string{strA, strB},"")

	// 使用strings.Builder
	var builder strings.Builder
	builder.WriteString(strA)
	builder.WriteString(strB)
	stringJoinResultD := builder.String()

	// 使用bytes.Buffer
	var buffer bytes.Buffer
	buffer.WriteString(strA)
	buffer.WriteString(strB)
	stringJoinResultE := buffer.String()

	fmt.Println("使用 + 拼接:",stringJoinResultA)
	fmt.Println("使用fmt.Sprintf():",stringJoinResultB)
	fmt.Println("使用strings.Join():",stringJoinResultC)
	fmt.Println("使用strings.Builder:",stringJoinResultD)
	fmt.Println("使用bytes.Buffer:",stringJoinResultE)
}

运行结果如下所示：

使用 + 拼接: Hello,Surpass,Welcome to Shanghai
使用fmt.Sprintf(): Hello,Surpass,Welcome to Shanghai
使用strings.Join(): Hello,Surpass,Welcome to Shanghai
使用strings.Builder: Hello,Surpass,Welcome to Shanghai
使用bytes.Buffer: Hello,Surpass,Welcome to Shanghai

虽然以上几种方法都可以完成字符串拼接，但每种方法在性能上有所差异，性能差异取决于字符串长度和拼接的数量，并不是某一种方法可以适合所有场景。密文文档建议使用strings.Builder。

3.5.5 字符串长度

Go 内置方法len可以获取切片、字符串、通道等数据类型的长度，示例如下所示：

package main

import "fmt"

func main()  {
	strA:="Hello,Surpass"
	strB:=",Welcome to Shanghai"
	strC:="你好，Surpass"

	fmt.Println("strA的长度：",len(strA))
	fmt.Println("strB的长度：",len(strB))
	fmt.Println("strA与strB拼接后长度：",len(strA+strB))
	fmt.Println("strC的长度：",len(strC))
}

运行结果如下所示：

strA的长度： 13
strB的长度： 20
strA与strB拼接后长度： 33
strC的长度： 16

Go 默认采用的是UTF-8进行编码，而 len()方法只计算字节数长度，因此在使用 len()方法获取长度的时候注意事项如下所示：

字符串的字母、空格、符号占1字节
每个中文占用3字节

如果字符串含有多字节的字符，可以使用utf8.RuneCountInString()或[]rune()获取字符串的实际长度，示例如下所示：

package main

import (
	"fmt"
	"unicode/utf8"
)
func main() {
	strA := "Hello,Surpass"
	strB := ",Welcome to Shanghai"
	strC := "你好，Surpass"

	fmt.Println("strA的UTF-8长度:", len(strA))
	fmt.Println("strB的UTF-8长度:", len(strB))
	fmt.Println("strA与strB拼接后的UTF-8长度:", len(strA+strB))
	fmt.Println("strC的UTF-8长度：", len(strC))

	fmt.Println("strA的实际长度:", utf8.RuneCountInString(strA))
	fmt.Println("strB的实际长度:", len([]rune(strB)))
	fmt.Println("strA与strB拼接后的实际长度:", len([]rune(strA+strB)))
	fmt.Println("strC的实际长度：", utf8.RuneCountInString(strC))
	fmt.Println("strC的实际长度：", len([]rune(strC)))
}

运行结果如下所示：

strA的UTF-8长度: 13
strB的UTF-8长度: 20
strA与strB拼接后的UTF-8长度: 33
strC的UTF-8长度： 16
strA的实际长度: 13
strB的实际长度: 20
strA与strB拼接后的实际长度: 33
strC的实际长度： 10
strC的实际长度： 10

3.5.6 字符串遍历

遍历字符串可以通过for循环来实现，示例如下所示：

package main

import "fmt"

func hello(name string) string {
	return fmt.Sprintf("你好，%s", name)
}

func main() {
	strA := hello("Surpass")
	for i := 0; i < len(strA); i++ {
		fmt.Printf("%c:%[1]d,%s\n", strA[i], string(strA[i]))
	}
}

最终的输出结果如下所示：

ä:228,ä
½:189,½
 :160,
å:229,å
¥:165,¥
½:189,½
ï:239,ï
¼:188,¼
:140,
S:83,S
u:117,u
r:114,r
p:112,p
a:97,a
s:115,s
s:115,s

从输出结果来看，只要包含中文，则无法正确输出每个字符。通过前面的学习，我们可以使用[]rune()，示例如下所示：

package main

import "fmt"

func hello(name string) string {
	return fmt.Sprintf("你好，%s", name)
}

func main() {
	strA := hello("Surpass")
	charArray := []rune(strA)
	for i := 0; i < len(charArray); i++ {
		fmt.Printf("%c:%[1]d\n", charArray[i])
	}
}

最终的输出结果如下所示：

你:20320
好:22909
，:65292
S:83
u:117
r:114
p:112
a:97
s:115
s:115

Go 语言也提供了另一种循环方法，同时也不需要将中文转换为[]rune()，这个方法为range，示例如下所示：

package main

import "fmt"

func hello(name string) string {
	return fmt.Sprintf("你好，%s", name)
}

func main() {
	strA := hello("Surpass")
	for _, item := range strA {
		fmt.Printf("%c:%[1]d\n", item)
	}
}

最终的输出结果如下所示：

你:20320
好:22909
，:65292
S:83
u:117
r:114
p:112
a:97
s:115
s:115

3.5.7 字符位置与截取

在字符串查找某个字符的位置，可以使用内置的strings.Index()和strings.LastIndex()方法。在查询到对应的字符索引位置后，也可以对字符串进行截取操作。示例如下所示：

package main

import (
	"fmt"
	"strings"
)

func hello(name, loc string) string {
	return fmt.Sprintf("Hello,%s,welcome to %s", name, loc)
}

func main() {
	strA := hello("Surpass", "Shanghai")
	sIndex := strings.Index(strA, "S")
	lastIndex := strings.LastIndex(strA, "S")
	fmt.Printf("strA is:%s\n", strA)
	fmt.Printf("S 的最早的位置索引为:%d\n", sIndex)
	fmt.Printf("S 的最后的位置索引为:%d\n", lastIndex)
	fmt.Printf("向后截取字符串为：%s\n", strA[sIndex:])
	fmt.Printf("向前截取字符串为：%s\n", strA[:lastIndex])
}

最终的输出结果如下所示：

strA is:Hello,Surpass,welcome to Shanghai
S 的最早的位置索引为:6
S 的最后的位置索引为:25
向后截取字符串为：Surpass,welcome to Shanghai
向前截取字符串为：Hello,Surpass,welcome to

3.5.8 字符串分割

字符串分割是指对字符串按照指定的分隔符进行拆分为多个子字符串或子字符。在 Go 语言，使用方法strings.Split()实现。其基本使用方法如下所示：

func Split(s, sep string) []string

参数详细如下所示：

s:即将被分割的字符串
sep:代表使用的分割符

示例如下所示：

package main

import (
	"fmt"
	"strings"
)

func main() {
	strA := "Hello,Surpass"
	strB := "Welcome to Shanghai"
	strC := strings.Join([]string{strA, strB}, "@")
	strASplitResult := strings.Split(strA, ",")
	strBSplitResult := strings.Split(strB, " ")
	strCSplitResult := strings.Split(strC, "@W")
	fmt.Printf("strC 合并后的字符串为:%s\n", strC)
	fmt.Printf("strA 分割后的结果为:%v,类型为:%[1]T\n", strASplitResult)
	fmt.Printf("strB 分割后的结果为:%v,类型为:%[1]T\n", strBSplitResult)
	fmt.Printf("strC 分割后的结果为:%v,类型为:%[1]T\n", strCSplitResult)
	for idx, value := range strCSplitResult {
		fmt.Printf("index is: %d,value is %s\n", idx, value)
	}
}

最终的输出结果如下所示：

strC 合并后的字符串为:Hello,Surpass@Welcome to Shanghai
strA 分割后的结果为:[Hello Surpass],类型为:[]string
strB 分割后的结果为:[Welcome to Shanghai],类型为:[]string
strC 分割后的结果为:[Hello,Surpass elcome to Shanghai],类型为:[]string
index is: 0,value is Hello,Surpass
index is: 1,value is elcome to Shanghai

3.5.9 字符串替换

字符串替换是将字符串已经存在的字符或子字符替换成新的字符或子字符串，使用内置方法strings.Replace实现。其定义如下所示:

func Replace(s, old, new string, n int) string

s: 待替换的字符串
old: 替换前的字符
new：替换后的字符
n: 替换次数，若为负数则全部替换

参数详细如下所示：

s:即将被分割的字符串
sep:代表使用的分割符

示例如下所示：

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "Hello,Surpass,Welcome to Shanghai."
	m1 := strings.Replace(s, ",", " ", -1)
	m2 := strings.ReplaceAll(s, ",", " ")
	m3 := strings.Replace(s, ",", " ", 1)
	fmt.Printf("使用Replace方法替换全部后的结果:%s\n", m1)
	fmt.Printf("使用ReplaceAll方法替换全部的结果:%s\n", m2)
	fmt.Printf("使用Replace方法仅替换一次后的结果:%s\n", m3)
}

最终的输出结果如下所示：

使用Replace方法替换全部后的结果:Hello Surpass Welcome to Shanghai.
使用ReplaceAll方法替换全部的结果:Hello Surpass Welcome to Shanghai.
使用Replace方法仅替换一次后的结果:Hello Surpass,Welcome to Shanghai.

3.6 数据类型转换

数据类型转换主要是整型、浮点型、字符串、布尔型等基础数据类型的转换。

3.6.1 整型与浮点型

如果是整型与浮点型之间的运算，一般建议是将整型转换为浮点型后再进行计算，从而尽可能减小类型转换所带来的精度丢失问题。整型与浮点型转换可以使用内置方法int、float32、float64等，示例代码如下所示：

package main

import "fmt"

func main() {
	n := 123
	f := 123.456

	fmt.Printf("浮点型转换为整型:%T:%[1]v\n", int(f))
	fmt.Printf("整型转换为浮点型:%T:%[1]v\n", float64(n))

	sum1 := n + int(f)
	sum2 := float64(n) + f
	fmt.Printf("浮点型转换为整型运算结果:%T:%[1]v\n", sum1)
	fmt.Printf("整型转换为浮点型运算结果:%T:%[1]v\n", sum2)
}

代码运算结果：

浮点型转换为整型:int:123
整型转换为浮点型:float64:123
浮点型转换为整型运算结果:int:246
整型转换为浮点型运算结果:float64:246.45600000000002

根据以上运行结果，可得出如下结论：

整型转换为浮点型可以根据需求选择 float32 或 float64
浮点型转换为整型，可以选择 int、int8、int16、int32、int64 等，一般使用 int 即可
如果涉及到整型与浮点型的运算，一般为确保数据准确性，都是将低精度的数据类型转换为高精度类型后再进行运算

3.6.2 整型与字符串

整型与字符串的类型转换一般使用内置方法strconv.Itoa和strconv.Atoi，示例代码如下所示：

package main

import (
	"fmt"
	"strconv"
)

func main() {
	s := strconv.Itoa(123)
	fmt.Printf("整型转换为字符串:%T:%[1]v\n", s)
	i, err := strconv.Atoi("123")
	if err == nil {
		fmt.Printf("字符串转换为整型:%T:%[1]v\n", i)
	}
}

运行结果如下所示：

整型转换为字符串:string:123
字符串转换为整型:int:123

以上示例仅仅是字符串与整型的转换，但整型有 int8、int16、int32、int64 等等。如果需要把字符串转换更加精细的数字，可以使用方法strconv.ParseInt,其方法定义如下所示：

func ParseInt(s string, base int, bitSize int) (i int64, err error)

s：代表要转换的字符串
base: 字符串的对应进制数，例如：2、8、10、16，分别对应二进制、八进制、十进制、十六进制
bitSize: 转换后的整型类型，仅支持 0、8、16、32、64，分别对应为 int、int8、int16、int32、int64

如果 base 指定为 0，则默认根据字符串的前缀进行推断，例如 0b 代表二进制、0.0o 代表八进制，0x 代表十六进制，其他则为十进制

示例代码如下所示：

package main

import (
	"fmt"
	"strconv"
)

func main() {
	s := "100"
	if o, err := strconv.ParseInt(s, 2, 32); err == nil {
		fmt.Printf("二进制字符串%s转换为int32结果:%T:%[2]v\n", s, o)
	}
	if o, err := strconv.ParseInt(s, 8, 32); err == nil {
		fmt.Printf("八进制字符串%s转换为int32结果:%T:%[2]v\n", s, o)
	}
	if o, err := strconv.ParseInt(s, 10, 32); err == nil {
		fmt.Printf("十进制字符串%s转换为int32结果:%T:%[2]v\n", s, o)
	}
	if o, err := strconv.ParseInt(s, 16, 32); err == nil {
		fmt.Printf("十六进制字符串%s转换为int32结果:%T:%[2]v\n", s, o)
	}

	s2 := "0b100"
	if o, err := strconv.ParseInt(s2, 0, 32); err == nil {
		fmt.Printf("二进制字符串%s转换为int32结果:%T:%[2]v\n", s2, o)
	}
	s3 := "0o100"
	if o, err := strconv.ParseInt(s3, 0, 32); err == nil {
		fmt.Printf("八进制字符串%s转换为int32结果:%T:%[2]v\n", s3, o)
	}
	s4 := "100"
	if o, err := strconv.ParseInt(s4, 0, 32); err == nil {
		fmt.Printf("十进制字符串%s转换为int32结果:%T:%[2]v\n", s4, o)
	}
	s5 := "0x100"
	if o, err := strconv.ParseInt(s5, 0, 32); err == nil {
		fmt.Printf("十进制字符串%s转换为int32结果:%T:%[2]v\n", s5, o)
	}
}

运行结果如下所示：

二进制字符串100转换为int32结果:int64:4
八进制字符串100转换为int32结果:int64:64
十进制字符串100转换为int32结果:int64:100
十六进制字符串100转换为int32结果:int64:256
二进制字符串0b100转换为int32结果:int64:4
八进制字符串0o100转换为int32结果:int64:64
十进制字符串100转换为int32结果:int64:100
十进制字符串0x100转换为int32结果:int64:256

3.6.3 浮点型与字符串

浮点型与字符串的相互转换可通过方法strconv.FormatFloat和strconv.ParseFloat，其定义如下所示：

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

各参数解释如下所示：

f:代表需要转换的浮点数
fmt:代表浮点数的标记格式，支持'b'、'e'、'f'、'x'等，可查看源码获取
prec：代表精度，即需要保留的位数，包括整数位和小数点后的位数
bitSize：代表浮点数类型，值为 32/64 表示 float32/float64

func ParseFloat(s string, bitSize int) (float64, error)

各参数解释如下所示：

s：代表需要转换的字符串
bitSize：代表浮点数类型，值为 32/64 表示 float32/float64

示例代码如下所示：

package main

import (
	"fmt"
	"strconv"
)

func main() {
	f := 123.45678
	fmt.Printf("浮点型转换字符串结果:%s\n", strconv.FormatFloat(f, 'b', 5, 64))
	fmt.Printf("浮点型转换字符串结果:%s\n", strconv.FormatFloat(f, 'e', 5, 64))
	fmt.Printf("浮点型转换字符串结果:%s\n", strconv.FormatFloat(f, 'E', 5, 64))
	fmt.Printf("浮点型转换字符串结果:%s\n", strconv.FormatFloat(f, 'f', 5, 64))
	fmt.Printf("浮点型转换字符串结果:%s\n", strconv.FormatFloat(f, 'x', 5, 64))

	s := "123.45678"
	if v, err := strconv.ParseFloat(s, 32); err == nil {
		fmt.Printf("字符串转换为浮点型结果:%f\n", v)
	}
	if v, err := strconv.ParseFloat(s, 64); err == nil {
		fmt.Printf("字符串转换为浮点型结果:%f\n", v)
	}
}

运行结果如下所示：

浮点型转换字符串结果:8687498568818145p-46
浮点型转换字符串结果:1.23457e+02
浮点型转换字符串结果:1.23457E+02
浮点型转换字符串结果:123.45678
浮点型转换字符串结果:0x1.edd3cp+06
字符串转换为浮点型结果:123.456779
字符串转换为浮点型结果:123.456780

更多类型间的数据转换可以查看内置包strconv提供的方法。

本文同步在微信订阅号上发布，如各位小伙伴们喜欢我的文章，也可以关注我的微信订阅号：woaitest，或扫描下面的二维码添加关注：

posted @ 2025-07-08 16:39 Surpassme 阅读(27) 评论(0) 收藏举报

刷新页面返回顶部

Surpassme

不去努力就不会知道自己有多么优秀！

3.数据类型

3.数据类型

3.1 整型

3.2 浮点型

3.3 布尔类型

3.4 字符类型

3.4.1 ASCII 与 UniCode 编码

3.4.2 字符类型

3.5 字符串

3.5.1 字符串定义

3.5.2 字符串转义符

3.5.3 字符串格式化

3.5.4 字符串拼接

3.5.5 字符串长度

3.5.6 字符串遍历

3.5.7 字符位置与截取

3.5.8 字符串分割

3.5.9 字符串替换

3.6 数据类型转换

3.6.1 整型与浮点型

3.6.2 整型与字符串

3.6.3 浮点型与字符串

公告