Golang学习 Day_08

最新推荐文章于 2024-10-17 18:29:54 发布
最新推荐文章于 2024-10-17 18:29:54 发布
阅读量40 收藏
点赞数
文章标签： golang 学习 开发语言 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52423136/article/details/129431051
版权

错误处理

package main


import "fmt"


func test() {
    num1 := 10
    num2 := 0
    res := num1 / num2
    fmt.Println("res=", res)
}


func main() {
    test()
    
    fmt.Println("main()下面的代码...")
}

  1. 在默认情况下，当发生错误后(panic)，程序会崩溃

  1. 如果我们希望，当发生错误后，可以捕获到错误，并进行处理，保证程序可以继续执行。还可以在捕获到错误后，给管理员一个提示。

基本说明

  1. Go语言不支持传统的try...catch...finally这种处理。

  1. Go中引入的处理方式为：defer，panic，recover

  1. Go中可以抛出一个panic的异常，然后在defer中通过recover捕获这个异常，然后正常处理。

使用defer和recover处理异常

package main


import "fmt"


func test() {
    //使用 defer + recover 来捕获和处理异常
    defer func() {
        err := recover()
        if err != nil {
            fmt.Println("err=", err)
        }
    }()
    num1 := 10
    num2 := 0
    res := num1 / num2
    fmt.Println("res=", res)
}


func main() {
    test()
    fmt.Println("main()下面的代码...")
}

进行错误处理后，程序不会轻易地崩溃，如果加入预警代码，就可以让程序更加健壮

自定义错误

Go支持自定义错误，使用errors.New 和 panic 内置函数

  1. errors.New("错误说明")，会返回一个error类型的值，表示一个错误

  1. panic内置函数，接收一个interface{}类型的值作为参数，可以接受error类型的变量，输出错误信息，并退出程序。

数组和切片

数组可以存放多个同一类型数据。数据也是一种数据类型，在Go中，数组是值类型

package main


import "fmt"


func main() {
    var hens [6]float64
    hens[0] = 3.0
    hens[1] = 5.0
    hens[2] = 1.0
    hens[3] = 3.4
    hens[4] = 2.0
    hens[5] = 50.0
    totalWeight := 0.0
    for i := 0; i < len(hens); i++ {
        totalWeight += hens[i]
    }


    avgWeight := fmt.Sprintf("%.2f", totalWeight/float64(len(hens)) )
    fmt.Printf("totalWeight=%v avgWeight=%v", totalWeight, avgWeight)
}

  1. 使用数组来解决问题，程序的可维护性增加

  1. 方法清晰，更容易扩展

数组的定义和内存布局

定义

var 数组名 [数组大小] 数据类型

var a[5]int

数组在内存中的布局

package main


import "fmt"


func main() {
    var intArr [5]int
    for i := 0; i < len(intArr); i++ {
        fmt.Printf("%p\n", &intArr[i])
    }
}

  1. 数组的地址可以通过数组名来获取&

  1. 数组的第一个元素的地址，就是数组的首地址

  1. 数组的各个元素的地址大小间隔是依据数组的类型决定的

数组的使用

  1. 循环输入

package main


import "fmt"


func main() {
    var score [5]float64


    for i := 0; i < len(score); i++ {
        fmt.Printf("请输入第%d个元素的值\n", i)
        fmt.Scanln(&score[i])
    }


    for i := 0; i < len(score); i++ {
        fmt.Printf("第%d个值是%v\n", i, score[i])
    }
}

  1. 初始化数组

//四种初始化方式
var nums1 [3]int = [3]int{1, 2, 3}
fmt.Println("nums1=", nums1)


var nums2 = [3]int{5, 6, 7}
fmt.Println("nums2=", nums2)


var nums3 = [...]int{9, 8, 10}
fmt.Println("num3=", nums3)


var nums4 = [...]int{1: 800, 0: 900, 2: 999}
fmt.Println("num=", nums4)

  1. 类型推导

strs := [...]string{1: "tom", 0: "jack", 2: "mary"}
fmt.Println("strs=", strs)

数组的遍历

for-range结构遍历

语法：

for index,value := range array{}

  1. 第一个返回值index是数组的下标

  1. 第二个value是在该下标位置的值

  1. 他们都是仅在for循环内部可见的局部变量

  1. 遍历数组元素的时候，如果不想使用下标index，可以直接把下标为下划线

  1. index和value的名称不是固定的，及程序员可以自行指定，一般命名为index和value

heros := [...]string{"刘备", "关羽", "张飞"}
for i, v := range heros {
    fmt.Printf("i=%v v=%v\n", i, v)
}

数组的注意事项和细节

  1. 数组是多个相同类型的数据组合，一个数组一旦声明/定义了，长度是固定的，不能动态变化。

  1. var arr[]int 这时arr就是一个slice切片

  1. 数组中的元素可以是任何数据类型，包括值类型和引用类型，但不能混用

  1. 数组创建后，如果没有赋值，有默认值

  1. 使用数组的步骤

  1. 声明数组并开辟空间

  1. 给数组的各个元素赋值

  1. 使用数组

  1. 数组的下标是从0开始的

  1. 数组下标必须贼指定范围内使用，否则报panic，数组越界

  1. Go的数组属于值类型，在默认情况下是值传递，因此会进行拷贝。数组之间不会相互影响

  1. 如果想在其他函数中，去修改原来的数组，可以使用引用传递(指针方式)

package main


import "fmt"


func test01(arr [3]int) {
    arr[0] = 9
}


func test02(arr *[3]int) {
    arr[0] = 9
    fmt.Printf("%p\n", &arr[0])
    (*arr)[0] = 10
    fmt.Printf("%p\n", &arr[0])
}


func main() {
    arr := [3]int{1, 3, 4}
    fmt.Println(arr)
    arr[2] = 8
    fmt.Println(arr)
    test01(arr)
    fmt.Println(arr)
    test02(&arr)
    fmt.Println(arr)


}

  1. 长度是数组类型的一部分，在传递函数参数时，需要考虑数组的长度

练习

创建一个byte类型的26个元素的数组，分别放置'A'-'Z'

使用for循环访问所有元素并打印出来。'A'+1 ->'B'

package main


import "fmt"


func main() {
    //创建一个byte类型的26个元素的数组，分别放置'A'-'Z'
    //使用for循环访问所有元素并打印出来。'A'+1 ->'B'


    var myChar [26]byte
    for i := 0; i < 26; i++ {
        myChar[i] = 'A' + byte(i)
    }
    for _, v := range myChar {
        fmt.Printf("%c\n", v)
    }
}
求出一个数组的最大值，并得到对应下标
package main


import "fmt"


func main() {
    // 求出一个数组的最大值，并得到对应下标
    var intArr = [...]int{1, -2, 4, 15, -9, 123, 43}
    maxVal := intArr[0]
    maxValIndex := 0


    for i, v := range intArr {
        if maxVal < v {
            maxVal = v
            maxValIndex = i
        }
    }
    fmt.Printf("最大值为%v,下标为%v\n", maxVal, maxValIndex)
}

数组的复杂使用-数组反转

随机生成五个数，并其反转打印

package main


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


func main() {
    // 随机生成五个数，并其反转打印
    var arry [5]int
    rand.Seed(time.Now().Unix())
    for i := 0; i < len(arry); i++ {
        arry[i] = rand.Intn(100)
    }
    fmt.Println(arry)


    temp := 0
    for i := 0; i < len(arry)/2; i++ {
        temp = arry[len(arry)-1-i]
        arry[len(arry)-1-i] = arry[i]
        arry[i] = temp
    }
    fmt.Println(arry)
}

切片(slice)

  1. 切片的英文是slice

  1. 切片是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用传递的机制

  1. 切片的使用和数组类似，遍历切片、访问切片的元素和求切片的长度len都一样

  1. 切片的长度可以变化，因此切片是一个可以动态变化数组

  1. 语法：

var 变量名 []类型

package main


import "fmt"


func main() {
    // 演示切片的基本内容
    var intArr [5]int = [...]int{1, 22, 34, 23, 43}


    slice := intArr[1:3]
    fmt.Println(slice)
    //切片的容量是动态变化的
    fmt.Println("slice 的容量 =", cap(slice))
}

切片使用

  1. 定义一个切片，然后让切片去引用一个已经创建好的数组

  1. 通过make来创建切片

var 切片名 []type = make([]type,len,[cap])

  1. 通过make方式创建切片可以指定切片的大小和容量

  1. 如果没有给切片的各个元素赋值，那么就会使用默认值

  1. 通过make方式创建的切片对应的数组是由make底层维护，对外不可见，即只能通过slice去访问各个元素

  1. 定义一个切片，直接就指定具体数组，使用原理类似make的方式

var strSlice []string = []string{"tom", "jack", "mary"}
fmt.Println("strSlice=", strSlice)
fmt.Println("strSlice size=", len(strSlice))
fmt.Println("strSlice size=", cap(strSlice))

切片遍历

  1. 常规遍历

var arr [5]int = [...]int{10, 20, 30, 40, 50}
slice := arr[1:4]
for i := 0; i < len(slice); i++ {
    fmt.Printf("slice[%v]=%v\n", i, slice[i])
}

  1. for-range遍历

for i, v := range slice {
    fmt.Printf("slice[%v]=%v\n", i, v)
}

切片注意事项和细节说明

  1. 切片初始化时 varslice = arr[startIndex:endIndex]

从arr数组下标startIndex，取到下标为endIndex的元素

  1. 切片初始化时，仍然不能越界。范围在[0-len(arr)]之间，但是可以动态增长

  1. var slice = arr[0:end]可以简写 var slice = arr[:end]

  1. var slice = arr[start:len(arr)] 可以简写 var slice = arr[start:]

  1. var slice = arr[0:len(arr)]可以简写 var slice = arr[:]

  1. cap是一个内置函数，用于统计切片的容量，即最大可存放多少个元素

  1. 切片定义完后，还不能使用，因为本身是一个空的，需要让其引用到一个数组，或者make一个空间供切片来使用

  1. 切片可以继续切片

  1. append内置函数，将元素追加到切片的末尾，动态增加切片

  1. 切片append操作的本质就是对数组扩容

  1. go底层会创建一下新的数组newArr

  1. 将slice原来包含的元素拷贝到新的数组newArr

  1. slice重新引用到newArr

  1. 注意newArr是在底层用来维护的，程序员不可见

var slice3 []int = []int{100, 200, 300}
slice3 = append(slice3, 400, 500)
fmt.Println("slice3", slice3)

  1. 切片使用copy内置函数完成拷贝

var a []int = []int{1, 2, 3, 4, 5}
var slice4 = make([]int, 10)
copy(slice4, a)
fmt.Println(a)
fmt.Println(slice4)

  1. copy(para1,para2)参数的数据类型是切片

  1. 按照上面的代码来看，slice4和a的数据空间是独立的，相互不影响

  1. 切片是引用类型，所以在传递时，遵守引用传递机制

package main


import "fmt"


func test(slice []int) {
    slice[0] = 100
}


func main() {
    var slice = []int{1, 2, 3, 4}
    fmt.Println("slice=", slice)
    test(slice)
    fmt.Println("slice=", slice)
}

string和slice的关系

  1. string底层是一个byte数组，因此string也可以进行切片处理

package main


import "fmt"


func main() {
    str := "hello golang"
    slice := str[6:]
    fmt.Println("slice=",slice)
}

  1. string本身是不可变的，也就是说不能通过 str[0] = 'z'方式来修改字符

  1. 如果需要修改字符串，可以先将string-->[]byte/或者[]rune -->修改-->重写string

package main


import "fmt"


func main() {
    str := "hello golang"
    slice := str[6:]
    fmt.Println("slice=", slice)


    // arr1 := []byte(str)
    // arr1[0] = 'z'
    // str = string(arr1)
    // fmt.Println("str=", str)


    // 细节，转成byte后，可以处理英文和数字，但不能处理中文
    // 解决方法，将 string转成 []rune


    arr1 := []rune(str)
    arr1[0] = '一'
    str = string(arr1)
    fmt.Println("str=", str)
}

练习

编写一个函数fbn(n int)

  1. 可以接收一个n int

  1. 能够将斐波那契额的数列放到切片中

package main


import "fmt"


func fbn(n int) []uint64 {
    fbnSlice := make([]uint64, n)
    fbnSlice[0] = 1
    fbnSlice[1] = 1
    for i := 2; i < n; i++ {
        fbnSlice[i] = fbnSlice[i-1] + fbnSlice[i-2]
    }
    return fbnSlice
}
func main() {
    fnbSlice := fbn(20)
    fmt.Println("fnbSlice=", fnbSlice)
}

排序和查找

排序

排序是将一组数据，按指定的顺序进行排列的过程

  1. 内部排序：将需要处理的所有数据都加载到内部存储器中进行排序，包括（交换式排序、选择式排序法和插入式排序法）

  1. 外部排序法：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。（合并排序法和直接合并排序法）

交换式排序法

运用数据值比较后，按判断规则对数据位置进行交换，以达到排序的目的

  1. 冒泡排序法（Bubble sort)

  1. 快速排序法(Quick sort)

余木榆木
关注
Golang学习 Day_09
qq_52423136的博客
03-10 112
Golang学习 Day_09 map,面向“对象”编程，结构体，方法 “如果你无力去做那种惊天动地的大事，那就满怀热情地做好眼前的小事”
Golang学习 Day_11
qq_52423136的博客
03-12 114
Golang学习Day_11
Golang学习 Day_12
qq_52423136的博客
03-13 209
Golang学习 Day_12
Golang学习 Day_05
qq_52423136的博客
03-06 80
Golang学习 Day_05
Golang学习 Day_16 Gin框架
qq_52423136的博客
03-20 121
Golang学习 Day_16 Gin框架
Golang学习 Day_14
qq_52423136的博客
03-15 144
Golang学习 Day_14
Golang学习 Day_10
qq_52423136的博客
03-11 103
Golang学习 Day_10
Golang学习 Day_04
qq_52423136的博客
03-05 173
Golang学习 Day_04
Golang学习 Day_17 Gin框架02
qq_52423136的博客
03-21 160
Golang学习 Day_17 Gin框架02
Golang学习 Day_02
qq_52423136的博客
03-03 94
Golang学习 Day_02 因为是从语雀笔记上直接贴过来的，有些地方格式不舒服见谅
Day3 Golang学习笔记
weixin_51920241的博客
05-03 194
今日学习部分 1. 常见的四种变量声明方式与多变量声明方式 2. const与iota知识点注意事项 3. Golang中函数的多返回值的三种写法 4. import导包路径问题与init方法调用流程 总结 知道了变量的声明方式以及其简洁的声明方法，还有Goland里节省内存的表现： var a int fmt.Println("a = ", a) 声明了变量a，后面就必须得用到a，不然声明变量的那行代码中，a处就会划红线，提示错误为Unused variable ‘a’ 声明全局变量，方法一、二、
Golang学习笔记
技术宇宙
01-05 2022
目录特点天然并发函数可以返回多个值开发目录结构Golang 执行流程分析参考 特点 Go 语言保证了既能到达静态编译语言的安全和性能，又达到了动态语言开发维护的高效率动态语言开发维护的高效率 使用一个表达式来形容 Go 语言：Go = C + Python 说明 Go 语言既有 C 静态语言程序的运行速度，又能达到 Python 动态语言的快速开发 天然并发 从语言层面支持并发，实现简单 goroutine，轻量级线程，可实现大并发处理，高效利用多核 基于 CSP 并发模型(Communicating S
日常学习总结golang(day5)---文件操作
lili9415的博客
03-28 193
文件操作 文件是什么？ 计算机中的文件是存储再外部介质(通常是磁盘)上的数据集合，文件分为文本文件和二进制文件。 1. 打开和关闭文件 os.Open()函数能够打开一个文件，返回一个*File和一个err。对得到的文件实例调用close()方法能够关闭文件。 func main() { //只读的方式打开当前目录下的demo.go file,err:=os.Open("./demo.go")...
日常学习总结golang(day1)---数组、切片、指针
lili9415的博客
03-24 265
对于go语言的语法还是简单易懂的，不过还是要多看看，加深一下印象。而只学基本语法是根本无法满足开发的需求的。最近跟着视频学习，除了基本语法还有并发、中间件、日志库、互联网协议、Mysql、redis、gin、docker等等。为了以后自己复习方便，看完后进行一些总结。有需要的同学也可以看一下！ 1. for…range(键值循环) Go语言中可以使用for...range遍历数组、切片、字符串、...
日常学习总结golang(day4)---包、接口
lili9415的博客
03-27 169
1. 包(package) 包的定义： package关键字，包名通常是和目录名一致，不能含有- 一个文件夹就是一个包，文件夹里存放的都是.go文件 包的导入：使用import关键字。 a.包导入路径是从$GOPATH/src后面的路径开始写起的； b.可以单行导入，也可以多行导入； c.可以给导入的包起别名，也可以匿名导入：import _"包的路径"。匿名导入的包与其它方式导入的包一样都会被...
Golang笔记_day10
Runing_WoNiu的博客
10-16 252
1、什么是channel，为什么它可以做到线程安全。2、Golang Epoll原理。
Windows 下 golang 多版本管理
最新发布
追风2019
10-17 1012
本文介绍了在Windows环境下管理多个版本的Golang的方法。首先，需要下载不同版本的Golang安装包，并修改目录名称。接着，通过添加GPPATH环境变量、配置PATH环境变量以及在命令行和Goland中设置go env环境，实现多版本共存。此外，还提到了官方建议和使用g工具进行版本管理的方法。作者通过这些步骤解决了特定框架在不同Golang版本间的兼容性问题。
Go Wails 学习笔记：创建第一个项目
程序媛平平无奇的一天
10-14 1148
Wails 通过结合前端技术和 Go 后端，提供了一个高效的方式来开发跨平台的桌面应用。其简单的项目初始化和清晰的结构使得开发者能够快速上手。通过 Wails，可以充分利用 Web 开发技能，同时获得原生桌面应用的优势。
GO语言指针有那些限制
lisus2007的专栏
10-16 489
GO语言指针类型限制
golang mysql时间戳_mysql-无效的复制时间戳
05-31
好的，关于你的问题，你可以尝试查看你使用的 MySQL 版本是否支持时间戳。如果支持，你可以使用 UNIX_TIMESTAMP 函数将时间戳转换为可读日期格式。如果还是出现无效的复制时间戳错误，可能是你的复制配置有问题，你需要检查你的配置文件是否正确。另外，你也可以尝试使用其他的 MySQL 驱动程序来解决这个问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值