进入GO语言（一）
安装环境：
1.下载go语言
官方网站 https://golang.org/dl/
在这个页面中可以选择合适的安装包。
2.在windows系统中安装go语言环境
在页面中下载.msi的安装包
双击安装包进行安装，默认的安装路径为C:\GO
设置环境变量（如果没有修改默认路径环境变量会自动配置不用手动配置）
添加 GOPATH 环境变量：创建一个新的用户变量 GOPATH，值为一个目录路径，例如 C:\GoProjects。这个路径将是你的 Go 代码存放目录。
修改 PATH 环境变量：在用户变量 PATH 中添加 %GOPATH%\bin 和 C:\Go\bin。如果已经存在 C:\Go\bin，则只需添加 %GOPATH%\bin。
3.开发工具基本的环境配置
安装基本插件go
go的基本概念
简介：go语言的背景
Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。
Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发，后来还加入了Ian Lance Taylor, Russ Cox等人，并最终于2009年11月开源，在2012年早些时候发布了Go 1稳定版本。现在Go的开发已经是完全开放的，并且拥有一个活跃的社区。
语言特点：
简洁，快速，安全，并行，有趣，开源，
内存管理，数组安全，编译迅速
语言优势：
简单易学，自由高效，强大的标准库，部署方便，原生支持并发，稳定性强，垃圾回收
代码结构：
go语言程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号由6个标记组成：
如: fmt.println("Hello,World")
代码中6个标记分别为：
1：fmt
2：.
3: println
4: (
5: "Hello,World!"
6: )
行分隔符：在go程序中一行代表一个语句结束，每个语句不需要向c家族中的其他语言一样以；结尾，因为这些
工作都由编译器自动完成。
注：如将多个语句写在同一行，他们则必须需要区分使用；但在开发中不要使用这种方法。
注释：与js相同
数据类型：
数据类型用于声明函数及变量，他的出现是为了把数据分成内存大小不同的数据，可以充分地利用内存
数据类型：
基本数据类型分为：布尔型（bool），整形（int），浮点型（float），复数型（complex），字符串（string），字符型（rune），错误类型（error）
复合类型包括：指针（pointer）、数组（array）、切片（slice）、字典（map）、通道（chan）、结构体（struct）、接口（interface）
1.布尔类型
布尔类型的值只可以是常量的true或false。如：var b bool = true。
bool的默认值是false。
2.整形
整形中包括有符号和无符号两种类型
（1）有符号整形：int8，int16，int32，int64，int（默认为机械字长，通常为32位或64位）
（2）无符号整形：uint8（也写作byte),uint16,uint32,uint64,uint（默认为机械字长，通常是32位或64位）
2.1 浮点型
浮点型用于表示带小数点的数值
float32
float64
2.2复数类型
complex64
complex128
在计算机中，复数是由两个浮点数表示的，其中一个表示实部（real），一个表示虚部（imag）。
complex128为复数的默认类型，复数的值由三部分组成R+li，其中R是实数部分，R和l均为float类型，最后的i是虚数单位。
如：c1 = 1+2i
3.字符串型
字符串类型用于储存文本信息。
4.字符类型
用于储存单个字符
5.复合类型
将多个元素组成一个单一的值。
6.切片
是一种动态大小的序列类型。
7.map类型
一种键值对集合类型
运算符和表达式
1.运算符分为算数运算符，关系运算符，逻辑运算符，赋值运算符，位运算符，其他运算符。
1.1 算数运算符
假定 A 值为 10，B 值为 20。
运算符 描述 实例
+ 相加 A + B 输出结果 30
- 相减 A - B 输出结果 -10
* 相乘 A * B 输出结果 200
/ 相除 B / A 输出结果 2
% 求余 B % A 输出结果 0
++ 自增 A++ 输出结果 11（++为自增每次加1）
-- 自减 A-- 输出结果 9（--为自减每次减1）
1.2 关系运算符
假定值与上述相同
运算符 描述 实例
== 检查两个值是否相等，如果相等返回 True 否则返回 False。 (A == B) 为 False
!= 检查两个值是否不相等，如果不相等返回 True 否则返回 False。 (A != B) 为 True
> 检查左边值是否大于右边值，如果是返回 True 否则返回 False。 (A > B) 为 False
< 检查左边值是否小于右边值，如果是返回 True 否则返回 False。 (A < B) 为 True
>= 检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。 (A >= B) 为 False
<= 检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。 (A <= B) 为 True
1.3 逻辑运算符
假定值A为true，B为false简单来说就是与或非的基本关系
运算符 描述 实例
&& 逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False。 (A && B) 为 False
|| 逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False。 (A || B) 为 True
! 逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。 !(A && B) 为 True
解释：
逻辑与（&&）：当且仅当两个操作数都为真时，结果才为真。如果其中一个或两个操作数为假，则结果为假。例如，true && false 的结果为 false。
逻辑或（||）：只要至少有一个操作数为真，结果就为真。只有当所有操作数都为假时，结果才为假。例如，true || false 的结果为 true。
逻辑非（!）：这是一个一元运算符，用于反转操作数的逻辑状态。如果操作数为真，则结果为假；如果操作数为假，则结果为真。例如，!true 的结果为 false。
1.4 赋值运算符
运算符 描述 实例
= 简单的赋值运算符，将一个表达式的值赋给一个左值 C = A + B 将 A + B 表达式结果赋值给 C
+= 相加后再赋值 C += A 等于 C = C + A
-= 相减后再赋值 C -= A 等于 C = C - A
*= 相乘后再赋值 C *= A 等于 C = C * A
/= 相除后再赋值 C /= A 等于 C = C / A
%= 求余后再赋值 C %= A 等于 C = C % A
<<= 左移后赋值 C <<= 2 等于 C = C << 2
>>= 右移后赋值 C >>= 2 等于 C = C >> 2
&= 按位与后赋值 C &= 2 等于 C = C & 2
^= 按位异或后赋值 C ^= 2 等于 C = C ^ 2
|= 按位或后赋值 C |= 2 等于 C = C | 2
1.5 位运算符
假定 A 为60，B 为13：
运算符 描述 实例
& 按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。 (A & B) 结果为 12, 二进制为 0000 1100
| 按位或运算符"|"是双目运算符。 其功能是参与运算的两数各对应的二进位相或 (A | B) 结果为 61, 二进制为 0011 1101
^ 按位异或运算符"^"是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。 (A ^ B) 结果为 49, 二进制为 0011 0001
<< 左移运算符"<<"是双目运算符。左移n位就是乘以2的n次方。 其功能把"<<"左边的运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 A << 2 结果为 240 ，二进制为 1111 0000
>> 右移运算符">>"是双目运算符。右移n位就是除以2的n次方。 其功能是把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数。 A >> 2 结果为 15 ，二进制为 0000 1111
1.6 其他运算符
运算符 描述 实例
& 返回变量存储地址 &a; 将给出变量的实际地址。
* 指针变量。 *a; 是一个指针变量
Go语言中的表达式确实是由多个运算符组成的，用于表达某种计算或逻辑功能的式子。
go语言控制结构
1.if语句（条件语句）：条件语句需要开发者通过指定一个或多个条件，并通过测试条件去判断条件是否为真来实现指定语句，
如果条件为假的情况下去执行其他语句。
图例：
起始语句
|
|
判断条件------------|
| |
| |
如果条件为真 | 如果条件为假
|——————----|
|
条件代码
|
|
在go语言中提供了以下几种判断语句：
语句 描述
if 语句 if 语句 由一个布尔表达式后紧跟一个或多个语句组成。
if...else 语句 if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。
if 嵌套语句 你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。
switch 语句 switch 语句用于基于不同条件执行不同动作。
select 语句 select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。
注：：Go 没有三目运算符，所以不支持 ?: 形式的条件判断。
三目运算符的基本解释：
1.1什么是三目运算符
三目运算符又称条件运算符，是计算机语言的重要组成部分，它是唯一体格有三个操作符的运算符，有时又被称为三元运算符。一般来说三目运算符的结合性是右结合的。
1.2三目运算符具体运算规则
布尔表达式?表达式1:表达式2
运算过程：如果布尔表达式的值为 true ，则返回 表达式1 的值，否则返回 表达式2 的值
1.3三目运算符怎么用
java与c++，php省略
javascript使用方法
<script>
var a, b;
a = 3;
b = 8;
var max = a > b ? a : b;
console.log(max); // 输出 8
</script>
python中的使用方法
a = 3
b = 6
maxNum = a if a > b else b
print(maxNum) // 输出6
循环语句（for循环和while循环）：
1.for循环语句：
1.1语法：
for(初始化表达式;循环条件表达式;循环后操作表达式){
//语句序列
}
1.1.1 初始化表达式：用于在进入循环之前执行一次，它可以是赋值表达式、运算表达式等，甚至可以是空语句（什么都不执行），但它不会影响循环的继续与否。
1.1.2 循环条件表达式：值为boolean型的表达式，指定循环条件。循环条件表达式必须是产生布尔值的表达式，即结果为true或false。这通常涉及条件运算符、比较运算符等，用于决定循环是否继续执行。
1.1.3 循环后操作表达式：负责修整变量，改变循环条件。在每次循环体执行完毕后执行，它也可以是赋值表达式、运算表达式等，同样不会影响循环条件的判断。
基本示例：
for (let i = 0; i < 10; i++){
console.log(i);
}
1.2多种不同情况下的for循环的执行顺序：
在多种for循环语句执行中的顺序描述
描述一、
在执行for循环时，首先执行初始化表达式，这一步通常是完成某一变量的初始化工作；下一步判断循环条件表达似乎的值，若循环条件表达式的值为true，
则进入循环体；在执行完循环体后紧接着计算循环后操作表达式，这一步通常是增加或者减少循环控制变量的一个表达式。这样一轮循环就结束了。
第二轮循环从计算循环操作后表达式开始，若循环条件表达式返回true，则继续重复上述循环，否则跳出整个for语句结束循环。
描述二
①执行初始化表达式。
②判断循环条件表达式，如果结果为true执行步骤③④，结果为false跳到步骤⑤。
③执行循环体中的代码。
④执行循环后操作表达式。重复步骤②③④
⑤跳出整个for循环，循环结束。
描述三：
初始化表达式：首先，程序会执行for循环中的初始化表达式，通常是为循环计数器或其他计数变量赋初始值。
循环条件判断：在每次循环开始之前，循环条件表达式会被判断。如果条件为true，执行步骤3和步骤4；如果条件为false，循环结束，执行步骤5。
循环体执行：如果循环条件为true，程序会执行for循环体内的代码块。这是实际的循环操作部分，会重复执行。
循环后操作：在执行完循环体后，会执行循环后操作表达式，通常用于更新循环计数器或其他计数变量的值。
循环结束：程序会跳出整个for循环，循环结束。
3、for循环适用场景
for循环：
1.遍历数组或集合：
遍历数组或集合：当您知道要遍历的次数时，例如遍历数组中的元素，for循环非常适合，因为您可以在循环头部明确设置循环次数。
2.数值范围迭代：
如果需要在一定范围内按照固定步长迭代，例如输出1到10的整数，for循环能够轻松实现。
3.数值范围迭代：
处理固定次数的任务：在某些情况下，您可能需要执行一段代码固定次数，比如打印输出特定的消息，for循环可以很好地处理这种情况。
2.1while循环
注：go语言中没有while关键词但是可以通过for循环的模拟来模拟while循环的功能。
如：sum:=0 给sum赋值为0
for sum < 10{
sum+=1
}
3.1跳转语句（goto ，break，continue）
跳转语句的区别：
3.1.1 break语句
用于提前退出循环，跳出循环体的执行
for i := 0; i < 10; i++ {
if i == 5 {
break // 提前退出循环
}
fmt.Println(i)//打印0,1,2,3,4因为提前跳出了循环。
}
3.1.2 continue语句
用于跳出本次循环的剩余代码，继续执行下一次循环。
for i := 0; i < 5; i++ {
if i == 2 {
continue // 跳过本次循环的剩余代码
}
fmt.Println(i)
}//输出为0，1，3，4因为continue是从循环中跳出执行剩下的循环。
3.1.2 go to语句
用于无条件地跳转到指定标签的代码位置，通常不建议多使用go to语句，以免造成程序流程混乱。
i := 0
loop:
for {
fmt.Println(i)
i++
if i == 5 {
goto loop // 无条件跳转到标签loop
}
在i是5时就会跳转到别的标签
函数
1.1 什么是函数
函数是构建程序最基本的模块，是一段可以重复使用的代码，它执行特定的任务并可能返回一个结果
函数可以接受输入参数（也称为参数），并在执行任务后返回输出值。Go语言中的函数非常灵活，支持多种
参数和返回值类型，并且可以嵌套定义其他函数。
1.2 函数的作用（优势）
1.代码复用：通过定义函数，我们可以避免重复编写相同的代码，提高代码的复用性。
2模块化：函数可以帮助我们将复杂的任务分解为更小的、易于管理的部分，使得代码结构更加清晰。
3.可读性：良好的函数命名可以提高代码的可读性，使其他开发者更容易理解你的代码。
4.测试性：函数是独立的单元，可以单独进行测试，确保每个部分的功能正确无误。
1.3 函数的定义
在go语言中，函数的定义遵循以下的语法：
func functionName(parameter1 type1, parameter2 type2) returnType {
// 函数体
}
func 是关键字，用于声明一个函数。
functionName 是函数的名称，应该具有描述性，以便其他开发者理解其用途。
parameter1, parameter2 等是函数的参数，每个参数后面跟着其类型。
returnType 是函数的返回值类型，如果函数不返回任何值，则可以省略 returnType。
{} 中包含函数的主体，即函数的具体实现。
最简单的函数是没有参数且只返回一个值的函数。
例：
func add （ a int, b int）int{
return a+b
}
读取用户输入的值：
func main() {
var a, b int
fmt.Print("请输入 a 的值: ")
fmt.Scan(&a) // 读取用户输入的 a
fmt.Print("请输入 b 的值: ")
fmt.Scan(&b) // 读取用户输入的 b
day1(a, b) // 调用 day1 函数
}
go语言中的fmt常用的具体函数
在go语言的fmt包中主要实现了类似与C语言printf和scanf的格式化i/o。主要分为向外输出内容和获取
输入内容两大部分。
向外输出
标准库fmt提供了以下几种输出的函数。
print：print系列函数会将内容输出到系统的标准输出，区别于Print函数的直接输出内容，Printf函数
支持格式化输出字符串，println函数会在输出内容的结尾添加一个换行符。
Fprint：Fprint系列函数会将内容输出到一个io.Writer接口类型的变量w中，我们通常用这个函数往文件中写入内容。
sprint：sprint系列函数会把传入的数据生成并返回一个字符串。
errorf：errorf函数根据format参数生成的格式化字符串并返回一个包含该字符串的错误。
格式化占位符
*printf系列函数都支持format格式化参数，在这里我们按照占位符将被替换的变量类型划分，方便查询和记忆。
占位符：
通用占位符
占位符 说明
%v 值的默认格式表示
%+v 类似%v，但输出结构体时会添加字段名
%#v 值的Go语法表示
%T 打印值的类型
%% 百分号
布尔型
占位符 说明
%t true或false
整型
占位符 说明
%b 表示为二进制
%c 该值对应的unicode码值
%d 表示为十进制
%o 表示为八进制
%x 表示为十六进制，使用a-f
%X 表示为十六进制，使用A-F
%U 表示为Unicode格式：U+1234，等价于”U+%04X”
%q 该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示
浮点数与复数
占位符 说明
%b 无小数部分、二进制指数的科学计数法，如-123456p-78
%e 科学计数法，如-1234.456e+78
%E 科学计数法，如-1234.456E+78
%f 有小数部分但无指数部分，如123.456
%F 等价于%f
%g 根据实际情况采用%e或%f格式（以获得更简洁、准确的输出）
%G 根据实际情况采用%E或%F格式（以获得更简洁、准确的输出）
字符串和[]byte
占位符 说明
%s 直接输出字符串或者[]byte
%q 该值对应的双引号括起来的go语法字符串字面值，必要时会采用安全的转义表示
%x 每个字节用两字符十六进制数表示（使用a-f）
%X 每个字节用两字符十六进制数表示（使用A-F）
指针
占位符 说明
%p 表示为十六进制，并加上前导的0x
宽度标识符
宽度通过一个紧跟在百分号后面的十进制数指定，如果未指定宽度，则表示值时除必需之外不作填充。精度通过（可选的）宽度后跟点号后跟的十进制数指定。如果未指定精度，会使用默认精度；如果点号后没有跟数字，表示精度为0。举例如下：
占位符 说明
%f 默认宽度，默认精度
%9f 宽度9，默认精度
%.2f 默认宽度，精度2
%9.2f 宽度9，精度2
%9.f 宽度9，精度0
其他falg
占位符 说明
’+’ 总是输出数值的正负号；对%q（%+q）会生成全部是ASCII字符的输出（通过转义）；
’ ‘ 对数值，正数前加空格而负数前加负号；对字符串采用%x或%X时（% x或% X）会给各打印的字节之间加空格
’-’ 在输出右边填充空白而不是默认的左边（即从默认的右对齐切换为左对齐）；
’#’ 八进制数前加0（%#o），十六进制数前加0x（%#x）或0X（%#X），指针去掉前面的0x（%#p）对%q（%#q），对%U（%#U）会输出空格和单引号括起来的go字面值；
‘0’ 使用0而不是空格填充，对于数值类型会把填充的0放在正负号后面；
获取输入的值
包含于三个函数包含fmt.scan、fmt.scanf、fmt.scanin三个函数，可以在程序运行过程中从标准输入用户的输入。
fmt.scan
1.1.1 scan 从标准输入扫描文本，读取由空白符分隔的值保存到传递给本参数的参数中，换行符视为空白符。
1.1.2 本函数成功扫描的数据个数和遇到的任何错误，如果读取的数据个数比提供的参数少，会返回一个错误报告原因。
fmt.scanF
2.1 scanF从标准输入扫描文本，根据format参数指定的格式去读取由空白符分隔的值保存到传递给本参数的参数中。
2.1.2 本函数返回成功扫描的数据个数和遇到的任何错误。
fmt.scanLn
1.2.1scanln类似于scan，他遇到换行时才会停止扫描。最后一个数据后面必须有换行或者到达结束位置。
1.2.2本函数返回成功扫描的数据个数和遇到的任何错误。
bufio.NewReader
有时候我们想完整获取输入的内容，而输入的内容可能包含空格，这种情况下可以使用bufio包来实现。
Fscan系列
这几个函数功能分别类似于fmt.Scan、fmt.Scanf、fmt.Scanln三个函数，只不过它们不是从标准输入中读取数据而是从io.Reader中读取数据。
Sscan系列
这几个函数功能分别类似于fmt.Scan、fmt.Scanf、fmt.Scanln三个函数，只不过它们不是从标准输入中读取数据而是从指定字符串中读取数据。
Go语言中的函数
函数主要有三种类型：普通函数、匿名函数（闭包）、类方法。
1.1 函数的定义
go语言函数的基本组成包括：关键字func、函数名、参数列表、返回值、函数体和返回语句。go语言是强类型语言，
无论是参数还是返回值，在定义函数时，都需要声明其类型。
func add （a,b int）int {
sum:=a+b
return sum
}
关键字：func
函数名：add
参数列表：（a，b int）
返回值类型：int
功能体：{
sum:=a+b
return sum
}
简单示例：
参数类型：int
返回值类型：int
func add（a,b int）{
return a+b
}
1.2 函数的调用
1.2.1 调用同一个包定义的函数
如果函数在同一个包中，只需要直接调用即可
例：func add(a,b int) int{
return a+b
}
func main (){
fmt.println(add(1,2))//输出值：3
}
1.2.2 调用其他包定义的函数
如果函数是在不同的包中，需要先导入该函数所在的包，然后才能调用该函数，例如add的函数在calculator包中。
package calculator
func Add (a,b int) int {
return a+b
}
在main包中调用Add函数
package main
import（
“fmt”
“calculator”
）
func main（）{
fmt.prinntln(calculator(1,2))//输出3
}
注意：在调用其他包定义的函数时，只有这个函数名首字母大写的才可以被调用，例如函数名为add就会出现报错
1.2.3
系统内置函数
Go语言中内置了常用的函数，如下所示
名称 说明
close 用于在管道通信中关闭一个管道
len、cap len 用于返回某个类型的长度（字符串、数组、切片、字典和管道），cap 则是容量的意思，用于返回某个类型的最大容量（只能用于数组、切片和管道）
new、make new 和 make 均用于分配内存，new 用于值类型和用户自定义的类型（类），make 用于内置引用类型（切片、字典和管道）。它们在使用时将类型作为参数：new(type)、make(type)。new(T) 分配类型 T 的零值并返回其地址，也就是指向类型 T 的指针，可以用于基本类型：v := new(int)。make(T) 返回类型 T 的初始化之后的值，所以 make 不仅分配内存地址还会初始化对应类型。
copy、append 分别用于切片的复制和动态添加元素
panic、recover 两者均用于错误处理机制
print、println 打印函数，在实际开发中建议使用 fmt 包
complex、real、imag 用于复数类型的创建和操作
1.3 参数传递
13.1 按值传参
Go语言默认使用按值传参来传递参数，也就是传递参数值的一个副本，函数收到传递进来的参数后，会将参数值拷贝给声明该参数的变量（也叫做形式参数，简称形参），如果在函数体中有对参数值做修改，实际上修改的是形参值，这不会影响到实际传递进来的参数值（也叫实际参数，简称实参）。
// 参数传递
// 1.3.1 按值传参
package main
import "fmt"
// 包内传值
func add (a,b int) int{
a *=2
b *=3
return a + b
}
func main(){
x , y := 1,2
z:= add(x,y)
fmt.Printf("add(%d, %d) = %d\n", x, y, z)
}
传参：输出结果add（1,2）= 8
// go语言变量
package main
import "fmt"
// 全局变量和局部变量
// 全局变量：在函数外定义的变量，在整个程序中都可以访问到
// 局部变量：在函数内定义的变量，只能在函数内访问到
// 全局变量
// var name = "小明"
// var age =18
// var ok bool
// 简写
var (
name = "小明"
age = 18
ok bool
)
func main(){
// go语言是静态语言，静态语言和动态语言相比变量的差异很大
// 1.变量必须先定义后使用 2.变量必须有类型 3.类型定下来后不能改变
// 定义变量的方法
// 1.正常定义
// var name int
// name = 1
// 2.简短定义
// 不常用：var name = 1
// 常用：name := 1
// 注：在go语言中变量定义后是不可以不使用的。
// 2.多变量定义
var user1, user2,user3 = "小明", 1, "小刚"
fmt.Println(user1, user2, user3)
/* 注意：
1.变量必须要先定义才能使用
2.go语言是静态语言，要求变量类型和赋值类型一致
3.变量名不能重复
4.局部变量和全局变量可以重名，但建议不要这样做局部变量的优先级要比全局变量高
简洁变量不可作用于全局变量
如：name := 1
变量是有零值的，也就是默认值。
全局变量定义后可以不使用
*/
fmt.Println(name, age, ok)
}
常量
// go语言的常量
package main
import (
"fmt"
)
func main (){
// fmt.Println("day02")
// 常量，定义的时候就就指定的值，不能接受修改，常量尽量用大写（ Go 语言中，常量的命名规则是全部大写）
const PI float32 = 3.1415926//显式定义
// const PI2 = 3.1415926 //隐式定义，默认float64类型
// 以组定义常量
const(
A = 1
B = 2
C = "hello"
)
const(
X = 1
Y
S = "world"
Z
)//在go语言中，不给常量指定类型，他会继承前者的数值及类型。
/*
1.常量类型只可以定义bool，数值（整数，浮点数，复数）和字符串类型。
2.不曾使用的常量，没有强制使用的要求。
3.显示指定类型的时候，必须确保常量左右的类型一致。
*/
fmt.Println(X,Y,S,Z)
}
