go语言基础

感谢大家的支持和关注，一起进步吧

前言

go语言的优势：
go语言靠近C语言，也靠近python语言。
因此go语言对开发友好，同时性能好。天生支持高并发。

计算机

冯诺依曼体系：
cpu :
运算器
控制器
存储器：
内存
外存
输出设备：
输入设备：

越靠近cpu的速度越快。
因此我们再编写一个程序，或者运行一个程序，都可以基于此图来考虑。

go go go

一.安装环境

• 官网
• go中文网
• 安装sdk
  安装集成开发环境
• vs code或 goland
• 编译器路径放置到全局变量
• 用户变量GOPATH 空项目位置
• 项目名称下创建src文件夹，以后就在这里创建文件写程序
• 终端下输入 go env 配置环境
• go语言最小单元是一个文件夹

二.编译型和解释型

go是编译型语言
go程序-->编译-->可执行程序(.exe)--> 操作系统 从安装sdk ,和运行程序就可以知道go语言就是编译型语言 js和python都是解释型语言程序–>解释器–> 操作系统

三.hello.go

package main

// 导包 io操作包
import (
	"fmt"
)
// 打印后自动换行
fmt.Println("hello world")

终端下：
输入 go run hello.go
会在终端打印结构
----------------------
输入go build
会生成hello.exe文件

四.goland基础

创建项目如下

1.变量和变量赋值

package main

import "fmt"

// 全局变量
// x := 10 //全局变量不可以使用:= 的简洁语法

// 函数
func foo1() {
	// 局部变量
}

func foo2() {

}
func main() {
	// 局部变量
	fmt.Println("———————start—————————")
	fmt.Println("变量")
	// 声明变量  var 变量 类型
	var age int
	fmt.Println("未赋值", age) // 声明未赋值，有默认零值
	age = 24
	fmt.Println("修改后的：", age)
	age = 18
	fmt.Println("多次修改后的：", age)

	// 声明和赋值一行实现
	fmt.Println("变量声明后没有用会标红")
	// var name string = "yao"
	// 会自动判断类型
	var name = "yao"
	fmt.Println(name)

	// 一行声明多个相同类型的变量
	var x, y int
	fmt.Println("默认值", x, y)

	//var i int
	//var b bool
	//var s string

	var (
		i int
		b bool
		s string
	)
	fmt.Println("默认值", i, b, s)
	fmt.Println("类型确定下来只能使用同类型的值")

	// 声明并赋值的简洁写法
	//var name = "yao" 的简洁写法
	name1 := "yai"
	fmt.Println(name1)

	// 一行声明赋值多个变量
	var name2, age2, gender = "yao", 23, false
	fmt.Println(name2, age2, gender)
	// 局部变量的另一种写法
	name3, age3, gender3 := "yao", 23, false
	fmt.Println(name3, age3, gender3)

	fmt.Println("全局变量不可以使用:= 的简洁语法")
	fmt.Println("———————end—————————")

}

执行结果

2.值拷贝

package main

import "fmt"

func main() {
	//值拷贝
	fmt.Println("--------start------------")
	var x = 10
	var y = x //值拷贝，x,y 对应不同的内存地址
	x = 20
	fmt.Println(x) //20
	fmt.Println(y) //10

	var a = 1 + 1
	fmt.Println(a) //2
	var b = x * y
	fmt.Println(b) //200
	var c = x + y
	fmt.Println(c) //30
	fmt.Println("只要有新的变量就会开辟新的空间")
	fmt.Println("变量可以重复的使用")
	fmt.Println("--------end------------")

}

执行结果

3.匿名变量和命名规范

不能以数字开头，右字母数字下划线组成的，要见名知义，不能用保留字

package main

import "fmt"

func foo() (int, int, string) {
	return 100, 2, "nnn"
}

func main() {
	fmt.Println("*************** 匿名变量 **********")

	var a, _ = 1, 2
	fmt.Println(a)

	//使用场景 函数 有多个返回值，不用的返回值用_
	var b, _, _ = foo()
	// fmt.Println(_) //无法用作值
	fmt.Println("返回需要用的值", b)

	fmt.Println("变量规范，见名知义，不要用保留字")

	fmt.Println("**************** end **************")

}

执行结果

4.语句分隔符

package main

import "fmt"

func foo() {

}

func main() {
	fmt.Println("*************** 分割符 **********")
	// ; 作为分隔符，还有换行作为分隔符,运行时候会自动换成换行的形式
	var x = 100
	var y = 200
	var z = 300

	fmt.Println(x, y, z)
	fmt.Println("**************** end **************")

}

执行结果

5.整型和字节

package main

import (
	"fmt"
)

func main() {
	fmt.Println("______start____")
	/*1GB = 1024MB
	1MB = 1024KB
	1KB = 1024B
	1B = 8bits
	1个bit只能是一个0或一个1
	—    1b     2
	--   2b     4
	---  3b     8
	8b   1B     2的8次方 = 256
	int8  1B    [-128 ~ 127]
	uint8 1B    [0-255]
	*/

	// 所有根据情况选择类型
	// 年龄 正数 一般 100岁以类
	var age uint
	age = 100
	fmt.Println(age)

}

6.浮点型和布尔类型

float32 单精度 float64双精度 后者精确更高
科学计数法 e 类型归到float64

package main

import (
	"fmt"
	"reflect"
)

func main() {
	fmt.Println("______start____")

	var f1 float32 = 12.111111111333333
	var f2 float64 = 12.1112112212222311
	var f3 = 10e3
	var f4 = 10e-3

	fmt.Println(f1)
	fmt.Println(f2)
	fmt.Println(f3)
	fmt.Println(f4)

	// bool
	var b bool
	b = true
	b = false
	// 控制语句时候使用
	c := 3 > 5
	fmt.Println("bool值:", b)
	fmt.Println("bool值:", c)
	fmt.Println("c的类型:", reflect.TypeOf(c))

}

执行结果

7.字符串

主要作用提示给我们看，给数据一个合适的格式打印输出或存储

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println("go语言不支持负索引")

	var s string //默认为 ”“
	s = "hello world"

	fmt.Println(s)
	// 索引
	fmt.Println("索引取值")
	fmt.Println(string(s[0]))
	fmt.Println(string(s[1]))
	fmt.Println(string(s[2]))

	//切片 前取后不取
	fmt.Println("切片前取后不取")
	fmt.Println(string(s[2:3]))
	fmt.Println(string(s[1:8]))
	fmt.Println(string(s[:]))
	fmt.Println(string(s[0:]))

	// 拼接 +
	var s1 = "hello"
	var s2 = " world"
	fmt.Println(s1 + s2)

	// 转义符号
	// \n 换行
	// 加\ 取消特殊功能
	fmt.Println("第一行\n第二行")

	// 多行打印
	fmt.Println("1.打开冰箱")
	fmt.Println("2.放入大象")
	fmt.Println("3.关闭冰箱")
	fmt.Println("_________")

	// 多行文本输出
	info := `
1.打开冰箱
2.放入大象
3.关闭冰箱
请输入你的选择>>>`
	fmt.Println(info)

	// string包
	var name = "Yao"
	var upperName = strings.ToUpper(name)
	fmt.Println("变大写", upperName)
	var ss = "yao is beautiful girl"
	fmt.Println("判断以是否以什么开头", strings.HasPrefix(ss, "yao"))
	fmt.Println("判断以是否以什么结尾", strings.HasSuffix(ss, "rl"))
	fmt.Println("判断以是否以什么结尾", strings.Contains(ss, "rl"))

	var sss = "   yao     "
	fmt.Println(sss)
	sss = strings.Trim(sss, "")
	fmt.Println(sss)

	var ss1 = "abcdef"
	fmt.Println("没有找到返回-1", strings.Index(ss1, "cdf"))
	fmt.Println("找到返回第一个的索引", strings.Index(ss1, "cd"))

	var cmd = "mysql ... -u rootaafffaa -p 123dsaffa"
	// 取出用户名和密码
	var username string
	var password string
	var u_index = strings.Index(cmd, "-u")
	var p_index = strings.Index(cmd, "-p")
	username = cmd[u_index+3 : p_index-1]
	password = cmd[p_index+3:]
	fmt.Println("用户名:", username, "\n密码:", password)

	// 分割符 拼接
	var ss2 = "a b c d"
	ss2_list := strings.Split(ss2, " ")
	fmt.Println(ss2_list)
	fmt.Println("长度",len(ss2_list))

	new_ss2 := strings.Join(ss2_list, "***")
	fmt.Println(new_ss2)

}

执行结果

8.数据类型转换

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	fmt.Println("_______start_______")
	// 整型之间的转换
	var x int8 = 10
	var y int16 = 20
	// 注意溢出
	fmt.Println(x + int8(y))

	//字符串与整型
	var aS = "10"
	var a, _ = strconv.Atoi(aS)
	fmt.Println(a)

	// Parse 系列函数 参数的意义
	var ret, _ = strconv.ParseInt("233", 10, 64)
	fmt.Println(ret, "类型:", reflect.TypeOf(ret))

	var ret1, _ = strconv.ParseFloat("233.112", 64)
	fmt.Println(ret1, "类型:", reflect.TypeOf(ret1))

	var ret2, _ = strconv.ParseBool("0")
	var ret3, _ = strconv.ParseBool("1")
	var ret5, _ = strconv.ParseBool("t")
	var ret6, _ = strconv.ParseBool("f")
	fmt.Println(ret2)
	fmt.Println(ret3)
	fmt.Println(ret5)
	fmt.Println(ret6)

}

执行结果

9.运算符

10.输出函数

注意到它们的区别

package main

import "fmt"

func main() {
	fmt.Println("_______start_______")
	//
	fmt.Println("姓名：", "yao", "年龄", "23")
	fmt.Print("姓名：")
	fmt.Print("yao")
	fmt.Println()

	// Printf 标准化输出
	fmt.Printf("姓名:%s,年龄：%d,性别：%t", "x1", 23, false)
	fmt.Println()

	// 接收打印的数据
	s := fmt.Sprintf("姓名:%s,年龄：%d,性别：%t", "x1", 23, false)
	fmt.Println(s)
}

执行结果

11.输入函数

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println("_______start_______")

	// 输入函数1
	// fmt.Scan 空格和换行来区分输入
	var name string
	var age int
	fmt.Println("输入名字和年龄")
	fmt.Scan(&name, &age) //等待用户输入一个值
	fmt.Println(name)
	fmt.Println(age)

	//输入应用
	fmt.Println("请输入按格式：年-月-日", ">>>")

	var birth string
	fmt.Scan(&birth)
	fmt.Println(birth)
	birthSlice := strings.Split(birth, "-")
	fmt.Println(birthSlice)
	fmt.Printf("你的生日是:%s年-%s月-%s日", birthSlice[0], birthSlice[1], birthSlice[2])
	fmt.Println()
	fmt.Println("_______end_______")
}

执行结果

12.流程控制语句

执行结果

package main

import "fmt"

func main() {
	fmt.Println("_______start_______")
	// 单分支语句
	var name = "root"
	fmt.Println(name == "yao")
	if name == "yao" {
		// 条件为真
		fmt.Println("姓名匹配成功")
	}
	fmt.Println("________end_1_______")

	// 多分支语句
	var age int
	fmt.Println("请输入你的年龄:")
	fmt.Scan(&age)
	if age > 18 {
		fmt.Println("成年")
	} else {
		fmt.Println("未成年")
	}
	fmt.Println("________end_2_______")

	// 登录逻辑
	var username, password string
	fmt.Println("请输入用户名和密码：")
	fmt.Scan(&username, &password)
	if (username == "root") && (password == "123") {
		fmt.Println("登录成功")
	} else {
		fmt.Println("用户名或者密码错误")

	}
	fmt.Println("________end_3_______")

	// 成绩判断
	var score int
	fmt.Println("请输入你的成绩")
	fmt.Scan(&score)
	if score < 0 || score > 100 {
		fmt.Println("输入的成绩不合法")
	} else if score > 90 && score <= 100 {
		fmt.Println("优秀")
	} else if score > 80 && score <= 90 {
		fmt.Println("良好")
	} else {
		fmt.Println("不合格")
	}

	// 星期判断
	// 依赖switch语句进行分支判断,switch值判断
	var week int
	fmt.Println("请输入0-6")
	fmt.Scanln(&week)
	switch week {
	default:
		fmt.Println("输入错误")
	case 0:
		fmt.Println("星期一")
	case 1:
		fmt.Println("星期二")
	case 2:
		fmt.Println("星期三")
	case 3:
		fmt.Println("星期四")
	case 4:
		fmt.Println("星期五")
	case 5:
		fmt.Println("星期六")
	case 6:
		fmt.Println("星期七")

	}
	// 分支嵌套
	if true {
		fmt.Println("执行代码1")
		if true {
			fmt.Println("执行代码2")

		} else {
			fmt.Println("不执行代码3")

		}
		fmt.Println("执行代码4")
	}
}

执行结果

13.循环控制语句

go语言只有for
break 终止整个循环和continue跳出当前这个条件的循环

package main

import "fmt"

func main() {
	// 打印下列语法
	fmt.Println("_______start_0_______")
	fmt.Println("_______start_1______")
	fmt.Println("_______start_2______")
	fmt.Println("_______start_3_____")
	fmt.Println("_______start_4______")
	fmt.Println("_______start_5______")
	fmt.Println("_______start_6______")
	fmt.Println("_______start_100____")
	fmt.Println("_______start_8______")
	fmt.Println("_______start_9______")

	// go里面只有 for 循环

	// 死循环 没意义
	for true {
		fmt.Println("_______start_0_______")
		break

	}
	fmt.Println("_______end______")
	fmt.Println("_______end______")
	for i := 0; i < 10; i++ {
		if i == 7 {
			fmt.Println("_______start_100____")
			continue
		}

		fmt.Printf("_______start_%d____\n", i)

	}

	fmt.Println("_______end______")

}

执行结果

14.指针

这玩意学不懂， 会引发一系列的问题

package main

import (
	"fmt"
	"reflect"
)

func main() {
	fmt.Println("_______指针_______")
	// 指针
	// 指针就是地址
	// 取地址符号&
	// go语言的指针就只有两种操作，取值，取地址
	// 地址的值是16进制的地址
	var x = 10 //x是整型变量，看存的什么值
	var y string
	fmt.Printf("赋值之前x的对应地址：%p \n", &x)
	fmt.Printf("赋值之前y的对应地址：%p \n", &y)
	x = 100
	y = "yao"
	fmt.Printf("赋值之后x的对应地址：%p \n", &x)
	fmt.Printf("赋值之前y的对应地址：%p \n", &y)
	// 指针类型
	var p *int     //p是一个(整型)指针类型 //指针类型用来存储地址
	var p1 *string //p是一个(字符串)指针类型
	// 1.取地址操作
	p = &x  //p 叫指针变量，类型是整型类型
	p1 = &y //p1 叫指针变量，类型是字符串类型
	fmt.Println("p存的x的地址", p)
	fmt.Println("p存的y的地址", p1)
	// 2.取值操作  *指针变量
	fmt.Println("*p存的x的值：", *p, "p的类型：", reflect.TypeOf(*p))
	fmt.Println("*p1存的y的值：", *p1, "p1的类型：", reflect.TypeOf(*p1))
	fmt.Println("______eg1______")

	// eg:1
	var a = 1
	var b = a //值拷贝
	b = 100
	fmt.Println("a=", a)
	fmt.Println("b=", b)
	fmt.Println("_____eg2_______")
	// eg:2
	var c = 1
	var d = &c //值拷贝
	*d = 100
	fmt.Println("c=", c)
	fmt.Println("*d=", *d)

	//eg:3
	fmt.Println("______eg3______")

	var e = 1
	var f = &e //值拷贝
	var g *int
	g = f //值拷贝，只是拷贝的是地址 //引用拷贝
	*f = 101
	fmt.Println("e=", e)
	fmt.Println("*f=", *f)
	fmt.Println(f) //都存着 e的地址,但是f和g 都有各自自己的地址
	fmt.Println(g)
	fmt.Println(f == g)
	fmt.Println(*f)
	fmt.Println(*g)
	fmt.Println(*g == *f)
	fmt.Println(*g == e)
	fmt.Println("_____eg4_______")
	// eg4
	var xx = 100
	var yy = &xx
	var zz = &yy
	fmt.Println("xx的值：", xx)
	fmt.Println("yy指针的值是xx的值：", *yy)
	fmt.Println("yy指针的地址：", &yy)
	fmt.Println("zz指针的地址：", &zz)
	fmt.Println("zz指针的值是yy的地址：", *zz)
	fmt.Println("zz指针的值的值是xx的值：", *(*zz))
	// 修改 xx的值
	xx = 101
	fmt.Println("修改后xx的值：", xx)
	*yy = 102
	fmt.Println("修改后xx的值：", xx)
	**zz = 103
	fmt.Println("修改后xx的值：", xx)
	// 用一个变量去接收地址要先声明指针变量的类型
	var pp *int
	pp = yy
	var pp1 **int
	pp1 = zz
	fmt.Println(pp, pp1)

	fmt.Println("_______eg4_______")
	pf1 := 1
	pf2 := &pf1
	*pf2++ // 就是(*p2)++  //”++“ 优先级虽然高于* p2++是没有返回值的
	fmt.Println(pf1)
	fmt.Println(*pf2)
	fmt.Println("_______end_______")
}

执行结果

15.new函数

package main

import "fmt"

func main() {
	fmt.Println("_______start_______")
	// 基本数据类型 （整型浮点型字符串布尔类型属于值类型）
	//值类型特点（当声明未赋值之前存在一个默认值）
	var x int
	var name string
	fmt.Println(x)
	fmt.Println(name)

	// 指针类型属于引用类型，包括切片，map,channel 都属于引用类型
	// 引用类当声明未赋值之前是没有开辟空间的，即没有默认值
	var p *int
	//*p = 10  //panic: runtime error: invalid memory address or nil pointer dereference
	p = new(int) //开辟了空间
	fmt.Println(*p)
	*p = 100
	fmt.Println(*p)
}

执行结果

16.数组

package main

import (
	"fmt"
)

func main() {
	fmt.Println("_______数组_______")
	// 切片依赖于数组
	// 存一个名字
	// 存100给名字

	// 存在一个字符串中
	// s := "a b c d" //但是不好管理

	// 链表 非连续的
	// 1.数组必须限制长度
	var arr [3]int //开辟了空间，是连续的
	fmt.Println(arr)
	//数组[index]
	fmt.Println(arr[0], &arr)
	fmt.Println(arr[0], &arr[0])
	fmt.Println(arr[1], &arr[1])
	fmt.Println(arr[2], &arr[2])
	fmt.Println("__________")
	// 索引赋值
	arr[0] = 11
	arr[1] = 22
	arr[2] = 33
	fmt.Println(arr[0], &arr[0])
	fmt.Println(arr[1], &arr[1])
	fmt.Println(arr[2], &arr[2])
	fmt.Println("__________")
	// 数组声明并赋值
	var names = [3]string{"aa", "bb", "cc"}
	fmt.Println(names)
	var score = [4]int{12, 22, 33, 44}
	fmt.Println(score)
	fmt.Println("__________")
	// 省略长度注意叫点点点
	var level = [...]string{"a", "b", "c", "d", "e"}
	fmt.Println(level)
	fmt.Println("__________")
	// 索引赋值
	var level1 = [...]string{0: "a", 9: "e"}
	fmt.Println(level1)
	fmt.Println("__________")
	// 长度
	fmt.Println(len(level1))
	fmt.Println(len("hello"))
}

执行结果

17.数组遍历

package main

import (
	"fmt"
	"reflect"
)

func main() {
	fmt.Println("_______数组操作_______")
	// 索引
	var names = [4]string{"a", "b", "c", "d"}
	names[1] = "bb"
	fmt.Println(names)
	//切片 数组[start:end] 前取后不取
	ss := names[0:3]
	fmt.Println("___切出的值____类型____长度___")

	fmt.Println(ss, reflect.TypeOf(ss), len(ss))
	ss1 := names[3:]
	fmt.Println(ss1, reflect.TypeOf(ss1), len(ss1))
	ss2 := names[0:]
	fmt.Println(ss2, reflect.TypeOf(ss2), len(ss2))
	ss3 := names[:]
	fmt.Println(ss3, reflect.TypeOf(ss3), len(ss3))
	// 遍历数组
	fmt.Println("_______遍历数组_______")
	size := len(names)
	for i := 0; i < size; i++ {
		fmt.Println(i, names[i])
	}

	//range
	fmt.Println("_______range _______")

	for index, v := range names {
		fmt.Println(index, v)
	}

}

执行结果

18.切片的底层存储

package main

import (
	"fmt"
	"reflect"
)

func main() {
	fmt.Println("_______start_______")
	var arr = [5]int{111, 222, 333, 444, 555}

	for i, v := range arr {
		// arr[0] 的值给v
		// ......
		// arr[4] 的值给v
		v = 0
		fmt.Println(i, v)
	}
	fmt.Println(arr)

	//声明数组
	var games = [6]string{"a", "b", "c", "11", "22", "cc"}
	fmt.Println(games, reflect.TypeOf(games))
	s1 := games[0:2]
	fmt.Println(s1, reflect.TypeOf(s1))
	s2 := games[1:]

	fmt.Println(s2, reflect.TypeOf(s2))
	ss := games[:] //a是数组，ss是切片 //起始地址，长度 容量
	ss[2] = "1111"
	fmt.Println(ss)
	newSlice := ss[1:3]
	fmt.Println(newSlice)
	newSlice[0] = "10000"
	//长度6-0，容量 6-0
	fmt.Println(ss, len(ss), cap(ss))
	//长度3-1，容量 6-1=5
	fmt.Println(newSlice, len(newSlice), cap(newSlice))
	// 切片，一变则变
	fmt.Println("xxxxxxxxxxx")
	// var arr1 = [5]int{10, 22, 33, 45} //这是数组
	// s := arr[:]
	//直接声明切片
	var ii = []int{10, 22, 33, 45, 55} //这是切片
	ii1 := ii[1:4]                     //[22, 33, 45]
	fmt.Println(len(ii1), cap(ii1))
	ii2 := ii[3:]
	fmt.Println(len(ii2), cap(ii2))
	ii3 := ii1[1:2] //[33] ---ii[33]
	fmt.Println(ii3, len(ii3), cap(ii3))
	ii4 := ii[2:] // [33,45,55]
	fmt.Println(ii4, len(ii4), cap(ii4))
	ii5 := ii4[1:] //[45,55]
	fmt.Println(ii5, len(ii5), cap(ii5))

	fmt.Println("xxxxxxxxxxxx")
	var a = []int{1, 2, 3} //a切片存了三个值，起始地址，长度，容量
	b := a
	a[0] = 100
	fmt.Println(b)
	fmt.Println("xxxxxxxxxxxx")
	var aa = []int{1, 2, 3} //a切片存了三个值，起始地址，长度，容量
	bb := a
	cc := a[1:]
	aa[0] = 100
	fmt.Println(bb)
	fmt.Println(cc)

}

执行结果

19.make函数

作用：创建切片

package main

import "fmt"

func main() {
	fmt.Println("_______make函数_______")

	// 以前
	//var s = []int{1, 2, 3}
	//s[0] = 1

	//现在
	//var s = []int{1,2,3,4,5}
	// var s []int //切片
	// s[0] = 1 //报错，没有索引因为没有数组，数组是有长度的
	// 没有初始化空间，没有开辟空间，就像指针要new函数
	//初始化空间创造
	// 容量是5 长度是5
	// 长度是已经存在的值，容量是还可以扩展的值
	//make([]int, len,cap)
	//make([]int, 5)
	var sss = make([]int, 5, 10) //还有5个空间可用
	//sss 起始值，长度是5，容量是10
	fmt.Println(sss, len(sss), cap(sss))
	sss[0] = 100
	fmt.Println(sss, len(sss), cap(sss))
	//make函数的作用，

	b := sss[2:3]
	sss[2] = 200
	fmt.Println(b, len(b), cap(b))

}

执行结果

20.append追加函数

数组长度是确定的，append函数追加后返回一个新的切片

package main

import "fmt"

func main() {
	fmt.Println("_______start_______")
	var s = []int{1, 2}
	fmt.Println(s)
	s1 := append(s, 2, 3, 4)
	fmt.Println(s1)

	s2 := append(s1, s1...)
	fmt.Println(s2)

	var s3 = make([]int, 10, 20)
	s4 := append(s2, s3...)
	fmt.Println(s4)

}

执行结果

21.append扩容原理

package main

import "fmt"

func main() {
	fmt.Println("_______start_______")

	a := []int{11, 22, 33}
	fmt.Println(len(a), cap(a)) //3 3

	c := append(a, 44)
	a[0] = 100
	// 容量不够，两倍扩容，不是同一个数组，根原有数组没有关系了
	fmt.Println(a, len(a), cap(a)) //[100 22 33] 3 3
	fmt.Println(c, len(c), cap(c)) //[11 22 33 44] 4 6

	//make //容量够，是同一个数组
	aa := make([]int, 3, 10)
	fmt.Println(aa, len(aa), cap(aa)) //[0 0 0] 3 10
	b := append(aa, 11, 23)
	fmt.Println(aa, len(aa), cap(aa)) //[0 0 0 11 23] 5 10
	fmt.Println(b, len(b), cap(b))    //[0 0 0 11 23] 5 10
	aa[0] = 100
	fmt.Println(aa, len(aa), cap(aa)) //[100 0 0 11 23] 5 10
	fmt.Println(b, len(b), cap(b))    //[100 0 0 11 23] 5 10

}

执行结果

22.基于append切片的删除和插入

package main

import "fmt"

func main() {
	fmt.Println("_______切片的删除和插入_______")
	var s = []int{1, 2, 3}
	fmt.Println(s, len(s), cap(s))
	fmt.Printf("%p\n", &s)

	s = append(s, 4)
	fmt.Println(s, len(s), cap(s))
	fmt.Printf("%p\n", &s)

	//s的地址还是没有变,但是扩容了
	//  [1 2 3] 3 3 xc0000081b0
	//  [1 2 3 4] 4 6 0xc0000081b0

	//插入操作
	var a = []int{1, 2, 3}
	// 插入一个
	fmt.Println(append([]int{0}, a...))
	//插入多个
	fmt.Println(append([]int{0, 0, 0, 0}, a...))

	//中间插入
	var b = []int{1, 2, 3, 4, 5}
	//插入位置
	var i = 3
	fmt.Println(append(b[:i], append([]int{1000}, b[i:]...)...))
	fmt.Println(append(b[:i], append([]int{1000, 2000, 3000}, b[i:]...)...))

	//删除
	var c = []int{1, 2, 3, 4, 5}
	//删除最后一个
	var idx = len(c) - 1
	var d = append(c[:idx], c[idx+1:]...)
	fmt.Println(d)

	//删除中间任意一个
	idx = 3
	f := append(c[:idx], c[idx+1:]...)
	fmt.Println(f)

	//删除第一个
	e := append(c[1:])
	fmt.Println(e)

}

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果

执行结果