一、数据类型转换
1.转换规则
类型转换用于将一种数据类型的变量转换为另外一种类型的变量。Go 语言类型转换基本格式如下:
type_name(expression)
2.实例
package main
import "fmt"
func main() {
var sum int = 17
var count int = 5
var mean float32
mean = float32(sum)/float32(count)
fmt.Printf("mean 的值为: %f\n",mean)
}
二、接口
1.接口含义
Go 语言提供了另外一种数据类型即接口,它把所有的具有共性的方法定义在一起,任何其他类型只要实现了这些方法就是实现了这个接口。
2.实例
package main
import "fmt"
type Phone interface {
/* 定义结构体 */
call()
}
type NokiaPhone struct {
/* 定义结构体 */
}
func (nokiaPhone NokiaPhone) call() {
/* 实现接口方法 */
fmt.Println("I am Nokia, I can call you!")
}
type IPhone struct {
/* 定义结构体 */
}
func (iPhone IPhone) call() {
/* 实现接口方法 */
fmt.Println("I am iPhone, I can call you!")
}
func main() {
var phone Phone
phone = new(NokiaPhone)
phone.call()
phone = new(IPhone)
phone.call()
}
三、错误处理
1.error简介
Go 语言通过内置的错误接口提供了非常简单的错误处理机制。
type error interface {
Error() string}
我们可以在编码中通过实现 error 接口类型来生成错误信息。
函数通常在最后的返回值中返回错误信息。使用errors.New 可返回一个错误信息:
func Sqrt(f float64) (float64, error) {
if f < 0 {
return 0, errors.New("math: square root of negative number")
}
}
在下面的例子中,我们在调用Sqrt的时候传递的一个负数,然后就得到了non-nil的error对象,将此对象与nil比较,结果为true,所以fmt.Println(fmt包在处理error时会调用Error方法)被调用,以输出错误,请看下面调用的示例代码:
result, err:= Sqrt(-1)
if err != nil {
fmt.Println(err)
}
2.实例
package main
import "fmt"
// 定义一个 DivideError 结构
type DivideError struct {
dividee int
divider int
}
// 实现 `error` 接口
func (de *DivideError) Error() string {
strFormat := `
Cannot proceed, the divider is zero.
dividee: %d
divider: 0
`
return fmt.Sprintf(strFormat, de.dividee)
}
// 定义 `int` 类型除法运算的函数
func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
if varDivider == 0 {
dData := DivideError{
dividee: varDividee,
divider: varDivider,
}
errorMsg = dData.Error()
return
} else {
return varDividee / varDivider, ""
}
}
func main() {
// 正常情况
if result, errorMsg := Divide(100, 10); errorMsg == "" {
fmt.Println("100/10 = ", result)
}
// 当除数为零的时候会返回错误信息
if _, errorMsg := Divide(100, 0); errorMsg != "" {
fmt.Println("errorMsg is: ", errorMsg)
}
}
四、并发
1.并发介绍
Go 语言支持并发,我们只需要通过 go 关键字来开启 goroutine 即可。
Goroutine 是轻量级线程,Goroutine 的调度是由 Golang 运行时进行管理的。Goroutine 是 Go 语言并发模型的核心。一个 goroutine 是一个轻量级的线程,由 Go 运行时管理。启动一个 goroutine 是非常容易的,只需要在函数调用前加上关键字 go
。
语句:go f(x, y, z)
如:开启一个新的 goroutine:
f(x, y, z)
2.实例
package main
import (
"fmt"
"time"
)
func say(s string) {
for i := 0; i < 5; i++ {
time.Sleep(100 * time.Millisecond)
fmt.Println(s)
}
}
func main() {
go say("world")
say("hello")
}
在上面的代码中,main 函数中的 say("hello") 在主 goroutine 中调用,而 go say("world") 会在新的 goroutine 中执行。两个 goroutines 将并发执行。
Channel:
Channel 是 Go 中的一个非常重要的特性,它提供了一种在 goroutines 之间进行同步通信的方式。一个 channel 是一个通信机制,可以让一个 goroutine 发送特定值到另一个 goroutine。
package main
import (
"fmt"
"time"
)
func worker(done chan bool) {
fmt.Print("working...")
time.Sleep(time.Second)
fmt.Println("done")
// 发送一个值来通知我们已经完工啦。
done <- true
}
func main() {
done := make(chan bool, 1) // 创建一个通道
go worker(done) // 启动一个 goroutine
<-done // 阻塞,直到在通道中接收到 worker 发出的完成信号
}
在这个例子中,worker goroutine 工作完毕后,通过 done channel 发送了一个信号。main 函数中的 <-done 语句会阻塞直到从 channel 中接收到值,这是一种等待 goroutine 完成的方法。
Select
select 语句使一个 goroutine 可以等待多个通信操作。select 会阻塞到其中一个 case 可以继续执行,这时该 case 中的通信操作(发送或接收)就会执行,其他的不会执行。
package main
import (
"fmt"
"time"
)
func main() {
c1 := make(chan string)
c2 := make(chan string)
go func() {
time.Sleep(1 * time.Second)
c1 <- "one"
}()
go func() {
time.Sleep(2 * time.Second)
c2 <- "two"
}()
for i := 0; i < 2; i++ {
select {
case msg1 := <-c1:
fmt.Println("received", msg1)
case msg2 := <-c2:
fmt.Println("received", msg2)
}
}
}
在这个例子中,select 用来等待两个通道 c1 和 c2 的值。每个通道等待不同的时间后发送值,select 语句在每个通道准备好后接收值。
3.使用并发的注意事项
虽然 Go 语言让并发变得简单,但是仍然需要注意一些问题,比如共享资源的竞争条件,goroutine 泄露,以及channel的死锁等问题。确保正确地同步和通信是编写并发程序的关键。使用像互斥锁(sync.Mutex)这样的工具可以帮助管理对共享资源的访问,避免竞争条件。