标签：map slice string fmt 笔记 Println go main
文章目录
go的错误处理机制
package main
import (
"fmt"
"time"
)
func test() {
defer func() {
err := recover() //recover()内置函数可以捕获到异常
if err != nil {
fmt.Println("err=", err)
fmt.Println("将错误信息发送给管理员")
}
}() //调用匿名函数直接在最后加个括号
num1 := 10
num2 := 0
res := num1 / num2
fmt.Println("res=", res)
}
func main() {
test()
for {
fmt.Println("程序结束")
time.Sleep(time.Second * 2)
}
}
自定义错误的使用(用来判断某个步骤是否出错)
package main
import (
"errors"
"fmt"
)
func readConf(name string) error {
if name == "fyf.jpg" {
return nil
} else {
return errors.New("文件读取失败！") //errors内置函数，返回自定义错误
}
}
func test02() {
err := readConf("fyf.jp")
if err != nil {
panic(err) //终止程序，并返回一个错误类型
}
fmt.Println("程序继续执行")
}
func main() {
test02()
fmt.Println("文件读取结束")
}
四种定义数组的方式
package main
import "fmt"
func main() {
var arr [3]int = [3]int{1, 2, 3}
var arr1 = [3]int{4, 5, 6}
arr2 := [3]int{7, 8, 9}
var arr3 = [...]int{10, 11, 12}
var name = [3]string{1: "jack", 2: "tom", 0: "merry"}
fmt.Println(arr)
fmt.Println(arr1)
fmt.Println(arr2)
fmt.Println(arr3)
fmt.Println(name)
}
数组的遍历
for-reange遍历
package main
import "fmt"
func main() {
st := "fzuishuai是的"
st2 := []rune(st) //将st转换成切片
for i := 0; i < len(st2); i++ { //普通遍历
fmt.Printf("%c", st2[i])
}
fmt.Println("\n")
str := "fis帅哥"
for index, val := range str { //利用go中自带的方法来遍历，其中index为字符串数组下标，str被赋值给val
//index和val都是变量，不过是局部变量
fmt.Printf("index=%d,val=%c \n", index, val)
}
for _, val := range str { //利用下划线忽略index的值
fmt.Printf("val=%c \n", val)
}
}
数组的小细节
1:浮点类型的数组初始值也是0，而不是0.0
go中数组是值类型，默认情况下是值拷贝，数组之间不会相互影响
go中不同长度的数组认为是不同的类型
[3]改成[4]调用test函数会报错，因为长度为3和4的数组是不一样的
package main
import "fmt"
func test(arr [3]int) {
arr[0] = 23
}
func test1(arr *[3]int) {
arr[0] = 99 //(*arr)[0]解引用
}
func main() {
//1:浮点类型的数组初始值也是0，而不是0.0
//go中数组是值类型，默认情况下是值拷贝，数组之间不会相互影响
//go中不同长度的数组认为是不同的类型
arr := [3]int{1, 2, 3} //[3]改成[4]调用test函数会报错，因为3和4的数组是不一样的
test(arr)
fmt.Println(arr) //arr[0]不会变，因为调用为值传递
//当传入地址时，数组会被修改
test1(&arr)
fmt.Println(arr)
}
slice 切片
切片是和数组相似的数据类型，是数组的引用，长度不固定，可以随需求增长。
slice的定义方式
package main
import "fmt"
func main() {
var arr = [5]int{1, 2, 3, 4, 5}
slice1 := arr[1:3] //不包括下标3，所以只有两个元素
var slice = []int{1, 2, 3}
fmt.Println(slice)
fmt.Println(slice1)
fmt.Println("sice1的容量为", cap(slice1)) //这个容量一般为长度的两倍
fmt.Println("sice的容量为", cap(slice)) //因为slice是直接定义和赋值的，所以长度就为3
}
slice的内存分析
slice其实是一个struct结构体，分别存放指向数组的数据的第一个元素的首地址，所取数组数据的总长度，容量。
切片的遍历
for-range遍历
package main
import "fmt"
func main() {
slice := []int{1, 2, 3, 4}
for i, v := range slice {
fmt.Printf("i=%v,v=%v\n", i, v)
}
}
切片可以继续切片
slice={2,3}，虽然1：3超过了slice的长度，
但是没有超过arr数组的长度，可以越界。
package main
import "fmt"
func main() {
var arr = [4]int{1, 2, 3, 4}
slice := arr[1:3] //2,3
for i, v := range slice {
fmt.Printf("i=%v,v=%v\n", i, v)
}
slice2 := slice[1:3] //slice={2,3}，虽然1：3超过了slice的长度，
// 但是没有超过arr数组的长度，可以越界。
fmt.Println(slice2)
}
通过append函数对切片进行动态扩容
package main
import "fmt"
func main() {
slice := []int{1, 2, 3, 4}
slice = append(slice, 5)
slice2 := append(slice, 5, 6)
//这里注意append是在slice后新开了一个数组(当容量不够时才开辟，够的话直接在后面加）
//如果不用原来的值进行接收，那么原来的切片不会改变，将会赋值给新的切片
fmt.Println(slice)
fmt.Println(slice2)
//也可以将slice切片追加到另一个切片
slice = append(slice, slice2...) //这里的...是必须的
fmt.Println(slice)
}
切片的拷贝-copy
package main
import "fmt"
func main() {
slice := []int{1, 2, 3}
slice1 := make([]int, 6)
copy(slice1, slice) //将后面的值copy到前面的
fmt.Println(slice1)
}
String与切片
package main
import "fmt"
func main() {
str := "hello,CHINA!"
slice := str[6:]
fmt.Println(slice)
//String 类型是不可修改的，要修改需要转成byte切片或者rune切片在转回去
//注意byte不能处理中文，需要用rune
arr1 := []byte(str)
arr1[0] = 'H'
str = string(arr1)
fmt.Println(str)
arr2 := []rune(str)
arr2[6] = '中'
arr2[7] = '国'
arr2[8] = ' '
arr2[9] = ' '
arr2[10] = ' '
str = string(arr2)
fmt.Println(str)
}
map
map的定义和初始化
package main
import "fmt"
func main() {
//map的声明
//var a map[string]string //[]里的是keytype，也就是相当于数组的下标，[]后的是key对应的值，也就是相当于数组的值
//var a map[string]int
//var a map[string]map[string]int//这里a的value值为map类型，可以看出是二维数组
//注意map是要先进行make函数来分配内存，才能进行赋值和使用，声明不会开辟内存。
//注意map的存储是无序的，所以输出也就是无序的
//map的初始化
//第一张方式
var a map[string]string
a = make(map[string]string, 10)
a["fyf "] = "在江西"
a["CHINA "] = "是fyf的motherland！"
fmt.Println(a)
//第二种
b := make(map[string]int)
b["ok"] = 12
b["jx"] = 13
fmt.Println(b)
//自动扩容
//第三种
c := map[string]int{
"high": 100, //要加上逗号，即使最后一个也要
"low": 2, //别忘了
}
fmt.Println(c)
}
map的查找、元素删除和全部清除
package main
import "fmt"
func main() {
num := make(map[string]string)
num["正数"] = "123"
num["负数"] = "-123"
num["有理数"] = "12.3"
num["无理数"] = "12.333333"
delete(num, "正数") //删除对应的key及其值
//查找
v, ok := num["负数"] //ok是bool类型的变量，v是你所要找的key（正数）的值
if ok {
fmt.Printf("找到你了:%v", v)
} else {
fmt.Println("不存在你要找的数据哦！")
}
v, ok1 := num["无理数"]
if ok1 {
fmt.Printf("查找到了：%v\n", v)
} else {
fmt.Println("没有你要的数据！")
}
//另一种删除方式，直接全部清空
num = make(map[string]string) //用make在重新分配空间，原来的就被回收了
fmt.Println(num)
}
map的遍历
package main
import "fmt"
func main() {
num := make(map[string]int)
num["十："] = 10
num["十一："] = 11
num["十二"] = 12
for i, v := range num { //和数组的遍历差不多
fmt.Printf(" 编号为：%v 的值为：%v", i, v)
}
}
map切片
package main
import "fmt"
func main() {
var ok []map[string]string
ok = make([]map[string]string, 1) //这里必须加，1，不然编译错误
if ok[0] == nil {
ok[0] = make(map[string]string) //这里可以不加，1可以自动扩容
ok[0]["name"] = "fyf"
ok[0]["age"] = "20"
}
fmt.Println(ok[0])
}
map的按顺序输出
package main
import (
"fmt"
"sort"
)
func main() {
num := make(map[int]int)
num[1] = 12
num[2] = 33
num[6] = 45
num[7] = 889
var keys []int //定义一个切片来存放map的编号
for k, _ := range num { //循环遍历，将map的key赋值给定义的切片。
keys = append(keys, k)
}
sort.Ints(keys) //利用内置sort函数来对map的key进行排序
for _, v := range keys { //注意这里遍历的是定义的切片，v的值是map的key值
fmt.Printf("编号为%v的值为%v\n", v, num[v])
}
}
标签：map,slice,string,fmt,笔记,Println,go,main 来源： https://blog.csdn.net/F1718835499/article/details/123475682
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。