变量的介绍
- 变量的概念
- 变量的使用步骤
变量快速入门案例
变量的声明，初始化和赋值
⚠️变量使用注意事项
小数类型/浮点型
字符类型
- 基本介绍
- 案例演示
string 类型
基本数据类型的默认值
- 基本介绍
- 基本数据类型的默认值如下
基本数据类型的相互转换
基本数据类型和string 的转换
指针
值类型和引用类型
- 值类型和引用类型的说明
- 值类型和引用类型的使用特点
标识符的命名规范

变量的介绍

变量的概念

变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，同样的道理，通过变量名可以访问到变量(值)。

变量的使用步骤

声明变量(也叫定义变量)
非变量赋值
使用变量
变量快速入门案例
```go package main

import “fmt”

func main() { // 1. 声明变量(也叫定义变量) var i int // 2. 非变量赋值 i = 10 // 3. 使用变量 fmt.Println(“i=”, i) }

输出
```go
PS E:\GoProject\src\go_code\chapter03> go run .\main.go
i= 10

变量的声明，初始化和赋值

声明变量

基本语法：var 变量名数据类型

var a int //声明了一个变量 变量名是 a
var num1 float32 //声明了一个变量 表示一个单精度类型的小数 变量名是num1

初始化变量

在声明变量时就给值

var a int = 1 //这就是初始化变量a
使用细节：如果声明时就直接赋值 可以省略数据类型
var b = 2

给变量赋值

var num int //声明变量num 默认值为0
num = 1 //先声明 再给值 这就是给变量赋值

⚠️变量使用注意事项

变量表示内存中的一个存储区域
该区域有自己的名称（变量名）和类型（数据类型）
Golang 变量使用的三种方式
1. 第一种：指定变量类型，声明后若不赋值，使用默认值
2. 第二种：根据值自行判定变量类型(类型推导)
3. 第三种：省略 var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误 ```go package main

import “fmt”

func main() { //golang的变量使用方式1 //第一种：指定变量类型，声明后若不赋值，使用默认值 // int 的默认值是0 , 其它数据类型的默认值后面马上介绍 var i int fmt.Println(“i=”, i) //输出 i= 0

//第二种：根据值自行判定变量类型(类型推导)
var num = 10.11
fmt.Println("num=", num) //输出 num= 10.11
//第三种：省略var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误
//下面的方式等价 var name string = "tom"
// := 的 :不能省略，否则错误
name := "tom"
fmt.Println("name=", name) //输出 name= tom

}


4. 多变量声明，在编程中，有时我们需要一次性声明多个变量，Golang 也提供这样的语法
```go
package main
import "fmt"
func main() {
    //一次性声明多个变量的方式1
    // var n1, n2, n3 int
    // fmt.Println("n1=", n1, "n2=", n2, "n3=", n3) // n1= 0 n2= 0 n3= 0
    //一次性声明多个变量的方式2
    // var n1, name, n3 = 100, "tom", 888
    // fmt.Println("n1=", n1, "name=", name, "n3=", n3) //n1= 100 name= tom n3= 888
    //一次性声明多个变量的方式3, 同样可以使用类型推导
    n1, name, n3 := 100, "tom~", 888
    fmt.Println("n1=", n1, "name=", name, "n3=", n3) // n1= 100 name= tom~ n3= 888
}

定义全局变量 ```go package main

import “fmt”

// //定义全局变量 var n1 = 100 var n2 = 200 var name = “jack”

//上面的声明方式，也可以改成一次性声明 var ( n3 = 300 n4 = 900 name2 = “mary” )

func main() {

//输出全局变量
fmt.Println("n1=", n1, "name=", name, "n2=", n2)//n1= 100 name= jack n2= 200
fmt.Println("n3=", n3, "name2=", name2, "n4=", n4)//n3= 300 name2= mary n4= 900

}


6. 数据值可以在同一类型范围内不断变化(重点)
```go
package main
import "fmt"
func main() {
    //该区域的数据值可以在同一类型范围内不断变化
    var i int = 10
    i = 30 //正确
    i = 50 //正确
    fmt.Println("i=", i) // i= 50
    //i = 1.2 //错误,原因是不能改变数据类型
}

变量在同一个作用域(在一个函数或者在代码块)内不能重名 ```go package main import “fmt”

func main() { var i int = 1 i := 2 //错误变量重名 }


8. **变量=变量名+值+数据类型**，这一点请大家注意，变量的三要素
8. Golang 的变量如果没有赋初值，编译器会使用默认值,  比如 int 默认值 0    string 默认值为空串， 小数默认为 0
<a name="zG8F0"></a>
# 数据类型的基本介绍
每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间<br />![](https://cdn.nlark.com/yuque/0/2022/jpeg/2608713/1652410588097-cc60ec6d-85d5-4d60-b253-78321db0e923.jpeg)
<a name="KhPj2"></a>
# 整数类型
<a name="R8qLu"></a>
## 基本介绍
简单的说，就是**用于存放整数值**的，比如 0, -1, 2345 等等
<a name="ejSGk"></a>
## 整数的各个类型
<a name="BxUAb"></a>
### int 的有符号的类型
| **类型** | **有无符号** | **占用存储空间** | **表数范围** | **备注** |
| --- | --- | --- | --- | --- |
| int8 | 有 | 1字节 | -128~127 |  |
| int16 | 有 | 2字节 | -2^15~2^15-1 |  |
| int32 | 有 | 4字节 | -2^31~2^31-1 |  |
| int64 | 有 | 8字节 | -2^63~2^63-1 |  |
<a name="uHBRl"></a>
### int 的无符号的类型
| **类型** | **有无符号** | **占用存储空间** | **表数范围** | **备注** |
| --- | --- | --- | --- | --- |
| uint8 | 无 | 1字节 | 0~255 |  |
| uint16 | 无 | 2字节 | 0~2^16-1 |  |
| uint32 | 无 | 4字节 | 0~2^32-1 |  |
| uint64 | 无 | 8字节 | 0~2^64-1 |  |
<a name="HbpwH"></a>
### int 的其他类型
| **类型** | **有无符号** | **占用存储空间** | **表数范围** | **备注** |
| --- | --- | --- | --- | --- |
| int | 有 | 32位系统4个字节<br />64位系统8个字节 | -2^31~2^31-1<br />-2^63~2^63-1 |  |
| uint | 无 | 32位系统4个字节<br />64位系统8个字节 | 0~2^32-1<br />0~2^64-1 |  |
| rune | 有 | 4字节 | -2^31~2^31-1 | 等价int32 表示一个Unicode码 |
| byte | 无 | 1字节 | 0~255 | 当要存储字符时选用byte |
<a name="o4VD3"></a>
## 整型的使用细节
1. Golang 各整数类型分：有符号和无符号，int uint  的大小和系统有关。
1. Golang 的整型默认声明为 int 型
```go
    //整型的使用细节
    var n1 = 100 // ? n1 是什么类型
    //这里我们给介绍一下如何查看某个变量的数据类型
    //fmt.Printf() 可以用于做格式化输出。
    fmt.Printf("n1 的 类型 %T \n", n1)//n1 的 类型 int

如何在程序查看某个变量的字节大小和数据类型（使用较多）

 //如何在程序查看某个变量的占用字节大小和数据类型 （使用较多）
 var n2 int64 = 10
 //unsafe.Sizeof(n1) 是unsafe包的一个函数，可以返回n1变量占用的字节数
 fmt.Printf("n2 的 类型 %T  n2占用的字节数是 %d ", n2, unsafe.Sizeof(n2))//n2 的 类型 int64  n2占用的字节数是 8

Golang 程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型
bit: 计算机中的最小存储单位。byte:计算机中基本存储单元。 1byte = 8 bit

小数类型/浮点型

基本介绍
小数类型就是用于存放小数的，比如 1.2 -0.23 3.1415926 等等

浮点型分类
| 类型 | 有无符号 | 占用存储空间 | 表数范围 | | —- | —- | —- | —- | | 单精度float32 | 有 | 4个字节 | -3.403E38~3.403E38 | | 双精度float64 | 有 | 8个字节 | -1.798E308~1.798E308 |
浮点型的存储分为三部分：符号位+指数位+尾数位
尾数部分可能丢失，造成精度损失。
1. float64 的精度比 float32 的要准确
2. 如果我们要保存一个精度高的数，则应该选用 float64
```
var num3 float32 = -123.0000901
var num4 float64 = -123.0000901
fmt.Println("num3=", num3, "num4=", num4) // num3= -123.00009 num4= -123.0000901
```
  浮点型使用细节
Golang 浮点类型有固定的范围和字段长度，不受具体 OS(操作系统)的影响。

Golang 的浮点型默认声明为 float64 类型

 //Golang 的浮点型默认声明为float64 类型
 var num5 = 1.1
 fmt.Printf("num5的数据类型是 %T \n", num5)//num5的数据类型是 float64

浮点型常量有两种表示形式
1. 十进制数形式：1.23、.123 (必须有小数点）
2. 科学计数法形式: 3.1415e2 3.1415 * 10 的 2 次方、3.1415E-2 3.1415/10 的 2 次方
通常情况下，应该使用 float64 ，因为它比 float32 更精确。开发中，推荐使用 float64
字符类型
基本介绍
Golang 中没有专门的字符类型，如果要存储单个字符(字母)，一般使用 byte 来保存。字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。也就是说对于传统的字符串是由字符组成的，而 Go 的字符串不同，它是由字节组成的。
案例演示
```go package main import ( “fmt” )

//演示golang中字符类型使用 func main() {

var c1 byte = 'a'
var c2 byte = '0' //字符的0

//当我们直接输出byte值，就是输出了的对应的字符的码值
// 'a' ==> 97
fmt.Println("c1=", c1) //c1= 97
fmt.Println("c2=", c2) //c2= 48
//如果我们希望输出对应字符，需要使用格式化输出
fmt.Printf("c1=%c c2=%c\n", c1, c2) // c1=a c2=0

//var c3 byte = '北' //overflow溢出
var c3 int = '北' //overflow溢出
fmt.Printf("c3=%c c3对应码值=%d\n", c3, c3) //c3=北 c3对应码值=21271

//可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的unicode 字符
var c4 int = 22269 // 22269 -> '国' 120->'x'
fmt.Printf("c4=%c\n", c4) // c4=国

//字符类型是可以进行运算的，相当于一个整数,运算时是按照码值运行
var n1 = 10 + 'a' //  10 + 97 = 107
fmt.Println("n1=", n1) //n1= 107

}

对上面代码说明

- 如果我们保存的字符在 ASCII 表的,比如[0-1, a-z,A-Z..]直接可以保存到 byte
- 如果我们保存的字符对应码值大于 255,这时我们可以考虑使用 int 类型保存
- 如果我们需要安装字符的方式输出，这时我们需要格式化输出，即 fmt.Printf(“%c”, c1)
<a name="UMekQ"></a>
## 字符类型使用细节

1. 字符常量是用单引号('')括起来的单个字符。如 `var c1 byte = 'a'`
1. Go 中允许使用转义字符 `\`来将其后的字符转变为特殊字符型常量。例如：`var c3 char = '\n'` '\n'表示换行符
1. Go   语 言 的 字 符 使 用 UTF-8  编 码    ， 如 果 想 查 询 字 符 对 应 的 utf8 码 值[http://www.mytju.com/classcode/tools/encode_utf8.asp](http://www.mytju.com/classcode/tools/encode_utf8.asp) 英文字母-1 个字节    汉字-3 个字节
1. 在 Go 中，字符的本质是一个整数，直接输出时，是该字符对应的 UTF-8 编码的码值。
1. 可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的 unicode 字符
1. **字符类型是可以进行运算**的，相当于一个整数，因为它都对应有 Unicode 码
<a name="dofNc"></a>
## 字符类型本质探讨

1. 字符型 存储到 计算机中，需要将字符对应的码值（整数）找出来
   1. 存储：字符--->对应码值--->二进制-->存储
   1. 读取：二进制----> 码值 ----> 字符 --> 读取
2. 字符和码值的对应关系是通过字符编码表决定的(是规定好)
2. Go 语言的编码都统一成了 utf-8。非常的方便，很统一，再也没有编码乱码的困扰了
<a name="QdCzH"></a>
# 布尔类型
<a name="kkXPU"></a>
## 基本介绍

1. 布尔类型也叫 bool 类型，bool 类型数据只允许取值 true 和 false
1. bool 类型占 1 个字节。
1. bool 类型适于**逻辑运算**，一般用于程序流程控制
<a name="A8ON7"></a>
## 案例演示
```go
package main
import (
    "fmt"
    "unsafe"
)

//演示golang中bool类型使用
func main() {
    var b = false
    fmt.Println("b=", b)
    //注意事项
    //1. bool类型占用存储空间是1个字节
    fmt.Println("b 的占用空间 =", unsafe.Sizeof(b) )
    //2. bool类型只能取true或者false

}

string 类型

基本介绍

字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本

案例演示

package main
import (
    "fmt"
)

//演示golang中string类型使用
func main() {
    //string的基本使用
    var address string = "北京长城 110 hello world!"
    fmt.Println(address)
}

string 使用注意事项和细节

Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本，这样 Golang 统一使用 UTF-8 编码,中文乱码问题不会再困扰程序员。

字符串一旦赋值了，字符串就不能修改了：在 Go 中字符串是不可变的

 var str = "hello"
 str[0] = 'a' //这里就不能去修改str的内容，即go中的字符串是不可变的。

 s := "left foot"
 t := s
 s += ", right foot"
 //这并不会导致原始的字符串值被改变，但是变量s将因为+=语句持有一个新的字符串值，
 //但是t依然是包含原先的字符串值
 fmt.Println(s) // "left foot, right foot"
 fmt.Println(t) // "left foot"

字符串的两种表示形式
1. 双引号"" , 会识别转义字符
2. 反引号```` ，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果
字符串拼接方式用+连接字符串
当一行字符串太长时，需要使用到多行字符串，可以分行写,但是注意，需要将+保留在上一行
```
 //当一个拼接的操作很长时，怎么办，可以分行写,但是注意，需要将+保留在上一行.
 str4 := "hello " + "world" + "hello " + "world" + "hello " +
     "world" + "hello " + "world" + "hello " + "world" +
     "hello " + "world"
 fmt.Println(str4)
```
💡Go字符串的内存布局
Go字符串的内存布局为两字长的数据结构表示，分别是一个指向字符串存储数据的指针和字符串的长度。

基本数据类型的默认值
基本介绍
在 go 中，数据类型都有一个默认值，当程序员没有赋值时，就会保留默认值，在 go 中，默认值又叫零值。
基本数据类型的默认值如下

整型 0
浮点型 0
字符串 “”

布尔类型 false

  var a int          // 0
  var b float32      // 0
  var c float64      // 0
  var isMarried bool // false
  var name string    // ""
  //这里的%v 表示按照变量的值输出
  fmt.Printf("a=%d,b=%v,c=%v,isMarried=%v name=%v", a, b, c, isMarried, name)//a=0,b=0,c=0,isMarried=false name=

基本数据类型的相互转换

基本介绍

Golang 和 java / c 不同，Go 在不同类型的变量之间赋值时需要显式转换。也就是说 Golang 中数据类型不能自动转换

基本语法

表达式 T(v) 将值 v 转换为类型 T

T: 就是数据类型，比如 int32，int64，float32 等等

v: 就是需要转换的变量

案例演示

  var i int32 = 100
  //希望将 i => float
  var n1 float32 = float32(i)
  var n2 int8 = int8(i)
  var n3 int64 = int64(i) //低精度->高精度

  fmt.Printf("i=%v n1=%v n2=%v n3=%v \n", i ,n1, n2, n3)//i=100 n1=100 n2=100 n3=100

基本数据类型相互转换的注意事项

Go 中，数据类型的转换可以是从表示范围小—>表示范围大，也可以范围大—->范围小

被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化！

 var i int32 = 100
 //希望将 i => float
 var n1 float32 = float32(i)
 var n2 int8 = int8(i)
 var n3 int64 = int64(i) //低精度->高精度

 //被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化
 fmt.Printf("i type is %T\n", i) // i type is int32

在转换中，比如将 int64 转成 int8 【-128—-127】，编译时不会报错，只是转换的结果是按溢出处理，和我们希望的结果不一样。因此在转换时，需要考虑范围

 var num1 int64 = 999999
 var num2 int8 = int8(num1) 
 fmt.Println("num2=", num2) //num2= 63

基本数据类型和string 的转换

基本介绍

在程序开发中，我们经常将基本数据类型转成 string,或者将 string 转成基本数据类型

基本类型转string 类型

方式 1 : fmt.Sprintf方法

func Sprintf(format [string](https://pkg.go.dev/builtin#string), a ...[any](https://pkg.go.dev/builtin#any)) [string](https://pkg.go.dev/builtin#string)
Sprintf根据format参数生成格式化的字符串并返回该字符串。

 var num1 int = 99
 var num2 float64 = 23.456
 var b bool = true
 var myChar byte = 'h'
 var str string //空的str

 //使用第一种方式来转换 fmt.Sprintf方法

 str = fmt.Sprintf("%d", num1)
 fmt.Printf("str type %T str=%q\n", str, str)//str type string str="99"

 str = fmt.Sprintf("%f", num2)
 fmt.Printf("str type %T str=%q\n", str, str)//str type string str="23.456000"

 str = fmt.Sprintf("%t", b)
 fmt.Printf("str type %T str=%q\n", str, str)//str type string str="true"

 str = fmt.Sprintf("%c", myChar)
 fmt.Printf("str type %T str=%q\n", str, str)//str type string str="h"

方式 2：使用 strconv 包的函数

 //第二种方式 strconv 函数
 var num3 int = 99
 var num4 float64 = 23.456
 var b2 bool = true

 str = strconv.FormatInt(int64(num3), 10)
 fmt.Printf("str type %T str=%q\n", str, str)//str type string str="99"

 // strconv.FormatFloat(num4, 'f', 10, 64)
 // 说明： 'f' 格式 10：表示小数位保留10位 64 :表示这个小数是float64
 str = strconv.FormatFloat(num4, 'f', 10, 64)
 fmt.Printf("str type %T str=%q\n", str, str)//str type string str="23.4560000000"

 str = strconv.FormatBool(b2)
 fmt.Printf("str type %T str=%q\n", str, str)//str type string str="true"

 //strconv包中有一个函数Itoa
 var num5 int64 = 4567
 str = strconv.Itoa(int(num5))
 fmt.Printf("str type %T str=%q\n", str, str)//str type string str="4567"

string 类型转基本数据类型

 var str string = "true"
 var b bool
 // b, _ = strconv.ParseBool(str)
 // 说明
 // 1. strconv.ParseBool(str) 函数会返回两个值 (value bool, err error)
 // 2. 因为我只想获取到 value bool ,不想获取 err 所以我使用_忽略
 b , _ = strconv.ParseBool(str)
 fmt.Printf("b type %T  b=%v\n", b, b)//b type bool  b=true

 var str2 string = "1234590"
 var n1 int64
 var n2 int
 n1, _ = strconv.ParseInt(str2, 10, 64)
 n2 = int(n1)
 fmt.Printf("n1 type %T  n1=%v\n", n1, n1)//n1 type int64  n1=1234590
 fmt.Printf("n2 type %T n2=%v\n", n2, n2)//n2 type int n2=1234590

 var str3 string = "123.456"
 var f1 float64
 f1, _ = strconv.ParseFloat(str3, 64)
 fmt.Printf("f1 type %T f1=%v\n", f1, f1)//f1 type float64 f1=123.456

string 转基本数据类型的注意事项

在将 String 类型转成基本数据类型时，要确保 String 类型能够转成有效的数据，比如我们可以把 “123” , 转成一个整数，但是不能把 “hello” 转成一个整数，如果这样做，Golang 直接将其转成 0 ，其它类型也是一样的道理.

 var str4 string = "hello"
 var n3 int64 = 11
 n3, _ = strconv.ParseInt(str4, 10, 64)//如果转换失败，n3 等于默认值 0
 fmt.Printf("n3 type %T n3=%v\n", n3, n3)//n3 type int64 n3=0

指针

基本介绍

基本数据类型，变量存的就是值，也叫值类型
获取变量的地址，用&，比如：var num int, 获取 num 的地址：&num
指针类型，指针变量存的是一个地址，这个地址指向的空间存的才是值。比如：var ptr *int = &num

获取指针类型所指向的值，使用：*，比如：var ptr *int, 使用*ptr 获取 ptr 指向的值

 //基本数据类型在内存布局
 var i int = 10
 // i 的地址是什么,&i
 fmt.Println("i的地址=", &i) //i的地址= 0xc000016088

 //下面的 var ptr *int = &i
 //1. ptr 是一个指针变量
 //2. ptr 的类型 *int
 //3. ptr 本身的值&i
 var ptr *int = &i
 fmt.Printf("ptr=%v\n", ptr)//ptr=0xc000016088
 fmt.Printf("ptr 的地址=%v \n", &ptr)//ptr 的地址=0xc000006030
 fmt.Printf("ptr 指向的值=%v \n", *ptr)//ptr 指向的值=10

变量 - 图2

案例演示

写一个程序，获取一个 int 变量 num 的地址，并显示到终端
将 num 的地址赋给指针 ptr , 并通过 ptr 去修改 num 的值

package main
import "fmt"

func main() {
    //获取一个 int 变量 num 的地址，并显示到终端
    var num int = 1
    fmt.Printf("num address=%v\n", &num) //num address=0xc000016088
    //将 num 的地址赋给指针 ptr , 并通过 ptr 去修改 num 的值
    var ptr *int = &num
    *ptr = 10 //这里修改时，会到num的值变化
    fmt.Println("num =" , num)//num = 10
}

指针的使用细节

值类型，都有对应的指针类型，形式为 *数据类型，比如 int 的对应的指针就是 int, float32对应的指针类型就是float32, 依次类推
值类型包括：基本数据类型 int 系列, float 系列, bool, string 、数组和结构体 struct

值类型和引用类型

值类型和引用类型的说明
值类型：基本数据类型 int 系列, float 系列, bool, string 、数组和结构体 struct
引用类型：指针、slice 切片、map、管道 chan、interface 等都是引用类型

值类型和引用类型的使用特点
值类型：变量直接存储值，内存通常在栈中分配

变量 - 图3

引用类型：变量存储的是一个地址，这个地址对应的空间才真正存储数据(值)，内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由 GC 来回收

变量 - 图4

内存的栈区和堆区示意图

变量 - 图5

标识符的命名规范

标识符概念

Golang 对各种变量、方法、函数等命名时使用的字符序列称为标识符
凡是自己可以起名字的地方都叫标识符

标识符的命名规则
由 26 个英文字母大小写，0-9 ，_ 组成
数字不可以开头。var num int //ok var 3num int //error
Golang 中严格区分大小写。
标识符不能包含空格。
下划线_本身在 Go 中是一个特殊的标识符，称为空标识符。可以代表任何其它的标识符，但是它对应的值会被忽略(比如：忽略某个返回值)。所以仅能被作为占位符使用，不能作为标识符使用

不能以系统保留关键字作为标识符（一共有 25 个），比如 break，if 等等…

标识符的案例

hello    // ok
hello12 //ok
1hello // error ,不能以数字开头
h-b    // error ,不能使用 -
x h    // error, 不能含有空格
h_4    // ok
_ab    // ok
int    // ok , 我们要求大家不要这样使用
float32 // ok ,  我们要求大家不要这样使用
_    // error 
Abc    // ok

标识符命名注意事项

包名：保持 package 的名字和目录保持一致，尽量采取有意义的包名，简短，有意义，不要和标准库不要冲突

变量名、函数名、常量名：采用驼峰法 如var stuName string = “tom”形式: xxxYyyyyZzzz
如果变量名、函数名、常量名首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包中使用 ( 注：可以简单的理解成，首字母大写是公开的，首字母小写是私有的) ,在 golang 没有public , private 等关键字。

系统保留关键字

Go共有25个保留关键字，各有其作用，不能用作标识符。Go的25个关键字按照作用可以分为3类，分别为包管理、程序实体声明与定义与程序流程控制。

包管理（2个）：
    import    package

程序实体声明与定义（8个）：
    chan    const    func    interface    map    struct    type    var

程序流程控制（15个）：
    break    case    continue    default    defer    else    fallthrough    
    for        go        goto        if        range    return    select        switch

系统的预定义标识符

内建常量	内建类型	内建函数
true	int	make
false	int8	len
iota	int16	cap
nil	int32	new
-	int64	append
-	uint	copy
-	uint8	close
-	uint16	delete
-	uint32	complex
-	uint64	real
-	uintprt	imag
-	float32	panic
-	float64	recover
-	complex64	-
-	complex128	-
-	bool	-
-	byte	-
-	rune	-
-	string	-
-	error	-

变量

变量的介绍

变量的概念

变量的使用步骤

变量快速入门案例

变量的声明，初始化和赋值

声明变量

初始化变量

给变量赋值

⚠️变量使用注意事项

小数类型/浮点型

基本介绍

浮点型分类

浮点型使用细节

字符类型

基本介绍

案例演示

string 类型

基本介绍

案例演示

string 使用注意事项和细节

💡Go字符串的内存布局

基本数据类型的默认值

基本介绍

基本数据类型的默认值如下

基本数据类型的相互转换

基本介绍

基本语法

案例演示

基本数据类型相互转换的注意事项

基本数据类型和string 的转换

基本介绍

基本类型转string 类型

方式 1 : fmt.Sprintf方法

方式 2：使用 strconv 包的函数

string 类型转基本数据类型

string 转基本数据类型的注意事项

指针

基本介绍

案例演示

指针的使用细节

值类型和引用类型

值类型和引用类型的说明

值类型和引用类型的使用特点

标识符的命名规范

标识符概念

标识符的命名规则

标识符的案例

标识符命名注意事项

系统保留关键字

系统的预定义标识符