初识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

go-1

最受欢迎的5种语言和最想使用的语言之一

go-2

来源: 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类型为0
bool类型为false
string类型为”“(空)

类型转换

表达式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程序员