欢迎来到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)根路径名称
控制打印如下的效果，可以看到我们导包之后，是拿到了对应的数值的：
在go语言中关键字就是程序发明者规定的有特殊含义的单词，又叫保留字，go语言中一共有25个关键字，如下：
一共有36个预定义标识符，包含基础数据类型和系统内嵌函数：
