Golang学习历程【第三篇基本数据类型类型转换】

Golang学习历程【第三篇基本数据类型】

1. 总览
2. 基本数据类型
- 2.1 整型
- 2.2 浮点型
- 2.2 布尔型
- 2.3 字符
- 2.4 字符串
- - 2.4.1 常用定义方式
  - 2.4.2 转移字符
  - 2.4.3 常用方法
  - 2.4.3 字符串中字符替换
3. 类型转换
- 3.1 整型与整型转化
- 3.2 浮点数与整型转换
- 3.3 其他类型与string类型转换
- 3.4 strconv 字符串类型转换工具
- - 3.4.1 strconv.Atoi(字符串转int) 和 strconv.Itoa(int转字符串)
  - 3.4.2 strconv.Parse 字符串解析为其他类型
  - 3.4.3 strconv.Format 数字格式化为string
  - 3.4.4 其他方法

1. 总览

Go语言中数据类型分为：基本数据类型和复合数据类型

基本数据类型：整型，浮点型，布尔型，字符串
复合数据类型：数组，切片，结构体，函数，map，通道（channel）、接口等

2. 基本数据类型

2.1 整型

类型	范围	占用空间	有无符号
int8	$2^7$ ~ $2^7-1$	1个字节	有
int16	$2^{15}$ ~ $2^{15}-1$	2个字节	有
int32	$2^{31}$ ~ $2^{31}-1$	4个字节	有
int64	$2^{63}$ ~ $2^{63}-1$	8个字节	有
uint8	$0$ ~ $2^8-1$	1个字节	无
uint16	$0$ ~ $2^{16}-1$	2个字节	无
uint32	$0$ ~ $2^{32}-1$	4个字节	无
uint64	$0$ ~ $2^{64}-1$	8个字节	无

特殊类型：

类型	描述
uint	32位操作系统上为uint32,64位操作系统上为uint64
int	32位操作系统上为int32,64位操作系统上为int64
uintptr	无符号整型，用于存放一个指针
简单示例：

var (
	num1 int  = 666
	num2 uint = 666
	// 以下赋值可选最大值，math 为math包，使用即自动引入
	num1 int  = 666
	num2 uint = 666
	// 以下赋值可选最大值
	num3  int8   = math.MaxInt8
	num4  int16  = math.MaxInt16
	num5  int32  = math.MaxInt32
	num6  int64  = math.MaxInt64
	num7  uint8  = math.MaxUint8
	num8  uint16 = math.MaxUint16
	num9  uint32 = math.MaxUint32
	num10 uint64 = math.MaxUint64
)
fmt.Println(num1, num2, num3, num4, num5, num6, num7, num8, num9, num10)

结果：

666 666 127 32767 2147483647 9223372036854775807 255 65535 4294967295 18446744073709551615

2.2 浮点型

Go语言支持两种浮点数：float32和float64，遵循IEEE 745标准。32位操作系统中，默认为float32；64位操作系统中默认为float64。

float32：-3.4e38~3.4e38 ，占用4个字节
float64：-1.8e308~1.8e308，占用8个字节

// 1. 基本定义
var num1 float32 = 1.06
num2 := 3.1415926
// 保留小数据，可以使用%.nf或者%0.nf 指定保留n位小数，
fmt.Printf("原样输出：%v; 默认保留6位小数: %f; 指定保留3为小数: %0.3f \n", num1, num2, num2)
// 2. 其他常用样例
var (
	num3 float32 = 3.1415926
	num4 float64 = 1.113
	num5         = 3.14e2  // 使用科学计数法表示，3.14*10^2 的值：为314
	num6         = 3.14e-2 // 使用科学计数法表示，3.14*10-2 的值：为0.0314
)
fmt.Println(num3, num4, num5, num6)

结果：

原样输出：1.06; 默认保留6位小数: 3.141593; 指定保留3为小数: 3.142 
3.1415925 1.113 314 0.0314

2.2 布尔型

bool值仅有两个值：true和false。声明不赋值，默认为false

var (
	bool1 bool
	bool2 = true
)
fmt.Println(bool1, bool2)

结果：

false true

2.3 字符

字符是单个数值，属于int类型，Go语言中有两种表示：byte和rune

byte: int类型，代表ASCII码的值
rune: int类型，代表UTF-8编码

注：UTF-8的国际通用编码，是ASCII码的扩展，包括了各国的常用的语言文字</font
常用示例：

var a = 'A'
var a = 'A'
// 使用%c输出字符
fmt.Printf("字符ASCII值:%v; 原样编码:%c \n", a, a)
var (
	b = 'B'
	c = '你'
	d = "this" // 可以获取字符串中的单个字符
)
fmt.Printf("%c,%c,%c,%c,%c,%c", b, c, d[0], d[1], d[2], d[3])

结果：

字符ASCII值:65; 原样编码:A 
B,你,t,h,i,s

2.4 字符串

2.4.1 常用定义方式

// 字符串定义
var val1 string = "hello world"
var val2 = "你好 go"
val3 := "Good"
fmt.Println(val1, val2, val3)
// 字符串val2中2个中文，3个英文(空格也算)；共2*3+3=9个字符，可通过len函数获取
fmt.Println(len(val2))
// 多行字符串：会原样输出
var info = `姓名：张三
年龄：18`
fmt.Println(info)

结果：

hello world 你好 go Good
9
姓名：张三
        年龄：18

字符串中，英文字母占一个字节，中文占用3个字节。可使用len函数打印字符串字节长度

2.4.2 转移字符

转义符号使用\表示
常用的转义字符有：

\r：回车符（返回行首）
\n：换行符（跳至下一行同列）
\t：制表符（可用于整齐输出一系列值）
\'：单引号，输出'
\"：双引号，输出"
\\：反斜杠，输出\

var val1 string = "hello\r"
var val2 string = "world\n"
var val3 string = "hello world\t"
var val4 string = "'hello' \\ \"world\""
/*
	var1：\r 回车符，hello输出结束后回车，光标移动至当前行首，意味着清空hello值
	val2: \n 换行符，world输出之后换行
	val3: \t 制表符，hello world简易理解为一个大的空格，格式美观，自带对齐
	val4: Go语言中'可以直接写在"内部，\\输出\, \" 转义字符，输出"
*/
fmt.Println(val1, val2, val3, val4)

结果：

 world
 hello world     'hello' \ "world"

2.4.3 常用方法

方法名基本上为常用英文名缩写，各语言基本通用，使用多了自然熟记

方法	描述
len	获取字符串长度
+或fmt.Springf	拼接字符串
strings.Split	拆分字符串
strings.Contains	获取字符串长度
strings.HasPrefix,strings.HasSuffix	获取字符串长度
strings.Index,strings.LastIndex	获取字符串长度
strings.Join	获取字符串长度
strings.ToLower	字符串全转小写
strings.ToUpper	字符串全转大写
示例：

var val = "Hello World"
// 1. len求长度
length := len(val)
fmt.Printf("%s长度: %d\n", val, length)

// 2. + 拼接字符串，Sprint中S代表返回字符串，同理含有：Sprinf、Sprinln，与Prinf、Prinln类似，区别在于S开头函数代表返回字符串，可用变量接收
str1 := val + "小明"
str2 := fmt.Sprint(val, "小红")
fmt.Printf("+拼接：%s;\tSprint函数拼接: %s \n", str1, str2)

// 3. 字符串拆分结果为：切片（类似于数组）；参数为(<原字符串>, <切片字符串>)，示例中将Hello World以空格拆分为Hello和World
splitVal := strings.Split(val, " ") // 切片结果为[Hello World]
// 4. Join将切片拼接成新的字符串；参数为(<原字符串>, <连接符>)
newStr := strings.Join(splitVal, ",") //
fmt.Printf("切片值：%v;\tJoin连接成新的字符串: %s \n", splitVal, newStr)

// 5.字符串是否包含子串，Contains参数为(<原字符串>,<子串>)
bool1 := strings.Contains(val, "Hello")
bool2 := strings.Contains(val, "Hello")
fmt.Printf("是否包含Hello：%v;\t是否包含olleH: %v \n", bool1, bool2)

// 6. 前缀判断：HasPrefix ,参数为(<原字符串>,<子串>); 后缀判断：HasSuffix，参数(<原字符串>,<子串>)
bool3 := strings.HasPrefix(val, "He")
bool4 := strings.HasPrefix(val, "llo")
bool5 := strings.HasSuffix(val, "World")
bool6 := strings.HasSuffix(val, "Wor")
fmt.Printf("前缀包含He：%v;\t前缀包含llo: %v\t后缀包含World：%v;\t后缀包含Wor: %v \n", bool3, bool4, bool5, bool6)

// 7. 返回子串在原字符串首次出现的位置，Index，从前向后查找；LastIndex，从后向前查找，参数都为(<原字符串>,<子串>)。结果：查询到，返回下标值，查询不到，返回-1。注：下标从0开始
index1 := strings.Index(val, "o")
index2 := strings.LastIndex(val, "o")
index3 := strings.Index(val, "a")
fmt.Printf("o从前到后查询在第%v位;\to从后到前查询在第%v位\ta从前到后查询在第%v位\n", index1, index2, index3)
// 8. strings.ToLower和strings.ToUpper
str3 := strings.ToLower(val)
str4 := strings.ToUpper(val)
fmt.Printf("全小写： %v;\t全大写：%v\n", str3, str4)

运行结果

Hello World长度: 11
+拼接：Hello World小明; Sprint函数拼接: Hello World小红
切片值：[Hello World];  Join连接成新的字符串: Hello,World
是否包含Hello：true;    是否包含olleH: true
前缀包含He：true;       前缀包含llo: false      后缀包含World：true;    后缀包含Wor: false 
o从前到后查询在第4位;   o从后到前查询在第7位    a从前到后查询在第-1位
全小写hello world;      全大写HELLO WORLD

温馨提示：这里的len、split、contains、prefix、suffix、index、join、lower、upper等所表示的含义在各个编程语言大同小异，只要通一门语言，其他也就简单了

2.4.3 字符串中字符替换

	// 字符串中替换字符
	var val1 = "hello xioaming"
	byteStr := []byte(val1) // 英文字符 转成byte数组类型即可，然后替换值
	byteStr[0] = 'a'
	fmt.Println(string(byteStr)) // string(byteStr)为将数组转成字符串返回，fmt.Println再打印输出结果
	var val2 = "你好小明"
	runeStr := []rune(val2) // 包含中文字符 需要转成rune数组类型即可，然后替换值
	runeStr[0] = '我'
	fmt.Println(string(runeStr))

结果：

aello xioaming
我好小明

3. 类型转换

数字类型装换有两种：低精度转高精度，高精度转低精度
注：高精度转低精度，慎用，由于类型表示范围不同，可能造成精度丢失

3.1 整型与整型转化

示例：

// 进度转换可通过 int8(<整型>),int16(<整型>),int32(<整型>),int64(<整型>)转换
// 1. 低精度转高精度
var a int8 = 127
b := int64(a)
fmt.Printf("a=%v,类型：%T\tb=%v,类型：%T \n", a, a, b, b)
// 2. 高精度转低精度
var c int64 = 127
d := int16(c)
fmt.Printf("a=%v,类型：%T\tb=%v,类型：%T \n", c, c, d, d)

结果：

a=127,类型：int8        b=127,类型：int64 
a=127,类型：int64       b=127,类型：int16

3.2 浮点数与整型转换

示例：

// 3. 整型转浮点型，可通过 float32(<整型>),float64(<整型>)，浮点数转浮点数据也可以这样操作
var e int16 = 256
f := float32(e)
fmt.Printf("a=%v,类型：%T\tb=%v,类型：%T \n", e, e, f, f)
// 4. 浮点型转整型
var g float64 = 3.145
h := int16(g) // 注：类型会丢失，不是四舍五入，直接截取整数部分
fmt.Printf("a=%v,类型：%T\tb=%v,类型：%T \n", g, g, h, h)

结果：

a=256,类型：int16       b=256,类型：float32 
a=3.145,类型：float64   b=3,类型：int16

3.3 其他类型与string类型转换

var (
	intV   = 123
	folatV = 3.145
	boolV  = true
	charV  = 'A'
)
// 1. 通过 fmt.Sprintf进行转换
str1 := fmt.Sprintf("%d", intV)   // 转换int
str2 := fmt.Sprintf("%f", folatV) // 转换float
str3 := fmt.Sprintf("%t", boolV)  // 转换 bool
str4 := fmt.Sprintf("%c", charV)  // 转换 字符
fmt.Println(str1, str2, str3, str4)

结果：

123 3.145000 true A

3.4 strconv 字符串类型转换工具

3.4.1 strconv.Atoi(字符串转int) 和 strconv.Itoa(int转字符串)

简单记忆：i(int) ，itoa中i在首字母，表示int转string。atoi中i在末尾，表示string转int

var str = "123"
// 1. 将string转换为int类型，strconv.Atoi(<string>)， 返回类型有两个：<转换数据,异常err>
num1, _ := strconv.Atoi(str)
fmt.Printf("转化值：%v\t类型：%T\n", num1, num1)
// 2. 将int类型转换为string, strconv.Itoa(<int>),类型必须int，返回类型有一个：<string>
var num2 int64 = 456
str2 := strconv.Itoa(int(num2))
fmt.Printf("转化值：%v\t类型：%T\n", str2, str2)

结果：

转化值：123     类型：int
转化值：456     类型：string

3.4.2 strconv.Parse 字符串解析为其他类型

strconv.Parse能将将字符串解析为指定类型，前提：允许转换

var (
	str1 = "256"
	str2 = "3.145"
	str3 = "true"
)
// 以下的bitSize参数感觉意义不大，返回值有特定的返回类型
/*
	1. ParseInt
		params
			参数1: string数据
			参数2：base 指定进制，取值范围是 2 到 36。如果 base 为 0
			参数3：bitSize 指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64
		return
			int64: 返回始终为int64数值
			err: 转换失败后返回的失败信息
*/
num1, _ := strconv.ParseInt(str1, 10, 0)
fmt.Printf("转化值：%v\t类型：%T\n", num1, num1)
/*
	2. ParseFloat
		params
			参数1: string数据
			参数2：bitSize 指定了返回值的类型，32 表示 float32，64 表示 float64；
		return
			float64: 返回始终为float64数值
			err: 转换失败后返回的失败信息
*/
num2, _ := strconv.ParseFloat(str2, 32)
fmt.Printf("转化值：%0.3f\t类型：%T\n", num2, num2)
/*
	3. ParseBool
		params
			参数1: string数据
		return
			bool: 返回始终为bool数值
			err: 转换失败后返回的失败信息
*/
boo, _ := strconv.ParseBool(str3)
fmt.Printf("转化值：%v\t类型：%T\n", boo, boo)

结果：

转化值：256     类型：int64
转化值：3.145   类型：float64
转化值：true    类型：bool

3.4.3 strconv.Format 数字格式化为string

var (
	intV   = 123
	floatV = 3.145e2
	booV   = true
)
// 以下的bitSize参数感觉意义不大，返回值有特定的返回类型
/*
	1. FormatInt
		params
			参数1: int64数据
			参数2：base 指定进制，取值范围是 2 到 36。如果 base 为 0
		return
			string: 返回始终为string数值
*/
str1 := strconv.FormatInt(int64(intV), 10)
fmt.Printf("转化值：%v\t类型：%T\n", str1, str1)
/*
	2. FormatFloat
		params
			参数1: float64数据
			参数2：格式化类型
					 'b' (-ddddp±ddd, 二进制指数),
					 'e' (-d.dddde±dd, 十进制e指数),
					 'E' (-d.ddddE±dd, 十进制E指数),
					 'f' (-ddd.dddd, 无指数),
					 'g' ('e'表示大指数，'f'表示其他指数),
					 'G' ('E'表示大指数，'F'表示其他指数),
					 'x' (-0xd.ddddp±ddd, 十六进制分数和二进制指数 小写),
					 'X' (-0Xd.ddddP±ddd, 十六进制分数和二进制指数 大写).
			参数3：保留的小数点位数，四舍五入。-1代表不对小数点格式化处理
			参数4：bitSize 指定了返回值的类型，32 表示 float32，64 表示 float64；
		return
			string: 返回始终为string数值
*/
str2 := strconv.FormatFloat(floatV, 'f', -1, 64)
fmt.Printf("转化值：%v\t类型：%T\n", str2, str2)
/*
	3. FormatFloat
		params
			参数1: bool数据
		return
			string: 返回始终为string数值
*/
str3 := strconv.FormatBool(booV)
fmt.Printf("转化值：%v\t类型：%T\n", str3, str3)

结果：

转化值：123     类型：string
转化值：314.5   类型：string
转化值：true    类型：string

3.4.4 其他方法

其他还包含strconv.Append(字符换追加)、strconv.IsPrint（是否可打印）和 strconv.IsGraphic（是否图形字符）、strconv.Quote（字符串转义）和 strconv.Unquote（取出转义）、strconv.CanBackquote（判断是否可以表示为单行反引号字符串）等。
这里学习到这，不做详细示例分析，有印象即可，需要时再学习；可参考链接