初识Golang
Go介绍
Go是一种开源编程语言，可以轻松构建简单，可靠和高效的软件。
Go是Google开发的一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言。为了方便搜索和识别，有时会将其称为Golang。
罗伯特·格瑞史莫，罗勃·派克（Rob Pike）及肯·汤普逊于2007年9月开始设计Go语言，稍后Ian Lance Taylor、Russ Cox加入项目。Go语言是基于Inferno操作系统所开发的。Go语言于2009年11月正式宣布推出，成为开放源代码项目，并在Linux及Mac OS X平台上进行了实现，后来追加了Windows系统下的实现。
受欢迎程度
截止目前为止，越来越多的开发者开始使用GO，并喜欢用Go，目前在Github统计中，Go排名第9
最受欢迎的5种语言和最想使用的语言之一
来源: https://insights.stackoverflow.com/survey/2017#most-loved-dreaded-and-wanted
Go 是云基础架构语言
每个云计算公司都在用Go实现云基础架构关键组件，包括Google Cloud, AWS, Microsoft Azure, DigitalOcean, Heroku。Go是阿里巴巴，cloudflare和Drobox等云计算公司的重要组成部分
Go开源软件的影响力
Go 有很多出色的开源软件，并且很流行，举几个常见并且正在用的例子
kubernetes：容器编排系统，是一个自动化部署，扩展和管理容器的系统，最初由Google涉及并用于GRE
Moby(Docker)：容器
Prometheus：是一个开源的监控解决方案和时间序列数据库，支持metric和Alert
Granfana：仪表盘和图形
说了这么多，下面我们开始正式了解Go的语法及格式等。
Hello 世界
因为Go是二进制方式，所以安装比较简单，这里不做过多介绍，可以参照官方文档：https://golang.org/doc/install
每个语言都以Hello World开始，Go也不例外，我们先写一个Hello World
$ vim hello.go
package main
import(
"fmt"
)
func main() {
fmt.Println("Hello 世界")
}
$ go run hello.go
Hello 世界
Go的目录组织结构(Workspaces)
src: 包含Go源文件，src下有不同目录，每个目录可以理解为一个项目，在
pkg: 包含package object
bin: 包含可执行命令文件
bin/
hello # 可执行命令
outyet # 可执行命令
pkg/
linux_amd64/
github.com/golang/example/
stringutil.a # package object
src/
github.com/golang/example/
.git/ # Git repository metadata
hello/
hello.go # 源码
outyet/
main.go # 源码
main_test.go # 测试源码
stringutil/
reverse.go # 源码
reverse_test.go # 测试源码
golang.org/x/image/
.git/ # Git repository metadata
bmp/
reader.go # package source
writer.go # package source
... (many more repositories and packages omitted) ...
Go基本命令介绍
go run: 编译和执行go程序
go build: 编译程序，生成二进制可执行文件
go install: 编译和安装可执行程序到bin目录
go test：执行单元测试或压力测试
go env： 显示go相关的环境变量
go fmt：格式化源代码
package(包)
每个Go程序都是由包组成的。程序运行的入口是包main。这个程序导入了包fmt和math/rand。
按照惯例，包名与导入路径的最后一个目录一致。例如，math/rand 包由package rand语句开始
- math.rand: 包rand执行伪随机生成一个数字，为了安全考虑，建议使用crypto/rand
package main
import (
"fmt"
"math/rand"
)
func main() {
fmt.Println("My favorite number is", rand.Intn(50))
}
导入
使用圆括号组合导入，也可以写多个导入语句
import "fmt"
import "math"
import (
"fmt"
"math"
)
变量
定义及初始化变量
var语句定义了一个变量的列表；类型在后面，定义类型可以再函数外面，初始化值必须在函数内部
$ vim var.go
package main
import "fmt"
var c, python, java bool /./定义类型
func main() {
c, python, java = true, false, true //初始化值
var i int #不初始化默认为0
fmt.Println(c, python, java, i)
}
$ go run var.go
true false true 0
短变量声明
在函数中，:= 简洁赋值语句在明确类型的地方，可以用于替代var定义。
函数外的每个语句都必须一关键字开始(var、func、等等)，:= 结构不能再函数外使用。
$ vim short-variable.go
package main
import "fmt"
func main() {
var x string = "你好"
y := 3
c, python, java := true, false, true
fmt.Println(x, y, c, python, java)
}
$ go run short-variable.go
你好 8 true false true
变量基本类型(Base types)
bool // 布尔值 true 和 false
string // 字符串
int int8 int16 int32 int64 //整数, int8 表示8位二进制，最大为128 范围：-128 -> 127，int64表示（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807）
uint uint8 uint16 uint32 uint64 uintptr 无符号整数
byte // uint8 的别名
rune // int32 的别名
// 代表一个Unicode码
float32 float64
complex64 complex128
%T: 返回变量的类型值
%v: 返回变量的值，默认的打印方式
$ vim basic-type.go
package main
import (
"fmt"
"math/cmplx"
)
var (
ToBe bool = false
MaxInt uint64 = 1<<64 - 1
z complex128 = cmplx.Sqrt(-5 + 12i)
)
func main() {
const f = "%T(%v)\n"
fmt.Printf(f, ToBe, ToBe)
fmt.Printf(f, MaxInt, MaxInt)
fmt.Printf(f, z, z)
}
$ go run basic-type.go
bool(false)
uint64(18446744073709551615)
complex128((2+3i))
零值
变量在定义时没有明确的初始化变量值就会被赋予零值
对于不同类型的零值是:
int类型为
0bool类型为
falsestring类型为”“(空)
类型转换
表达式T(v) 将v转为为类型T
$ vim type-con.go
package main
import (
"fmt"
)
func main() {
var i int = 88
var b float64 = float64(i)
fmt.Println(b)
//简单形式的写法
c := 99
f := float64(c)
u := uint(f)
fmt.Println(c, f, u)
}
$ go run type-con.go
88
99 99 99
类型推导
在定义一个变量却不指定其类型时，go会根据变量的值来推导其类型
i := 42 //int
f := 3.1415 //float64
常量
常量的定义与变量类似，只不过使用 const 关键字。
常量可以是字符、字符串、布尔或数字类型的值。
常量不能使用 := 语法定义。
$ vim const.go
package main
import "fmt"
const nu = 3.14
func main() {
const no = false
fmt.Println(nu, no)
}
$ go run const.go
3.14 false
函数
函数定义关键字使用func 函数名() 中括号来进行定义，函数可以没有参数，也可以接受多个参数。
$ vim Add.go
package main
import(
"fmt"
)
func Add(x int, y int) int {
return x + y
}
func main() {
fmt.Println(Add(8,9))
}
$ go run Add.go
17
当两个或者多个连续的函数命名参数是同一类型，则除了最后一个类型之外，其他都可以省略
x int, y int
// 可以写为
x , y int
多值返回
函数可以返回任意数量的返回值。
muti函数返回了两个字符串
$ vim muti.go
package main
import "fmt"
func Muti(x, y string) (string, string) {
return x, y
}
func main() {
fmt.Println(Muti("你好","Go"))
}
$ go run muti.go
你好 Go
返回值命名
Go 的返回值可以被命名，并且就像在函数体开头声明的变量那样使用。
没有参数的return返回函数中各个变量的值。这种用法被称作”裸”返回。
$ vim name-return.go
package main
import "fmt"
func Split(sum int)(x, y int) {
x = sum - 3
y = sum * 5 / 2
return
}
func main() {
fmt.Println(Split(50))
}
$ go run name-return.go
47 125
总结
关于Go的基本介绍就到这里了，上述的内容会在接下来的博客进行细分详解，感谢您的阅读，祝您早日成为一个出色的Go程序员