【启程Golang之旅】基本变量与类型讲解

欢迎来到Golang的世界！在当今快节奏的软件开发领域，选择一种高效、简洁的编程语言至关重要。而在这方面，Golang（又称Go）无疑是一个备受瞩目的选择。在本文中，带领您探索Golang的世界，一步步地了解这门语言的基础知识和实用技巧。

变量的概念

数据类型的概念

数据类型转换

基本数据类型指针

标识符的概念

变量的概念

一个程序就是一个世界，不论是使用哪种高级程序语言编写程序，变量都是其程序的基本组成单位，相当于内存中一个数据存储空间的表示，以下是go定义变量并使用的基本方式：

package main
import "fmt"
func main() {
	// 1.声明变量
	var age int
	// 2.变量赋值
	age = 18
	// 3.使用变量
	fmt.Println("age = ", age)
	
	// 声明和赋值可以合并成一句
	var age2 int = 20
	fmt.Println("age2 = ", age2)
}

上面这种显然易见，控制台打印 age=18 和 age2 = 20，接下来总结一下变量的使用方式：

package main
import "fmt"
func main() {
	// 第一种方式，指定变量的类型并赋值
	var num int = 18
	fmt.Println(num)
	// 第二种方式，指定变量的类型，但是不赋值，使用默认值
	var num2 int
	fmt.Println(num2)
	// 第三种方式，如果没有写变量的类型，会根据等号后面的值进行判断变量的类型（自动判断）
	var num3 = "tom"
	fmt.Println(num3)
	// 第四种方式：省略var，注意 := 不能写为 =
	sex := "男"
	fmt.Println(sex)
}

最终控制台打印的效果如下所示：

声明在函数内部的是局部变量，如果想声明全局变量可以将变量写在函数外面，如下：

package main
import "fmt"
// 单个全局变量
var n = 100
var m = 10.0
// 一次性声明全局变量
var (
	n1 = 12
	n2 = 15
)
func main() {
	fmt.Println(n, m, n1, n2) // 100 10 12 15
}

数据类型的概念

数据类型是编程中用来区分数据存储方式、操作方式以及数据的范围和限制的一种分类方式。它定义了数据的种类以及对这些种类数据进行的操作，如下图所示展示golang的数据类型的分类：

上述数据类型中字符类型有特殊的转义字符，这里简单的讲解一下：

转义符	含义	Unicode值
\b	退格(backspace)	\u0008
\n	换行	\u000a
\r	回车	\u000d
\t	制表符(tab)	\u0009
\"	双引号	\u0022
\'	单引号	\u0027
\\	反斜杠	\u005c

接下来对这些转义字符进行一个简单的测试：

package main
import "fmt"
func main() {
	// 转义字符
	// \n 换行
	fmt.Println("aaa\nbbb")
	// \b 退格
	fmt.Println("aaa\bbbb")
	// \r 光标回到本行的开头，后续输入会替换原有字符
	fmt.Println("aaa\rbbb")
	// \t 制表符 以8个距离为单位
	fmt.Println("aaa\tbbb")
	fmt.Println("aaaaa\tbbb")
	// \"
	fmt.Println("\"aaa\"")
	// \v 垂直制表符
	fmt.Println("aaa\vbbb")
	// \f 换页符
	fmt.Println("aaa\fbbb")
	// \a 响铃
	fmt.Println("aaa\abbb")
	// \000 空字符
	fmt.Println("aaa\000bbb")
	// \xhh 十六进制
	fmt.Println("aaa\x01bbb")
	// \uhhhh 十六进制
	fmt.Println("aaa\u01bbb")
}

上面代码执行，最终达到的效果如下：

数据类型转换

go在不同类型的变量之间赋值时需要显式转换，并且只有显式转换(强制转换)，代码如下：

package main
import "fmt"
func main() {
	// 进行类型转换
	var n1 int = 100
	//var n2 float32 = n1 在这里自动转换不好使，比如显式转换
	fmt.Println(n1) // 100
	var n2 float32 = float32(n1)
	fmt.Println(n2) // 100
	// 注意：n1的类型其实还是int类型，只是将n1的值100转为float32类型，n1还是int类型
	fmt.Printf("%T", n1) // int
	fmt.Println()

	// 将int64类型转为int8的时候，编译不会出错，但是会数据溢出
	var n3 int64 = 888888
	var n4 int8 = int8(n3)
	fmt.Println(n4) // 56

	var n5 int32 = 12
	var n6 int64 = int64(n5) + 30 // 一定要匹配 = 左右的数据类型
	fmt.Println(n5)               // 12
	fmt.Println(n6)               // 42

	var n7 int64 = 12
	var n8 int8 = int8(n7) + 127 //编译通过但是结果可能会溢出
	//var n9 int8 = int8(n7) + 128 //编译不会通过
	fmt.Println(n8) // -117
	//fmt.Println(n9) // -128
}

基本数据类型转换为string：在程序开发中，我们经常需要用到基本数据类型转换成string类型，或者将string类型转换成基本数据类型，接下来我们开始讲解两者之间的转换方式，这里我们先介绍一下整数常用的代替字符：

接下来我们通过 fmt.Sprintf("%参数", 表达式) 的方式进行字符串的转换，代码如下：

package main
import "fmt"
func main() {
	var n1 int = 10
	var n2 float32 = 4.78
	var n3 bool = false
	var n4 byte = 'a'

	var s1 string = fmt.Sprintf("%d", n1)
	fmt.Printf("s1对应的类型是：%T，s1 = %q \n", s1, s1)
	var s2 string = fmt.Sprintf("%f", n2)
	fmt.Printf("s2对应的类型是：%T，s2 = %q \n", s2, s2)
	var s3 string = fmt.Sprintf("%t", n3)
	fmt.Printf("s3对应的类型是：%T，s3 = %q \n", s3, s3)
	var s4 string = fmt.Sprintf("%c", n4)
	fmt.Printf("s4对应的类型是：%T，s4 = %q \n", s4, s4)
}

最终达到的效果如下：

接下来我们通过 strconv包的函数的方式进行字符串的转换，代码如下：

package main
import (
	"fmt"
	"strconv"
)
func main() {
	var n1 int = 18
	// 第一个参数必须转为int64类型，第二个参数指定字面值的进制形式为十进制
	var s1 string = strconv.FormatInt(int64(n1), 10)
	fmt.Printf("s1对应的类型是：%T，s1 = %q \n", s1, s1)
	var n2 float64 = 4.79
	// 第二个参数：'f' (-ddd.ddd) 第三个参数：9 保留小数点后面9位 第四个参数：表示这个小数是float64类型
	var s2 string = strconv.FormatFloat(n2, 'f', 9, 64)
	fmt.Printf("s2对应的类型是：%T，s2 = %q \n", s2, s2)
	var n3 bool = true
	var s3 string = strconv.FormatBool(n3)
	fmt.Printf("s3对应的类型是：%T，s3 = %q \n", s3, s3)
}

最终达到的效果如下：

string转基本数据类型：接下来我们开始学习如何将上面讲解的类型转换互换过来，如下：

package main
import (
	"fmt"
	"strconv"
)
func main() {
	// string --> bool
	var s1 string = "true"
	var b bool
	/*
		ParseBool这个函数的返回值有两个：(value bool, err error)
		value就是我们得到的布尔类型的数据，err出现的错误
		我们只关注得到的布尔类型的数据，err可以用 _ 直接忽略
	*/
	b, _ = strconv.ParseBool(s1)
	fmt.Printf("b的类型是：%T, b = %v \n", b, b)

	// string --> int64
	var s2 string = "20"
	var num1 int64
	num1, _ = strconv.ParseInt(s2, 10, 64)
	fmt.Printf("num1的类型是：%T, num1 = %v \n", num1, num1)

	// string --> float32/float64
	var s3 string = "3.14"
	var f1 float64
	f1, _ = strconv.ParseFloat(s3, 64)
	fmt.Printf("f1的类型是：%T, f1 = %v", f1, f1)
}

最终达到的效果如下：

注意：string向基本数据类型转换的时候，一定要确保string类型能够转成有效的数据类型，否则最后得到的结果就是按照对应的类型的默认值输出：

package main
import (
	"fmt"
	"strconv"
)
func main() {
	// string --> bool
	var s1 string = "golang"
	var b bool
	b, _ = strconv.ParseBool(s1)
	fmt.Printf("b的类型是：%T, b = %v \n", b, b)

	// string --> int64
	var s2 string = "golang"
	var num1 int64
	num1, _ = strconv.ParseInt(s2, 10, 64)
	fmt.Printf("num1的类型是：%T, num1 = %v \n", num1, num1)
}

最终达到的效果如下：

基本数据类型指针

在Go语言中，指针是一个表示内存地址的值。它指向存储在内存中的变量或者数据结构的位置。

通过指针，我们可以在函数之间共享数据，以及在函数内部修改外部变量的值。在Go语言中，我们使用"&"符号来获取变量的内存地址，使用"*"符号来访问指针所指向的变量的值。

package main
import "fmt"
func main() {
	var age int = 18
	// &符号 + 变量 就可以获取这个变量的内存的地址
	fmt.Println(&age) //0xc00001a088
	/*
		ptr 指针变量的名字
		ptr 对应的类型是：*int 是一个指针类型（可以理解位 指向int类型的指针）
		&age 就是一个地址，是ptr变量的具体的值
	*/
	var ptr *int = &age
	fmt.Println(ptr)
	fmt.Println("ptr本身这个存储空间的地址为：", &ptr)
	// 想获取ptr这个指针或者这个地址指向的那个数据
	fmt.Printf("ptr指向的数据值为：%v", *ptr) // ptr指向的数值为：18
}

总结：指针中最重要的两个符号是：& 取内存地址；* 根据地址取值；当然指针还可以进行如下的操作：

通过指针改变指向值：代码如下：

package main
import "fmt"
func main() {
	var num int = 10
	fmt.Println(num) // 10
    // 注意，指针接收的一定是地址值，所以要对num进行取地址&num，如果直接赋值num则会报错
	var ptr *int = &num 
	*ptr = 20
	fmt.Println(num) // 20
}

标识符的概念

在Go语言中，标识符（identifier）就是指程序员自己定义的变量、常量、函数、类型等命名实体的名称。标识符可以包含字母、数字和下划线（_），但是必须以字母或下划线开头，不能以数字开头。

在Go语言中，是可以使用汉字作为变量名的，但是并不推荐这样做。虽然Go语言支持Unicode字符作为标识符的一部分，包括汉字，但是通常不建议在代码中使用非ASCII字符作为标识符，包括汉字。虽然Go语言允许使用汉字作为变量名，但是出于代码可读性、可维护性以及跨平台兼容性考虑，建议仍然使用英文单词或者符合ASCII字符集的命名方式。如下演示一下：

package main
import "fmt"
func main() {
	var 年龄 int = 10
	fmt.Println(年龄) // 10
}

起名规则：

1）包名：尽量保持package的名字和目录保持一致，采取有意义的包名，简短，有意义，不要和标准库冲突。举例：main包是一个程序的入口包，所以main函数它所在的包建议定义为main包，如果不定义为main包，那么就不能得到可执行文件。

2）变量名、函数名、常量名等尽量采用驼峰命名法。

3）如果变量名、函数名、常量名首字母大写，则可以被其他的包访问，如果首字母小写，则只能在本包中使用（利用首字母大写小写完成权限控制）

注意：如果导包失败需要在文件夹里运行下面的命令生成mod文件 go mod init (study)根路径名称