Go语言入门学习和环境安装

Go语言入门

(一) Go语言导学

1）为什么学Go

• go语言简单易学
• 国内公司纷纷开始使用go ：BAT，字节，b站等, 小米，滴滴，京东，360，七牛云，知乎，美团
• 云原生时代的领导语言
• go适合高并发和微服务开发
• 快速增长的职位需求

2）go语言可以进行微服务框架开发

• 初级开发重视功能，高级开发重视原理
• 自研是了解细节最好的方法
• 大公司都在自研，非常看着自研能力

3） 学习工程化的重要性

• 工程化思维决定了我们编码的方式
• 好的工程化思提高代码的质量

4）高级Go工程师养成

• 知识广度
• 知识深度
• 规范的开发体系

5） Go语言介绍

1. Google开源
2. 编译行语言（静态语言）
3. 2006开始，09年开源，国内发展迅速

6）核心作者：Ken Thompson, Rob Pike, Robert Griesemer

7） Go语言优势

1. 语言简单，开发效率高
2. 集成个语言优势，大量参考C和Python
3. 执行性能高，直接编译成二进制，部署分成简单
4. 并发编程非常高效-goroutine
5. 编译速度快-比c++,java编译快

8）Go语言能做什么

1. 文本开发，-gin.beego等
2. 容器虚拟化：docker，k8s,istio
3. 中间件-etcd,tidb,influxdb,nsq等
4. 区块链：-以太坊，fabric
5. 微服务：-go-zero,dapr,rpcx,kratos,dubbo-go,kitex

(二) Go语言开发环境的安装

1) go

下载地址：https://studygolang.com/dl go中文网

Windows会自动添加环境变量

2) goland, vscode

jetbrians旗下的产品

3）编写代码

package main

import "fmt"

func main() {
	fmt.Println("hello world")

}

编译：go build .\helloworld.go

编译完会生成一个EXE文件

直接运行：go run .\helloworld.go

注意：go语言同一个目录下只能有一个main函数

(三) 基础语法

1） 定义变量

//go是静态语言
	//1. 变量必须先定义后使用
	//2.变量必须有类型
	//3.类型确定不能改变
	//定义变量的方式：
	//var name int
	//name = 1
	//var name int = 1
	//var age =1
	age := 1
	//go语言中变量定义了不使用是不行的
	fmt.Print(age)

	var age2 int
	fmt.Println(age2)

	//2.多变量定义
	var user1, user2, user3 string
	user1 = "jcak"
	user2 = "mikc"
	user3 = "nico"
	fmt.Println(user1, user2, user3)

2-3）常量 和iota

//常量， 不能被修改，定义的时候指定的值
	const (
		ERR1 = iota
		ERR2
		ERR3
		ERR5

		ERR4
	)
	fmt.Println(ERR1, ERR2, ERR3, ERR5, ERR4)

	每次出现const  iota桂0

4) 匿名变量

var _ int
_, ok := a()
if ok {
   fmt.Println(ok)
}

5）变量的作用域

全局作用域和局部作用域

代码块中的变量出了代码块就无了

(四）go基本数据类型

bool类型
布尔型的值只可以是常量 true 或者 false。⼀个简单的例⼦：var b bool = true

数值型

1. 整数型
   可以简单讲解⼀下⼆进制和位数的关系，以及 int 和 uint 的关系
   int8 有符号 8 位整型 (-128 到 127) ⻓度：8bit
   int16 有符号 16 位整型 (-32768 到 32767)
   int32 有符号 32 位整型 (-2147483648 到 2147483647)
   int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
   uint8 ⽆符号 8 位整型 (0 到 255) 8位都⽤于表示数值：
   uint16 ⽆符号 16 位整型 (0 到 65535)
   uint32 ⽆符号 32 位整型 (0 到 4294967295)
   uint64 ⽆符号 64 位整型 (0 到 18446744073709551615)

2. 浮点型
   float32 32位浮点型数

float64 64位浮点型数
其他
byte 等于 uint8
rune 等于 int32
uint 32 或 64 位

3. 字符
   Golang中没有专⻔的字符类型，如果要存储单个字符(字⺟)，⼀般使⽤byte来保存。
   字符串就是⼀串固定⻓度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。也就是说对于传统的字符串是由字符组成的，⽽Go的字符串不同，它是由字节组成的。

//type byte = uint8
	//var c byte //主要用于存放字符
	//c = 'a'
	//fmt.Printf("c=%c", c)
	c1 := 'a'
	print(c1)
	//type rune = int32 也是字符
	var c2 rune
	c2 = 'a'
	fmt.Println(c2)

	f1 = 3.10
	f2 = 3.14
	fmt.Println(f1, f2)

1）数据类型转换：

valueOfTypeB = typeB(valueOfTypeA)

a := 5.0
b := int(a)
//IT 类型的底层是int类型  type 是取别名
type IT int
var a IT = 5
b := int(5)
c := IT(b)
var a int32 = 1
var b int64 = 3
b = int64(a)
fmt.Println(a, b)


var a int8 = 12
var b = uint8(a)

var f float32 = 3.14
var c = int32(f)

fmt.Print(b, c)
	
type IT int
//类型转换很严格，只能是IT
var c IT =IT(a)

int 转换为字符串：Itoa()

println(“a” + strconv.Itoa(32))

string 转换为 int：Atoi()

//有出错的可能
i,_ := strconv.Atoi("3")
println(3 + i) 
i,err := strconv.Atoi("a")
if err != nil {
 println("converted failed")
}

Parse 类函数⽤于转换字符串为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint()。

b, err := strconv.ParseBool("true")
f, err := strconv.ParseFloat("3.1415", 64)
i, err := strconv.ParseInt("-42", 10, 64)
u, err := strconv.ParseUint("42", 10, 64)

ParseInt() 和 ParseUint() 有 3 个参数：

func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (uint64, error)

说明：

1. bitSize 参数表示转换为什么位的 int/uint，有效值为 0、8、16、32、64。当 bitSize=0 的时候，表示转换为 int 或 uint 类型。例如 bitSize=8 表示转换后的值的类型为 int8 或 uint8。
2. base 参数表示以什么进制的⽅式去解析给定的字符串，有效值为 0、2-36。当 base=0 的时候，表示根据string 的前缀来判断以什么进制去解析： 0x 开头的以 16 进制的⽅式去解析， 0 开头的以 8 进制⽅式去解析，其它的以 10 进制⽅式解析。

将给定类型格式化为 string 类型：FormatBool()、FormatFloat()、FormatInt()、FormatUint()。

s := strconv.FormatBool(true)
s := strconv.FormatFloat(3.1415, 'E', -1, 64)
s := strconv.FormatInt(-42, 16)
s := strconv.FormatUint(42, 16)

第⼆个参数 base 指定将第⼀个参数转换为多少进制，有效值为 2<=base<=36 。当指定的进制位⼤于 10 的时候，超出 10 的数值以 a-z 字⺟表示。例如 16 进制时，10-15 的数字分别使⽤ a-f 表示，17 进制时，10-16 的数值分别使⽤ a-g 表示。

2) format 进行格式化转换

FormatFloat() 参数众多：

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

bitSize 表示 f 的来源类型（32：float32、64：float64），会据此进⾏舍⼊。
fmt 表示格式：‘f’（-ddd.dddd）、‘b’（-ddddp±ddd，指数为⼆进制）、‘e’（-d.dddde±dd，⼗进制指数）、
‘E’（-d.ddddE±dd，⼗进制指数）、‘g’（指数很⼤时⽤’e’格式，否则’f’格式）、‘G’（指数很⼤时⽤’E’格式，否
则’f’格式）。
prec 控制精度（排除指数部分）：对’f’、‘e’、‘E’，它表示⼩数点后的数字个数；对’g’、‘G’，它控制总的数字个数。
如果 prec 为 - 1，则代表使⽤最少数量的、但⼜必需的数字来表示 f。


bitSize 表示 f 的来源类型（32：float32、64：float64），会据此进⾏舍⼊。
fmt 表示格式：‘f’（-ddd.dddd）、‘b’（-ddddp±ddd，指数为⼆进制）、‘e’（-d.dddde±dd，⼗进制指数）、
‘E’（-d.ddddE±dd，⼗进制指数）、‘g’（指数很⼤时⽤’e’格式，否则’f’格式）、‘G’（指数很⼤时⽤’E’格式，否
则’f’格式）。
prec 控制精度（排除指数部分）：对’f’、‘e’、‘E’，它表示⼩数点后的数字个数；对’g’、‘G’，它控制总的数字个数。
如果 prec 为 - 1，则代表使⽤最少数量的、但⼜必需的数字来表示 f。