go 语言学习第一天

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

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

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

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()却可以
}
​

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

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)
}
​

匿名变量

比如下面这样的

常量的使用

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

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

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

多个变/常量的声明

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)
}
​

枚举的使用

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

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 基本数据类型

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
}
​

格式化输出

键盘输入

package main

import "fmt"

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

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

类型转换

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

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
}
​

类型别名

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 语言中，一元运算符拥有最高的优先级，二元运算符的运算方向均是从左至右。

golang 流程控制

if if..else

package main

import "fmt"

func main() {

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

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

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

	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

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，还要执行紧随其后的一个分支

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 可以没有条件

package main

import "fmt"

func main() {

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

for

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

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 语言的一样的：