Golang 编程入门

Golang 的优势和特点

  • 可直接编译成机器码,不依赖其他库,glibc 的版本有一 - 定要求,部署就是扔一个文件上去就完成了
  • 静态类型语言,但是有动态语言的感觉,静态类型的语言就是可以在编译的时候检查出来隐藏的大多数问题,动态语言的感觉就是有很多的包可以使用,写起来的效率很高。
  • 语言层面支持并发,这个就是 Go 最大的特色,天生的支持并发。Go 就是基因里面支持的并发,可以充分的利用多核,很容易的使用并发。
  • 内置 runtime,支持垃圾回收,这属于动态语言的特性之一吧,虽然目前来说 GC (内存垃圾回收机制) 不算完美,但是足以应付我们所能遇到的大多数情况,特别是 Go1.1 之后的 GC
  • 简单易学,Go 语言的作者都有 C 的基因,那么 Go 自然而然就有了 C 的基因,那么 Go 关键字是 25 个,但是表达能力很强大,几乎支持大多数你在其他语言见过的特性:继承、重载、对象等
  • 丰富的标准库,Go 目前已经内置了大量的库,特别是网络库非常强大。
  • 内置强大的工具,Go 语言里面内置了很多工具链,最好的应该是 gofmt 工具,自动化格式化代码,能够让团队 review 变得如此的简单,代码格式一模一样,想不一样都很困难
  • 跨平台编译,如果你写的 Go 代码不包含 cgo,那么就可以做到 window 系统编译 linux 的应用,如何做到的呢?Go 引用了 plan9 的代码,这就是不依赖系统的信息。
  • 内嵌 C 支持,Go 里面也可以直接包含 C 代码,利用现有的丰富的 C 库。

Go 适合用来做什么

  • 服务器编程,以前你如果使用 C 或者 C++ 做的那些事情,用 Go 来做很合适,例如处理日志、数据打包、虚拟机处理、文件系统等。

  • 分布式系统,数据库代理器等。

  • 网络编程,这一块目前应用最广,包括 Web 应用、API 应用、下载应用。

  • 内存数据库,如 google 开发的 groupcache, couchbase 的部分组件。

  • 云平台,目前国外很多云平台在采用 Go 开发,CloudFoundy 的部分组件,前 VMare 的技术总监自己出来搞的 apcera 云平台。

golang 开发环境搭建

下载 go1.13.6.windows-amd64.msi 下载地址是 https://dl.google.com/go/go1.13.6.windows-amd64.msi
一路 Next 安装别有中文路径即可

mark

入门成功
mark

另外还可以下载 Go 的 IDE,直接用 LiteIDE 就行了

https://studygolang.com/pkgdoc 这里是 golang 的文档

比如我们可以查找 fmt 包

mark

golang 简单语法

  • 左括号和函数名称同行
  • go 语言以包作为管理单位,调用函数大部分需要导包
  • 每个文件必须先声明包
  • 程序必须有一个 main 包才能运行
  • 注释和 Java 相同,///**/
  • 导了包必须要使用,否则出错

golang 的包管理方式

一个包(文件夹)下之恩那个有一个 main 函数,在 IDE 的情况下

如果是非要放在一个包,可以直接 go run **.go

如果需要一个可执行程序,那么可以 go build xxx.go

关键字和常量

mark

变量的使用

声明了变量必须要使用,只声明,没有初始化的变量默认为 0

同一个 { } 里,变量名是唯一的

mark

直接看这段代码吧,比较好懂一点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package main

import "fmt"
// 注释
func main() {
// 声明变量默认为 0
var a int
fmt.Println ("a =", a)

// 同时声明多个变量
var b, c int
fmt.Println ("b =", b, ",c =", c)

// 声明时赋值
var d int = 10
fmt.Println ("d =", d)

// 先声明,再赋值
var e int
e = 20
fmt.Println ("e =", e)

// 类型自动推导
f := "I' am string"
fmt.Println ("f =", f)

//% T 用于打印变量的类型
fmt.Println ("Type is % T=", f)
fmt.Printf ("Type is % T\n", f)
fmt.Printf ("Type is % T\n", a)

// 类型自动推导只能用于初始化那一次
g := 100
fmt.Println ("g =", g)

//g:= "a str" -> error
//fmt.Println ("g =", g)
g = 200
//g = "a str" 赋值时改变类型 -> error

// 和 C 语言的 printf () 一样的
fmt.Printf ("% d % d % s", a, g, f)
//fmt.Println () 只是简单的拼接,不能使用 % T 去打印类型之类的信息,但是 fmt.Printf () 却可以
}

下面是一个变量交换的例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
func main(){
//-------------01----------
// 交换两个变量的值
var a0 int = 10
var b0 int = 20

var tmp int = a0
a0 = b0
b0 = tmp
fmt.Printf ("a0=% d, b0=% d\n", a0, b0)

//-------------02----------
a1 := 10
b1 := 20

tmp1 := a1
a1 = b1
b1 = tmp1
fmt.Printf ("a1=% d, b1=% d\n", a1, b1)

//-------------03----------
a2, b2 := 10, 20
a2, b2 = b2, a2
fmt.Printf ("a2=% d, b2=% d\n", a2, b2)

//-------------04----------
a3, b3, c3 := 10, 20, 30
a3, b3, c3 = c3, a3, b3
fmt.Printf ("a3=% d, b3=% d, c3=% d\n", a3, b3, c3)
}

匿名变量

mark

比如下面这样的

mark

常量的使用

变量声明为 var、常量声明为 const

mark

注意常量的类型自动推导不能使用 :=

而且常量定义完了可以不使用,变量必须使用

多个变 / 常量的声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package main

import "fmt"

func main() {
a, b := 10, 10.25

fmt.Printf ("a = % d, b = % f \n", a, b)
fmt.Println ("b =", b)

// 一次声明多个变量
var (
c int
d float64
)
c = 10
d = 99.99
fmt.Printf ("c = % d, d = % f \n", c, d)

// 一次声明多个变量并赋值
var (
e int = 10
f float64 = 30.00
)
fmt.Printf ("e = % d, f = % f \n", e, f)

// 一次声明多个常量
const (
g int = 10
h int = 20
)

// 一次声明多个常量并自动推导类型
const (
i = 10
j = 20
)
fmt.Printf ("g = % d, h = % d \n", g, h)
}

枚举的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

func main() {

//iota 给常量赋值使用
const (
a = iota
b = iota
c = iota
)

fmt.Printf ("a=% d, b=% d, c=% d", a, b, c) //a=0, b=1, c=2
}

iota 是一个常量自动生成器,每隔一行自动加一

iota 遇到 const,则重置为 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
"fmt"
)

func main() {

const (
a = iota
b = iota
c = iota
)

fmt.Printf ("a=% d, b=% d, c=% d\n", a, b, c) //a=0, b=1, c=2

//iota 遇到 const 重置为 0
const d = iota
fmt.Printf ("d=% d\n", d) //d=0

// 如果是同一行,值都一样
const e, f, g = iota, iota, iota
fmt.Printf ("e=% d, f=% d, g=% d\n", e, f, g) //e=0, f=0, g=0

const (
h, i, j = iota, iota, iota
)
fmt.Printf ("h=% d, i=% d, j=% d\n", h, i, j) //h=0, i=0, j=0

const (
k = iota
l, m = iota, iota
n = iota
)
fmt.Printf ("k=% d, l=% d, m=% d, n=% d\n", k, l, m, n) //k=0, l=1, m=1, n=2
}

golang 基本数据类型

mark

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package main

import "fmt"

func main() {

//-----bool 类型 ----------
var a = false
fmt.Println (a) //false

b := true
fmt.Println (b) //true

var c bool
fmt.Println (c) //false

//----- 浮点类型 ----------

var d = 3.14 // 这样赋值默认是 float64
fmt.Println (d)
fmt.Printf ("% T\n", d)

var e float32
fmt.Println (e)
fmt.Printf ("% T\n", e)

f := 10.00 // 这样赋值默认是 float64
fmt.Println (f)
fmt.Printf ("% T\n", f)

//----- 字符类型 ----------
var a1 byte
a1 = 'a'
fmt.Println (a1) //97
fmt.Printf ("a1=% d, a1=% c\n", a1, a1) //a1=97, a1=a
fmt.Printf ("% T\n", a1)

b1 := 'A'
fmt.Printf ("b1 = % c\n", b1)
fmt.Printf ("b1 = % c\n", b1 + ('a'-'A'))

//----- 字符串类型 ----------
a2 := "Tim"
fmt.Println (a2)
//len () 测字符串长度
fmt.Println (len(a2))

// 打印字符串中的某一个字符
fmt.Printf ("a2 [2] = % c\n", a2 [2]) //a2 [2] = m
//fmt.Printf ("a2 [3] = % c", a2 [3]) error 越界

//----- 复数类型 ----------
a3 := 2.1 + 3i
fmt.Println (a3) //(2.1+3i)

var b3 complex128 = 2.5 + 3i
fmt.Println (b3) //(2.5+3i)

// 通过内建函数取实部和虚部
fmt.Println (" 实部 real (b3) =", real(b3), " 虚部 imag (b3) =", imag(b3))
// 实部 real (b3) = 2.5 虚部 imag (b3) = 3
}

格式化输出

mark

键盘输入

1
2
3
4
5
6
7
8
9
10
11
package main

import "fmt"

func main() {
var name string;
fmt.Scanf ("% s", &name) // 手动输入格式
fmt.Scan (&name) // 自动匹配格式

fmt.Printf ("name=% s\n", name)
}

类型转换

Go 语言中不允许隐式转换,所有类型转换必须显式声明,而且转换只能发生在两种相互兼容的类型之间。

1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import "fmt"

func main() {
var a byte = 'A'

// 类型转换
var b int = int(a)

fmt.Printf ("% T\n", a) //uint8
fmt.Printf ("% T\n", b) //int
}

类型别名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main

import "fmt"


func main() {
type bigint int64

var a bigint = 100
fmt.Printf ("% T\n", a) //main.bigint

// 一次取多个别名
type (
long int64
char byte
)

var b char = 'A'
var c long = 100
fmt.Printf ("b=% c, type=% T\n", b, b) //b=A, type=main.char
fmt.Printf ("c=% d, type=% T\n", c, c) //c=100, type=main.long
}

golang 的运算符

和 c 语言一样,* 取值,& 取地址

在 go 语言中,一元运算符拥有最高的优先级,二元运算符的运算方向均是从左至右。

mark

golang 流程控制

if if..else

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package main

import "fmt"

func main() {

// 简单的 if 语句判断
var name string
name = "ABC"
if name == "ABC" {
fmt.Println (" 相等 & quot;)
}

//if 支持一个初始化语句
if a := 10; a == 10{
fmt.Println ("a==10")
}

//if 多分支
name = "AAA"
if name == "ABC" {
fmt.Println (" 相等 & quot;)
}else {
fmt.Println (" 不相等 & quot;)
}


name = "CCC"
if name == "ABC" {
fmt.Println ("name=ABC")
}else if name == "AAA" {
fmt.Println ("name=AAA")
}else if name == "BBB" {
fmt.Println ("name=BBB")
}else {
fmt.Println ("Other")
}
}

switch

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import "fmt"

func main() {
a := 12
switch a {
case 10:
fmt.Println ("a=10")
case 20:
fmt.Println ("a=20")
case 30:
fmt.Println ("a=30")
default:
fmt.Println ("Default")
}
}

可以看出没有写 break,go 语言保留了 break 关键字,不写 break,默认也包含 break

fallthrough 关键字的作用:不跳出 switch,还要执行紧随其后的一个分支

mark

1
2
3
4
5
6
7
8
9
10
11
12
13
func main() {
// 同样的,switch 也是支持一个初始化语句的
switch a := 10; a {
case 10:
fmt.Println ("a=10")
case 20:
fmt.Println ("a=20")
case 30:
fmt.Println ("a=30")
default:
fmt.Println ("Default")
}
}

switch 可以没有条件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import "fmt"

func main() {

var score int
//switch 可以没有条件
switch {
case score > 90:
fmt.Println (" 优秀 & quot;)
case score > 60 && score <= 90:
fmt.Println (" 及格 & quot;)
default:
fmt.Println (" 不及格 & quot;)
}
}

for

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import "fmt"

func main() {
num := 0
for i:=1; i<= 100; i++{
num += i
}
fmt.Printf ("num=% d\n", num) //5050

// 死循环的写法
for{
//TDDO...
}
}

range

关键字 range 会返回两个值,第一个返回值是元素的数组下标,第二个返回值是元素的值:

支持 string、array、slice、map

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package main

import "fmt"

func main() {

str := "GoLand"
//01 传统写法
for i:=0; i<len(str); i++{
fmt.Printf ("% c ",str [i])
}
fmt.Println ()

//02 迭代写法
for i := range str{
fmt.Printf ("% c ",str [i])
}
fmt.Println ()

//range 返回两个值,一个是 index、一个是元素本身
// 支持 string、array、slice、map
for i, data := range str{
fmt.Printf ("% d-% c\n",i, data)
}
}

goto

和 C 语言的一样的:

mark