更新于 

大厂面试题

For-Range

1. 以下代码是死循环么?

1
2
3
4
5
6
func main() {
    v := []int{1, 2, 3}
    for i := range v {
        v = append(v, i)
    }
}
答: 不会死循环, 只会循环3次

对于切片的for range，它的底层代码就是:

1
2
3
4
5
6
7
8
//   for_temp := range
//   len_temp := len(for_temp)
//   for index_temp = 0; index_temp < len_temp; index_temp++ {
//       value_temp = for_temp[index_temp]
//       index = index_temp
//       value = value_temp
//       original body
//   }

从上述代码可以看出第2行, 在进入循环之前已经确定好循环次数, 所以这段代码不会死循环。

2.下面这段代码有什么问题?

1
2
3
4
5
6
7
8
9
10
slice := []int{0, 1, 2, 3}
myMap := make(map[int]*int)
for index, value := range slice {
    fmt.Println(&index, &value)
    myMap[index] = &value
}
fmt.Println("=====new map=====")
for k, v := range myMap {
    fmt.Printf("%d => %d\n", k, *v)
}
输出的结果 value 一样
1
2
3
4
5
== ===new map=====
0 => 3
1 => 3
2 => 3
3 => 3

循环切片，index和value地址一开始分配好后，后面还是那个地址。结果完全一样，都是最后一次遍历的值。通过上面的底层代码看下，遍历后的值赋给了value，而在我们的例子中，会把value的地址保存到myMap的值中。这里的value是个「全局变量」，所以赋完值之后myMap里面所有的值都是value，所以结构都是一样的而且是最后一个值。

注意: 这里必须是保存指针才会有问题，如果直接保存的是value，因为 Golang 是值拷贝，所以值会重新复制再保存，这种情况下结果就会是正确的了。

3. var i interface{} = 3 会额外分配堆内存么?

1
2
3
var a int = 3
// 会有额外的堆内存分配么?
var i interface{} = a
不需要进行内存分配

接口类型
首先，在Go中，接口类型可以简单表示为:

1
2
3
4
type iface struct {
    tab *itab
    data unsafe.Pointer
}

其中 tab 是指向类型信息的指针; data 是指向值的指针。因此，一般来说接口意味着必须再堆中动态分配。

然而，从Go 1.15 开始，在 runtime 部分提到了一个改进:

Converting a small integer value into an interface value no longer causes allocation.

将小整数转换为接口值不再需要进行内存分配。(小整数是指 0 到 255 之间的数)

convert a small integer
Benchmark:

1
2
3
4
5
6
7
8
9
10
package integer

func Convert(val int) interface{} {
    var intSlice = make([]interface{}, 100)
    for i := 0; i < 100; i++ {
        intSlice[i] = val
    }

    return intSlice
}

integer_test.go

1
2
3
4
5
6
7
8
9
10
11
12
13
package integer_test

import (
    "testing"
    "test/integer"
)

func BenchmarkConvert(b *testing.B) {
    for i := 0; i < b.N; i++ {
        result := integer.Convert(50)
        _ = result
    }
}

分别使用 Go1.14 和 Go1.15 版本进行测试：

1
2
3
4
5
6
7
8
9
10
$ go version
go version go1.14.15 windows/amd64
$ go test -bench . -benchmem ./...
goos: windows
goarch: amd64
pkg: test/integer
cpu: Intel(R) Core(TM) i5-8400 CPU @ 2.80GHz
BenchmarkConvert-6        571444              1961 ns/op            2624 B/op        102 allocs/op
PASS
ok      integer/integer 1.521s
1
2
3
4
5
6
7
8
9
10
$ go version
go version go1.15 windows/amd64
$ go test -bench . -benchmem ./...
goos: windows
goarch: amd64
pkg: test/integer
cpu: Intel(R) Core(TM) i5-8400 CPU @ 2.80GHz
BenchmarkConvert-6       5008514               286.3 ns/op             0 B/op          0 allocs/op
PASS
ok   test/integer 1.754s

从上述测试结果可以清晰地看出，Go1.15版本执行分配了0次内存，而Go1.14.15分配了102次内存。我们将Convert中的参数由50改为500，再次运行：

1
2
3
4
5
6
7
8
$ go test -bench . -benchmem ./...
goos: windows
goarch: amd64
pkg: test/integer
cpu: Intel(R) Core(TM) i5-8400 CPU @ 2.80GHz
BenchmarkConvert-6        800016              1382 ns/op             800 B/op        100 allocs/op
PASS
ok      integer/integer 1.193s

实际上，Go 以前有一个优化，如果你将 0 转换为接口值，它将返回一个指向特殊静态零值的指针。这次新的 0-255 优化替代了该值。

对具体实现细节感兴趣的，可以阅读提交。

4. 以下代码输出什么? 如果去掉注释又会输出什么?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import (
    "fmt"
)

func main() {
    a := [2]int{5, 6}
    b := [2]int{5, 6}
    if a == b {
        fmt.Println("equal")
    } else {
        fmt.Println("not equal")
    }

  /*
    if a[:] == b[:] {
        fmt.Println("equal")
    } else {
        fmt.Println("not equal")
    }
    */
}
equal, invalid operation: a[:] == b[:] (slice can only be compared to nil)

切片之间不支持逻辑运算符，仅能判断是否为nil，比如：

1
2
3
var a []int
b := []int{}
fmt.Println(a == nil, b == nil) // true, false

5. 请问 n 是多少?

1
2
3
4
var m int32 = 0x12345678
var n int8 = int8(m)
fmt.Println(fmt.Sprintf("0x%x", n))
// A: 0x12  B: -0x1  C: 0x78   D: 0x7F
结果: C

为什么呢？

我们加一下代码来看看

1
2
3
4
5
6
var m int32 = 0x12345678
fmt.Println(fmt.Sprintf("%.32b", m))
var n int8 = int8(m)

fmt.Println(fmt.Sprintf("%.8b", n))
fmt.Println(fmt.Sprintf("0x%x", n))

打印结果:

1
2
3
00010010001101000101011001111000
01111000
0x78

可见，转换为int8后，只取了后面8bit

如果转为int16呢？

再添加代码

1
2
3
4
5
6
7
8
var m int32 = 0x12345678
fmt.Println(fmt.Sprintf("%.32b", m))
var n int8 = int8(m)
var i int16 = int16(m)
fmt.Println(fmt.Sprintf("%.16b", i))
fmt.Println(fmt.Sprintf("0x%x", i))
fmt.Println(fmt.Sprintf("%.8b", n))
fmt.Println(fmt.Sprintf("0x%x", n))

打印结果:

1
2
3
4
5
00010010001101000101011001111000
0101011001111000
0x5678
01111000 // 可见是从右往左截取的
0x78

6. 以下代码是否正确? 为什么?

1
2
3
4
5
6
7
8
9
10
package main

const cl = 100

var bl = 123

func main() {
    println(&bl, bl)
    println(&cl, cl)
}
不正确, 无法通过

Go中常量不可寻址
golang中不能寻址的可以总结为：不可变的，临时结果和不安全的。只要符合其中任何一个条件，它就是不可以寻址的。

  • 常量的值
  • 基本类型值的字面量
  • 算术操作的结果值
  • 对各种字面量的索引表达式和切片表达式的结果值
    • 不过有一个例外，对切片字面量的索引结果值却是可寻址的
  • 对字符串变量的索引表达式和切片表达式的结果值
  • 对字典变量的索引表达式的结果值
  • 函数字面量和方法字面量，以及对它们的调用表达式的结果值
  • 结构体字面量的字段值，也就是对结构体字面量的选择表达式的结果值
  • 类型转换表达式的结果值
  • 类型断言表达式的结果值
  • 接收表达式的结果值

7. 以下代码输出什么? 为什么?

1
2
3
4
5
6
7
8
9
10
11
12
13
package main

const s = "abnerwei.com"
// len(s) == 12
// 1 << 12 == 4096
// 4096 / 128 == 32

var a byte = 1 << len(s) / 128
var b byte = 1 << len(s[:]) / 128

func main() {
  println(a, b)
}
32 0

本题设计几个知识点:
len 函数
len 是一个内置函数。在官方标准库文档关于 len 函数有这么一句：

For some arguments, such as a string literal or a simple array expression, the result can be a constant. See the Go language specification’s “Length and capacity” section for details.

这很重要

当参数是字符串字面量和简单 array 表达式，len 函数返回值是常量。

如果将上述代码中 const s = "abnerwei.com" 改为 var s = "abnerwei.com", 结果是否有变化?

1
2
3
4
5
6
7
8
9
10
package main

var s = "abnerwei.com"

var a byte = 1 << len(s) / 128
var b byte = 1 << len(s[:]) / 128

func main() {
  println(a, b) // 0  0
}

接着, 我们再将变量s改为[]byte

1
2
3
4
5
6
7
8
9
10
package main

var s = [12]byte{'a','b','n','e','r','w','e','i','.','c','o','m'}

var a byte = 1 << len(s) / 128
var b byte = 1 << len(s[:]) / 128

func main() {
  println(a, b) // 4  0
}

内置函数 len 和 cap 获取各种类型的实参并返回一个 int 类型结果。实现会保证结果总是一个 int 值。

如果 s 是一个字符串常量，那么 len(s) 是一个常量 。如果 s 类型是一个数组或到数组的指针且表达式 s 不包含 信道接收 或（非常量的） 函数调用的话， 那么表达式 len(s) 和 cap(s) 是常量；这种情况下， s 是不求值的。否则的话， len 和 cap 的调用结果不是常量且 s 会被求值。

1
2
var a byte = 1 << len(s) / 128 // 第一句的 len(s) 是常量（因为 s 是字符串常量）, 值为12
var b byte = 1 << len(s[:]) / 128 // 第二句的 len(s[:]) 不是常量, 值为12

位移操作
关于位移操作符描述:

The right operand in a shift expression must have integer type or be an untyped constant representable by a value of type uint. If the left operand of a non-constant shift expression is an untyped constant, it is first implicitly converted to the type it would assume if the shift expression were replaced by its left operand alone.

在位移表达式的右侧的操作数必须为整数类型，或者可以被 uint 类型的值所表示的无类型的常量。如果一个非常量位移表达式的左侧的操作数是一个无类型常量，那么它会先被隐式地转换为假如位移表达式被其左侧操作数单独替换后的类型。

因此对于 var a byte = 1 << len(s) / 128，因为 1 << len(s) 是一个常量位移表达式，因此它的结果也是一个整数常量，所以是 4096，最后除以 128，最终结果就是 32。

而对于 var b byte = 1 << len(s[:]) / 128，因为 1 << len(s[:]) 不是一个常量位移表达式，而做操作数是 1，一个无类型常量，根据规范定义它是 byte 类型（根据：如果一个非常量位移表达式的左侧的操作数是一个无类号常量，那么它会先被隐式地转换为假如位移表达式被其左侧操作数单独替换后的类型）。

常量
常量是在编译的时候就确定好的。在 Go 中，字面值常量， true , false , iota 以及一些仅包含无类型的恒定操作数的 常量表达式 是无类型的。

所以 var b byte = 1 << len(s[:]) / 128 中，根据定义，1 会隐式转换为 byte 类型，因此 1 << len(s[:]) 的结果也是 byte 类型，而 byte 类型最大只能表示 255，很显然 4096 溢出了，结果为 0，因此最后 b 的结果也是 0。

8. 这道题 reslice题, 结果是什么?

1
2
3
4
5
6
7
8
9
10
11
package main

func a() []int {
    a1 := []int{3}
    a2 := a1[1:]
    return a2
}

func main() {
    a()
}

看到这个题, 你的第一反应是啥?

1
2
3
4
(A) 编译失败
(B) panic: runtime error: index out of range [1] with length 1
(C) []
(D) 其他
第一感觉len(a1) = 1, a1[1] 肯定会 panic, 但结果为`C: []`

a1, a2 共享共同的底层数组, len(a1) = 1, a1[1] 绝对会 panic, 但是 a[1:]却可以正常输出?
调试代码

1
2
3
4
5
a1 := []int{3}
fmt.Printf("len:%d, cap:%d", len(a1), cap(a1))
fmt.Println("a[0:]", a1[0:])
fmt.Println("a[1:]", a1[1:])
fmt.Println("a[2:]", a1[2:])

结果:

1
2
3
4
len: 1, cap: 1
a[0:] [1]
a[1:] []
panic: runtime error: slice bounds out of range [2:1]

从代码来看，从a[2:]才开始 panic，接下来看下汇编代码
汇编代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
"".a STEXT size=87 args=0x18 locals=0x18
	0x0000 00000 (main.go:3)	TEXT	"".a(SB), ABIInternal, $24-24
	0x0000 00000 (main.go:3)	MOVQ	(TLS), CX
	0x0009 00009 (main.go:3)	CMPQ	SP, 16(CX)
	0x000d 00013 (main.go:3)	PCDATA	$0, $-2
	0x000d 00013 (main.go:3)	JLS	80
	0x000f 00015 (main.go:3)	PCDATA	$0, $-1
	0x000f 00015 (main.go:3)	SUBQ	$24, SP
	0x0013 00019 (main.go:3)	MOVQ	BP, 16(SP)
	0x0018 00024 (main.go:3)	LEAQ	16(SP), BP
	0x001d 00029 (main.go:3)	FUNCDATA	$0, gclocals·2a5305abe05176240e61b8620e19a815(SB)
	0x001d 00029 (main.go:3)	FUNCDATA	$1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
	0x001d 00029 (main.go:4)	LEAQ	type.[1]int(SB), AX
	0x0024 00036 (main.go:4)	MOVQ	AX, (SP)
	0x0028 00040 (main.go:4)	PCDATA	$1, $0
	0x0028 00040 (main.go:4)	CALL	runtime.newobject(SB)
	0x002d 00045 (main.go:4)	MOVQ	8(SP), AX
	0x0032 00050 (main.go:4)	MOVQ	$1, (AX)
	0x0039 00057 (main.go:6)	MOVQ	AX, "".~r0+32(SP)
	0x003e 00062 (main.go:6)	XORPS	X0, X0
	0x0041 00065 (main.go:6)	MOVUPS	X0, "".~r0+40(SP)
	0x0046 00070 (main.go:6)	MOVQ	16(SP), BP
	0x004b 00075 (main.go:6)	ADDQ	$24, SP
	0x004f 00079 (main.go:6)	RET
	0x0050 00080 (main.go:6)	NOP
	0x0050 00080 (main.go:3)	PCDATA	$1, $-1
	0x0050 00080 (main.go:3)	PCDATA	$0, $-2
	0x0050 00080 (main.go:3)	CALL	runtime.morestack_noctxt(SB)
	0x0055 00085 (main.go:3)	PCDATA	$0, $-1
	0x0055 00085 (main.go:3)	JMP	0
	0x0000 65 48 8b 0c 25 00 00 00 00 48 3b 61 10 76 41 48  eH..%....H;a.vAH
	0x0010 83 ec 18 48 89 6c 24 10 48 8d 6c 24 10 48 8d 05  ...H.l$.H.l$.H..
	0x0020 00 00 00 00 48 89 04 24 e8 00 00 00 00 48 8b 44  ....H..$.....H.D
	0x0030 24 08 48 c7 00 01 00 00 00 48 89 44 24 20 0f 57  $.H......H.D$ .W
	0x0040 c0 0f 11 44 24 28 48 8b 6c 24 10 48 83 c4 18 c3  ...D$(H.l$.H....
	0x0050 e8 00 00 00 00 eb a9                             .......
	rel 5+4 t=17 TLS+0
	rel 32+4 t=16 type.[1]int+0
	rel 41+4 t=8 runtime.newobject+0
	rel 81+4 t=8 runtime.morestack_noctxt+0

主要看这两行

1
2
3
0x002d 00045 (main.go:4)	MOVQ	8(SP), AX
0x0032 00050 (main.go:4)	MOVQ	$1, (AX)
0x0039 00057 (main.go:6)	MOVQ	AX, "".~r0+32(SP)

在翻阅了官方文档，了解到这是故意的, 保持 reslice 的对称性。

思考一下:

  • a1, a2 是如何共享底层数组的?
  • a1[low:high]是如何实现的?

拓展

语法糖代码

map

1
2
3
4
5
6
7
8
9
10
// Lower a for range over a map.
// The loop we generate:
//   var hiter map_iteration_struct
//   for mapiterinit(type, range, &hiter); hiter.key != nil; mapiternext(&hiter) {
//           index_temp = *hiter.key
//           value_temp = *hiter.val
//           index = index_temp
//           value = value_temp
//           original body
//   }

channel

1
2
3
4
5
6
7
8
9
10
// Lower a for range over a channel.
// The loop we generate:
//   for {
//           index_temp, ok_temp = <-range
//           if !ok_temp {
//                   break
//           }
//           index = index_temp
//           original body
//   }

array

1
2
3
4
5
6
7
8
9
10
// Lower a for range over an array.
// The loop we generate:
//   len_temp := len(range)
//   range_temp := range
//   for index_temp = 0; index_temp < len_temp; index_temp++ {
//           value_temp = range_temp[index_temp]
//           index = index_temp
//           value = value_temp
//           original body
//   }

string

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Lower a for range over a string.
// The loop we generate:
//   len_temp := len(range)
//   var next_index_temp int
//   for index_temp = 0; index_temp < len_temp; index_temp = next_index_temp {
//           value_temp = rune(range[index_temp])
//           if value_temp < utf8.RuneSelf {
//                   next_index_temp = index_temp + 1
//           } else {
//                   value_temp, next_index_temp = decoderune(range, index_temp)
//           }
//           index = index_temp
//           value = value_temp
//           // original body
//   }
参考资料

欢迎大佬们补充答案或提交新的题目, 有不准确的地方也请斧正