【启程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)根路径名称