一、基本语法知识

其实编程语言的语法在大框架上都是大差不差的，这就是为啥一个人熟练掌握了一门语言，他能迅速上手另一个语言，如果你是java的老手，那么你上手go就会特别快，go的很多知识点都能在java上找到相似的定义。
我们从一个简单的例子来看看go的语法。

package mainimport "fmt"func main() {fmt.Println("hello world")
}

我从下面几个要点去解析：

1. package
   这是我们这个文件的包名，没错就是我们项目左侧目录，右键创建的direct目录名，但是main是个特殊的，这是我们整个程序的入口，你就理解为java中的@SpringBootAppliaction标注的main方法入口，我们的main方法一般都放在package main下。

2. import
   引入的包名，这跟java中你import其他类差不多意思，如果当前go文件中我要用其他文件中的方法或者定义的字段，在本文件中的import中就要引入那个文件的包名，记住是包名，不是引入那个文件，也不是引入那个方法。

   • 如果我们引入多个，可以用括号包起来

   import ("fmt""example"
   )

• 如果包名太长或者不顺眼，我们还可以起别名

  import (aaa "fmt"bbb "example"
  )
  

  起了别名后，那我们用的时候只需要用别名就好了，比如上面的输出函数我们可以换成这个：aaa.Println(“hello world”)

3. func
   这是go中声明一个方法的关键字，具体的我们后面讲到方法会讲，你只需要知道func main(),类似与java的void main()就行了

二、数据类型

go中的数据类型巨多，不像java中基本类型只有8个，它拆分的特别仔细，下面我会一一列出来，我会注明哪些是常用的，大家先关注常用的类型就行，心理有个印象。

1. bool
   bool值基本还是所有语言通用的

   类型	描述
   bool	true为真值，false为假值

2. 整型

   类型	描述
   uint8	无符号 8 位整型
   uint16	无符号 16 位整型
   uint32	无符号 32 位整型
   uint64	无符号 64 位整型
   int8	有符号 8 位整型
   int16	有符号 16 位整型
   int32	有符号 32 位整型
   int64	有符号 64 位整型
   uint	无符号整型 至少 32 位
   int	整型 至少 32 位
   uintptr	等价于无符号 64 位整型，但是专用于存放指针运算，用于存放死的指针地址。

   整型中常用的就是int32和int64，当然还有uint8，其他的你知道有就行了，等要用的时候再看。

3. 浮点型

   类型	描述
   float32	IEEE-754 32 位浮点数
   float64	IEEE-754 64 位浮点数

   常用的是float64

4. 字符类型

   类型	描述
   byte	等价 uint8 可以表达 ANSCII 字符
   rune	等价 int32 可以表达 Unicode 字符
   string	字符串即字节序列，可以转换为[]byte类型即字节切片

   都比较常用，rune用的稍微少一点。

5. 其他类型术语
   这里面列的大家看一下留个印象就好，后面的文章会一一详细讲解。

   类型	描述
   数组	[5]int，长度为 5 的整型数组
   切片	[]int，整型切片，跟数组一个意思，只是可以动态扩容
   映射表	map[string]int，键为字符串类型，值为整型的映射表，就是java的map
   结构体	type Gopher struct{}，Gopher 结构体，类似于java的类
   指针	*int，一个整型指针。
   接口	type Gopher interface{}，Gopher 接口，类似于java的接口
   通道	chan int，整型通道

6. nil
   java中的null，只是一个变量，不能比较，不能用nil == nil

三、常量

用const关键字声明的就是常量

1. 单独声明

const a = 1
const b = "2"

2. 组合声明

const (c = 3d = "4"
)

直接输出一下看

func main() {fmt.Println(a, b, c, d)
}
输出内容：1 2 3 4

3. iota
   iota是一个内置的常量标识符，表示一个常量声明中的无类型整数序数从0开始，一般都是在括号中使用，它可以让下面的常量递增

const (Num = iotaNum1Num2Num3Num4
)func main() {fmt.Println(Num, Num1, Num2, Num3, Num4)
}
输出：0 1 2 3 4

正是有这个特性，所以我们可以用它来表示枚举，因为go中没有正式的enum声明的枚举字段。

四、变量

go中的变量用var关键字来声明，特别说明的是，go中大部分的变量或者参数这些的声明，都是变量名在前，类型在后的。

var a int
var b string

如果连续的变量的类型一样，那我们只需要在最后面声明一次类型就好

var a,b,c int
var d,e,f string

还可以用括号包起来

var (aa stringbb stringcc int
)

在开发中，还经常用值等:=（冒号等号）的方法赋值，就是不需要声明类型，让go自己去判断，这种就是简化了变量的定义

func main() {a1 := 1b1 := "2"fmt.Println(a1, b1) //输出1,2a1 = 3 //第二次赋值就不需要冒号了，因为前面已经声明过了fmt.Println(a1, b1) //输出3,2
}

五、作用域

作用域是对基本语法的扩展，我们再第一点中讲到了包的概念，这里说说包之间怎么引用

记住一点：如果我们声明的方法、变量想要本文件私有，那么我们就首字母小写，相反，如果我声明的方法其他文件也能用，那就首字母大写，首字母小写的类似与java中的private字段，只有本类才能访问

1. 同包之下：新建一个package 叫 yu1，新建两个文件A.go和B.go，可以看到，我在B.go里面，不需要任何引用，直接就能调用a.go中的testA方法，也不需要大小写

package yu1import "fmt"func testA()  {fmt.Println("a.go")
}

package yu1func testB() {testA()
}

2. 不同包，新建一个package为yu2，新建一个文件c.go，在这时候，我如果在c中想引入yu1中a.go中的testA方法，记住必须要满足两个条件，请看我下面代码

package yu2import "newProject/yu1"func testC() {yu1.TestA()
}

相信大家也看出来了，这两个条件就是，import a.go文件的包名yu1，并且a.go中的方法首字母大写，用包名.方法名的方式去引用，这里是个重点，不是用a.go的文件，一定要用包名：包名.方法名，中间有个点，太小了大家别看不清

六、输入输出

go中最常用的输入输出就是fmt包，当然还有文件操作，这个后面我们在讲，本文先说说fmt包怎么格式化输出。
最简单的例子上面大家也看过了，直接用fmt.Println函数

fmt.Println("我是字符串")
fmt.Println(123)

fmt.Printf（）格式化输出，那么go还是提供了挺丰富的api，下面我贴一个表，大家先看看，用的时候再来查就行了，记不住的多用几次就记住了。

格式化	描述	接收类型
%%	输出百分号%	任意
%s	输出string/[] byte值	string,[] byte
%q	格式化字符串，输出的字符串两端有双引号""	string,[] byte
%d	输出十进制整型值	整型
%f	输出浮点数	浮点
%e	输出科学计数法形式 ,也可以用于复数	浮点
%E	与%e相同	浮点
%g	根据实际情况判断输出%f或者%e,会去掉多余的 0	浮点
%b	输出整型的二进制表现形式	数字
%#b	输出二进制完整的表现形式	数字
%o	输出整型的八进制表示	整型
%#o	输出整型的完整八进制表示	整型
%x	输出整型的小写十六进制表示	数字
%#x	输出整型的完整小写十六进制表示	数字
%X	输出整型的大写十六进制表示	数字
%#X	输出整型的完整大写十六进制表示	数字
%v	输出值原本的形式，多用于数据结构的输出	任意
%+v	输出结构体时将加上字段名	任意
%#v	输出完整 Go 语法格式的值	任意
%t	输出布尔值	布尔
%T	输出值对应的 Go 语言类型值	任意
%c	输出 Unicode 码对应的字符	int32
%U	输出字符对应的 Unicode 码	rune,byte
%p	输出指针所指向的地址	指针