【Golang】✔️走进 Go 语言✔️ 第十九课 错误处理 & 时间处理
【摘要】
【Golang】✔️走进 Go 语言✔️ 第十九课 错误处理 & 时间处理
概述错误处理除数为零错误
时间处理timerticker速率限制
概述
Golang 是一个跨平...
概述
Golang 是一个跨平台的新生编程语言. 今天小白就带大家一起携手走进 Golang 的世界. (第 19 课)
错误处理
在 Go 语言中, 使用的是一个单独的返回值来传达错误, 于传统的语言不同. 错误是最后一个返回值, 并有类型: error. 通过对它们实现Error()方法, 可以使用自定义类型作为错误.
定义:
type error interface {
Error() string
}
- 1
- 2
- 3
除数为零错误
解决方法:
package main
import "fmt"
// 结构体
type DividedError struct {
numerator int // 分子
denominator int // 分母
}
// Error接口, 处理任何类型错误, 返回字符串结果
func (de *DividedError)Error() string {
strFormat := "分母不能为 0"
return fmt.Sprint(strFormat, de.denominator)
}
// 定义除法函数
func Divide(numerator int, denominator int) (result int, errorMsg string){
if denominator == 0 {
error_data := DividedError{numerator, denominator}
errorMsg = error_data.Error()
return
} else {
return numerator / denominator, "ok"
}
}
func main() {
// 100除以10
result1, error1 := Divide(100, 10)
if error1 == "ok" {
fmt.Println("结果:", result1)
} else {
fmt.Println("错误:", error1)
}
// 除数为0
result2, error2 := Divide(1, 0)
if error2 == "ok" {
fmt.Println("结果:", result2)
} else {
fmt.Println("错误:", error2)
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
输出结果:
结果: 10
错误: 分母不能为 00
- 1
- 2
时间处理
计时器代表未来的一个事件, 可告诉计时器您想要等待多长时间. 计时器为我们提供了一个通道,在特定的时间执行对应的程序.
timer
timer 是定时器, 每到固定的时间后会执行一次
例子:
package main
import (
"fmt"
"time"
)
func main() {
// 创建计时器
timer1 := time.NewTimer(time.Second * 5)
<- timer1.C // 阻塞, 5秒后继续执行
fmt.Println("wait")
// 创建计时器
timer2 := time.NewTimer(time.Second * 5)
go func() {
<- timer2.C
fmt.Println("timer2 过期")
}()
// time.Sleep(time.Second * 10)
// 阻断time2
stop2 := timer2.Stop()
if stop2 {
fmt.Println("time2 终止")
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
输出结果:
wait
time2 终止
- 1
- 2
ticker
ticker 只要定义完成, 从此刻开始计时, 不需要任何其他操作. 每隔固定时间都会触发.
例子:
package main
import (
"fmt"
"time"
)
func main() {
// ticker
ticker := time.NewTicker(time.Second)
// 协程
go func() {
for t := range ticker.C { // 定时干活
fmt.Println("tick", t)
}
}()
// 等待10s, 使得协程能够运行
time.Sleep(time.Second * 10)
ticker.Stop()
fmt.Println("gameover")
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
输出结果:
tick 2021-08-17 01:28:19.7360444 -0400 EDT m=+1.004053601
tick 2021-08-17 01:28:20.7480858 -0400 EDT m=+2.016095001
tick 2021-08-17 01:28:21.7338822 -0400 EDT m=+3.001891401
tick 2021-08-17 01:28:22.7356228 -0400 EDT m=+4.003632001
tick 2021-08-17 01:28:23.7374798 -0400 EDT m=+5.005489001
tick 2021-08-17 01:28:24.7394163 -0400 EDT m=+6.007425501
tick 2021-08-17 01:28:25.7412068 -0400 EDT m=+7.009216001
tick 2021-08-17 01:28:26.7425907 -0400 EDT m=+8.010599901
tick 2021-08-17 01:28:27.7444257 -0400 EDT m=+9.012434901
gameover
tick 2021-08-17 01:28:28.7462812 -0400 EDT m=+10.014290401
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
速率限制
方法 1:
package main
import (
"fmt"
"time"
)
func main(){
// 创建通道
requests := make(chan int, 5)
// 发送任务
for i := 0; i < 5; i++ {
requests <- i
fmt.Println("发送任务:", i)
}
// 关闭通道
close(requests)
// 限制通道, 每200ms接收一个数据
limiter := time.Tick(time.Millisecond * 200)
// 接收任务
for request := range requests{
// 每200ms接收一个数据
<- limiter
fmt.Println("request", request, time.Now())
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
输出结果:
发送任务: 0
发送任务: 1
发送任务: 2
发送任务: 3
发送任务: 4
request 0 2021-08-17 02:50:33.6029614 -0400 EDT m=+0.207132401
request 1 2021-08-17 02:50:33.8014898 -0400 EDT m=+0.405660801
request 2 2021-08-17 02:50:34.006185 -0400 EDT m=+0.610356001
request 3 2021-08-17 02:50:34.2114027 -0400 EDT m=+0.815573701
request 4 2021-08-17 02:50:34.4003125 -0400 EDT m=+1.004483501
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
方法 2:
package main
import (
"fmt"
"time"
)
func main(){
// 时间限制器
time_limiter := make(chan time.Time, 3)
// 发送时间
go func() {
for t := range time.Tick(time.Millisecond * 200) {
time_limiter <- t
fmt.Println("发送任务:", t)
}
}()
// 请求限制器
requests_limiter := make(chan int, 5)
for i := 0; i < 5; i++ {
requests_limiter <- i
}
// 关闭通道
close(requests_limiter)
for request := range requests_limiter{
// 时间限制， 间隔200ms
<- time_limiter
fmt.Println("request", request, time.Now())
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
输出结果:
request 0 2021-08-17 02:48:51.6795088 -0400 EDT m=+0.207010401
发送任务: 2021-08-17 02:48:51.6792399 -0400 EDT m=+0.206741501
request 1 2021-08-17 02:48:51.8787624 -0400 EDT m=+0.406264001
发送任务: 2021-08-17 02:48:51.8786156 -0400 EDT m=+0.406117201
发送任务: 2021-08-17 02:48:52.0836354 -0400 EDT m=+0.611137001
request 2 2021-08-17 02:48:52.0837566 -0400 EDT m=+0.611258201
发送任务: 2021-08-17 02:48:52.2883148 -0400 EDT m=+0.815816401
request 3 2021-08-17 02:48:52.2883909 -0400 EDT m=+0.815892501
发送任务: 2021-08-17 02:48:52.4776006 -0400 EDT m=+1.005102201
request 4 2021-08-17 02:48:52.4776447 -0400 EDT m=+1.005146301
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
文章来源: iamarookie.blog.csdn.net，作者：我是小白呀，版权归原作者所有，如需转载，请联系作者。
原文链接：iamarookie.blog.csdn.net/article/details/119745669
【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）