Golang Study Notes_Design in 2022

欧尼焦

已于 2023-05-27 10:38:46 修改

阅读量927

点赞数

分类专栏： Golang 文章标签： golang

于 2022-11-19 00:35:37 首次发布

本文链接：https://blog.csdn.net/stange1/article/details/127857726

版权

Golang 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

注意
Chapter01：初始Golang
- 1.1 环境下载
- 1.2报错package awesomeProject is not in GOROOT
Chapter02: go语言入门
Chapter03 Golang 变量

注意

让我们开始：如果您已经掌握一门语言，且拥很高的学习能力，可以参考Golang 标准库 API 文档进行学习

Chapter01：初始Golang

1.1 环境下载

下载地址
在这里插入图片描述

1.2报错package awesomeProject is not in GOROOT

package awesomeProject is not in GOROOT (D:\mySoftware\myGo\Go\src\awesomeProject)

解决方法：

将GO111MODULE修改为off，在终端输入go env -w GO111MODULE=off

Chapter02: go语言入门

2.1 编写helloworld程序

package main

import "fmt" fmt提供格式化，输入输出的函数
func main()  {
	fmt.Println("hello.world")
	fmt.Println("hello.world")
	fmt.Println("hello.world")
}

2.2运行

2.2.1 使用go build编译成可执行的.exe文件运行

在这里插入图片描述

2.2.2 使用go run运行

在这里插入图片描述

2.3 go build编译运行与go run运行

2.3.1 执行流程分析

在这里插入图片描述

2.3.2 两种执行流程的方式区别

1) 如果我们先编译生成了可执行文件，那么我们可以将该可执行文件拷贝到没有 go 开发环境的机
器上，仍然可以运行
2) 如果我们是直接 go run go 源代码，那么如果要在另外一个机器上这么运行，也需要 go 开发
环境，否则无法执行。

2.4 Go 程序开发的注意事项

1、Go 方法由一条条语句构成，每个语句后不需要分号(Go 语言会在每行后自动加分号)
2、Go 语言严格区分大小写。 go 语言定义的变量或者 import 的包如果没有使用到，代码不能编译通过。
3、Go 应用程序的执行入口是 main()函数。这个是和其它编程语言（比如 java/c）
4、Go 编译器是一行行进行编译的，因此我们一行就写一条语句，不能把多条语句写在同一个，否
则报错

2.5 go语言转义字符

1) \t : 表示一个制表符，通常使用它可以排版。
2) \n ：换行符
3) \r ：一个回车

package main

import "fmt" //fmt提供格式化，输入输出的函数

func main() {
	fmt.Println("tom\tjack")
	fmt.Println("hello\nworld")
	fmt.Println("D:\\myAppDate\\goWorks\\src\\go_code\\project01\\main")
	fmt.Println("tom说 \"i love you\"")
	fmt.Println("天龙八部雪山飞狐\r张飞") // \r回车，从当前行的最前面开始输出，覆盖掉以前内容
}

/*
print:
tom	jack
hello
world
D:\myAppDate\goWorks\src\go_code\project01\main
tom说 "i love you"
 张飞
 */

2.6 Go 语言正确的代码风格.

package main
import "fmt"
func main() {
fmt.Println("hello,world!")
} 
/*
错误写法
func main()
{
	fmt.Println("hello,world!")
}

Chapter03 Golang 变量

3.1 解释

1) 变量 = 变量名+值+数据类型
2) 变量表示内存中的一个存储区域
3) 该区域有自己的名称（变量名）和类型（数据类型）
示意图：

3.2 程序入门

package main

import "fmt"
func main(){
	//定义变量/声明变量
	// 变量 = 变量名+值+数据类型
	var i int 
	//给i赋值
	i = 10
	//使用变量
	fmt.Println("i=",i)
}
//i= 10

3.3 Golang 变量使用的三种方式

package main
import "fmt"
func main(){
	//golang的变量使用方式1
	//第一种：指定变量类型，声明后若不赋值，使用默认值
	//int 的默认值是0，其他的数据类型的默认值后边介绍
	var i int
	fmt.Println("i=",i)

	//第二种，根据值自行判定变量类型(类型推导)
	var num = 10.11
	fmt.Println("num=",num)

	//第三种，省略var，注意 := 左侧的变量不应该是已经声明过的，否则会导致编译错误
	//下面的方式等价 var name string = ”tom“
	// := 的 :不能省略，否则错误
	name := "tom"
	fmt.Println("name=",name)
}
//i= 0
//num= 10.11
//name= tom

注意：“:= ”作用，根据值自行判定变量类型(类型推导)

3.4 多变量声明

package main

import "fmt"

//定义三全局变量
var n1 = 100
var n2 = 200
var name = "jack"
//上面的声明方式，也可以改写成一次性声明
/*
var (
	n1 = 100
	n2 = 200
	name = "jack"
)
*/

func main()  {

	//该案例演示golang如何一次性声明多个变量
	//var n1,n2,n3 int
	//fmt.Println("n1=",n1,"n2=",n2,"n3=",n3)

	//一次性声明多个变量的方式2
	//var n1,name,n3 = 100,"tom",888
	//fmt.Println("n1=",n1,"name=",name,"n3=",n3)
	//n1= 100 name= tom n3= 888

	//一次性声明多个变量的方式3，同样可以使用类型推导
	//n1,name,n3 := 100,"tom",888
	//fmt.Println("n1=",n1,"name=",name,"n3=",n3)
	//n1= 100 name= tom n3= 888

	//输出全局变量
	fmt.Println("n1=",n1,"name=",name,"n2=",n2)
	//n1= 100 name= jack n2= 200
}

3.5 变量相关说明

注意：变量在同一个作用域(在一个函数或者在代码块)内不能重名

package main

import "fmt"

//变量使用的注意事项
func main() {

	//该区域的数据值可以在同一类型范围内不断变化
	var i int = 10
	i = 30
	i = 50
	fmt.Println("i=",i)
	//i = 1.2 //int,原因是不能改变数据类型    报错！！！

	//变量在同一个作用域内不能重名
	//var i int = 29   重名
	//i := 99   重名

}

3.6 程序中 +号的使用

1) 当左右两边都是数值型时，则做加法运算
2) 当左右两边都是字符串，则做字符串拼接

package main

import "fmt"

func main() {
	var i = 1
	var j = 2
	var r = i + j //做加法运算
	fmt.Println("r=",r)

	var str1 = "hello"
	var str2 = "world"
	var res = str1 + str2 //做拼接运算
	fmt.Println("res=",res)

}
/*
：r= 3
res= helloworld
*/

3.7 数据类型的基本介绍

在这里插入图片描述

3.7.1 整数类型、int 的无符号的类型

package main

import (
	"fmt"
	"unsafe"
)

//演示golang中整数类型使用
func main() {
	var i int = 1
	fmt.Println("i=",i)

	//测试int8的范围
	//var j int8 = -129  //overflows:溢出
	//fmt.Println("j=",j)

	//测试uint8的范围(0~255)，其他16、32、64类推
	//var k uint = -1  //overflows:溢出
	//fmt.Println("k=",k)

	//int,uint,rune,byte的使用,不加符号就根据系统32位或者64位判断字节大小
	var a int = 8900
	fmt.Println("a=",a)
	var b uint = 1
	fmt.Println("b=",b)
	var c byte = 255
	fmt.Println("c=",c)

	//整型的使用细节
	var n1 = 100 //n1是什么类型？
	//这里给出一个方法
	//fmt.Print()方法，可以用作查看格式化输出
	fmt.Printf("n1的数据类型%T\n",n1)//:n1的数据类型int

	//如何在程序查看某个变量占用字节大小和数据类型 （使用较多）
	var n2 int64 = 120
	//unsafe.Sizeof(n1)是unsafe包的一个函数，可以返回n1变量占用的字节数
	fmt.Printf("n2的类型%T,n2占用的字节数%d",n2,unsafe.Sizeof(n1)) //:n2的类型int64,n2占用的字节数8

	//Golang 程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量
	//	//使用占用空间小的数据类型。【如：年龄】
	//如：var age byte = 90 1byte = 8bit

}

3.7.2 小数类型/浮点型

在这里插入图片描述

细节：
1) Golang 浮点类型有固定的范围和字段长度，不受具体 OS(操作系统)的影响。
2) Golang 的浮点型默认声明为 float64 类型

package main

import "fmt"

//演示golang中小数类型使用
func main() {
	var price float32 = 89.12
	fmt.Println("price=",price)
	var num1 float32 = -0.00000
	var num2 float64 = -154244.212156
	fmt.Println("num1=",num1,"num2=",num2)

	//尾数部分可能丢失，造成精度损失。 -123.0000901
	var num3 float32 = -123.0000901
	var num4 float64 = -123.0000901
	fmt.Println("num3=",num3,"num4=",num4) //:num3= -123.00009 num4= -123.0000901
	//说明：float64 的精度比 float32 的要准确.
	//说明：如果我们要保存一个精度高的数，则应该选用 float64

	//Golang 的浮点型默认声明为 float64 类型。
	var num5 = 1.1
	fmt.Printf("num5的数据类型是 %T\n",num5) //:num5的数据类型是 float64

	//十进制数形式：如：5.12 .512 (必须有小数点）
	num6 := 5.12
	num7 := .123
	fmt.Println("num6=",num6,"num7=",num7) //:num6= 5.12 num7= 0.123

	//科学计数法形式 := 表示类型推导
	num8 := 5.1234e2 //5.1234 * 10的2次方
	num9 := 5.1234E2 //5.1234 * 10的2次方
	num10 := 5.1234E-2 //5.1234 / 10的2次方
	fmt.Println("num8=",num8,"num9=",num9,"num10=",num10) //:num8= 512.34 num9= 512.34 num10= 0.051234
}

3.7.3 字符类型

细节:
字符常量是用单引号(‘’)括起来的单个字符。例如：var c1 byte = ‘a’ var c2 int = ‘中’ var c3
byte = ‘9’

字符类型本质探讨

字符型存储到计算机中，需要将字符对应的码值（整数）找出来
存储：字符—>对应码值---->二进制–>存储
读取：二进制----> 码值 ----> 字符 --> 读取
字符和码值的对应关系是通过字符编码表决定的(是规定好)
Go 语言的编码都统一成了 utf-8。非常的方便，很统一，再也没有编码乱码的困扰了

package main

import "fmt"

//演示golang中字符类型使用
func main() {
	var c1 byte = 'a'
	var c2 byte = '0'

//当我们直接输出byte(0~255)，就会输出其对应的字符码值
	fmt.Println("c1=",c1,"c2=",c2) //:c1= 97 c2= 48
	//如果我们希望输出对应字符，使用格式化输出 fmt.printf()
	fmt.Printf("c1=%c c2=%c\n",c1,c2) //:c1=a c2=0

	//var c3 byte = '北' //:overflows 溢出
	var c3 int = '北' //:overflows 溢出
	fmt.Printf("c3对应的码值%d\n",c3)
	fmt.Printf("c3=%c\n",c3)

	//字符类型是可以进行运算的，相当于一个整数，因为它都对应有 Unicode 码
	//字符常量是用单引号('')括起来的单个字符。例如：var c1 byte = 'a' var c2 int = '中' var c3 byte = '9'
	var c4 = 'a'
	fmt.Printf("a的码值=%d\n",c4)
	var c5 = 10 + 'a'
	fmt.Println("c5=",c5)

	/*
	%d 查看码值
	%T 查看数据类型
	%c 格式化输出(如输出中文，字母等)
	 unsafe.Sizeof()查看占用大小
	*/
}

3.7.4 布尔类型

介绍：

布尔类型也叫 bool 类型，bool 类型数据只允许取值 true 和 false
bool 类型占 1 个字节。
bool 类型适于逻辑运算

package main

import (
	"fmt"
	"unsafe"
)

//演示golang中小bool类型使用
func main() {
	var b = false
	fmt.Println("b=",b)
	//注意事项
	//bool 类型占 1 个字节
	fmt.Println("b的占用空间=",unsafe.Sizeof(b))

	//bool 类型数据只允许取值 true 和 false
	//b = 1 错误 只允许取值 true 和 false
}

3.7.5 string 类型

注意:

Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本，这样 Golang 统一使用 UTF-8 编码,中文
乱码问题不会再困扰程序员。
字符串一旦赋值了，字符串就不能修改了：在 Go 中字符串是不可变的。

package main

import "fmt"

//演示golang中string类型使用
func main() {
	//string的基本使用
	var address string = "北京长城 hello,world\n"
	fmt.Println(address) //:北京长城 hello,world

	//字符串一旦赋值了，字符串就不能修改了：在 Go 中字符串是不可变的
	//var str = "hello"
	//str[0] = 'a' //:cannot assign to str[0] (value of type byte)不能去修改str的内容，go中的字符串是不可变的

	//字符串的两种表示形式
	//(1) 双引号, 会识别转义字符
	//(2) 反引号  ``  ，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果
	str2 := "abc\nabc"
	fmt.Println(str2)

	//
	str3 :=`
	package main
	
	import "fmt"
	func main(){
		//定义变量/声明变量
		var i int
		//给i赋值
		i = 10
		//使用变量
		fmt.Println("i=",i)
	}	
	`
	fmt.Println(str3)

	//字符串拼接方式
	var str = "hello" + "world"
	str += "haha"
	fmt.Println(str)

	//当一行字符串太长时，需要使用到多行字符串，需要将+保存到上一行
	var str4 = "hello" + "hello" + "hello" + "hello" +
		"hello" + "hello" +"hello" +
		"hello" +"hello" +
		"hello"
	fmt.Println(str4)

	var a int //0
	var b float32 //0
	var c float64 //0
	var isMarried bool // false
	var name string //""
	fmt.Printf("a=%v,b=%v,c=%v,isMarried=%v,name=%v",a,b,c,isMarried,name) //：a=0,b=0,c=0,isMarried=false,name=“”
	/*
	%d 查看码值
	%T 查看数据类型
	%c 格式化输出(如输出中文，字母等)
	 unsafe.Sizeof()查看占用大小
	%v 按照变量的值输出
	*/
}

3.8 基本数据类型的默认值

在 go 中，数据类型都有一个默认值，当程序员没有赋值时，就会保留默认值，在 go 中，默认值
又叫零值。

3.9 基本数据类型的相互转换

注意：
Golang 和 java / c 不同，Go 在不同类型的变量之间赋值时需要显式转换。也就是说 Golang 中数
据类型不能自动转换。
Go 中，数据类型的转换可以是从表示范围小–>表示范围大，也可以范围大—>范围小
被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化！

3.9.1 案例演示

package main

import "fmt"

//演示golang中基本类型转换
func main() {
	var i int = 100
	//希望将i => float
	var n1 float32 = float32(i)
	var n2 int8 = int8(i)
	var n3 int64 = int64(i) //低精度->高精度
	fmt.Printf("i=%v n1=%v n2=%v n3=%v\n",i,n1,n2,n3)

	//被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化！
	//只是转换的结果是按溢出处理，和我们希望的结果不一样，因此转换的过程需要考虑范围
	//占大个内存不能转换成小的，不能强转
	var num1 int64 = 99999
	var num2 int8 = int8(num1)
	fmt.Println("num2=",num2)
	/*
	%d 查看码值
	%T 查看数据类型
	%c 格式化输出(如输出中文，字母等)
	 unsafe.Sizeof()查看占用大小
	%v 按照变量的值输出
	*/
}

3.9.2 课堂练习

package main

import "fmt"

func main() {

	//课堂练习
	//var n1 int32 = 12
	//var n2 int64
	//var n3 int8
	//n2 = n1 + 20 //int32-->int64 错误
	//n3 = n1 + 20 //int32-->int8 错误
	/* 正确表述
	n2 = int64(n1) + 20
	n3 = int8(n1) + 20
	fmt.Println("n2=",n2,"n3=",n3)
	 */

	var n1 int32 = 12
	//var n3 int8
	var n4 int8
	n4 = int8(n1) + 127 //编译通过，结果会溢出 -117
	//n3 = int8(n1) + 128 //编译不通过，128超出n3范围
	fmt.Println(n4)
}