侧边栏壁纸
博主头像
枕头下放双臭袜子博主等级

今我何功德,曾不事农桑

  • 累计撰写 166 篇文章
  • 累计创建 32 个标签
  • 累计收到 0 条评论

Golang学习笔记

枕头下放双臭袜子
2021-08-24 / 0 评论 / 0 点赞 / 391 阅读 / 20,062 字 / 正在检测是否收录...

0、vs code小技巧

0.1 vs code 调试报错go.mod file not found in current directory or any parent directory; see 'go help modules'

( 前提vscode已经创建编辑好了调试所需的launch.json文件 )在IDE软件选择调试模式的时候,这个报错是因为当前go文件所在目录或上级目录中缺少go.mod文件,终端进入当前目录,使用go mod init 文件/文件夹名即可解决问题

0.2 vs code调试按钮介绍

vscode_debug_button.png

1、变量

package main

import "fmt"

// 单个声明变量
var name string
var age int
var city string = "北京"

// 批量声明
var (
	school string
	height int
)
var company, org string

// 单一常量声明
const name66 = "zhijb"

// 批量常量声明
const (
	webName = "ishells"
	pi      = 3.141592
)

// 同时声明多个常量时,如果省略了值则表示和上面一行的值相同
const (
	n1 = 100
	n2
	n3
)

// iota
const (
	iota_1 = iota // 0
	iota_2        // 1
	iota_3        // 2
)

// iota在const关键字出现时被重置为0 const中每新增一行常量声明将使iota计数一次(即值+1)
// 使用 _ 匿名变量跳过iota的值
const (
	iota_4 = iota // 0
	iota_5        // 1
	_             // 2,匿名变量不保存,丢弃2
	iota_6        // 3
)

const (
	iota_7 = iota // 0
	num    = 100  // 100
	iota_8 = iota // 2
	iota_9        // 3
)

/*
	定义数量级 (这里的<<表示左移操作,
	1<<10表示将1的二进制表示向左移10位,也就是由1变成了10000000000,也就是十进制的1024。
	同理2<<2表示将2的二进制表示向左移2位,也就是由10变成了1000,也就是十进制的8。)
*/
const (
	_  = iota             // 0,匿名变量丢弃
	KB = 1 << (10 * iota) // 1左移10位,变成二进制10000000000,十进制1024
	MB = 1 << (10 * iota)
	GB = 1 << (10 * iota)
	TB = 1 << (10 * iota)
	PB = 1 << (10 * iota)
)

// 多个iota定义在一行
const (
	a, b = iota + 1, iota + 2 //1, 2
	c, d = iota + 1, iota + 2 //c=1+1,d=1+2
	e, f                      //3,4
)
const (
	g, h = iota, iota
	i, j // 1,1
)

func main() {

	// var sex string
	// 初始化变量
	// name = "zhijb"
	// age = 88
	// school = "xcu"
	// height = 170
	fmt.Println("hello world")
	// fmt.Print(name)                   // 直接打印输出
	// fmt.Println("school is" + school) // 输出后换行
	// fmt.Printf("age is: %d", age)     // 格式化输出

	fmt.Println("n1: ", n1)
	fmt.Println("n2: ", n2)
	fmt.Println("n3: ", n3)

	fmt.Println("iota_1: ", iota_1)
	fmt.Println("iota_2: ", iota_2)
	fmt.Println("iota_3: ", iota_3)

	fmt.Println("iota_4: ", iota_4)
	fmt.Println("iota_5: ", iota_5)
	fmt.Println("iota_6: ", iota_6)

	fmt.Println("iota_7: ", iota_7)
	fmt.Println("iota_8: ", iota_8)
	fmt.Println("iota_9: ", iota_9)
	fmt.Println("KB: ", KB)
	fmt.Println("MB: ", MB)
	fmt.Println("GB: ", GB)
	fmt.Println("TB: ", TB)
	fmt.Println("PB: ", PB)

	fmt.Println("i: ", i)
	fmt.Println("j: ", j)

}

/*
    0、函数外只能放置标识符(变量、常量、函数、类型)的声明,不能放置任何语句
    // 程序的入口函数
   		func main(){
       		fmt.Println("Hello world")
   		}

	// 变量
		单变量声明:
		第一种,指定变量类型,如果没有初始化,则变量值为该类型默认值
		var v_name v_type
		v_name = value
		第二种,根据值自行判断变量类型
		var v_name = value
		第三种,省略var,使用 :=   (这种方式只能用在函数内部)
		v_name := value


		多变量非全局变量声明:
		var vname1, vname2, vname3 v_type
		vname1, vname2, vname3 = v1, v2, v3

		var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型,自动推断
		vname1, vname2, vname3 := v1, v2, v3

		多变量全局变量声明:
		var(
			v_name1 v_type1
			v_name2 v_type2
		)

		1、 GO语言中的变量需要先声明才能使用,
			声明变量时需要指定变量类型,
			不像Python之类的解释性语言可以直接使用变量

		2、变量声明时,如果没有进行初始化,会自动对变量对应内存区域执行初始化操作
			例如:
			整型和浮点型变量的默认值为 0
			字符串型变量的默认值为 空字符串
			布尔型变量的默认值为 false
			切片、函数、指针变量的默认为	nil

		3、同一作用域内不支持变量的重复声明

		4、匿名变量:
			在使用多重赋值时,如果想要忽略某个值,可以使用匿名变量,匿名变量用一个下划线_表示
			匿名变量不占用命名空间,不会分配内存,所以匿名变量之间不存在重复声明。


	// 常量
		1、常量就是恒定不变的值,多用于定义程序运行期间不会改变的那些值。
		  常量的声明和变量的声明非常相似,关键字是 const
		  常量定义时必须赋值,定义之后不能重复赋值

		2、常量批量定义
		批量定义时,如果未给定值,与上一行保持一致
		const(
			n1 = 100
			n2		// 100
			n3		// 100
		)

		iota:
			iota是go语言的常量计数器,只能在常量的表达式中使用
			iota在const关键字出现时被重置为0,在const中每新增一行常量声明将使iota计数一次(即值+1)
		例:

*/

/*
	变量声明易错点:
		1、变量声明后未使用
		2、变量类型不匹配
		3、同一作用域下,变量只能声明一次
*/

2、数据类型

package main

import (
	"fmt"
	"math"
	"strings"
	"unicode/utf8"
)

func main() {
	// 1、整型
	/*
		整型分为以下两个大类:
			按长度分为:int8、int16、int32、int64
			对应无符号整型:uint8、uint16、uint32、uint64

			uint8	无符号 8位整型 (0 到 255)
			uint16	无符号 16位整型 (0 到 65535)
			uint32	无符号 32位整型 (0 到 4294967295)
			uint64	无符号 64位整型 (0 到 18446744073709551615)
			int8	有符号 8位整型 (-128 到 127)
			int16	有符号 16位整型 (-32768 到 32767)
			int32	有符号 32位整型 (-2147483648 到 2147483647)
			int64	有符号 64位整型 (-9223372036854775808 到 9223372036854775807)

			uint	32位操作系统上就是uint32,64位操作系统上就是uint64
			int		32位操作系统上就是int32,64位操作系统上就是int64
			uintptr	无符号整型,用于存放一个指针
	*/
	//  %d	十进制
	//	%b	二进制
	//	%o	八进制
	//	%ox	十六进制
	//  %T	显示数据类型

	// 2、浮点型
	/*
		Go语言支持两种浮点型数:float32和float64。
		float32 的浮点数的最大范围约为 3.4e38,可以使用常量定义:math.MaxFloat32
		float64 的浮点数的最大范围约为 1.8e308,可以使用一个常量定义:math.MaxFloat64
	*/
	fmt.Printf("保留两位小数的pi值: %.2f\n", math.Pi)

	// 3、布尔值
	// go语言以 bool 类型进行声明布尔型数据,只有	true 和 false 两个值
	/*
		注意:
			① 布尔类型变量的默认值为false。
			② Go 语言中不允许将整型强制转换为布尔型.
			③ 布尔型无法参与数值运算,也无法与其他类型进行转换。
	*/

	// 4、字符串
	/*

			① go语言中的字符串只能使用双引号"",单引号''的是字符
			② 1 字节 = 8 Bit(8个二进制位)
		   	  1个字符 'A' = 1 字节
		   	  1个utf8编码汉字 '学' = 一般占3个字节

	*/
	// 4.1 多行字符串(原样输出,带格式)
	s := `
			1
			2
			3
	`
	fmt.Println("3、多行字符串原样输出: " + s)

	// 字符串求长度 len(str)
	// len()返回的是字符串长度的字节数,与其他编程语言不同的地方

	str_len := "直接"
	fmt.Printf("使用len方法计算\"直接\"字节长度:%v\n", len(str_len))

	// 可以使用utf8库下的RuneCountInString方法获取字符长度
	fmt.Printf("使用utf8.RuneCountInString方法计算\"直接\"字符长度:%v\n", utf8.RuneCountInString(str_len))

	// 正经计算字符长度的时候,就使用utf8下的方法来计算,不要使用len()/3来进行计算(避免错误,有的表情之类的是4字节)

	// 4.2 字符串拼接  +或者fmt.Sprintf
	var name string = "zhijb"
	var age string = "22"

	word := name + age
	fmt.Println("4.1 +字符串拼接: " + word)
	ss := fmt.Sprintf("%s%s", name, age)
	fmt.Println("4.2 Sprintf字符串拼接:" + ss)

	// 4.3 字符串分割 strings.Split
	var dir_location string = "/home/zhijb/data_dir/code_dir/src"
	fmt.Println()
	fmt.Println(strings.Split(dir_location, "/"))

	// 4.4 字符串判断包含 strings.Contains
	fmt.Print("6.1 字符串是否包含字符zhijb: ")
	fmt.Println(strings.Contains(dir_location, "zhijb"))
	fmt.Print("6.2 字符串是否包含字符支付宝: ")
	fmt.Println(strings.Contains(dir_location, "zhifubao"))

	// 4.5 前缀开头判断strings.HasPrefix()	结尾判断strings.HasSuffix()
	fmt.Print("7.1 判断路径是否以/home字符串开头: ")
	fmt.Println(strings.HasPrefix(dir_location, "/home"))
	fmt.Print("7.2 判断路径是否以src结尾: ")
	fmt.Println(strings.HasSuffix(dir_location, "src"))

	// 4.6 字符串位置判断
	fmt.Print("8.1 d字符在字符串中第一次出现位置: ")
	fmt.Println(strings.Index(dir_location, "d"))
	fmt.Print("8.2 d字符在字符串中最后一次出现位置: ")
	fmt.Println(strings.LastIndex(dir_location, "d"))

	// 5、字符类型:byte 和 rune
	/*
		Go 语言的字符有以下两种:
			uint8类型,或者叫 byte 型,代表了ASCII码的一个字符。
			rune类型,代表一个 UTF-8字符

		当需要处理中文、日文或者其他复合字符时,则需要用到rune类型。rune类型实际是一个int32 !!
		Go 使用了特殊的 rune 类型来处理 Unicode,让基于 Unicode 的文本处理更为方便,也可以使用 byte 型进行默认字符串处理,性能和扩展性都有照顾
	*/

	// 遍历字符串
	string1 := "hello世界"
	for i := 0; i < len(string1); i++ { //byte
		fmt.Printf("%v(%c) ", s[i], s[i])
	}
	fmt.Println()
	for _, r := range string1 { //rune
		fmt.Printf("%v(%c) ", r, r)
	}
	fmt.Println()

	var rune12 rune = '你'
	fmt.Println(rune12)

	// 5、修改字符串
	/*
		要修改字符串,需要先将其转换成 []rune 或 []byte
		完成后再转换为string。
		无论哪种转换,都会重新分配内存,并复制字节数组
	*/
	s1 := "big"
	// 强制类型转换
	byteS1 := []byte(s1)
	byteS1[0] = 'p'
	fmt.Println(string(byteS1))

	s2 := "白萝卜"
	runeS2 := []rune(s2)
	runeS2[0] = '红'
	fmt.Println(string(runeS2))

	// 6、类型转换
	/*
		go语言中类型转换与python类似,直接使用 data_type(变量/复杂算式/函数返回值) 进行强制转换
		不会更改原数据的类型

		go语言中没有隐式类型转换,即以下示例代码会报错:
			var num1 int = 13
			var num2 unint = 15
			// 下面这一句无法通过编译,因为golang是强类型语言,并且不会帮你做任何的转换
			println(a == c)
	*/
	var int_num int = 8
	fmt.Printf("%T\n", float32(int_num))

	stringsss := "s"
	stringbyte := '@'
	fmt.Printf("%T --- %T", stringsss, stringbyte)
}

3、条件语句

package main

import "fmt"

func main() {

	fmt.Println("hello world")
	// 1、if条件语句

	// Go语言规定与if匹配的左括号{必须与if和表达式放在同一行,{放在其他位置会触发编译错误。
	// 同理,与else匹配的{也必须与else写在同一行,else也必须与上一个if或else if右边的大括号在同一行。

	/*
		if 表达式1{
			分支1
		}else if 表达式2{
			分支2
		}else{
			分支3
		}
	*/

	/*
		在 if 表达式之前可以添加一个执行语句,再根据变量值进行判断
		if score := 65; score >= 90 {
			fmt.Println("A")
		} else if score > 75 {
			fmt.Println("B")
		} else {
			fmt.Println("C")
		}
	*/

	// 2、go语言中只有for循环,没有其它的循环语句

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

	for i := 0; i < 5; i++ {
		fmt.Println(i)
	}

	// 2.1 for循环的初始语句可以被忽略,但是初始语句后的分号必须要写
	/*
		i := 0
		for ; i < 10; i++ {
			fmt.Println(i)
		}
	*/

	// 2.2 for循环的初始语句和结束语句可以都省略
	/*
		i := 0
		for i < 10 {
			fmt.Println(i)
			i++
		}
	*/

	// 2.3 for range循环(键值循环)
	s := "helloworld世界"
	// i 表示索引, v 表示值
	fmt.Println("从字符串中拿出索引和字符:")
	for i, v := range s {
		fmt.Printf("%d %c\n", i, v)
	}

	// 从字符串中拿出具体的字符
	fmt.Println("从字符串中拿出具体的字符: ")
	for _, c := range s {
		fmt.Printf("%c\n", c)
	}

	// 2.4 continue、break跳出循环
	/*
		break 跳出循环
		continue	开始下一次循环

	*/

	// 2.5 使用goto语句简化代码
	/*
		goto语句通过标签进行代码间的无条件跳转。
		goto语句可以在快速跳出循环、避免重复退出上有一定的帮助。
		Go语言中使用goto语句能简化一些代码的实现过程。
		例如双层嵌套的for循环要退出时
	*/
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 设置退出标签
				goto breakTag
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
	return
	// 标签
breakTag:
	fmt.Println("结束for循环")

	// 3、switch canume
	// 当已给定条件的case都不满足的时候,默认会执行 default,
	// Go语言规定每个switch只能有一个default分支
	for num := 0; num < 5; num++ {
		switch num {
		case 1:
			fmt.Println("num is: 1")
		case 2:
			fmt.Println("num is: 2")
		case 3:
			fmt.Println("num is: 3")
		case 4:
			fmt.Println("num is: 4")
		default:
			fmt.Println("无效的输入!")
		}
	}

	// 一个分支可以有多个值,多个case值中间使用英文逗号进行分割
	switch num1 := 7; num1 {
	case 1, 3, 5, 7, 9:
		fmt.Println("奇数")
	case 2, 4, 6, 8:
		fmt.Println("偶数")
	default:
		fmt.Println(num1)
	}

	// 分支还能使用表达式,这时候switch后面不需要在跟判断变量
	age := 30
	switch {
	case age < 25:
		fmt.Println("年龄小于25")
	case age > 25 && age < 35:
		fmt.Println("年龄大于25小于35")
	case age > 60:
		fmt.Println("年龄大于60")
	default:
		fmt.Println("年轻真好")
	}

	// fallthrough 语法可以主动执行该case的下一个case
	// 下面例子当匹配到a的case时,顺带把b case也执行了!
	stringsss1 := "a"
	switch {
	case stringsss1 == "a":
		fmt.Println("a")
		fallthrough
	case stringsss1 == "b":
		fmt.Println("b")
	case stringsss1 == "c":
		fmt.Println("c")
	default:
		fmt.Println("...")
	}

}

// 打印乘法表
for i := 1; i <= 9; i++ {
		for j := 1; j <= i; j++ {
			fmt.Printf("%d * %d = %d   ", j, i, i*j)
		}
		fmt.Println()
	}

4、运算符

package main

func main() {
	// 算术运算符 + - * / %
	// ++(自增) --(自减) 在go语言中是单独的语句,不能放在等号=的右边

	// 关系运算符
	// == != > >= < <=

	// 逻辑运算符
	// &&(逻辑and运算符)  ||(逻辑or运算符) !(逻辑非运算符)

	// 位运算符
	// &(相与)	|(相或)		^(异或运算)	<<(左移n位就是乘以2的n次方)		>>(右移n位就是除以2的n次方)

	// 赋值运算符
	// =	+=		-=		*=		/=		%=		<<=		>>=		&=		|=		^=
}

5、数组

package main

import "fmt"

// 数组

// 声明数组时 必须指定 存放元素的 类型 和 长度
var a1 = [6]int{0, 1, 2, 3, 4, 5}

func main() {
	// var 数组名 [长度]数据类型
	var array1 [3]bool
	var array2 [3]bool

	fmt.Printf("a1:%T a2:%T", array1, array2)

	// 数组的初始化
	// 如果数组不进行初始化,默认元素都是零值(各种数据类型的初始默认值)
	fmt.Println()
	// 1、初始化方式1,根据数组长度分别进行初始化
	array1 = [3]bool{true, true, true}
	fmt.Println(array1)

	// 2、初始化方式2,自动推断数组长度进行初始化
	array6 := [...]int{0, 1, 2, 3, 4, 5}
	fmt.Println(array6)

	// 3、初始化方式3,根据索引指定值
	array3 := [5]int{0: 1, 3: 6}
	fmt.Println(array3)

	// 数组的遍历
	citys := [...]string{"beijing", "shanghai", "shenzhen"}
	// 1、根据索引遍历
	for i := 0; i < len(citys); i++ {
		fmt.Println(citys[i])
	}
	// 2、for range 进行遍历
	for i, v := range citys {
		fmt.Println(i, v)
	}

	// 多维数组
	// [[北京 上海] [广州 深圳] [成都 重庆]]
	array4 := [3][2]string{
		{"北京", "上海"},
		{"广州", "深圳"},
		{"成都", "重庆"},
	}
	fmt.Println(array4)
	// 根据索引取多维数组的值
	fmt.Println(array4[2][1])

	// 二维数组的遍历
	for _, v1 := range array4 {
		for _, v2 := range v1 {
			fmt.Printf("%s\t", v2)
		}
		fmt.Println()
	}

	// 多维数组只有第一层可以使用...来让编译器推导数组长度(多维数组仅最外层可以使用...)
	//支持的写法
	array7 := [...][2]string{
		{"北京", "上海"},
		{"广州", "深圳"},
		{"成都", "重庆"},
	}
	fmt.Println(array7)
	//不支持多维数组的内层使用...
	// b := [3][...]string{
	// 	{"北京", "上海"},
	// 	{"广州", "深圳"},
	// 	{"成都", "重庆"},
	// }

	// 数组是值类型 数组是值类型,赋值和传参会复制整个数组。因此,改变副本的值,不会改变本身的值
	b1 := [3]int{1, 2, 3}
	b2 := b1
	b2[0] = 100
	fmt.Println(b1, b2)
	var sum int
	z1 := [...]int{1, 2, 3, 4, 5, 6}
	for _, s := range z1 {
		sum = sum + s
	}
	fmt.Println(sum)
}

6、切片

package main

import (
	"fmt"
)

// 指针、容量、长度

// 切片slice

// 切片的定义
// 切片基于数组类型做了一层封装(依赖数组实现),支持自动扩容
// 切片是一个引用类型,它的内部结构包括 地址 长度 和 容量。切片一般用于快速地操作一块数据集合
func main() {
	// 1、声明切片
	// 声明切片的基本语法如下(切片不用声明长度):
	// var Name []Type

	var a []string              //声明一个字符串切片
	var b = []int{}             //声明一个整型切片并初始化
	var c = []bool{false, true} //声明一个布尔切片并初始化
	// var d = []bool{false, true} //声明一个布尔切片并初始化
	fmt.Println(a)        //[]
	fmt.Println(b)        //[]
	fmt.Println(c)        //[false true]
	fmt.Println(a == nil) //true
	fmt.Println(b == nil) //false
	fmt.Println(c == nil) //false
	// fmt.Println(c == d)   //切片是引用类型,不支持直接比较,只能和nil比较

	// 切片仅声明之后并未分配内存地址,其值为nil,需要初始化之后才会有内存地址

	// 2、切片的本质
	// 切片本身不保存数值,本质就是对底层的数组进行操作
	// 切片的本质就是对底层数组的封装,它包含三个信息:底层数组的指针、切片的长度(len)和切片的容量(cap)
	// https://www.liwenzhou.com/posts/Go/06_slice/ 参考理解切片的长度和容量两个概念

	// 切片的长度即为从底层数组中所获取到的元素个数,而切片的容量则是从底层数组获取到第一个元素开始,直到 底层数组的最后一个元素
	// 举例:
	// 数组 var a  = [8]int{0,1,2,3,4,5,6,7}
	// 切片 var s1 = a[:5] 此时,s1的值为{0,1,2,3,4},切片s1的长度len为5,容量cap为8
	// 切片 var s1 = a[3:6] 此时,s1的值为{3,4,5},切片s1的长度len为3,容量cap为5

	// 3、切片的长度和容量
	// 内置的len()函数求长度,内置的cap()函数求容量

	// 4、切片表达式
	// go里边的切片表达式类似python中的切片操作,就不详细记笔记了
	// 简单的切片表达式		a[low:high]
	// 完整的切片表达式(字符串不支持完整切片),按照high-low左包右不包进行切片获取元素,而容量会被设置为max-low		a[low:high:max]
	// 完整切片表达式需要满足的条件是0 <= low <= high <= max <= cap(a),其他条件和简单切片表达式相同
	// max 的值不能超出底层数组的总长度,否则就会越界

	array1 := [5]int{1, 2, 3, 4, 5}
	s1 := array1[1:3:5]
	fmt.Printf("s1:%v len(s1):%v cap(s1):%v \n", s1, len(s1), cap(s1))

	// 5、使用make()函数构造切片
	// 不仅可以通过数组来构造切片,如果需要动态的创建一个切片,可以使用内置的make()函数
	// make()函数创建完切片之后会填入默认值(即各个数据类型的零值)

	// make([]T, size ,cap)
	// T:切片的元素数据类型
	// size:切片中元素的数量,即长度
	// cap:切片的容量
	array2 := make([]int, 2, 10)
	fmt.Println(array2)      //[0 0]
	fmt.Println(len(array2)) //2
	fmt.Println(cap(array2)) //10

	// 6、判断切片是否为空
	// 要检查切片是否为空,请始终使用len(s) == 0来判断,而不应该使用s == nil来判断

	// 切片不能直接比较
	// 切片之间是不能比较的,不能使用==操作符来判断两个切片是否含有全部相等元素。
	// 切片唯一合法的比较操作是和nil比较
	// 一个nil值的切片并没有底层数组,一个nil值的切片的长度和容量都是0。
	// 但是我们不能说一个长度和容量都是0的切片一定是nil
	// 所以要判断一个切片是否是空的,要使用len(s) == 0来判断,不应该使用s == nil来判断

	// 下面的代码中演示了拷贝前后两个变量共享底层数组,对一个切片的修改会影响另一个切片的内容
	slice1 := make([]int, 3) //[0 0 0]
	slice2 := slice1         //将slice1直接赋值给slice2,slice1和slice2共用一个底层数组
	slice2[0] = 100
	fmt.Println(slice1) //[100 0 0]
	fmt.Println(slice2) //[100 0 0]
	/*
	   由于切片是引用类型,所以slice1和slice2其实都指向了同一块内存地址。修改slice2的同时slice2的值也会发生变化
	*/

	// 下面的代码演示了切片对数组的引用,修改切片的值并不会影响底层数组的值
	array3 := [6]int{0, 1, 2, 3, 4, 5}
	slice4 := array3

	slice5 := slice4
	slice4[0] = 100
	slice5[1] = 200
	

	// 修改之后 array3:[0 1 2 3 4 5] slice4:[100 1 2 3 4 5] slice5:[0 200 2 3 4 5]
	fmt.Printf("array3:%v slice4:%v slice5:%v", array3, slice4, slice5)

	// 7、切片的遍历和数组一样,支持索引遍历和 for range 遍历

	// 8、append()方法为切片增加元素
	// 内建函数append()可以为切片动态添加元素。
	// 可以一次添加一个元素,可以添加多个元素,也可以添加另一个切片中的元素(后面加…)

	// 调用append()函数必须用原来的切片变量接受返回值
	// 举例,如创业公司xxx初始就2个人,只需要2个工位,
	// 后来公司规模变大,就需要变更办公地址以容纳更多的员工,但是公司名称还是xxx,仅仅只是办公地址变了
	var slice6 []int
	slice6 = append(slice6, 1)       // [1]
	slice6 = append(slice6, 2, 3, 4) // [1 2 3 4]
	slice7 := []int{5, 6, 7}
	slice6 = append(slice6, slice7...) // [1 2 3 4 5 6 7]

	// 注意:通过var声明的零值切片可以在append()函数直接使用,无需初始化
	var slice8 []int
	slice8 = append(slice8, 1, 2, 3)

	// append() 方法可为切片动态添加元素,每个切片都指向一个底层数组
	// 当当底层数组不能容纳新增的元素时,切片就会自动按照一定的策略进行“扩容”,此时该切片指向的底层数组就会更换
	//append()添加元素和切片扩容
	var numSlice []int
	for i := 0; i < 10; i++ {
		numSlice = append(numSlice, i)
		fmt.Printf("%v  len:%d  cap:%d  ptr:%p\n", numSlice, len(numSlice), cap(numSlice), numSlice)
	}
	// 从输出结果可以看出来
	// ① append()函数将元素追加到切片的最后并返回该切片。
	// ② 切片numSlice的容量按照1,2,4,8,16这样的规则自动进行扩容,每次扩容后都是扩容前的2倍。

	// 9、切片的扩容策略
	// 查看$GOROOT/src/runtime/slice.go源码
	// https://www.liwenzhou.com/posts/Go/06_slice/#autoid-2-5-0
	/*
		首先判断,如果新申请容量(cap)大于2倍的旧容量(old.cap),最终容量(newcap)就是新申请的容量(cap)。
		否则判断,如果旧切片的长度小于1024,则最终容量(newcap)就是旧容量(old.cap)的两倍,即(newcap=doublecap),
		否则判断,如果旧切片长度大于等于1024,则最终容量(newcap)从旧容量(old.cap)开始循环增加原来的1/4,即(newcap=old.cap,for {newcap += newcap/4})直到最终容量(newcap)大于等于新申请的容量(cap),即(newcap >= cap)
		如果最终容量(cap)计算值溢出,则最终容量(cap)就是新申请容量(cap)
	*/

	// 10、使用copy()函数复制切片
	// copy()复制切片,copy(dst, src)
	// copy()函数不会自动扩容目的切片,如果目的切片容量不足也无法完成copy()
	slice9 := []int{1, 2, 3, 4, 5}
	slice10 := make([]int, 5, 5)
	slice11 := slice9
	copy(slice10, slice9) //使用copy()函数将切片slice9中的元素复制到切片slice10
	fmt.Println(slice9)   //[1 2 3 4 5]
	fmt.Println(slice10)  //[1 2 3 4 5]
	fmt.Println(slice11)  //[1 2 3 4 5]
	slice9[0] = 1000
	fmt.Println(slice9)  //[1000 2 3 4 5]
	fmt.Println(slice10) //[1 2 3 4 5]  copy()复制切片的值不受原值的影响
	fmt.Println(slice11) //[1000 2 3 4 5]

	// 11、Go语言中并没有删除切片元素的专用方法,我们可以使用切片本身的特性来删除元素
	// 从切片中删除元素
	slice12 := []int{30, 31, 32, 33, 34, 35, 36, 37}
	// 要删除索引为2的元素
	slice10 = append(slice12[:2], slice12[3:]...)
	fmt.Println(slice12) //[30 31 33 34 35 36 37 37]

	x1 := [...]int{1, 3, 5} // 数组
	// [:]就是从头取到尾,左包右也包
	s2 := x1[:]             // 切片,从数组x1的开始切到最后
	fmt.Println(s2, len(s2), cap(s2))
	/*
		1、切片不保存具体的值
		2、切片对应一个底层数组
		3、底层数组都是占用一块连续的内存
	*/
	fmt.Printf("%p\n", &s1[0])
	s2 = append(s2[:1], s2[2:]...) // 修改了切片的底层数组(非原始数组),将s2数组索引为0的元素和索引为2的元素拼接起来,相当于删除了索引为2的元素
	fmt.Printf("数组x1地址:%p 切片s2地址:%p \n", &x1, &s2)
	fmt.Printf("数组x1值:%v 切片s2值:%v \n", x1, s2) // 数组x1:[1 5 5] 切片s2:[1 5]
	x1[0] = 100
	fmt.Printf("数组x1值:%v 切片s2值:%v \n", x1, s2)
	// * 总结起来一句话,修改数组的值会同时修改引用该数组的切片值,而仅仅修改切片的值则不会修改其引用的原数组值(只是修改了切片对应内存地址的底层数组的值) *
	
	// append修改或删除切片的值,会修改(相当于挪动元素位置)该切片所引用的原数组值,具体看下例子:

	example_array := [...]int{1, 2, 3, 4, 5, 6}
	example_slice := example_array[:]
	fmt.Printf("未删除切片索引为2处的元素前 example_slice值为 %v\n", example_slice)
	// 删除掉切片索引为2处的元素
	example_slice = append(example_slice[:2], example_slice[3:]...)
	fmt.Printf("删掉索引2处元素后example_slice切片值为:%v \n", example_slice) // [1 2 4 5 6]
	fmt.Printf("删掉索引2处元素后example_array数组值为:%v \n", example_array) // [1 2 4 5 6 6] 前面的append操作相当于把数组后三个元素往前推了三位,其他元素不变

	// 切片真实面试题(非常nice)
	var a_test = make([]int, 5, 10)
	fmt.Printf("使用make创建完长度为5的切片之后,切片已经有5个int默认值了,即0 \n")
	fmt.Println(a_test)
	for i := 0; i < 10; i++ {
		a_test = append(a_test, i)
	}
	fmt.Println(a_test)

	// 12、指针
	/*
		go 语言中没有指针操作,只有两个符号:
		① & 获得地址
		② * 根据地址取值
	*/
	// 使用 & 取地址
	num := 23
	mem_add := &num
	fmt.Println(mem_add)
	fmt.Printf("%T \n,*int 代表int类型的指针", mem_add)
	// 使用 * 根据地址取值
	num1 := *mem_add
	fmt.Println(num1)
	fmt.Printf("%T \n", num1)

	// 指针类型数据的零值是 nil,很多类型数据的零值都是nil

	// 使用 new(Type) 函数申请一个内存地址,new()函数申请的是内存地址,如果需要赋值还需要结合*符号使用
	mem_add3 := new(int)
	*mem_add3 = 100
	print(*mem_add3)

	// 使用 make() 函数分配内存,区别于 new() 函数,make() 只能用于slice、map、chan的内存创建
	// func make(t Type, size ...IntegerType)

	// make() 函数创建slice、map的格式不同!

	/* 例:
	make创建map:	make(type,cap)  ->  make(map[string]int,200)
	make创建slice:	make([]T, size ,cap)  ->  make([]int, 5, 10)
	make创建元素为map类型的slice:	make([]map[int]string, 5, 10) slice格式是[]type,此例Type是键为int,value为string的map
	make创建元素为slice类型的map:	make(map[string][]int, 10)  map[string]Type , 此例中Type是int类型的slice
	声明元素类型为map的切片时,切片和map都需要分别初始化
	*/

	/* make和new的区别:
	① make和new都是用来申请内存的
	② new很少用,一般用来给基本数据类型申请内存,例如string、int,new()返回的是对应类型的指针(*string)
	③ make用来给slice、map、chan申请内存,make函数返回的是对应的这三个类型本身
	*/

}

7、map

package main

import (
	"fmt"
	"math/rand"
	"sort"
	"time"
)

func main() {
	// map 是一种无序的基于key-value的数据结构,go语言中的map是引用类型,必须初始化才能使用

	// 1、map 定义:
	// map[keyType]ValueType ,KeyType代表键的类型,ValueType代表键对应的值类型

	// map类型的变量默认初始值为nil,需要使用make()函数来分配内存。语法为:
	// make(map[keyType]ValueType, [cap])		cap即为容量大小,该参数非必须,但是最好在初始化map的时候就为其指定一个合适的容量

	var map1 map[string]int
	fmt.Println(map1 == nil) // map1还没有进行初始化(没有在内存空间中开辟空间)
	map1 = make(map[string]int, 10)
	map1["age"] = 23
	map1["height"] = 226
	fmt.Println(map1)
	fmt.Println(map1["age"])
	fmt.Println(map1["weigh"]) // 如果不存在这个key,拿到对应数值类型的零值
	// 约定成俗
	value, ok := map1["age"]
	if !ok {
		fmt.Println("map1中不存在此键值")
	} else {
		fmt.Println(value)
		//fmt.Printf("map1[%v]的值是%v", value, map1["age"])
	}

	// 2、map 的遍历

	for k, v := range map1 {
		fmt.Println(k, v)
	}
	// 只遍历key值
	for k := range map1 {
		fmt.Println(k)
	}
	// 只遍历value值
	for _, v := range map1 {
		fmt.Println(v)
	}

	// 3、使用delete()方法删除
	// delete(mapName,keyName)
	// 内建函数delete按照指定的键将元素从映射中删除,若map为空或无此元素,delete不进行操作
	delete(map1, "height")
	fmt.Println(map1)

	// 4、按照指定顺序遍历map
	/*
		① 首先声明一个map容量200,使用循环对map初始化赋值,key依次增加,value来自随机数
		② 将map的所有key值取出来存到切片中
		③ 对切片进行排序
		④ 根据排序后的key值获取value值
	*/
	rand.Seed(time.Now().UnixNano()) //初始化随机数种子

	var scoreMap = make(map[string]int, 200)

	for i := 0; i < 100; i++ {
		key := fmt.Sprintf("stu%02d", i) //生成stu开头的字符串
		value := rand.Intn(100)          //生成0~99的随机整数
		scoreMap[key] = value
	}
	//取出map中的所有key存入切片keys
	var keys = make([]string, 0, 200)
	for key := range scoreMap {
		keys = append(keys, key)
	}
	//对切片进行排序
	sort.Strings(keys)
	//按照排序后的key遍历map
	for _, key := range keys {
		fmt.Println(key, scoreMap[key])
	}

	// 5、元素为map类型的切片
	// 声明元素类型为map的切片时,切片和map都需要进行初始化

	// make创建切片格式 make([]Type,length,cap)

	var slice1 = make([]map[int]string, 10, 10) // 使用make创建切片
	slice1[0] = make(map[int]string, 1)         // 初始化slice中的第一个map元素
	slice1[0][0] = "beijing"
	fmt.Println(slice1)

	// 6、值为切片类型的map

	// 使用make创建map格式: make(type,cap)

	var map2 = make(map[string][]int, 10) // map[string]Type , 此例中Type []int ,是int类型的slice
	map2["beijing"] = []int{10, 20, 30}
	fmt.Println(map2)
}

8、函数

package main

import "fmt"

// 函数的定义
/*
	func 函数名(参数)(返回值){
		函数体
	}

	go语言是强引用类型,任何时候声明变量都是指定数据类型
	这里的参数、返回值也都必须指定数据类型

	函数名:由字母、数字、下划线组成。但函数名的第一个字母不能是数字。在同一个包内,函数名也称不能重名(包的概念详见后文)。
	参数:参数由参数变量和参数变量的类型组成,多个参数之间使用,分隔。
	返回值:返回值由返回值变量和其变量类型组成,也可以只写返回值的类型,多个返回值必须用()包裹,并用,分隔。
	函数体:实现指定功能的代码块
*/

// Go语言中函数传递的都是值类型,修改之后并不会影响初始变量的值

func sum(x int, y int) (ret int) {
	return x + y
}

// 函数的参数和返回值都是可选的,例如可以实现一个既没有参数也没有返回值的函数
func sayHello() {
	fmt.Println("Hello World")
}

// 参数类型简写
// 函数的参数中如果相邻变量的类型相同,则可以省略数据类型
// intSum函数有两个参数,这两个参数的类型均为int,因此可以省略x的类型,因为y后面有类型说明,x参数也是该类型
func intSum(x, y int) int {
	return x + y
}

// 可变参数
/*
	可变参数是指函数的参数变量不固定。Go语言中的可变参数通过在参数名后加  ...  来标识
	注意:可变参数通常要作为函数的最后一个参数
*/
func intSum2(x ...int) int {
	fmt.Println(x)
	sum := 0
	for _, v := range x {
		sum = sum + v
	}
	return sum
}

// 固定参数搭配可变参数使用时,可变参数要放到固定参数的后面,示例代码如下:
// 本质上,函数的可变参数是通过切片来实现的
func intSum3(x int, y ...int) int {
	fmt.Println(x, y)
	sum := x
	for _, v := range y {
		sum = sum + v
	}
	return sum
}

// 返回值
// Go语言中函数支持多返回值,函数如果有多个返回值时,定义返回参数必须用()将所有返回值包裹起来
func calc(x, y int) (int, int) {
	sum := x + y
	sub := x - y
	return sum, sub
}

// 返回值命名:
// 函数定义时可以给返回值命名,并在函数体中直接使用这些变量,最后通过 return 关键字返回
// 例如:
func calc1(x, y int) (sum, sub int) {
	sum = x + y
	sub = x - y
	return
}

// 返回值补充,当函数返回值类型为slice时,nil可以看作是一个有效的slice,没必要显示返回一个长度为0的切片
func someFunc(x string) []int {
	if x == "" {
		return nil // 没必要返回[]int{}
	} else {
		fmt.Println("helloworld")
	}
	return nil
}

func main() {
	// 调用函数可以通过  函数名()的方式
	r := sum(1, 2)
	fmt.Println(r)

	// 调用有返回值的函数时,可以不接收其返回值

}


0

评论