golang介绍及基础使用

1. 下载

1.1 下载golang

国内官网https://golang.google.cn/dl/

1.2 下载goland(ide)

goland下载(ide)https://www.jetbrains.com/go/

1.3 环境搭建教程

#1  ide,集成开发环境（goland等同于pycharm）
	-goland（jetbrains全家桶），vscode
    -推荐用goland，pycharm，idea，androidstudio
    一路下一步
#2 开发环境 sdk
一路下一步
# 测试安装成功
go version  把版本打印出来就装成功了

# 3注意事项（重点）
	-goland创建项目，选择go的安装路径（默认选中了）
    -gopath：所有的go代码必须放在这个路径下的src文件夹下，否则无法执行，默认创建到用户家目录下的go文件夹（mac,windows,linux）
   	-创建项目路径，go文件都不要出现中文
 
# 3 go命令

# 必须记住的
go env  # go的环境变量
	-GO111MODULE=空的，现在没有使用MODULE模式
    -GOPATH=C:\Users\oldboy\go #代码存放路径
    -GOROOT=c:\go # go sdk安装路径
go build  # 编译型语言，需要先编译再执行，编译成可执行文件，执行可执行文件
go run  # 编译并执行，开发阶段用，两步并作一步

# 其他不太需要记得
go get # 下载并安装包和依赖等同于pip install
go version
go fmt #运行gofmt进行格式化（go fmt ：自动将代码格式）

1.4 golang介绍

#1 Go 即Golang，是Google公司2009年11月正式对外公开的一门编程语言
#2  解释型，编译型
Go是静态（编译型）强类型语言，是区别于解析型语言的弱类型语言(静态：类型固定 强类型：不同类型不允许直接运算)。
python动态强类型语言
#3 哪些是编译，哪些是解释
编译：java，c，c++，c#，go
解析型：python，js，php...
编译型语言涉及到跨平台，因为它需要编译成该平台的可执行文件，java--》运行在jvm之上
go：跨平台编译，交叉编译，在windows平台编译出mac上可执行
解释型：不存在跨平台问题，有解释器

#4 特性
跨平台的编译型语言，交叉编译
管道（channel），切片（slice），并发（routine）
有垃圾回收的机制
支持面向对象和面向过程的编程模式（go的面向对象没有类的概念）

# 5 发展（go是用c写起来的）
2009年11月7日 weekly.2009-11-06 —— 早期的版本
2015年8月19日 go1.5 —— 实现的架构变化，同时保留了和旧版本的兼容性,本次更新中移除了”最后残余的C代码”。# 从此以后，自举，自己写自己
2018年8月24日 go 1.11  ：modules，包管理

2020 年 8 月 go 1.15

# Go语言应用
中国的互联网公司，多多少少都会用，有些没用的，都在准备用
##### docker  k8s   蓝鲸 云计算  百度  小米:falcon
##### 七牛云 
## 应用领域，go适合做什么
服务的开发，微服务开发，运维相关，区块链，云平台
第一款开源区块链产品是用go写的

# Go语言发展前景，为什么火

很新，生态不完善
完美契合当下高并发的互联网生态
语法简单，速度快
云计算和区块链的火，互联网企业高并发的需求

2. HelloWord

package main

import "fmt"

func main() {
	fmt.Println("hello word")
}

// 输出
// hello word

 3. 变量

3.1 全定义

package main

import "fmt"

func main() {
	//1 定义变量的第一种方式：全定义
	//var关键字 变量名 变量类型 = 变量值
	var name string = "xl" //在go中，变量定义了就必须使用，如果不使用就报错
	fmt.Println(name)
}

3.2 类型推导

package main

import "fmt"

func main() {
	//2 定义变量的第二种方式：类型推导（类型不需要写了）
	//var关键字 变量名 = 变量值
	var name = "xl"          //在go中，变量定义了就必须使用，如果不使用就报错
	fmt.Println(name)        //打印并换行
	fmt.Print(name)          //打印不换行
	fmt.Printf("%T\n", name) //查看变量类型
	fmt.Printf("%p", &name)  //查看变量内存地址
}

3.3 简略声明(最常用的)

package main

import "fmt"

func main() {
	//定义变量的第三种方式：简略声明（类型和var关键字都不写）这种用的多,冒号和等号是一家
	//var关键字 变量名 = 变量值
	name := "xl" //在go中，变量定义了就必须使用，如果不使用就报错
	//var a int = 100   //不能重复定义
	fmt.Println(name) //打印并换行

}

3.4 其他变形方式

/4 其他变形方式
	//4.1  只定义不赋值
	//var age int   //定义变量	//如果是只定义，不赋值，只能用这种
	//var age      //只定义，不赋值，不行

	//4.2 声明多个变量
	//var width, height int = 100, 50 // 声明多个变量
	//var width,height =100,50      // 声明多个变量
	//var width,height =100,"lqz"      // 声明多个变量
	//width,height :=100,";qz"           // 声明多个变量

	//4.3 声明多个变量,并赋初值
	//var (
	//	name   = "naveen"
	//	age  int  = 29
	//	height int
	//)
	//fmt.Println(name,age,height)


	//4.4 小坑
	//var a int =10
	var b =99
	//b,a:=99,100    //这个不报错，我们觉得是重复定义，冒号左侧，只要有一个没有定义过的变量，就可以
	//fmt.Println(b)
	//fmt.Print(a)

3.5 总结

/*
	总结：
		1 变量类型在定义阶段就确定了，一旦确定，不允许改变
		2 变量不可以重复定义
		3 变量要先定义再使用
	 */

4. 变量定义规范

/*
变量命名规范
	-变量命令建议用驼峰，（大小写有特殊意义）
	-go文件命名建议用 下划线
    - 一个名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线
    -大写字母和小写字母是不同的：Name和name是两个不同的变量
    -关键字和保留字都不建议用作变量名
 */

/*
Go语言中关键字有25个
break      default       func     interface   select
case       defer         go       map         struct
chan       else          goto     package     switch
const      fallthrough   if       range       type
continue   for           import   return      var

go语言中有37个保留字，主要对应内建的常量、类型和函数
内建常量: true false iota nil
内建类型:  int int8 int16 int32 int64
          uint uint8 uint16 uint32 uint64 uintptr
          float32 float64 complex128 complex64
          bool byte rune string error

内建函数: make len cap new append copy close delete
          complex real imag
          panic recover
 */

5. 类型

	/*
		基础数据类型
		数字：
			有符号整形
				-int：在32位机器是int32，在64位机器是int64
				-int8：表示整数范围是：8个比特位，8个bit是1byte ，负数和0， 2的7次方-1 的范围
				-int16 2的15次方减一
				-int32
				-int64
			无符号整型
				-uint8   2的8次方减一  定义一个人的年龄
				-uint16
				-uint32
				-uint64

			浮点型（小数），表示小数点后长度多少位
				-float32
				-float64
			复数
				-complex64
				-complex128
			byte：是int8的别名  单引号包裹
			rune：是int32的别名  单引号包裹
		字符串
			双引号包裹
			反引号包裹  ` `


		布尔
			bool true 和 false

		数据类型默认值：
			数字类型是0
			字符串类型是 空字符串
			布尔类型   false

	*/

/*
byte:int8
short :int16
int:int32
long:int64
float:float32
double:float64
*/

6. 常量

6.1 第一种

package main

import "fmt"

func main() {
	const name string = "xl"
	fmt.Println(name)
	fmt.Printf("%T", name) // string
}

6.2 类型推导

package main

import "fmt"

func main() {
	const name = "xl"
	fmt.Println(name)  // 常量可以不引用
	fmt.Printf("%T", name) // string
}

6.3 其他定义方式

//const 关键字定义，不允许改变
# 1
package main

import "fmt"

func main() {
	const name, age = "xl", 20
	fmt.Println(name)      // 常量可以不引用
	fmt.Printf("%T", name) // string
}


# 2
package main

import "fmt"

func main() {
	const (
		name string = "xl"
		age         = 20
	)

	fmt.Println(name)      // 常量可以不引用
	fmt.Printf("%T", name) // string
}


# 3
package main

import "fmt"

func main() {
	const (
		s1 = iota
		s2 = iota
		s3
		s4 = 99
		s5 = iota
	)
	fmt.Println(s3) // 常量可以不引用
}

7. 函数基础

定义方式

//定义方式
/*
	func 名字(参数名 类型，参数名 类型)(返回值类型，返回值类型){
		函数体内容
		return 返回值1，返回值2
	}

*/

有参数无返回值(定义函数)

package main

import "fmt"

// 调用
func main() {
	add(1, 1)
}

// 定义
//1 有参数无返回值(定义函数)
func add(a int, b int) {
	fmt.Println(a + b)
}

有参数无返回值,有多个相同类型参数

package main

import "fmt"

// 调用
func main() {
	add(1, 1)
}

// 定义
//2 有参数无返回值,有多个相同类型参数
func add(a, b int) {
	fmt.Println(a + b)
}

有参数无返回值,有多个相同类型参数，也有不同类型

package main

import "fmt"

// 调用
func main() {
	add(1, 1, "xl")
}

// 定义
//3 有参数无返回值,有多个相同类型参数，也有不同类型
func add(a, b int, msg string) {
	fmt.Println(a + b)
	fmt.Println(msg)
}

多个参数，一个返回值

package main

import "fmt"

// 调用
func main() {
	add(1, 1)
}

// 定义
//4 多个参数，一个返回值
func add(a, b int) int {
	fmt.Println(a + b)
	return a + b
}

多个参数，多个返回值

package main

import "fmt"

// 调用
func main() {
	a, b := add(1, 1)
	fmt.Println(a, b)
}

// 定义
//4 多个参数，多个返回值
func add(a, b int) (int, int) {
	return a + b, a
}

命名返回值

package main

import "fmt"

// 调用
func main() {
	a, b := add(1, 1)
	fmt.Println(a, b)
}

// 定义
//4 多个参数，多个返回值
func add(a, b int) (c int, d int) {
	c = a + b
	d = a * b
	return
}

多返回值时，忽略一个返回值

a,_:=add(3,4)
fmt.Println(a)
fmt.Println(_)


//4 多个参数，多个返回值
func add(a, b int) (int,int) {
	return a + b,a*b
}

匿名函数

package main

import "fmt"

// 调用
func main() {
	text()
}

//匿名函数(定义在函数内部的函数，不能是有名函数)，头等函数
func text() {
	var a func()
	a = func() {
		fmt.Println("我是匿名函数")
	}
	a()
}

函数返回值为函数

package main

import "fmt"

// 调用
func main() {
	a := text()
	fmt.Println(a)
}

// 定义
func text() func() {
	return func() {
	}

}

函数返回值为函数,返回的函数带参数

package main

import "fmt"

// 调用
func main() {
	a := text("xl")
	fmt.Println(a)
	a("xxl")
}

// 定义
func text(name string) func(msg string) {
	return func(msg string) {
		msg = name
		fmt.Println(msg)
	}

}

函数返回值为函数,返回的函数带参数,带返回值

package main

import "fmt"

// 调用
func main() {
	a := text()
	fmt.Println(a)
}

// 定义
//函数返回值为函数,返回的函数带参数,带返回值
func text() func(a, b int) int {
	return func(a, b int) int {
		return a + b
	}

}

函数参数为函数类型，返回值为带参数，带返回值的函数类型 

package main

import "fmt"

// 调用
func main() {
	a := text(func() {

	})
	fmt.Println(a)
	c, b := a(1, 2)
	fmt.Println(c, b)
}

// 定义
//函数参数为函数类型，返回值为带参数，带返回值的函数类型
func text(f func()) func(a, b int) (int, int) {
	return func(a, b int) (int, int) {
		f()
		return a + b, a * b
	}

}

 类型重命名

//类型重命名
var a MyFunc =test()
c,d:=a(1,2)
fmt.Println(c,d)


func test()MyFunc  {
	return func(a,b int)(int,string) {
		fmt.Println("xxx")
		return 10,"ok"
	}
}

8. 闭包函数

定义

1 定义在函数内部  
2 对外部作用域有引用
3 闭包函数就是多了一种函数传参的方法，包进去了

 案例

package main

import "fmt"

// 调用
func main() {
	text(18)()
}

// 定义
//函数参数为函数类型，返回值为带参数，带返回值的函数类型
func text(age int) func() {
	a := func() {
		fmt.Println(age)
	}
	return a
}

 9. 变量作用域范围

package main

import "fmt"

//在同一个包下，函数名不能重名
//var a int   //全局变量，全局有效，只要改了，就是改了
//func main() {
//	fmt.Println(a)  //0
//	a=19
//	fmt.Println(a) //19
//	test1()  //99
//	fmt.Println(a) //99
//}
//
//func test1()  {
//	a=99
//	fmt.Println(a)
//
//}


//变量的作用域范围

var a int   //全局变量，全局有效，只要改了，就是改了
func main() {
	var a int
	fmt.Println(a)  //0
	a=19
	fmt.Println(a) //19
	test1()  // 0
	fmt.Println(a) //19
}

func test1()  {
	fmt.Println(a)

}