一、Go面试题及答案2022
2022年，面试官们可能会问到这些Go语言面试题：
1、如何在Go中实现继承？
Go语言没有继承这个概念，但是我们可以通过 struct 的定义来达到类继承的效果，利用和内嵌结构体类似的语法可以定义出一个类似于 Go 语言继承的实现。2、谈谈你对goroutine的理解？
Goroutine 是 Go 的一个非常重要的特性，其优雅的并发机制令人称道。Goroutine 是一种用户线程，底层实现使用了 M:N 调度模型，一般情况下在底层会自动映射到系统线程。
3、如何进行面向对象编程？
在 Go 中，面向对象 OOP 构建需要用到结构体 struct。结构体可以有自己的属性和方法，可以通过接口 interface 实现多态。Go 支持封装，但不支持继承和多态，但是通过组合和嵌入可以达到类似的效果。
4、关于channel，以下哪种说法是错误的？
a. channel 支持无缓冲和有缓冲两种方式。
b. channel 的 send 和 receive 操作都是阻塞操作。
c. channel 必须关闭才能引发接收端的“closed channel”错误。
d. channel 可以用来协调多个 goroutine 的同步操作。
答案：c
在 Go 中，channel 是一种非常重要的通信机制，其可以用于 goroutine 之间的通信和同步，其 send 和 receive 操作都是阻塞操作，支持无缓冲和有缓冲两种方式，可用于协调多个 goroutine 的同步操作。但 channel 不需要显式关闭，关闭 channel 后再进行 send 操作会引发 panic 错误。
二、Go语言面试题及答案解析
在Go的面试中，常见的题目又包括：
1、如何创建一个goroutine并启动它？
go func() {
// do something
}()2、如何遍历切片？
a := []int{1, 2, 3, 4, 5}
for i := 0; i < len(a); i++ {
fmt.Println(a[i])
}
//或
for index, value := range a {
fmt.Printf("a[%d]: %d\n", index, value)
}3、如何实现接口的多重继承？
在 Go 中，一个类型可以实现多个接口，达到多重继承的目的。例如，可以通过以下代码实现多重继承：
type Speaker interface {
speak()
}
type Jumper interface {
jump()
}
type Animal interface {
Speaker
Jumper
}
三、Golang面试题及答案知乎
以下是知乎上出现的一些面试题：
1、怎么避免defer的性能问题？
defer 语句会在函数返回时执行，如果同时有大量的defer 语句，可能会影响函数性能。可以通过尽可能减少 defer 语句或者使用函数或代码块等方式尽量缩小 defer 的作用范围来减小影响。
2、请使用Go实现一份经典的卡片游戏21点（Blackjack）。
//黑杰克
const (
POKER_A int = 1 + iota
POKER_2
POKER_3
POKER_4
POKER_5
POKER_6
POKER_7
POKER_8
POKER_9
POKER_10
POKER_J
POKER_Q
POKER_K
)
const (
POKER_S int = iota
POKER_H
POKER_C
POKER_D
)
type Card struct {
number int
suit int // 花色
}
func (card Card) toString() string {
str := ""
switch card.number {
case POKER_A:
str = "A"
case POKER_J:
str = "J"
case POKER_Q:
str = "Q"
case POKER_K:
str = "K"
default:
str = strconv.Itoa(card.number)
}
switch card.suit {
case POKER_S:
str += "S"
case POKER_H:
str += "H"
case POKER_C:
str += "C"
case POKER_D:
str += "D"
}
return str
}
type Deck []Card
func (deck *Deck) Init() {
for i := 1; i <= 13; i++ {
*deck = append(*deck, Card{i, POKER_S})
*deck = append(*deck, Card{i, POKER_H})
*deck = append(*deck, Card{i, POKER_C})
*deck = append(*deck, Card{i, POKER_D})
}
}
func (deck *Deck) Shuffle() {
for i := len(*deck) - 1; i >= 0; i-- {
j := rand.Intn(i + 1)
(*deck)[i], (*deck)[j] = (*deck)[j], (*deck)[i]
}
}
type Players struct {
name string
Money int
hands []Card
}
func getSum(hands []Card) int {
sum, countA := 0, 0
for _, hand := range hands {
if hand.number == POKER_A {
countA++
continue
}
if hand.number >= POKER_J {
sum += 10
} else {
sum += hand.number
}
}
if countA > 0 {
if sum <= 10 {
sum += countA * 11
} else {
sum += countA
}
}
return sum
}
func (player *Players) Hit(card Card) {
player.hands = append(player.hands, card)
}
func (player *Players) Stand() {
// do nothing
}
func (player Players) ToString() string {
str := fmt.Sprintf("%s's hand is: \n", player.name)
for _, card := range player.hands {
str += card.toString() + "\n"
}
return str
}
func main() {
rand.Seed(time.Now().UnixNano())
var deck Deck
deck.Init()
deck.Shuffle()
var dealer Players
dealer.name = "Dealer"
dealer.Hit(deck[0])
dealer.Hit(deck[1])
fmt.Println(dealer.ToString())
var player Players
player.name = "Player"
player.Hit(deck[2])
player.Hit(deck[3])
fmt.Println(player.ToString())
hitMe := true
for hitMe {
fmt.Print("Do you want another card? y/n: ")
var s string
fmt.Scanf("%s\n", &s)
if s == "y" {
player.Hit(deck[4])
fmt.Println(player.ToString())
if getSum(player.hands) > 21 {
fmt.Println("You are busted!!!")
hitMe = false
}
continue
} else {
hitMe = false
}
}
for getSum(dealer.hands) < 17 {
dealer.Hit(deck[len(dealer.hands)+len(player.hands)])
fmt.Println(dealer.ToString())
if getSum(dealer.hands) > 21 {
fmt.Println("Dealer is busted!!!")
}
}
playerSum := getSum(player.hands)
dealerSum := getSum(dealer.hands)
if playerSum > 21 {
fmt.Println("You lost!!!")
} else if playerSum > dealerSum {
fmt.Println("You win!!!")
} else if playerSum == dealerSum {
fmt.Println("Draw!!!")
} else {
fmt.Println("You lost!!!")
}
}四、Go面试题
1、为什么要使用go channel而不是sync.Mutex来进行并发访问控制？
go channel 是 Go 语言的重要特性，可以用于 goroutine 之间的通信和同步；而 sync.Mutex 可以用于互斥锁，防止同时对共享资源进行访问。在实现并发访问控制时，使用 go channel 能够有效地避免死锁和饥饿等问题，同时能够提高程序的可读性和可维护性。
2、Go中如何实现单例模式？
Go 语言并没有提供 Singleton 模式的原生支持，但是可以通过使用 sync.Once 来实现单例设计模式。具体来说，我们可以在某个公开的全局变量中初始化一个私有的全局单例，让任何需要访问这个单例的函数直接对这个全局变量进行访问即可。3、go语言中如何实现函数的异步调用？
在 Go 语言中实现异步调用主要是依靠 goroutine 这个语言特性，只需使用 go 关键字即可创建新的 goroutine。当需要创建一个新的go协程的时候，可以使用以下方式：
func main() {
go DoSth()
}五、Golang高级面试题
以下是一些高级的Golang面试题：
1、请解释一下Go语言中的接口是如何工作的？
在 Go 语言中，接口定义了一些方法的集合，并且不关心具体类型如何实现这些方法，只需要满足方法的数量和参数、返回值类型。结构体实现接口的方法有很多，包括值接收与指针接收、嵌入匿名接口等，即使一个类型中没有实现任何接口，我们仍然可以声明一个接收该类型的参数的接口变量。
2、如何在Go语言中实现一个迭代器？
在 Go 中，提供了 range 关键字用于迭代数组、切片、字典和管道等结构。同时，我们也可以使用 for 循环来自己实现迭代器：func IterSlice(slice []int) chan int {
ch := make(chan int)
go func() {
for _, v := range slice {
ch <- v
}
close(ch)
}()
return ch
}
3、请解释一下在Go语言中什么是空interface？
空接口 interface{} 是 Go 语言的一个特殊类型，它没有任何方法的定义，就是一个没有字段和方法的接口，其可以表示任何类型的值。空接口可以用于参数的传递和数据的存储，因为其能够接受所有类型的值。
六、Go Channel面试题
以下是一些关于Go Channel的面试题：
1、Go 中的 channel 主要有哪些类型？它们的优缺点分别是什么？
Go 中主要有以下几种 channel：无缓冲 channel、有缓冲 channel、单项 channel 和广播 channel。无缓冲 channel 的优点是能够保证同步性，缺点是容易导致死锁；有缓冲 channel 的优点是可以提高程序并发吞吐量，缺点是在缓冲区不足时可能导致阻
