Go语言基础学习(一)

一 、Go 语言的字符类型

字符类型在工作中也会非常频繁地用到，是一个非常重要的数据类型。这里主要介绍 Go 语言中处理字符和字符串的数据类型

1.1 字符和字符串类型

序号	类型	说明
1	byte	uint8 类型的别名，同等于 uint8。一般用于表示 ASCII 字符，即只能操作简单的字符，不支持中文操作。
2	rune	int32 类型的别名，同等于 int32。一般用于表示 Unicode 字符，即可以处理任何字符。
3	string	一个指向 byte 数组的指针，可以为空字符串不可为nil。

1.2 代码示例

使用一段代码来更清晰地解释byte和rune的区别，以及了解这三个类型的关系。

package main

import "fmt"

// 将字符串转化为rune的数组，并替换数组第i个元素为ch
func str2Rune(str *string, i int, ch rune) {
	temp := []rune(*str)
	temp[i] = ch
	*str = string(temp)
}

// 将字符串转换为byte的数组，并替换数组第i个元素为ch
func str2Byte(str *string, i int, ch byte) {
	temp := []byte(*str)
	temp[i] = ch
	*str = string(temp)
}

func main() {
	str := "你好 Hello"
	str1 := "你好 Hello"
	str2 := "你好 Hello"
	str2Rune(&str, 1, 'A')  //将第1个字符替换为A
	str2Byte(&str1, 3, 'A') //将第3个字符替换为A
	str2Byte(&str2, 7, 'A') // 将第7个字符替换为A
	fmt.Println("rune 数组处理中文后: ", str)
	fmt.Println("byte 数组处理中文后: ", str1)
	fmt.Println("byte 数组处理中文后: ", str2)
}

输出结果如下：

---

结论

• string可以直接转换为rune或者byte的数组；
• rune和byte可以互相转换；
• byte 的操作单位是一个字节，可以理解为一个英文字符；
• rune 的操作单位是一个字符，不管这个字符是什么字符。

二、 Go 语言的强制类型转换

Go 语言是一种强类型语言，而且没有隐式转换。也就是说运算符左右的变量类型必须一致，若不一致就会报错。为了使用户更加的容易使用，所以 Go 语言提供了各个类型之间强制类型转换的内置方法。

2.1 整型和浮点型互相转换

整型和浮点型变量之间的相互转换相对容易，只需使用强制类型转换标志 type(variable)就好了。需要注意的是，当高精度向低精度类型转换的时候，会失真。即浮点型向整型转换的时候会失去其小数部分。需要避免这两个类型的互相转换。

但是也有无法避免的场景，比如说计算浮点数和整数的和之类的情况中。就要秉持不失真原则，将低精度向高精度转换之后进行计算。

package main

import "fmt"

func main() {
	var a int = 10       // 声明一个整型变量a 并给 a 赋值为10
	var b float32 = 3.14 // 声明一个浮点型变量b 并给 b 赋值为3.14

	fmt.Println("整型转换为浮点型: %f\n", float32(a)) // 将变量 a 强制转换为浮点型变量并打印
	fmt.Println("浮点型转换为整型: %d\n", int(b))     // 浮点型转为整型会失真
}

最终输出结果为

整型转换为浮点型: %f
 10
浮点型转换为整型: %d
 3

可以发现浮点型转为整型时候，3.14 失真了，结果为 3。

2.2 整形和字符串互相转换

整型和字符串类型的变量互相转换，需要依靠 Go 语言提供的转换包strconv。字符串转整型需要使用这个包的Atoi(string)方法，整型转字符串则是Itoa(int)。这种转换用得最多的就是给一些对象进行编号。比如需要给张三编号为NO.1，你可能需要将1转换为字符串之后与NO.进行拼接。

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var a int = 10      // 定义一个整型变量并赋值为 10
	var b string = "10" // 定义一个字符串类型变量赋值为 "10"

	fmt.Printf("整型转换为字符串：%s\n", strconv.Itoa(a))
	tmp, _ := strconv.Atoi(b)
	fmt.Printf("字符串转换为整型: %d\n", tmp)
}

输出结果

整型转换为字符串：10
字符串转换为整型: 10

2.3 浮点型和字符串互相转换

浮点型和字符串的互相转换没有直接封装好的转换接口了，需要调用strconvs包中稍微底层一点的接口。浮点型转字符串使用FormatFloat(float64,byte,int,int)方法，字符串转换为浮点型则使用ParseFloat(...)方法。因为浮点数在存储过程中容易因为精度问题而存在误差，所以有时候会将浮点数转换为字符串进行存储。

package main

import (
	"fmt"
	"strconv"
)

func main() {
	f1 := 0.123456789
	s1 := strconv.FormatFloat(f1, 'f', -1, 32)
	s2 := strconv.FormatFloat(f1, 'f', -1, 64)
	s3 := "0.123456789"
	f2, _ := strconv.ParseFloat(s3, 64)
	f3, _ := strconv.ParseFloat(s3, 32)
	fmt.Println("将浮点数转换为float32转换为string: ", s2)
	fmt.Println("将float64转换为string: ", s1)
	fmt.Println("将string转换为float64: ", f2)
	fmt.Println("将string转换为float32再强制转换为float54: ", f3)
}

输出结果

将浮点数转换为float32转换为string:  0.123456789
将float64转换为string:  0.12345679
将string转换为float64:  0.123456789
将string转换为float32再强制转换为float54:  0.12345679104328156

Go 语言中各个数据类型的互相强制转换。主要都是依赖与 strconvs 这个第三方包。这个包中还提供了其它很多的转换方法，在做类型转换的时候要注意：浮点型在转为整型时会失真。

三、 Go语言的常量

常量可以理解为是一个存储了不可以改变的值的变量。常量主要用于特殊值的语义化，使这些值在更容易维护的情况下不会被程序所修改。Go 语言中声明常量使用的关键字是const。常量的使用非常广泛，比如说圆周率，再比如说一些明确的错误信息等一些容易被多次使用的值，一般都会使用常量进行实例化，使其在需要更改时，更容易维护，同时增加代码可读性。

3.1 常量定义

常量定义的形式为 const 常量名 常量类型 = 常量值

package main

import "fmt"

const c1 string = "2023年4月23日"
const c2 = "2023年4月23日" // 和变量一样，常量也可以部使用数据类型直接赋值，其类型和值一致

func main() {
	fmt.Println(c1)
	fmt.Println(c2)

}

3.2 多常量定义

3.2.1 普通模式

和 Go 语言的变量一样，常量也可以进行多常量定义。定义形式为const 常量名,常量名= 常量值,常量值。

package main  

import (  
 "fmt"  
)  

const c1, c2 = "2020年3月8日", "2020年3月9日"  

func main() {  
 fmt.Println(c1)  
 fmt.Println(c2)  
}

输出结果

2023年4月23日
2023年4月23日

3.2.2 特殊方式

在常量的使用中，Go 语言还提供了一种特殊的多常量定义方式——const()。这种定义方式也是比较推荐的常量使用方式。

package main

import (
	"fmt"
)

const (
	c1 = "2020年3月8日"
	c2 = "2020年3月9日"
)

func main() {
	fmt.Println(c1)
	fmt.Println(c2)
}

输出结果

2020年3月8日
2020年3月9日