【Golang 面试基础题】每日 5 题（二）

Pandaconda

已于 2024-07-21 18:30:53 修改

阅读量430

点赞数 16

分类专栏： # Golang 面试专栏文章标签：面试职场和发展 golang 开发语言后端

于 2024-07-21 18:29:53 首次发布

本文链接：https://blog.csdn.net/Newin2020/article/details/140591673

版权

Golang 面试专栏专栏收录该内容

2 篇文章 0 订阅

订阅专栏

✍个人博客：Pandaconda-CSDN博客
📣专栏地址：http://t.csdnimg.cn/UWz06

📚专栏简介：在这个专栏中，我将会分享 Golang 面试中常见的面试题给大家~
❤️如果有收获的话，欢迎点赞👍收藏📁，您的支持就是我创作的最大动力💪

6. 如何在运行时检查变量类型？

在 Go 语言中，可以使用反射（reflection）机制来在运行时检查变量的类型。反射是一种在程序运行时检查变量类型、值的机制，可以在不知道具体类型的情况下操作对象。

Go 语言中的反射主要依赖于 reflect 包提供的函数和类型。通过 reflect 包中的 TypeOf 和 ValueOf 函数，可以获取一个变量的类型和值，从而进行相关操作。以下是一个简单的示例代码：

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x interface{}
    x = 42
    t := reflect.TypeOf(x)
    v := reflect.ValueOf(x)
    fmt.Printf("Type: %v\n", t)
    fmt.Printf("Value: %v\n", v)
}

在上面的示例代码中，我们定义了一个接口变量 x，并将其赋值为 42。接着，使用 reflect.TypeOf 和 reflect.ValueOf 函数获取了变量 x 的类型和值，并分别打印输出。

需要注意的是，反射机制的使用可能会带来一定的性能损失，因此应该尽量避免过度使用反射。在编写代码时，应该尽可能地使用静态类型检查，避免在运行时进行类型检查和转换。

7. Go 两个接口之间可以存在什么关系？

在 Go 语言中，接口是一种类型，可以被用作变量类型、函数参数或返回值的类型。Go 语言中的接口类型是基于所包含的方法签名来定义的，两个接口之间可以存在以下几种关系：

接口类型的嵌套：一个接口类型可以包含其他的接口类型作为它的一部分，这种方式称为接口的嵌套。嵌套接口会继承被嵌套接口的所有方法，并可以添加新的方法。嵌套接口的实现类必须实现所有嵌套接口的方法。
接口类型的扩展：一个接口类型可以通过添加新的方法来扩展另一个接口类型，这种方式称为接口的扩展。被扩展接口的实现类也必须实现新添加的方法。
接口类型的类型转换：可以将一个接口类型转换为另一个接口类型，前提是这两个接口类型都包含相同的方法集合。
接口类型的实现：一个接口类型可以被多个不同的类型实现，这些类型可以是基本类型、自定义类型或者其他接口类型。

需要注意的是，两个接口之间的关系并不是继承关系，而是通过包含相同的方法集合来建立联系。这意味着，一个接口类型并不会继承另一个接口类型的属性和方法。

嵌套和扩展的区别

扩展和嵌套是不同的概念。

接口类型的嵌套是将一个接口类型作为另一个接口类型的一部分，嵌套的接口类型可以继承被嵌套接口类型的所有方法，并可以添加新的方法。

接口类型的扩展是在一个接口类型的基础上新增方法，被扩展的接口类型的实现类也必须实现新添加的方法。

嵌套和扩展的区别在于，嵌套是将接口类型作为另一个接口类型的一部分，而扩展是在接口类型的基础上新增方法。嵌套是一种组合关系，扩展是一种继承关系。

实例演示

1、接口类型的嵌套：假设有两个接口类型 A 和 B，其中 B 嵌套了 A。A 定义了一个方法 DoSomething()，B 新增了一个方法 DoSomethingElse()。那么实现 B 接口的类必须实现 A 接口中的 DoSomething() 方法和 B 接口中的 DoSomethingElse() 方法。

type A interface {
    DoSomething()
}

type B interface {
    A // A是B的一部分
    DoSomethingElse()
}

type MyClass struct {}

func (mc *MyClass) DoSomething() {
    fmt.Println("Do something.")
}

func (mc *MyClass) DoSomethingElse() {
    fmt.Println("Do something else.")
}

func main() {
    var b B = &MyClass{}
    b.DoSomething()
    b.DoSomethingElse()
}

2、接口类型的扩展：假设有两个接口类型 A 和 B，其中 A 定义了一个方法 DoSomething()，B 通过扩展 A 接口新增了一个方法 DoSomethingElse()。那么实现 B 接口的类必须实现 A 和 B 接口中的所有方法。

type A interface {
    DoSomething()
}

type B interface {
    A // 扩展A接口
    DoSomethingElse()
}

type MyClass struct {}

func (mc *MyClass) DoSomething() {
    fmt.Println("Do something.")
}

func (mc *MyClass) DoSomethingElse() {
    fmt.Println("Do something else.")
}

func main() {
    var b B = &MyClass{}
    b.DoSomething()
    b.DoSomethingElse()
}

3、接口类型的类型转换：假设有两个接口类型 A 和 B，其中 A 和 B 都定义了方法 DoSomething()。那么可以将 A 类型的变量转换为 BB类型的变量，前提是 A 和 B 包含相同的方法集合。

type A interface {
    DoSomething()
}

type B interface {
    DoSomething()
}

type MyClass struct {}

func (mc *MyClass) DoSomething() {
    fmt.Println("Do something.")
}

func main() {
    var a A = &MyClass{}
    var b B = a.(B) // 类型转换
    b.DoSomething()
}

4、接口类型的实现：假设有一个接口类型 A，它定义了一个方法 DoSomething()。那么可以有多个类型实现 A 接口，只要这些类型实现了 A 接口中定义的所有方法。

type A interface {
    DoSomething()
}

type MyClass1 struct {}

func (mc *MyClass1) DoSomething() {
    fmt.Println("Do something in MyClass1.")
}

type MyClass2 struct {}

func (mc *MyClass2) DoSomething() {
    fmt.Println("Do something in MyClass2.")
}

func main() {
    var a A = &MyClass1{}
    a.DoSomething()

    a = &MyClass2{}
    a.DoSomething()
}

8. Go 当中同步锁有什么特点？作用是什么？

在 Go 语言中，同步锁是一种常用的并发编程技术，用于保证多个 Goroutine 之间的共享数据的安全访问。Go 语言中的同步锁是通过 sync 包提供的 Mutex 类型实现的。

同步锁的特点如下：

互斥性：同一时刻只能有一个 Goroutine 持有锁，其他 Goroutine 需要等待锁的释放才能获取锁。
阻塞性：如果一个 Goroutine 尝试获取一个已经被其他 Goroutine 持有的锁，它会被阻塞，直到锁被释放。
公平性：锁的获取是公平的，即锁会按照申请的先后顺序分配给等待的 Goroutine，避免某些 Goroutine 永远无法获取锁的情况。

同步锁的作用是保护共享数据，避免多个 Goroutine 同时对共享数据进行修改而导致的竞争条件和数据竞争问题。在需要保证共享数据的安全访问时，可以使用同步锁来对临界区进行加锁，以避免并发修改数据产生的问题。在使用同步锁时，需要注意避免死锁和饥饿等问题的发生，同时需要合理地设计锁的粒度和作用域，避免锁的竞争导致性能下降。

实例

假设有一个全局变量 counter，多个 Goroutine 都要对其进行修改，为了保证对其安全访问，可以使用同步锁来实现：

import (
    "fmt"
    "sync"
)

var counter int
var mutex sync.Mutex

func increment() {
    mutex.Lock()         // 获取锁
    counter = counter + 1 // 修改共享变量
    mutex.Unlock()       // 释放锁
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            increment() // 调用共享变量修改函数
        }()
    }
    wg.Wait()
    fmt.Println("Counter:", counter)
}

9. Go 语言中 cap 函数可以作用于哪些内容？

在 Go 语言中，cap() 函数可以用于以下类型的数据：

数组：cap() 函数返回数组的长度，因为数组的长度在创建时就已经确定了。
切片：cap() 函数返回切片的容量，即切片底层数组的长度，它可能大于或等于切片的长度。切片容量的大小是在切片创建时自动分配的，也可以通过对切片使用 append() 函数来改变容量大小。
Channel：cap() 函数返回 Channel 的容量，即 Channel 缓冲区的大小，只有在创建带缓冲的 Channel 时，才有意义。