学习go语言的一些笔记(一)

1 go语言的环境搭建

1.1 安装go

直接官网下载 msi文件，双击安装，全部19.1 版本的环境自己配好的，不用额外的进行配置，需要自定义配置的可以自行百度一下哦！

// 输入 go version 查看go是否安装成功
go version go1.19.1 windows/amd64   // 出现本本好就是安装成功

1.2 go的开发工具

我用的是Goland感觉很好用，具体的安装可以进行百度

1.2.1 配置国内代理和开发GOROOT选择

setting - > Go -> GOROOT 选择你的安装的go环境

setting - > Go -> Go Modules

GOPROXY=https://goproxy.cn,direct    // 国内代理进行配置

2 go进行包管理

通过goland 创建的项目一般，项目目录下面有一个 go.mod 文件
如果没有需要使用命令创建一个包管理文件

2.1 创建包管理文件

go mod init 项目名
// 会自动生成一个包管理的文件

2.2 运行go文件

2.2.1 命令运行

// 使用 go run   xxx.go


// 下载第三方包 go get 包名

2.2.2 编辑器右键运行

2.2.3 打包go文件为exe文件

go build xxx.go 
// 生成以恶个可执行文件

2.2.4 第一个Go文件

package main
// 包名

// 使用的包导入
import "fmt"
// 主函数
func main() {
	fmt.Println("Hello world!")
}

3 注释和转移字符

3.1 注释

单行注释    // 注释内容      -- 更推荐
多行注释		/* 注释的内容 */

快捷注释的方式    ctrl + /     win+GoLand上的快捷键

3.2 转义字符

go 语言的字符串是使用的是双引号来表示的，如果你想输出的内容是文本是 “hello world!” 格式的话

fmt.Println(""hello world"")   会报错

fmt.Println("hello world")   // 输出结果是 hello world

// 错误原因是特殊的字符会被 go语言自动转义，

fmt.Println("\"hello world\"")   // 正确 

\"  表示 \后面的" 灰灰被转移 会被原样输出

当然 也可以使用 `` 的形式输出，这表示 被包裹的数据会原样输出
fmt.Println(`"hello world"`)

3.2.1 其他常见的转义字符

符号	表示
"	双引号
\	反斜线
\a	报警声
\b	退格
\f	换页
\n	换行
\r	回车替换
\v	垂直制表符
\t	制表符

3.2.2 格式化字符串在使用fmt中的Println的时候，有没有发现除了这个函数，还有好几个函数

Print 函数直接输出内容
Printf 格式化输出字符串
Println 会在输出内容的结尾添加一个换行符
Printf和Println是用到最多的输出

符号	表示
%v	按值的本来值输出
%+v	在 %v 基础上，对结构体字段名和值进行展开
%#v	输出 Go 语言语法格式的值
%T	输出 Go 语言语法格式的类型和值
%%	输出 % 本体
%b（oOdxX）	整型的不同进制方式显示
%U	Unicode 字符
%s	字符串
%d	整数
%f	浮点数
%p	指针，十六进制方式显示

4 变量和常量

4.1 变量

一个变化的量，可以只用来表示一个固定或不固定的数据，相当于一个数据的名字
go语言中定义一个变量 使用关键字 var

// 格式 var 变量名称 类型 = 数值
var name string = "Tom"  // 定义一个变量为 name,存储的数据是：Tom,类型是：string(字符串)

// 变量的定义分为 1 声明变量   2 变量赋值
// 1 声明变量   之定义一个变量的名称和类型
var name string
// 2 变量赋值 给指定的变量赋值为固定的数据
name = "Tom"

4.1.1 定义变量的方法

1 先声明,再赋值

var name string
name = "Tom"

2 声明并复制

var name string ="Tom"

3 类型推断 变量的类型会由后面赋值数据的类型决定

var name ="Tom"

4 简短定义

格式   变量名:= 变量值
name:="Tom"

4.1.2 变量的统一声明和定义

多个变量一块定义和声明

格式：  var(
	变量名 类型 = 变量值  // 变量值和类型都是可有可无的
)

var(
	name string = "tom"
	age = 10
	likes string
)

4.1.3 匿名变量

匿名变量就是，没有名字的变量直接定义，但是可以不是不使用，一般用于接收返回值数据
匿名变量用"_" 表示，可以有多个

_, name, _ := 10000, "Tom", 100
// 也可以这样定义多个变量

4.1.4 变量的说明

1 在go语言中，变量定义后一定要使用，不然会报错
2 _  匿名变量可以有多个
3 用以个变量名被定义过之后可以重新赋值，但是不能重新定义
4 每个类型的变量都会由一个默认值 ps： int --> 0  string  --> "" ...

4.2 常量

常量：定义后不能被修改的量，使用关键字 const 定义 一般为大写

格式： const 名称 类型 = 值    常量必须由给定数值，不然就是默认值
const  MAXNUM int = 1000
const USERNAME ="Tom Cat"

4.2.1 定义常量

批量定义常量和批量定义变量相同

格式: const(
	MAXAGE int = 888
	YOURNAME string = "Tom"
	AGE int
)

4.3 全局变量

全局变量：一般是定义在函数的外面的变量 声明为全局变量后，这个变量不使用也不会报错

4.4 全局跨包变量

是定义的全局变量，且跨包使用，一般定义的格式是（首字母大写）

package version

var (
  Version int  = 2
)

// 使用的时候需要进行引用
// 通过包名.变量名进行使用

package main

import (
  "fmt"
  "go_study/version"
)

func main() {
  fmt.Println(version.Version)
}

4.4 iota

相当于一个常量的计数器，当定义一个iota的时候，他会根据数据的定义个数进行变大

const (
  a int = iota
  b     = 2
  c     = iota
  d     = iota
  e     = 1
  f     = iota
)
fmt.Println(a, b, c, d, e, f)
// 0 2 2 3 1 5
const (
  g = iota
  h = iota
)
fmt.Println(g, h)
// 0 1

5 基本数据类型

• 整数型 int(X) uint(X)
• 浮点型 float(X)
• 字符串型 多个字符的集合
• 字符型 byte rune
• 布尔型 false true

5.1 数据存储基础

Golang中所有的值类型变量常量都会在声明时被分配内存空间并赋予默认值

类型	默认值
数字类型	0
布尔类型	false
字符串	”“ 空串

bit：比特，二进制中的最小单位，表示数据的一位
byte：字节， 1byte =8bit

0	1	0	0	1	1	1	1

5.2 整数类型

整数类型分为 有符数（int）和无符数（uint）
根据表达的数据范围和使用的bi位不同又又不同的数据
无符号数：所有位置都用来存储数据
有符号数：第一位用于存储符号剩下的位置用于存储数据

有符号	范围	无符号	范围
int8	-128~127	uint8	0~255
int16	-32768 ~ 32767	uint16	0~65535
int32		uint32
int64		uint64
int (32/64)		uint (32/64)

int 和uint 的长度不写一般根据操作系统姊姊确定 32/64

decimal：十进制，无需前缀

binary: 二进制，前缀0b、0B

octal：八进制，前缀0o、0O

hexadecimal：十六进制，前缀0X、0x

5.3 浮点数

浮点数只有两种 默认是双精度

• float32 单精度(小数点6位)
• float64 双精度(小数点15位)

// 定义
var f1 flaot32 =25.25568
var f2 float64 = 254.45666455555
f := 1.2556

5.4 字符型

go语言中没有char类型的数据，字符型数据用 相对应的无符号位的整形数据表示

• byte：uint8的别名 表示ascil码的相对应数值
• rune：uint32 的别名 一般用于存储中文 4 byte = 32 bit
  存储的时候时间上是存储的是一个int类型的数

var(
	data1  byte = 65
	data2 rune = '国'
)

// 使用%c 来输出指定的字符表示的数据

5.5 布尔类型

布尔类型分别表示的是真和假
bool 的 默认值是 false

• 真 true
• 假 false

5.6 字符串

字符串实际上是一组，字符的结合，按照一定的顺序排列

// 默认值是 "" 
var str string = "Tom and you"
str2:="hello world!"

5.7 常见的函数

• reflect.TypeOf(aaa) 查看变量的类型 也可以用 %T 查看
• len(str) 查看字符串的长度

5.8 数据类型

• 数字型
• 字符串
• 数组
• 切片
• 指针
• 函数
• 结构体
• 接口
• 通道
• map

6 运算符

• 算术运算符
• 关系运算符
• 赋值运算符
• 逻辑运算符
• 位运算符
• 地址运算符

6.1 算术运算符

符号	作用
+	两数相加 a+b
-	两数相减 a-b
*	两数相乘 a*b
/	两数相除 a*b
%	求余 a%b
++	自增 a++
–	自减 a–

go语言中没有 ** 运算符表示数据的次方
而且 ++ ，和 – 运算符只能用于 a++ √ ++a ×

6.2 关系运算符

也叫比较运算符，是对两个变量进行比较的符号

符号	表示
>	大于
<	小于
>=	大于等于
<=	小于等于
==	等于
!=	不等于

6.1 赋值运算符

对数据变量进行赋值运算的符号

符号	表示
=	赋值 a=10 给a赋值位10
+=	赋值 a+=10 相当于 a=a+0
-=	赋值 a-=10 相当于a=a-10
*=	赋值 a*=10 相当于a=a*0
/=	赋值 a=10 相当于 a=a/10
%=	赋值 a=10 相当于 a=a%10

6.1 逻辑运算符

表示数据在进行逻辑运算

符号	表示
&&	且 两边都为真 结果为真
||	或 两边张子尧一个为真 结果就为真
！	非 符号后面的逻辑取反

6.1 位运算符

位运算符表示的是 两个数按照其二进制的形式进行运算

符号	表示
&	与 相同位置都为 1 结果才为 1
\	或 相同的位置 有一个是 1 结果就为 1
^	异或 相同的位置上 数据i相同 为 1 不同为 0

6.1 地址运算符

符号	表示
&	取地址 表示取一个数据的存储地址
*	取值 表示作用于一个地址，得到该地址的数据

7 判断语句

7.1 if 判断语句

使用if判断语句进行分支的数据判断

格式：
	if 表达式{
		.....
	}else if 表达式{
		...
	}.... else{
		...
	}
// 使用的时候和python的格式基本一致，else if 和else 都能省略

测试

if age < 14 {
		fmt.Println("你还是一个小孩子")
	} else if age > 14 && age < 18 {
		fmt.Println("你已经不小了，但是还未成年")
	} else {
		fmt.Println("你现在是一个大人了")
	}

7.2 switch分支语句

可以个据情况设计switch分支语句

格式： 默认是有一个break 进行数据完成后的返回
switch 表达式{
	case 表达式:
		...
	....
	default:
		....
}

测试

jijie := "秋"
	switch jijie {
	case "春":
		fmt.Println("现在是春天")
	case "夏":
		fmt.Println("现在是夏天")
	case "秋":
		fmt.Println("现在是秋天")
	case "冬":
		fmt.Println("现在是冬天")
	default:
		fmt.Println("啥都不是！")
	}

8 循环语句

go中循环语句只有一种，那就是 for循环

格式：
for 表达式{
	...
}

根据表达式的不同可以分为

• 无限循环
• 条件循环
• 标准循环

8.1 无限循环

// 无限循环 : 没有表达式  程序会一直执行下去

for{
	循环内容
}

8.2 条件循环

// 条件循环： 循环条件是一个 条件 历任 a > 3 ...
for a>3{
	循环内容
}

标准循环

// 标准循环 是值使用标准的循环表达式是
for 表达式1;表达式2;表达式3{
	....
}
// 当然表达式可以按需求省略
for i:=1;i<=10;i++{
	fmt.Println("打印下循环")
}
// 打印10次数据  打印下循环

9 lable 和 goto

9.1 lable

labe 是给某一个程序中打赏一个固定的标记 配合 goto 执行跳转执行到某个位置的代码
lable的名字可以随意命名：cat1,daog… 都行

package main

import "fmt"

func main() {
name:
	fmt.Println("aaaaaaaaaaaaaaa")
	fmt.Println("asdasdasda")
	fmt.Println("adadasdadqrcac")
	fmt.Println("sdasdasda aaaaaa")
sex:
	fmt.Println("aaaaaaaaagfasdgfsaaaaaa")
	fmt.Println("jgfdfds")
	fmt.Println("ghtywe")
}

9.2 goto

指定跳转的某个lable位置去执行代码

package main

import (
	"fmt"
)

func main() {
	goto sex

name:
	fmt.Println("aaaaaaaaaaaaaaa")
	fmt.Println("asdasdasda")
	fmt.Println("adadasdadqrcac")
	fmt.Println("sdasdasda aaaaaa")
	return
sex:
	fmt.Println("aaaaaaaaagfasdgfsaaaaaa")
	fmt.Println("jgfdfds")
	fmt.Println("ghtywe")
	goto name
}

// 程序执行孙旭
goto  sex ---> 执行sex下面的语句   ---> goto name --->  打印name下面的语句 ----> return 推出程序

// 结果
aaaaaaaaagfasdgfsaaaaaa
jgfdfds
ghtywe
aaaaaaaaaaaaaaa
asdasdasda
adadasdadqrcac
sdasdasda aaaaaa

9.3 break和continue

break 跳出整个当前层次循环
continue 根据条件跳出某次符合条件的循环