共计 3431 个字符，预计需要花费 9 分钟才能阅读完成。
Go 语言是 Google 开发的一种动态强类型、编译型、并发型，并具备垃圾回收性能的编程语言。Go 语言做到了在不损失应用程序性能的状况下升高代码的复杂性。
Go 语言语法简略，只有 25 个关键字，不须要消耗工夫去学习记忆；数据类型包含布尔型，数字类型（整型、浮点型、复数），字符串，切片（数组），字典 map，管道 chan 等，用起来还是比拟顺畅的。
Go 语言人造具备并发个性，基于 go 关键字就能很不便的创立协程去执行一些并发工作，而其基于协程 - 管道的 CSP 并发编程模型，相比于传统简单的多线程同步计划，能够说简略太多了。
Go 语言还具备垃圾回收能力，防止了应用层还须要关注内存的调配与开释，要晓得在 C /C++ 语言，内存治理可是可是让人十分头疼的。
Go 语言还提供了比较完善的规范库，比方咱们只须要几行代码就能创立并启动一个 HTTP 服务。
从本篇文章开始，将率领大家进入 Go 语言的世界。
环境搭建
咱们能够抉择下载源码编译装置，下载安装包装置，下载编译好的可执行文件，下载地址为：https://golang.google.cn/dl/
笔者本地装置的是 go1.18.darwin-amd64.tar.gz，这是编译好的可执行文件，只须要解压即可，解压到目录 $HOME/Documents/go1.18。最初再配置下环境变量：
export GOROOT=$HOME/Documents/go1.18
export PATH=$PATH:$GOROOT/bin
export GOPATH=$HOME/Documents/gopath$GOROOT 是 Go 的装置目录；$PATH 是为了让咱们能够在任意目录执行 go 命令；$GOPATH 工作目录，通过 go get 命令下载的依赖包等就放在 $GOPATH 目录，基于 gomod 治理的依赖文件也会放在该目录下。
装置配置实现后，执行 go version 验证是否装置胜利。
Go 我的项目开发还少不了适合的编辑器，举荐应用 Goland，下载地址为：https://www.jetbrains.com/go/。装置实现后，关上 Goland 新建我的项目，新建 main.go 文件，编写经典的 hello world：
package main
import "fmt"
func main() {fmt.Println("hello world")
}Go 语言所有文件都必须指定其所在的包，如上 ”package main”，咱们称之为 main 包，当然包名也能够命名为其余名称（个别包名与以后所在目录 / 文件夹名称保持一致），而 main 包里的 main 函数为程序的入口函数。
咱们的代码必定会仍然其余文件，怎么引入呢？通过 ”import 包名 ” 引入，引入后能力拜访该包内函数 / 变量。如下面代码所示，fmt 包是 Go 语言底层提供的格式化 /IO 包，Println 函数打印变量到规范输入。
数据类型
Go 语言数据类型包含布尔型，数字类型（整型、浮点型、复数），字符串，切片（数组），字典 map，管道 chan 等，各类型变量的申明以及简略应用如下：
package main
import "fmt"
func main() {
// 变量申明
var a int = 1 //var 申明并初始化变量, 类型 int 能够省略
b := 1 //:= 申明 + 初始化变量
b = 3 //= 只能针对已有变量从新赋值
fmt.Println(a, b)
// 字符串
str1 := "hello"
str2 := "world"
fmt.Println(len(str1), str1 + str2) // 能够 +；len 返回字符串长度
// 数组，容量固定
arr := [5]int{1,2,3,4,5}
arr[1] = 100 // 数组元素拜访
fmt.Println(len(arr), arr) //len 返回数组长度
// 切片，容量能够裁减，相当于动静数组
slice := []int{1,2,3}
slice[1] = 100 // 切片元素拜访
slice = append(slice, 4, 5, 6) //append 主动扩容
fmt.Println(len(slice),cap(slice), slice) //len 返回切片长度，cap 返回切片容量
//map，key-value 构造
score := map[string]int{
"zhangsan":100,
"lisi":99,
"wangwu":98,
}
score["who"] = 90 //map 赋值
s, ok := score["who"] //map 拜访，s 对应 value 值，ok 标识该 key 是否存在（不存在返回空值）delete(score, "lisi") // 删除 map 元素
fmt.Println(s, ok, score)
}这里并没有给出管道 chan 的事例，这将在第二章并发模型具体介绍。当然除了 Go 语言提供的这些根本类型，咱们也能够自定义类型，如接口，构造体等，这些也将在前面章节介绍。
分支构造
与其余语言相似，Go 语言同样反对 if/switch 分支构造，for 循环构造，如上面所示：
package main
import "fmt"
func main() {
//if 分支
condition := true
if condition {fmt.Println("true")
}else{fmt.Println("false")
}
//wsith 分支
expr := "zhangsan"
switch expr {
case "zhangsan":
fmt.Println("zhangsan")
case "lisi":
fmt.Println("lisi")
default: // 没有匹配到，默认执行
fmt.Println("who")
}
//for 循环
for i := 0; i < 100; i ++ {
if i /2 == 0 {fmt.Println("偶数")
}
}
// 无条件循环，死循环
i := 0
for {
i ++
fmt.Println("loop")
if i > 100 { // 检测条件，提前 break 退出循环
break
}
}
}函数
函数的定义，如名称，入参，返回值等基本概念这里就不做过多介绍了，Go 语言与其余语言不同的中央在于，其反对多返回值（大部分语言只能返回一个值），以及可变参数（大部分语言其实也反对），另外 Go 语言还反对闭包（匿名函数），实例如下：
package main
import "fmt"
func main() {add, sub := addSub(4, 3)
fmt.Println(add, sub)
sum(1, 2, 3)
nums := []int{1, 2, 3, 4}
sum(nums...) // 切片转可变参数，通过... 实现
// 变量 f 为函数类型
f := func (in string) {fmt.Println(in)
}
f("hello world") // 执行函数
// 申明匿名函数，留神与下面却别，加括号间接执行该匿名函数
func (in string) {fmt.Println(in)
}("hello world")
}
// 返回两个 int 值
func addSub(a, b int) (int, int){return a + b, a - b}
//... 示意参数数目可变
func sum(nums ...int) {
total := 0
//nums 其实是切片类型（[]int），for + range 可遍历切片元素
for _, num := range nums {total += num}
fmt.Println(total)
}协程并发
Go 语言人造具备并发个性，基于 go 关键字就能很不便的创立协程去执行一些并发工作。上面程序创立 10 个协程并发执行工作，主协程期待各子协程执行完结后，也主动退出：
package main
import (
"fmt"
"sync"
)
func main() {
//WaitGroup 用于协程并发管制
wg := sync.WaitGroup{}
// 启动 10 个协程并发执行工作
for i := 0; i < 10; i ++ {
// 标记工作开始
wg.Add(1)
go func(a int) {fmt.Println(fmt.Sprintf("work %d exec", a))
// 标记工作完结
wg.Done()}(i)
}
// 主协程期待工作完结
wg.Wait()
fmt.Println("main end")
}总结
本篇作为深刻了解 Go 语言系列第一篇，简略介绍了 Go 语言的根本语法，包含根本数据类型，分支构造，函数等基本概念，旨在让你对 Go 语言能有初步意识，从下一篇开始，咱们将开始 Go 语言的全面摸索。