go快速入门

2022.3.27

Go速速复习通关

开发环境

搭建语言环境

Windows安装

1.4之前需要配置GOPATH,之后啥都不需要配置
下载安装目录：https://golang.google.cn/dl/

安装过程：除了路径找个自己熟悉的专门的地方，其他的都next

验证：

打开cmd（或者powershell))

go version
//出现对应的版本号就是安装好了

开发编辑器

1. goland
2. vs code

因为比较小白，这里就不说怎么下载安装了

hello world

现在就可以编写第一个go程序了__经典的hello world

1. 在桌面（或者一个你找的到地方新建一个文件夹haha）

2. 在这个文件夹右键—打开powershell

3. 一个go程序先要建立mod，所以要go mod init haha—然后就出现了go.mod这个文件

4. 接着创建一个文本文档，后缀改一下，例如hello.go,记事本（或者编辑器）打开，写程序如下

   package main
   
   import "fmt"
   
   func main() {
   
   	fmt.Println("hello,世界")
   
   }
   

5. 保存，在终端输入go run hello.go就成功了

图示：

扩展：

也可以不go run hello.go

而是在写完成程序后go build hello.go生成一个二进制.exe文件

接着就会出现一个hello.exe文件

直接在黑窗口（终端）运行 ./hello.exe(或者hello.exe)就可以了

区别：

配置包相关的配置
PS C:\Users\jingz\Desktop\hello> go install

go run临时编译并执行，不会留下.exe文件
PS C:\Users\jingz\Desktop\hello> go run main.go
hello world!

go build会构建.exe的二进制文件
PS C:\Users\jingz\Desktop\hello> go build main.go
运行.exe文件
PS C:\Users\jingz\Desktop\hello> ./main.exe
hello world!

Go语言基础

Go编程基础

25个内置关键字

break default func interface select

case defer go map struct

chan else goto package switch

const fall through if range type

continue for import return var

注释

和java一样

//单行注释
/*多行注释*/

包

package main （main包必须是第一行，只有一个main包）包组织管理

fmt包自动格式化代码

包别名：
import std "fmt"
省略调用：
import . "fmt"//不建议使用

可见性规则

使用大小写决定该常量，变量，类型，接口，结构或者函数是否可以背外部调用

函数名首字母小写—包内部，函数名首字母大写—全局调用

简写

const (
	PI = 3.14
	const1 = 3
)
var (//只在全局变量中
	name1 = "jingzhi帅"
	name2 = "jingyu帅"
)
type (
	newType int
	type1 float32
)

类型

Go基本类型

• 布尔型：bool（1字节，不可以用数字代表true和false）
• 整形int/uint（根据平台，32或64位）
  • int8/uint8
  • int16/uint16
  • int32/uint32(rune)
  • int64/uint64
  • uintptr—无符号整型，用于存放一个指针
  • uint或者int后不加数字—和电脑系统位数一致，一般是64位
  • u代表无符号
• 浮点型：float32/float64
• 字节型：byte(uint8的别名)
• 复数：complex64/complex128
• 足够保存指针的32位或64位整数型：uintptr
• 其他值类型：array,struct,string
• 引用类型：slice.map.channel(通道)
• 接口类型：inteface
• 函数类型func

//整形
fmt.Printf("%d \n", a)
//浮点型
fmt.Printf("%。2f\n", math.Pi)
//复数
//complex64的实部和虚部为32位，complex128的实部和虚部为64位。
	var c1 complex64
	c1 = 1 + 2i
	var c2 complex128
	c2 = 2 + 3i
	fmt.Println(c1)
	fmt.Println(c2)

字符串常用操作

1. len() //求长度
2. +拼接字符串
3. strings.Split分割

字符型

• uint8类型，或者叫byte型，代表了ASCII码的一个字符
• rune类型，代表一个UTF-8字符—处理中文等复合字符

类型零值

false 0 null 空 [] (懂得都懂)

类型转换

和java差不多一样

var a float32 = 1.1
b := int(a)

变量与常量

变量

Go语言的变量声明后必须使用

单个

声明：var 变量名 变量类型

赋值：变量名 = 表达式

同时：var 变量名 变量类型 = 表达式

var a int = 1

多个

全局变量声明可以用var()简写—不可以省略var

所有变量都可以用类型推断

局部变量不可以用var()简写，只能并行写

var a,b,c,d (int) = 1,2,3,4
a,b,c,d := 1,2,3,4
a,_,c,d := 1,2,3,4//赋值忽略

短变量

 //短变量声明 在函数内部，可以使用更简略的 := 方式声明并初始化变量。
//最简方式：
a := 1   

注意事项：

1. 函数外的每个语句都必须以关键字开始（var、const、func等）
2. :=不能使用在函数外。
3. _多用于占位，表示忽略值

常量

与java相同，go中也是推荐大写的

声明：const 变量名 变量类型

赋值：变量名 = 表达式

同时：const 变量名 变量类型 = 表达式

批量

const(
	a = 1
	b//默认赋值上边的，和上边一样1
	c
)

iota计数器，从零开始，组中 每定义一个常量就递增1

每遇到一个const就重置

iota

• 常量计数器
• const中每新增一行常量声明将使iota计数一次

const (
		n1 = iota //0
		n2        //1
		n3        //2
		n4        //3
	)

运算符

运算符

从左到右，优先级从高到低

• 一元 ^ !
• 二元 * / % << >> & &^ + - | ^ == != < <= >= > <- && ||

把10进制转化为二进制，再进行运算，在转化为10进制

^只有一个是1时为1

&^，第二个为1时，强制改第一个为1，否则不改，取第一个

1 << 10 //1左移10位代表—>0001的1左移10位，为二进制的1000000000，为10进制的2^10==1024

指针

&取变量地址，*访问目标对象，默认值nil

a ;= 1
var p = &a
fmt.Print(*p)

++

++ --和java不一样，在go中作为语句不是表达式

a ;= a++   //错
a++        //对

练习：

有一堆数字，如果除了一个数字以外，其他数字都出现了两次，那么如何找到出现一次的数字？

package main

import "fmt"

func main()  {
	b := []int{1,2,2,3,3}
	a := 0
	for _, i := range b {
		a ^= i
	}
	fmt.Println(a)
}
/*
	举个例子就懂了，
	a^a^c^c^d^d^t = t
	1.异或运算满足交换律
	2.先把每一个变量转化为二进制，然后比较每一位，一旦有一个不一样，就等于它赋值给a
	3.如此但凡有两个一样的都可以消去，最后就只剩下一个只出现一次的
	4.时间复杂度o(1)
*/

流程控制

循环结构

for

go只有这一种循环结构

这一部分极其类似java，跳过

条件不需要括号，代码块需要{}

for 初始语句;条件表达式;结束语句{
    循环体语句
}

• 初始值可以省略，；不可省略
• 当初始值和结束语句都省略时，就都不需要;
• 退出语句，break goto return panic

for range键值循环

package main

import "fmt"

func main()  {
	b := []int{1,2,2,3,3}
	a := 0
	for _, i := range b {
		a ^= i
	}
	fmt.Println(a)
}

---

分支结构

if else

if a := 1 表达式1 {
    分支1
} else if 表达式2 {
    分支2
} else{
    分支3
}

switch case

Go	java
自动带有break,一旦满足条件就跳出，除非加fallthrough 同样的不满足条件就会自动往下走	会自动往下执行语句，break跳出
判断条件不加()	判断条件加()

func main() {
	switch n := 7; n {
	case 1, 3, 5, 7, 9:
		fmt.Println("奇数")
	case 2, 4, 6, 8:
		fmt.Println("偶数")
	default:
		fmt.Println(n)
	}
}

跳转语句

goto//不一定跳出循环，调整执行顺序，简单说就时跳到指定标签

break//跳出当前循环

continue //跳出本次循环，进入下次循环

层级关系lable:

数组

一维数组

声明：
var a [3]int//同时也是赋值为0值
声明+赋值：
方法一
var a [2]int{1,3}
var a =  [3]int{1,7}
方法二
var a = [...]int{1,2,3,4}//长度推断，自动判断长度
var a = [...]int{17: 7}

数组长度是常量,[3]int 和 [7]int是不同的类型

遍历：

	var a = [...]int{1,2,3,4}
	fmt.Println(a)
	//第一种
	for i := 0; i < len(a); i++ {
		fmt.Print(a[i] )
	}
	fmt.Println()
	//第二种
	for k, v := range a {//k代表索引，v代表值
		fmt.Println(k,v)
	}

二维/多维数组

//定义：
func main() {
	a := [3][2]string{
		{"北京", "上海"},
		{"广州", "深圳"},
		{"成都", "重庆"},
	}
	fmt.Println(a) //[[北京 上海] [广州 深圳] [成都 重庆]]
	fmt.Println(a[2][1]) //支持索引取值:重庆
}
//遍历
func main() {
	a := [3][2]string{
		{"北京", "上海"},
		{"广州", "深圳"},
		{"成都", "重庆"},
	}
	for _, v1 := range a {
		for _, v2 := range v1 {
			fmt.Printf("%s\t", v2)
		}
		fmt.Println()
	}
}
//-------------借用李文周博客例子-----------------

注意:多维数组只有第一层可以使用...来让编译器推导数组长度

• 可以使用==和!!= (数组类型相同时)
• 数组指针 * [n]T ，指针数组 [n]*T
• 数组是值类型，可以作为参数，返回值

var a = [...]int{17: 7}
var p *[18]int = &a
a := [...]*int{&x,&y}

---