GOLANG 面试题集

golang 使用什么数据类型？
基本数据类型
复合数据类型
特殊类型
go程序中的包是什么？
导入包的方式，现在已经不能使用相对路径？
go支持什么形式的类型转换
什么是gorotine?你如何停止它
go convey 是什么？一般用来做什么？
go 语言中的 new 和make 作用是什么？
new
make
go语言中数组和切片的区别是什么？
go语言中值传递和地址传递
值传递（Value Passing）
地址传递（Pointer Passing）
示例

golang 使用什么数据类型？

Go 语言（通常称为 Golang）支持多种数据类型，这些数据类型可以大致分为基本数据类型和复合数据类型两大类。下面是 Go 语言中的一些主要数据类型：

基本数据类型

布尔类型（bool）：表示逻辑上的真 (true) 或假 (false)。
整数类型：
- 有符号整数：int8, int16, int32, int64。
- 无符号整数：uint8（等同于 byte），uint16, uint32, uint64，以及 uintptr（用于存放指针）。
浮点数类型：float32, float64（默认的浮点数类型）。
复数类型：complex64, complex128。
字符串类型（string）：UTF-8 编码的字符序列。
rune 类型：等同于 int32，用于表示一个Unicode码点。

复合数据类型

数组（[n]Type）：固定长度的相同类型元素序列。
切片（[]Type）：可变长度的、动态数组，是对数组的封装。
结构体（struct）：聚合不同类型的数据项集合。
映射（map[KeyType]ValueType）：键值对的集合，键是唯一的。
通道（chan Type）：用于goroutine间的通信，可以是带缓冲或无缓冲的。
接口（interface{}）：定义一组方法规范，任何实现这些方法的类型都可视为该接口的实例。
函数：函数本身也是一种类型，可以作为变量的类型或者作为其他函数的返回值。

特殊类型

空接口（interface{}）：不包含任何方法的接口，可以被任何类型的值所满足。
指针类型（*Type）：指向某个类型的内存地址。

Go 语言的设计鼓励简洁明了的代码风格，其数据类型的选择也体现了这一点，旨在提供高效且易于理解的类型系统。

go程序中的包是什么？

在Go语言中，包（Package）是一种组织和重用代码的基本单位。包的主要目的是将相关的函数、类型、变量和常量等组织在一起，提供清晰的命名空间和模块化结构，以支持代码的模块化开发和避免命名冲突。以下是关于Go语言中包的一些关键点：

文件与包的关系：每个Go源文件（以.go为扩展名）都以package关键字开头，后面跟着该文件所属的包名。一个包可以包含多个源文件，所有文件必须声明相同的包名。
包名与目录：Go的包名通常与源文件所在的目录名相匹配。这种目录结构反映了包的层级关系，也称为工作区（Workspace）结构的一部分，有助于管理和组织代码。
导入包：在Go程序中，使用import语句来导入其他包，以便使用它们提供的功能。导入时可以使用相对路径或绝对路径（推荐使用全路径，即从GOPATH或模块路径开始的路径）。
初始化函数：每个包可以有一个或多个无参数、无返回值的函数，名为init。当包被导入时，其所有的init函数会自动执行，按照依赖顺序依次执行，但init函数在包的其他部分之前执行，用于设置包级别的变量或执行必要的初始化操作。
可见性规则：Go语言中，大写字母开头的标识符（如类型、函数、变量名）在包外是可见的，可以被其他包导入并使用；小写字母开头的则是未导出的，只能在同一个包内访问。
标准库包：Go语言提供了一个丰富的标准库，包含了很多预定义的包，如fmt（格式化输入输出）、os（操作系统功能）、net/http（网络编程与HTTP服务）等，这些包覆盖了日常开发中的大部分需求。

通过合理地组织和使用包，开发者能够编写出结构清晰、易于维护和重用的代码。

导入包的方式，现在已经不能使用相对路径？

实际上，Go 语言确实支持使用相对路径来导入本地包，但这通常仅限于在开发期间且有一定的限制条件。从Go 1.11 版本开始，Go 引入了模块（module）系统，该系统改变了包的管理和导入方式，鼓励使用绝对路径和模块化的包管理。不过，在某些特定的场景下，如在没有启用模块的项目或者在进行一些临时的开发调试时，仍然可以使用相对路径来导入本地包。

使用相对路径导入本地包的基本形式是这样的：

import (
    "./localPackage" // 当前目录下的 localPackage 文件夹
    "../anotherPackage" // 上一级目录中的 anotherPackage 文件夹
)

但是，这种做法有几个需要注意的点：

仅限于非模块化项目：在Go模块（go.mod）启用的情况下，推荐使用绝对路径来导入包，并且相对路径的导入可能会导致编译错误或不预期的行为。
限制性使用：相对路径导入主要适用于开发阶段或者小型项目，不适合用于构建大型系统或发布到生产环境的代码，因为这可能导致可移植性问题。
GOPATH 相关：在旧的 GOPATH 模式下，相对路径是相对于 $GOPATH/src 目录的。而在模块模式下，推荐的做法是使用模块路径。

总结来说，虽然Go语言技术上支持相对路径导入本地包，但在现代Go开发实践中，特别是使用Go模块的情况下，更倾向于使用绝对路径和模块系统来管理依赖，以提高代码的可维护性和跨环境一致性。

go支持什么形式的类型转换

Go语言支持以下几种形式的类型转换：

显式类型转换（Explicit Conversion）：这是最常见的类型转换方式，通过类型转换运算符来实现。其基本语法是将一个值放在要转换成的类型的括号中，例如：
```
var a int = 10
var b float64 = float64(a) // 将整型变量a转换为浮点型
```
类型断言（Type Assertions）：主要用于接口类型到具体类型的转换。有两种形式，一种是在确定值属于某一类型时使用，如果断言失败会引发panic；另一种是使用两个结果的形式（值，bool），第二个返回值表示断言是否成功。
```
var i interface{} = 10
j, ok := i.(int) // 如果i保存的值是int类型，j会赋值，ok为true；否则，j为类型int的零值，ok为false
```
使用标准库转换：如strconv包提供了字符串和其他基本类型之间的转换函数，如strconv.Atoi()将字符串转换为整型，strconv.Itoa()将整型转换为字符串。
隐式类型转换：Go语言在特定情况下允许编译器自动进行类型转换，这通常发生在两种类型兼容且不会导致数据丢失的情况下，例如将一个小的整型赋值给一个大的整型。
指针类型转换：在涉及不同类型的指针之间转换时，有时可以直接进行，但必须保证转换是安全的，即转换后的指针类型必须是原始类型的子类型或者是可以相互转换的类型。

需要注意的是，类型转换必须遵循类型安全原则，尤其是在进行数值类型转换时，确保不会发生精度损失或溢出。此外，不同类型之间的转换规则需要遵守Go语言的类型系统规则。

什么是gorotine?你如何停止它

Goroutine 是 Go 语言中的一个轻量级线程概念。它是协程（coroutine）的一种实现，允许程序同时执行多个函数或方法，而不需要创建操作系统级别的线程。与传统的线程相比，Goroutines 更加轻量级，创建和上下文切换的开销很小，使得一个 Go 应用程序可以轻松地同时运行成千上万个 Goroutine。要在 Go 中启动一个 Goroutine，你只需要在函数调用前加上关键字 go。

停止一个正在运行的 Goroutine 在 Go 语言中并不直接提供内置的支持，因为 Go 设计哲学鼓励通过通信来协调而不是通过共享内存或其他同步机制。尽管如此，有几种常见的模式可以用来“停止”或优雅地终止一个 Goroutine：

使用 Channel 作为信号：创建一个 channel 作为停止信号，当需要停止 Goroutine 时，向这个 channel 发送一个消息。Goroutine 在运行过程中需要定期检查这个 channel，一旦收到消息就自行退出。

done := make(chan struct{})
go func() {
    for {
        select {
        case <-done:
            // 收到停止信号，退出循环
            return
        default:
            // 执行正常任务
        }
    }
}()
// 当需要停止时
done <- struct{}{}

使用 Context 包：对于处理请求和长时间运行的任务，Go 标准库中的 context 包提供了一种取消和截止时间的功能，可以用来控制 Goroutine 的生命周期。

ctx, cancel := context.WithCancel(context.Background())
go func(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            // 上下文被取消，退出
            return
        default:
            // 执行任务
        }
    }
}(ctx)
// 当需要停止时
cancel()

关闭 Channel 作为数据流的终止：如果你的 Goroutine 是在读取一个 Channel 中的数据，那么关闭那个 Channel 就可以自然地结束循环。
OS Signal 处理：对于整个程序的响应外部信号（如 Ctrl+C）来终止运行中的 Goroutine，可以使用 os/signal 包来监听 OS 信号，并在接收到信号时执行清理和退出逻辑。

总的来说，停止一个 Goroutine 更多的是通过合作的方式来实现，即 Goroutine 需要主动检查某种外部条件（通常是通过 Channel）来决定是否继续执行或退出，而不是被外部强制中断。

go convey 是什么？一般用来做什么？

GoConvey 是一个为 Go 语言设计的测试框架，它遵循行为驱动开发（Behavior Driven Development, BDD）的理念，旨在使编写测试更加简洁、可读性强，并提供丰富的可视化界面来实时显示测试结果。GoConvey 通过简化测试代码的结构和增加自动化的特性，提升了开发者的测试效率和体验。

GoConvey 的主要特点包括：

行为驱动开发风格：GoConvey 支持使用自然语言风格的表述来定义测试场景，使得非技术人员也能理解测试的目的。
自动化与可视化：它提供一个Web界面，可以实时监控代码变化并在文件改动时自动运行相关测试，测试结果以图形化的方式展现，包括通过、失败、以及代码覆盖率等信息。
断言简化：内置了易于理解的断言函数，使得测试失败时的错误信息更加明确，便于快速定位问题。
并发测试支持：鉴于Go语言对并发的支持，GoConvey也很好地集成了并发测试的能力。

一般用来做什么：

编写单元测试和集成测试：GoConvey 可以帮助开发者编写结构化的测试用例，验证函数、方法或模块的行为是否符合预期。
提高代码质量：通过编写全面的测试，可以在开发初期发现并修复错误，保证代码的稳定性和可靠性。
促进团队协作：由于测试用例采用了易于理解的BDD风格，非编写者也能容易理解测试目的，有利于代码审查和团队间的沟通。
持续集成/持续部署（CI/CD）：结合自动化测试工具，可以在代码提交后自动运行GoConvey测试，确保每次提交的代码都能通过基本的质量检查。
代码覆盖率分析：帮助开发者了解测试覆盖程度，识别哪些部分代码还未被测试覆盖，从而指导进一步的测试编写。

总之，GoConvey 是一个提升Go语言项目测试质量和开发效率的强大工具，特别适合那些追求高效测试流程和高质量代码的团队和项目。

go 语言中的 new 和make 作用是什么？

在Go语言中，new和make都是用于内存分配的内置函数，但它们之间存在一些关键差异，主要用途和适用场景也不相同。

new

用途: new函数用于分配一个类型的零值，并返回该类型的指针。换句话说，它在堆上分配内存，并为该类型的所有字段设置零值。这对于基本类型或者结构体等是很有用的，当你需要一个零初始化的实例并且后续需要显式地设置各个字段的值时。
返回值: 返回的是指向新分配的零值对象的指针（*T）。
适用类型: new可以用于任何类型的内存分配，无论是基本类型、结构体、数组还是自定义类型。

示例:

p := new(int) // 分配一个int类型的零值，并返回一个指向该int的指针

make

用途: make函数专门用于初始化切片（slice）、映射（map）和通道（channel）这类动态数据结构。它不仅分配内存，还会初始化这些数据结构的内部元数据（如长度和容量对于切片，映射的哈希表等），使得它们可以直接使用而无需额外的初始化步骤。
返回值: 返回的是已经初始化完成的引用类型对象本身（比如slice、map或channel），而不是指针。
适用类型: 仅用于切片（[]T）、映射（map[K]V）和通道（chan T）这三种类型。

示例:

s := make([]int, 10) // 分配并初始化一个长度为10的int切片
m := make(map[string]int) // 初始化一个空的string到int的映射
ch := make(chan int) // 创建一个无缓冲的int通道

总结来说，当你需要为基本类型或结构体等分配内存并获取一个零值指针时，应该使用new。而当你需要初始化并使用切片、映射或通道时，应该使用make。

go语言中数组和切片的区别是什么？

Go语言中数组和切片是两种不同的数据结构，它们有以下主要区别：

内存分配与所有权：
- 数组：数组是值类型，这意味着当你创建一个数组时，它会在栈或堆上分配固定大小的连续内存空间来存储元素。数组之间赋值会进行值拷贝，即完全复制整个数组的内容。
- 切片：切片是引用类型，它本质上是一个结构体，包含指向底层数组的指针、长度（len）和容量（cap）。当你创建或复制切片时，只是复制这个结构体，底层数组不会被复制，因此多个切片可能共享同一个底层数组。
长度与容量：
- 数组：长度（数组中的元素数量）是固定的，在声明时确定，之后不可改变。
- 切片：长度也是动态的，可以根据需要调整，但它还有一个容量的概念，表示底层数组的总大小。切片的长度可以在其容量范围内自由调整，但超过容量时，如果不进行扩容操作，就需要创建一个新的底层数组。
初始化与使用：
- 数组：需要明确指定所有元素的初始值，或者显式地初始化为零值。
- 切片：可以通过内置函数make来创建，指定长度和容量，或者通过数组的一部分来创建切片。
内存管理与扩展：
- 数组：大小固定，无法直接扩展。
- 切片：当需要更多空间时，可以通过追加元素（如使用append函数）来自动扩展切片的容量，但这可能导致底层数组的重新分配和数据复制。
传递给函数：
- 数组：作为参数传递时，整个数组会被复制，对于大数组这可能非常低效。
- 切片：传递给函数时，只传递切片的描述信息（指针、长度和容量），不会复制底层数组，因此效率更高。

总的来说，数组适用于静态大小、固定不变的数据集合，而切片则提供了更灵活的动态数据结构，适用于需要灵活调整大小或高效操作集合的情况。

go语言中值传递和地址传递

在Go语言中，参数传递主要分为值传递和地址传递（也可以理解为引用传递，尽管Go中没有传统意义上的引用类型，但指针的使用效果类似）。

值传递（Value Passing）

含义：当函数的参数是基础类型（如int、float、bool等）或复合类型的值（如数组、结构体）时，Go语言采用值传递。这意味着函数接收的是参数的一个副本，对这个副本的修改不会影响到原始数据。
特点：简单直观，安全，因为不会影响到原始数据。但如果参数是大型结构体或数组，可能会因为复制整个数据结构而消耗较多资源。

地址传递（Pointer Passing）

含义：当函数的参数是指针类型时，Go语言采用地址传递。这里传递的是变量的地址而非实际的值，因此在函数内部对指针解引用后可以修改原始数据。
特点：高效，特别是对于大型数据结构，因为只需要传递一个地址（通常是一个指针大小）。这允许函数直接操作外部数据，但也要求开发者注意数据同步和潜在的并发问题。

示例

假设我们有一个简单的例子来说明两者的区别：

package main

import "fmt"

// 使用值传递
func modifyValue(x int) {
    x = x + 10
}

// 使用地址传递
func modifyPointer(x *int) {
    *x = *x + 10
}

func main() {
    val := 10
    fmt.Println("Before value pass:", val)
    modifyValue(val)
    fmt.Println("After value pass:", val) // val 不变，仍然是 10

    ptr := new(int)
    *ptr = 10
    fmt.Println("Before pointer pass:", *ptr)
    modifyPointer(ptr)
    fmt.Println("After pointer pass:", *ptr) // *ptr 变为 20
}

在这个例子中，modifyValue函数采用值传递，所以对x的修改不会影响到main函数中的val。而modifyPointer函数通过指针（地址传递）修改了外部变量，因此main函数中的ptr指向的值发生了改变。

最后编辑: Simon 文档更新时间: 2024-05-17 22:30 作者：Simon