Golang基础面试题1

来源于fullstack，绿色为重点

1. Go语言是什么

Go 是一种通用编程语言，设计初衷是为了进行系统编程。它最初是由 Google 的 Robert Griesemer、Rob Pike 和 Ken Thompson 在 2007 年开发的。Go 语言是强类型且静态类型的，它内置了对垃圾回收的支持，并支持并发编程。程序通过使用包（package）来构建，以高效管理依赖关系。Go 编程的实现使用传统的编译和链接模型来生成可执行二进制文件。

简而言之，Go 语言是为了高效、可靠和并发地构建软件系统而设计的，特别适用于需要高性能和快速开发的场景。

2.Go是语言？库？还是框架

Go 不是库也不是框架，它是一种全新的语言。

Go 语言主要在 C 语言家族（基本语法）的基础上发展而来，同时也大量借鉴了 Pascal/Modula/Oberon 家族（声明、包）的特点。Go 语言拥有一个庞大的库，被称为运行时（runtime），它是每个 Go 程序的一部分。尽管运行时对于语言来说更加核心，但 Go 的运行时与 C 语言库 libc 是类似的。然而，重要的是要理解，Go 的运行时并不包括一个虚拟机，如 Java 运行时所提供的那样。Go 程序会提前编译成原生机器代码。

简而言之，Go 语言通过提前编译成原生机器代码来提供高效的性能，而不是依赖虚拟机来执行代码。这使得 Go 程序在运行时可以接近或达到与用底层语言（如 C 或 C++）编写的程序相同的性能水平。

3.Go有异常exceptions吗

不，Go 语言采用了不同的方法。对于普通的错误处理，Go 语言的多返回值特性使得报告错误而不重载返回值变得非常容易。Go 代码使用错误值来指示异常状态。

具体来说，Go 鼓励函数返回两个值：预期的结果和一个错误值。当函数遇到错误时，它会返回一个非空的错误值，调用者可以检查这个错误值以确定是否发生了错误，并据此采取适当的行动。这种错误处理模式在 Go 社区中非常普遍，它提供了一种清晰、简洁的方式来处理错误，同时避免了像其他语言中使用异常处理机制可能带来的性能开销和复杂性。

func Open(name string) (file *File, err error)
f, err := os.Open("filename.ext")
if err != nil {
    log.Fatal(err)
}
// do something with the open *File f
1
2
3
4
5
6

4. Go支持什么样的类型转换

Go 语言在显式类型方面非常严格。它不支持自动的类型提升或转换。要将一个类型的变量赋值给另一个类型的变量，需要显式的类型转换。

这意味着你不能简单地将一个整数（int）赋值给一个浮点数（float64）变量，除非你明确地告诉 Go 语言你希望进行这样的转换。这种显式的类型转换要求有助于减少错误和类型不匹配的问题，使得代码更加清晰和可维护。

例如，如果你有一个 int 类型的变量 i，你想将它赋值给一个 float64 类型的变量 f，你需要这样做：

i := 42  
f := float64(i) // 显式类型转换
1
2

5. 使用Go语言的好处

• 支持类似于动态语言的编程模式：例如类型推断（x := 0 是有效声明一个类型为 int 的变量 x 的方式）。

• 编译速度快

• 内置并发支持：比如轻量级的进程（通过 goroutines）、通道（channels）和 select 语句来支持并发编程

• 简洁性、简单性和安全性

• 支持接口和类型嵌入：Go 语言支持接口，这使得代码更加灵活和可重用。此外，类型嵌入允许在一个类型中嵌入另一个类型的字段，从而简化了代码结构。

• 支持静态链接：Go 编译器支持静态链接，这意味着所有的 Go 代码可以被静态链接到一个单独的大二进制文件中。这使得部署到云服务器变得容易，无需担心依赖关系的问题。

6. Go语言是如何被创造的

Go 语言的诞生源于对现有系统编程语言及其环境的失望。Go 语言试图实现以下目标：

1. 拥有解释型、动态类型语言的特性，同时保持静态类型、编译型语言的高效性和安全性。
2. 支持网络和多核计算。
3. 快速编译。

为了实现这些目标，需要解决一系列语言学问题，如表达性强但轻量级的类型系统、并发和垃圾回收、严格的依赖规范等。这些问题无法仅通过库或工具来很好地解决，因此诞生了新的编程语言 Go。

7. Goroutine是什么

Goroutine 是与其他函数或方法并发运行的函数或方法。可以将 Goroutine 视为轻量级的线程。与线程相比，创建 Goroutine 的成本非常小。在 Go 应用程序中，通常会有数千个 Goroutine 同时运行，这是很常见的。

在 Go 中，你可以使用 go 关键字来启动一个 Goroutine。例如：

go func() {  
    // 这个匿名函数将会作为一个 Goroutine 运行  
    fmt.Println("Hello, World!")  
}()
1
2
3
4

在上面的代码中，go 关键字告诉编译器将匿名函数作为一个独立的 Goroutine 来执行，而不会阻塞当前的执行流。

Goroutine 的调度和管理是由 Go 运行时（runtime）自动处理的，开发者通常不需要关心底层的线程管理细节。这使得并发编程在 Go 中变得简单而高效。

8. 一个函数允许有多个返回值吗

允许

package main
import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}
func main() {
   a, b := swap("Tom", "Jerry")
   fmt.Println(a, b)
}
1
2
3
4
5
6
7
8
9
10

9. Go里的动态类型变量声明

动态类型变量声明要求编译器根据传递给变量的值来解释变量的类型。编译器不需要变量具有静态类型作为必要条件。

10. 可以一次性声明不同类型的变量吗

可以，使用类型推理可以一次性使用不同类型的变量

var a, b, c =  3,  4,  "foo"  
1

11.Go里的静态类型变量声明是什么

在Go语言中，静态类型变量声明为编译器提供了保证，即存在一个具有给定类型和名称的变量，这样编译器就可以在不需要知道变量完整细节的情况下继续进行编译。变量声明只在编译时有其意义，编译器在程序链接时需要实际的变量声明。

// 静态类型变量声明  
var age int  // 声明一个名为 age 的变量，类型为 int  
var name string // 声明一个名为 name 的变量，类型为 string  
  
// 为变量赋值  
age = 30  
name = "Alice"
1
2
3
4
5
6
7

12. 使用Go的时候有哪些优势

Go 是一种尝试引入新的、并发的、带有快速编译和以下优点的垃圾收集语言：

• 可以在单个计算机上在几秒钟内编译一个大型 Go 程序。

• Go 提供了一种软件构建模型，使依赖关系分析变得简单，并避免了 C 风格包含文件和库的许多开销。

• Go 的类型系统没有层次结构，因此不会花费时间去定义类型之间的关系。虽然 Go 有静态类型，但该语言试图使类型感觉比典型的面向对象语言更轻量级。

• Go 完全支持垃圾收集，并为并发执行和通信提供基本支持。

• 通过其设计，Go 提出了一种在多核机器上构建系统软件的方法。

13. 指针是什么

指针可以保存变量的地址

var x =  5 
var p *int p =  &x
fmt.Printf("x = %d",  *p)
1
2
3

*运算符，叫解引用运算符，访问地址中的值；&运算符，称为地址运算符，用于返回变量的地址

14. 如何高效拼接字符串

详细方法对比

从Go 1.10版本开始，引入了一个名为strings.Builder的类型，它用于高效地生成字符串，通过Write方法实现。使用strings.Builder可以最小化内存复制操作，从而提高字符串拼接的性能。此外，strings.Builder的零值（即未初始化的状态）已经准备好可以直接使用，无需进一步初始化。

package main

import (
    "strings"
    "fmt"
)
func main() {
    var sb strings.Builder
    for i := 0; i < 1000; i++ {
        sb.WriteString("a")
    }
    fmt.Println(sb.String())
}
1
2
3
4
5
6
7
8
9
10
11
12
13

15. Go里的类型rune是什么

在Go语言中，rune类型是一个别名，它等价于int32类型。它被用来表示一个Unicode字符。Go语言使用UTF-8编码来表示字符串，UTF-8编码是一种可变长度的编码方式，一个字符可以由1到4个字节表示。由于一个字节可能不足以表示一个完整的字符，特别是对于那些大于一个字节且小于等于4个字节的字符（如中文字符），使用rune类型就非常有用。

以下是一个使用rune类型的示例：

package main  
  
import "fmt"  
  
func main() {  
    var r rune = '中' // '中'是一个中文字符，使用rune类型来表示  
    fmt.Println(r)    // 输出：中  
  
    s := "Hello, 世界!"  
    for _, c := range s {  
        fmt.Println(c) // 遍历字符串s中的每一个字符，并打印出来  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13

Go 语言中，字符串的底层表示是 byte (8 bit) 序列，而非 rune (32 bit) 序列。例如下面的例子中 语 和 言 使用 UTF-8 编码后各占 3 个 byte，因此 len("Go语言") 等于 8，当然我们也可以将字符串转换为 rune 序列。

fmt.Println(len("Go语言")) // 8
fmt.Println(len([]rune("Go语言"))) // 4
1
2