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安装别有中文路径即可
入门成功
另外还可以下载Go 的IDE，直接用LiteIDE就行了
https://studygolang.com/pkgdoc 这里是golang的文档
比如我们可以查找fmt包
golang简单语法
- 左括号和函数名称同行
- go语言以包作为管理单位，调用函数大部分需要导包
- 每个文件必须先声明包
- 程序必须有一个main包才能运行
- 注释和Java相同，
//和/**/ - 导了包必须要使用，否则出错
golang的包管理方式
一个包（文件夹）下之恩那个有一个main函数，在IDE的情况下
如果是非要放在一个包，可以直接go run **.go
如果需要一个可执行程序，那么可以go build xxx.go
关键字和常量
变量的使用
声明了变量必须要使用，只声明，没有初始化的变量默认为0
同一个{ }里，变量名是唯一的
直接看这段代码吧，比较好懂一点
1package main
2
3import "fmt"
4//注释
5func main() {
6 //声明变量默认为0
7 var a int
8 fmt.Println("a =", a)
9
10 //同时声明多个变量
11 var b, c int
12 fmt.Println("b =", b, ",c =", c)
13
14 //声明时赋值
15 var d int = 10
16 fmt.Println("d =", d)
17
18 //先声明，再赋值
19 var e int
20 e = 20
21 fmt.Println("e =", e)
22
23 //类型自动推导
24 f := "I' am string"
25 fmt.Println("f =", f)
26
27 //%T用于打印变量的类型
28 fmt.Println("Type is %T=", f)
29 fmt.Printf("Type is %T\n", f)
30 fmt.Printf("Type is %T\n", a)
31
32 //类型自动推导只能用于初始化那一次
33 g := 100
34 fmt.Println("g =", g)
35
36 //g:= "a str" -> error
37 //fmt.Println("g =", g)
38 g = 200
39 //g = "a str" 赋值时改变类型 -> error
40
41 //和C语言的printf()一样的
42 fmt.Printf("%d %d %s", a, g, f)
43 //fmt.Println()只是简单的拼接，不能使用%T去打印类型之类的信息，但是fmt.Printf()却可以
44}
下面是一个变量交换的例子
1func main(){
2 //-------------01----------
3 //交换两个变量的值
4 var a0 int = 10
5 var b0 int = 20
6
7 var tmp int = a0
8 a0 = b0
9 b0 = tmp
10 fmt.Printf("a0=%d, b0=%d\n", a0, b0)
11
12 //-------------02----------
13 a1 := 10
14 b1 := 20
15
16 tmp1 := a1
17 a1 = b1
18 b1 = tmp1
19 fmt.Printf("a1=%d, b1=%d\n", a1, b1)
20
21 //-------------03----------
22 a2, b2 := 10, 20
23 a2, b2 = b2, a2
24 fmt.Printf("a2=%d, b2=%d\n", a2, b2)
25
26 //-------------04----------
27 a3, b3, c3 := 10, 20, 30
28 a3, b3, c3 = c3, a3, b3
29 fmt.Printf("a3=%d, b3=%d, c3=%d\n", a3, b3, c3)
30}
匿名变量
比如下面这样的
常量的使用
变量声明为var、常量声明为const
注意常量的类型自动推导不能使用 :=
而且常量定义完了可以不使用，变量必须使用
多个变/常量的声明
1package main
2
3import "fmt"
4
5func main() {
6 a, b := 10, 10.25
7
8 fmt.Printf("a = %d, b = %f \n", a, b)
9 fmt.Println("b =", b)
10
11 //一次声明多个变量
12 var (
13 c int
14 d float64
15 )
16 c = 10
17 d = 99.99
18 fmt.Printf("c = %d, d = %f \n", c, d)
19
20 //一次声明多个变量并赋值
21 var (
22 e int = 10
23 f float64 = 30.00
24 )
25 fmt.Printf("e = %d, f = %f \n", e, f)
26
27 //一次声明多个常量
28 const (
29 g int = 10
30 h int = 20
31 )
32
33 //一次声明多个常量并自动推导类型
34 const (
35 i = 10
36 j = 20
37 )
38 fmt.Printf("g = %d, h = %d \n", g, h)
39}
枚举的使用
1package main
2
3import "fmt"
4
5func main() {
6
7 //iota给常量赋值使用
8 const (
9 a = iota
10 b = iota
11 c = iota
12 )
13
14 fmt.Printf("a=%d, b=%d, c=%d", a, b, c) //a=0, b=1, c=2
15}
iota 是一个常量自动生成器，每隔一行自动加一
iota遇到const，则重置为0
1package main
2
3import (
4 "fmt"
5)
6
7func main() {
8
9 const (
10 a = iota
11 b = iota
12 c = iota
13 )
14
15 fmt.Printf("a=%d, b=%d, c=%d\n", a, b, c) // a=0, b=1, c=2
16
17 //iota遇到const重置为0
18 const d = iota
19 fmt.Printf("d=%d\n", d) // d=0
20
21 //如果是同一行，值都一样
22 const e, f, g = iota, iota, iota
23 fmt.Printf("e=%d, f=%d, g=%d\n", e, f, g) // e=0, f=0, g=0
24
25 const (
26 h, i, j = iota, iota, iota
27 )
28 fmt.Printf("h=%d, i=%d, j=%d\n", h, i, j) // h=0, i=0, j=0
29
30 const (
31 k = iota
32 l, m = iota, iota
33 n = iota
34 )
35 fmt.Printf("k=%d, l=%d, m=%d, n=%d\n", k, l, m, n) // k=0, l=1, m=1, n=2
36}
golang基本数据类型
1package main
2
3import "fmt"
4
5func main() {
6
7 //-----bool类型----------
8 var a = false
9 fmt.Println(a) //false
10
11 b := true
12 fmt.Println(b) //true
13
14 var c bool
15 fmt.Println(c) //false
16
17 //-----浮点类型----------
18
19 var d = 3.14 //这样赋值默认是float64
20 fmt.Println(d)
21 fmt.Printf("%T\n", d)
22
23 var e float32
24 fmt.Println(e)
25 fmt.Printf("%T\n", e)
26
27 f := 10.00 //这样赋值默认是float64
28 fmt.Println(f)
29 fmt.Printf("%T\n", f)
30
31 //-----字符类型----------
32 var a1 byte
33 a1 = 'a'
34 fmt.Println(a1) //97
35 fmt.Printf("a1=%d, a1=%c\n", a1, a1) //a1=97, a1=a
36 fmt.Printf("%T\n", a1)
37
38 b1 := 'A'
39 fmt.Printf("b1 = %c\n", b1)
40 fmt.Printf("b1 = %c\n", b1 + ('a'-'A'))
41
42 //-----字符串类型----------
43 a2 := "Tim"
44 fmt.Println(a2)
45 // len()测字符串长度
46 fmt.Println(len(a2))
47
48 //打印字符串中的某一个字符
49 fmt.Printf("a2[2] = %c\n", a2[2]) //a2[2] = m
50 //fmt.Printf("a2[3] = %c", a2[3]) error 越界
51
52 //-----复数类型----------
53 a3 := 2.1 + 3i
54 fmt.Println(a3) //(2.1+3i)
55
56 var b3 complex128 = 2.5 + 3i
57 fmt.Println(b3) //(2.5+3i)
58
59 //通过内建函数取实部和虚部
60 fmt.Println("实部 real(b3) =", real(b3), "虚部 imag(b3) =", imag(b3))
61 //实部 real(b3) = 2.5 虚部 imag(b3) = 3
62}
格式化输出
键盘输入
1package main
2
3import "fmt"
4
5func main() {
6 var name string;
7 fmt.Scanf("%s", &name) //手动输入格式
8 fmt.Scan(&name) //自动匹配格式
9
10 fmt.Printf("name=%s\n", name)
11}
类型转换
Go语言中不允许隐式转换，所有类型转换必须显式声明，而且转换只能发生在两种相互兼容的类型之间。
1package main
2
3import "fmt"
4
5func main() {
6 var a byte = 'A'
7
8 //类型转换
9 var b int = int(a)
10
11 fmt.Printf("%T\n", a) //uint8
12 fmt.Printf("%T\n", b) //int
13}
类型别名
1package main
2
3import "fmt"
4
5
6func main() {
7 type bigint int64
8
9 var a bigint = 100
10 fmt.Printf("%T\n", a) //main.bigint
11
12 //一次取多个别名
13 type (
14 long int64
15 char byte
16 )
17
18 var b char = 'A'
19 var c long = 100
20 fmt.Printf("b=%c, type=%T\n", b, b) //b=A, type=main.char
21 fmt.Printf("c=%d, type=%T\n", c, c) //c=100, type=main.long
22}
golang的运算符
和c语言一样，*取值，&取地址
在go语言中，一元运算符拥有最高的优先级，二元运算符的运算方向均是从左至右。
golang流程控制
if if..else
1package main
2
3import "fmt"
4
5func main() {
6
7 //简单的if语句判断
8 var name string
9 name = "ABC"
10 if name == "ABC" {
11 fmt.Println("相等")
12 }
13
14 //if支持一个初始化语句
15 if a := 10; a == 10{
16 fmt.Println("a==10")
17 }
18
19 //if多分支
20 name = "AAA"
21 if name == "ABC" {
22 fmt.Println("相等")
23 }else {
24 fmt.Println("不相等")
25 }
26
27
28 name = "CCC"
29 if name == "ABC" {
30 fmt.Println("name=ABC")
31 }else if name == "AAA" {
32 fmt.Println("name=AAA")
33 }else if name == "BBB" {
34 fmt.Println("name=BBB")
35 }else {
36 fmt.Println("Other")
37 }
38}
switch
1package main
2
3import "fmt"
4
5func main() {
6 a := 12
7 switch a {
8 case 10:
9 fmt.Println("a=10")
10 case 20:
11 fmt.Println("a=20")
12 case 30:
13 fmt.Println("a=30")
14 default:
15 fmt.Println("Default")
16 }
17}
可以看出没有写break，go语言保留了break关键字，不写break，默认也包含break
fallthrough 关键字的作用：不跳出switch，还要执行紧随其后的一个分支
1func main() {
2 //同样的，switch也是支持一个初始化语句的
3 switch a := 10; a {
4 case 10:
5 fmt.Println("a=10")
6 case 20:
7 fmt.Println("a=20")
8 case 30:
9 fmt.Println("a=30")
10 default:
11 fmt.Println("Default")
12 }
13}
switch可以没有条件
1package main
2
3import "fmt"
4
5func main() {
6
7 var score int
8 //switch可以没有条件
9 switch {
10 case score > 90:
11 fmt.Println("优秀")
12 case score > 60 && score <= 90:
13 fmt.Println("及格")
14 default:
15 fmt.Println("不及格")
16 }
17}
for
1package main
2
3import "fmt"
4
5func main() {
6 num := 0
7 for i:=1; i<= 100; i++{
8 num += i
9 }
10 fmt.Printf("num=%d\n", num) //5050
11
12 //死循环的写法
13 for{
14 //TDDO...
15 }
16}
range
关键字range 会返回两个值，第一个返回值是元素的数组下标，第二个返回值是元素的值:
支持string、array、slice、map
1package main
2
3import "fmt"
4
5func main() {
6
7 str := "GoLand"
8 //01 传统写法
9 for i:=0; i<len(str); i++{
10 fmt.Printf("%c ",str[i])
11 }
12 fmt.Println()
13
14 //02 迭代写法
15 for i := range str{
16 fmt.Printf("%c ",str[i])
17 }
18 fmt.Println()
19
20 //range返回两个值，一个是index、一个是元素本身
21 //支持string、array、slice、map
22 for i, data := range str{
23 fmt.Printf("%d-%c\n",i, data)
24 }
25}
goto
和C语言的一样的：
