Go语言编程设计学习Day1：helloworld 变量 常量

简单认识go语言

简单了解一下go语言的历史, 二十世纪八十年代，肯·汤普逊在内的Plan 9项目原班人马加入了谷歌在Google，他们创造了Go语言。早在2007年9月，Go语言还是这帮大牛的20%自由时间
的实验项目。幸运的是，到了2008年5月，Google发现了Go语言的巨大潜力，从而开始全力支持
这个项目，让这批人可以全身心投入Go语言的设计和开发工作中。Go语言的第一个版本在2009
年11月正式对外发布，并在此后的两年内快速迭代，发展迅猛。第一个正式版本的Go语言于2012
年3月28日正式发布，让Go语言迎来了第一个引人瞩目的里程碑。

谷歌一贯的作风 拥抱开源，所以我们也可以在github上去下载go的源码来查看，甚至为go贡献一些新的内容

下面罗列一下Go语言最主要的特性：
 自动垃圾回收
 更丰富的内置类型
 函数多返回值
 错误处理
 匿名函数和闭包
 类型和接口
 并发编程
 反射
 语言交互性

配置开发环境

• 下载go

• 设置gopath(go代码存放空间), goroot(go语言sdk/bin文件夹)

• vscode 导入go的多个插件

  

• 创建go的代码存放结构

第一个go程序

//  声明文件所存在的位置 packge
package main

// 进入需要使用的工具库(包)
import "fmt"

// main 函数 程序的入口
func main(){
	fmt.Println("hello golang")
}

常用的命令

• 执行go文件 go run xxxx
• 生成可执行文件 go build xxx

变量

​ 我们可以将一个程序 看作一个小世界 不论哪个世界 都有构成他的一部分, 变量就是构建程序世界的一部分

变量实际上就是存放在内存中的一个数据空间的表示 他可能有不同的类型 .

Go语言的变量声明方式与C和C++语言有明显的不同。对于纯粹的变量声明，Go语言引入了

Go语言的变量声明方式与C和C++语言有明显的不同。对于纯粹的变量声明，Go语言引入了
关键字var，而类型信息放在变量名之后，示例如下：

var v1 int
var v2 string
// 数组
var v3 [10]int
// 数组切片
var v4 []int
var v5 struct {
  f int
  }
 // 指针
var v6 *int
 // map，key为string类型，value为int类型
var v7 map[string]int
var v8 func(a int) int

变量声明语句不需要使用分号作为结束符。与C语言相比，Go语言摒弃了语句必须以分号作
为语句结束标记的习惯。

关键字var，而类型信息放在变量名之后，示例如下：

1. var v1 int
2. var v2 string
3. var v3 [10]int
4. // 数组
5. var v4 []int
6. // 数组切片
7. var v5 struct {
8. f int
9. }
10. var v6 *int
11. // 指针
12. var v7 map[string]int
13. // map，key为string类型，value为int类型
14. var v8 func(a int) int
15. 变量声明语句不需要使用分号作为结束符。与C语言相比，Go语言摒弃了语句必须以分号作
16. 为语句结束标记的习惯。

变量的使用流程

在go 语言中 声明变量(类型有默认值可以直接使用)就必须要使用, 否则会出现编译异常

• 声明
• 复制
• 使用

示例:

	var age int
	age = 18
	fmt.Println("age=",age)

变量初始化方式

​ 对于声明变量时需要进行初始化的场景，var关键字可以保留，但不再是必要的元素

var v1 int = 10 // 正确的使用方式1
var v2 = 10
// 正确的使用方式2，编译器可以自动推导出v2的类型
v3 := 10
// 正确的使用方式3，编译器可以自动推导出v3的类型

​ 指定类型已不再是必需的，Go编译器可以从初始化表达式的右值推导出该变量应该声明为
哪种类型，这让Go语言看起来有点像动态类型语言，尽管Go语言实际上是不折不扣的强类型语
言（静态类型语言）。

需要注意的事 := 左侧的变量不应该是已经被声明过的 否则会出现异常

var i int
i := 2
会导致类似如下的编译错误：
no new variables on left side of :=

变量赋值

​ 在Go语法中，变量初始化和变量赋值是两个不同的概念。下面为声明一个变量之后的赋值
过程：

var v10 int
v10 = 123

​ Go语言的变量赋值与多数语言一致，但Go语言中提供了C/C++程序员期盼多年的多重赋值功
能，比如下面这个交换i和j变量的语句：

i, j = j, i

​ 在不支持多重赋值的语言中，交互两个变量的内容需要引入一个中间变量：

t = i; i = j; j = t;

匿名变量

​ 在Go中这种情况可以通过结合使用多重返回和匿名变量来避免定义一些不必要变量的丑陋写法，让代码看起来更加优雅。

​ 假设 GetName()函数的定义如下，它返回3个值，分别为firstName、 lastName和
nickName：

func main(){
	// var v1 int  = 10
	// var v2 = 10
	// v3:= 3
	// fmt.Println(v1,v2,v3);
	_, _, nickName:= GetName()
	fmt.Println(nickName);
}
//若只想获得nickName，则函数调用语句可以用如下方式编写
func GetName()(firstName,lastName,nickName string){
	return "may", "chan", "chibi maruko"
}

输出结果：

chibi maruko

​ 这种用法可以让代码非常清晰，基本上屏蔽掉了可能混淆代码阅读者视线的内容，从而大幅降低沟通的复杂度和代码维护的难度。

常量

​ 在Go语言中，常量是指编译期间就已知且不可改变的值。常量可以是数值类型（包括整型、浮点型和复数类型）、布尔类型、字符串类型等。

字面常量

​ 所谓字面常量（literal），是指程序中硬编码的常量，如：

-12
3.14159265358979323846
// 浮点类型的常量
3.2+12i
// 复数类型的常量
true
// 布尔类型的常量
"foo"
// 字符串常量

​ 在go语言中 它是无类型的。只要这个常量在相应类型的值域
范围内，就可以作为该类型的常量

常量定义

​ 通过const关键字，你可以给字面常量指定一个友好的名字：

const Pi float64 = 3.14159265358979323846
const zero = 0.0 // 无类型浮点常量
const (
size int64 = 1024
eof = -1 // 无类型整型常量
)
const u, v float32 = 0, 3 // u = 0.0, v = 3.0，常量的多重赋值
const a, b, c = 3, 4, "foo"
// a = 3, b = 4, c = "foo", 无类型整型和字符串常量

​ Go的常量定义可以限定常量类型，但不是必需的。如果定义常量时没有指定类型，那么它
与字面常量一样，是无类型常量。
常量定义的右值也可以是一个在编译期运算的常量表达式，比如

const mask = 1 << 3

预定义常量

​ Go语言预定义了这些常量：true、false和iota。

​ iota比较特殊，可以被认为是一个可被编译器修改的常量，在每一个const关键字出现时被
重置为0，然后在下一个const出现之前，每出现一次iota，其所代表的数字会自动增1。

从以下的例子可以基本理解iota的用法：

const (
// iota被重设为0
c0 = iota// c0 == 0
c1 = iota// c1 == 1
c2 = iota// c2 == 2
)
const (
a = 1 << iota// a == 1 (iota在每个const开头被重设为0)
b = 1 << iota// b == 2
c = 1 << iota// c == 4
)
const (
u = iota * 42 // u == 0
v float64 = iota * 42 // v == 42.0
w = iota * 42// w == 84
)
const x = iota// x == 0 (因为iota又被重设为0了)
const y = iota// y == 0 (同上)
    

​ 如果两个const的赋值语句的表达式是一样的，那么可以省略后一个赋值表达式。因此，上面的前两个const语句可简写为：

const (
// iota被重设为0
c0 = iota // c0 == 0
c1 // c1 == 1
c2 // c2 == 2
)
const (
a = 1 <<iota // a == 1 (iota在每个const开头被重设为0)
b // b == 2
c // c == 4
)

枚举

​ 枚举指一系列相关的常量，比如下面关于一个星期中每天的定义。通过上一节的例子，我们看到可以用在const后跟一对圆括号的方式定义一组常量，这种定义法在Go语言中通常用于定义枚举值。Go语言并不支持众多其他语言明确支持的enum关键字。

const (
Sunday = iota
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
numberOfDays // 这个常量没有导出
)

​ 同Go语言的其他符号（symbol）一样，以大写字母开头的常量在包外可见。
以上例子中numberOfDays为包内私有，其他符号则可被其他包访问。