151-180.md

> 目录
>
> * [151\. 下面列举的是 recover() 的几种调用方式，哪些是正确的？](#151-%E4%B8%8B%E9%9D%A2%E5%88%97%E4%B8%BE%E7%9A%84%E6%98%AF-recover-%E7%9A%84%E5%87%A0%E7%A7%8D%E8%B0%83%E7%94%A8%E6%96%B9%E5%BC%8F%E5%93%AA%E4%BA%9B%E6%98%AF%E6%AD%A3%E7%A1%AE%E7%9A%84)
> * [152\. 下面代码输出什么，请说明？](#152-%E4%B8%8B%E9%9D%A2%E4%BB%A3%E7%A0%81%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88%E8%AF%B7%E8%AF%B4%E6%98%8E)
> * [153\. flag 是 bool 型变量，下面 if 表达式符合编码规范的是？](#153-flag-%E6%98%AF-bool-%E5%9E%8B%E5%8F%98%E9%87%8F%E4%B8%8B%E9%9D%A2-if-%E8%A1%A8%E8%BE%BE%E5%BC%8F%E7%AC%A6%E5%90%88%E7%BC%96%E7%A0%81%E8%A7%84%E8%8C%83%E7%9A%84%E6%98%AF)
> * [154\. 下面的代码输出什么，请说明？](#154-%E4%B8%8B%E9%9D%A2%E7%9A%84%E4%BB%A3%E7%A0%81%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88%E8%AF%B7%E8%AF%B4%E6%98%8E)
> * [155\. 下面的代码输出什么？](#155-%E4%B8%8B%E9%9D%A2%E7%9A%84%E4%BB%A3%E7%A0%81%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88)
> * [156\. 下面的代码输出什么？](#156-%E4%B8%8B%E9%9D%A2%E7%9A%84%E4%BB%A3%E7%A0%81%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88)
> * [157\. 下面的代码输出什么？](#157-%E4%B8%8B%E9%9D%A2%E7%9A%84%E4%BB%A3%E7%A0%81%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88)
> * [158\. 下面的代码输出什么？](#158-%E4%B8%8B%E9%9D%A2%E7%9A%84%E4%BB%A3%E7%A0%81%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88)
> * [159\. 下面代码有什么问题吗？](#159-%E4%B8%8B%E9%9D%A2%E4%BB%A3%E7%A0%81%E6%9C%89%E4%BB%80%E4%B9%88%E9%97%AE%E9%A2%98%E5%90%97)
> * [160\. 下面代码输出什么，请说明。](#160-%E4%B8%8B%E9%9D%A2%E4%BB%A3%E7%A0%81%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88%E8%AF%B7%E8%AF%B4%E6%98%8E)
> * [161\. 关于 slice 或 map 操作，下面正确的是？](#161-%E5%85%B3%E4%BA%8E-slice-%E6%88%96-map-%E6%93%8D%E4%BD%9C%E4%B8%8B%E9%9D%A2%E6%AD%A3%E7%A1%AE%E7%9A%84%E6%98%AF)
> * [162\. 下面代码输出什么？](#162-%E4%B8%8B%E9%9D%A2%E4%BB%A3%E7%A0%81%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88)
> * [163\. 关于字符串连接，下面语法正确的是？](#163-%E5%85%B3%E4%BA%8E%E5%AD%97%E7%AC%A6%E4%B8%B2%E8%BF%9E%E6%8E%A5%E4%B8%8B%E9%9D%A2%E8%AF%AD%E6%B3%95%E6%AD%A3%E7%A1%AE%E7%9A%84%E6%98%AF)
> * [164\. 下面代码能编译通过吗？可以的话，输出什么？](#164-%E4%B8%8B%E9%9D%A2%E4%BB%A3%E7%A0%81%E8%83%BD%E7%BC%96%E8%AF%91%E9%80%9A%E8%BF%87%E5%90%97%E5%8F%AF%E4%BB%A5%E7%9A%84%E8%AF%9D%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88)
> * [165\. 判断题：对变量x的取反操作是 ~x？](#165-%E5%88%A4%E6%96%AD%E9%A2%98%E5%AF%B9%E5%8F%98%E9%87%8Fx%E7%9A%84%E5%8F%96%E5%8F%8D%E6%93%8D%E4%BD%9C%E6%98%AF-x)
> * [166\. 下面代码输出什么，请说明原因。](#166-%E4%B8%8B%E9%9D%A2%E4%BB%A3%E7%A0%81%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88%E8%AF%B7%E8%AF%B4%E6%98%8E%E5%8E%9F%E5%9B%A0)
> * [167\. 下面的代码输出什么，请说明。](#167-%E4%B8%8B%E9%9D%A2%E7%9A%84%E4%BB%A3%E7%A0%81%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88%E8%AF%B7%E8%AF%B4%E6%98%8E)
> * [168\. 下面的代码输出什么，请说明？](#168-%E4%B8%8B%E9%9D%A2%E7%9A%84%E4%BB%A3%E7%A0%81%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88%E8%AF%B7%E8%AF%B4%E6%98%8E)
> * [169\. 下面代码输出什么？](#169-%E4%B8%8B%E9%9D%A2%E4%BB%A3%E7%A0%81%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88)
> * [170\. 下面的代码能编译通过吗？可以的话输出什么，请说明？](#170-%E4%B8%8B%E9%9D%A2%E7%9A%84%E4%BB%A3%E7%A0%81%E8%83%BD%E7%BC%96%E8%AF%91%E9%80%9A%E8%BF%87%E5%90%97%E5%8F%AF%E4%BB%A5%E7%9A%84%E8%AF%9D%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88%E8%AF%B7%E8%AF%B4%E6%98%8E)
> * [171\. 下面代码有什么问题，请说明？](#171-%E4%B8%8B%E9%9D%A2%E4%BB%A3%E7%A0%81%E6%9C%89%E4%BB%80%E4%B9%88%E9%97%AE%E9%A2%98%E8%AF%B7%E8%AF%B4%E6%98%8E)
> * [172\. 假设 x 已声明，y 未声明，下面 4 行代码哪些是正确的。错误的请说明原因？](#172-%E5%81%87%E8%AE%BE-x-%E5%B7%B2%E5%A3%B0%E6%98%8Ey-%E6%9C%AA%E5%A3%B0%E6%98%8E%E4%B8%8B%E9%9D%A2-4-%E8%A1%8C%E4%BB%A3%E7%A0%81%E5%93%AA%E4%BA%9B%E6%98%AF%E6%AD%A3%E7%A1%AE%E7%9A%84%E9%94%99%E8%AF%AF%E7%9A%84%E8%AF%B7%E8%AF%B4%E6%98%8E%E5%8E%9F%E5%9B%A0)
> * [173\. 下面的代码有什么问题，请说明？](#173-%E4%B8%8B%E9%9D%A2%E7%9A%84%E4%BB%A3%E7%A0%81%E6%9C%89%E4%BB%80%E4%B9%88%E9%97%AE%E9%A2%98%E8%AF%B7%E8%AF%B4%E6%98%8E)
> * [174\. 下面代码输出什么，为什么？](#174-%E4%B8%8B%E9%9D%A2%E4%BB%A3%E7%A0%81%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88%E4%B8%BA%E4%BB%80%E4%B9%88)
> * [175\. 下面这段代码输出什么？](#175-%E4%B8%8B%E9%9D%A2%E8%BF%99%E6%AE%B5%E4%BB%A3%E7%A0%81%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88)
> * [176\. 下面的代码有什么问题？](#176-%E4%B8%8B%E9%9D%A2%E7%9A%84%E4%BB%A3%E7%A0%81%E6%9C%89%E4%BB%80%E4%B9%88%E9%97%AE%E9%A2%98)
> * [177\. 关于 cap 函数适用下面哪些类型？](#177-%E5%85%B3%E4%BA%8E-cap-%E5%87%BD%E6%95%B0%E9%80%82%E7%94%A8%E4%B8%8B%E9%9D%A2%E5%93%AA%E4%BA%9B%E7%B1%BB%E5%9E%8B)
> * [178\. 下面代码输出什么？](#178-%E4%B8%8B%E9%9D%A2%E4%BB%A3%E7%A0%81%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88)
> * [179\. 关于 switch 语句，下面说法正确的是？](#179-%E5%85%B3%E4%BA%8E-switch-%E8%AF%AD%E5%8F%A5%E4%B8%8B%E9%9D%A2%E8%AF%B4%E6%B3%95%E6%AD%A3%E7%A1%AE%E7%9A%84%E6%98%AF)
> * [180\. 下面代码能编译通过吗？可以的话，输出什么？](#180-%E4%B8%8B%E9%9D%A2%E4%BB%A3%E7%A0%81%E8%83%BD%E7%BC%96%E8%AF%91%E9%80%9A%E8%BF%87%E5%90%97%E5%8F%AF%E4%BB%A5%E7%9A%84%E8%AF%9D%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88)
>
> * [181\.181-194题](https://github.com/yqchilde/Golang-Interview/blob/master/181-194.md)

## 151. 下面列举的是 recover() 的几种调用方式，哪些是正确的？

* A

  ```go
  func main() {
      recover()
      panic(1)
  }
  ```

* B

  ```go
  func main() {
      defer recover()
      panic(1)
  }
  ```

* C

  ```go
  func main() {
      defer func() {
          recover()
      }()
      panic(1)
  }
  ```

* D

  ```go
  func main() {
      defer func() {
          defer func() {
              recover()
          }()
      }()
      panic(1)
  }
  ```

**答：C**

**解析：**

recover() 必须在 defer() 函数中直接调用才有效。上面其他几种情况调用都是无效的：直接调用 recover()、在 defer() 中直接调用 recover() 和 defer() 调用时多层嵌套。

## 152. 下面代码输出什么，请说明？

```go
func main() {
    defer func() {
        fmt.Print(recover())
    }()
    defer func() {
        defer fmt.Print(recover())
        panic(1)
    }()
    defer recover() 
    panic(2)
}
```

**答：21**

**解析：**

recover() 必须在 defer() 函数中调用才有效，所以第 9 行代码捕获是无效的。在调用 defer() 时，便会计算函数的参数并压入栈中，所以执行第 6 行代码时，此时便会捕获 panic(2)；此后的 panic(1)，会被上一层的 recover() 捕获。所以输出 21。

## 153. flag 是 bool 型变量，下面 if 表达式符合编码规范的是？

- A. if flag == 1
- B. if flag
- C. if flag == false
- D. if !flag

**答：B C D**

## 154. 下面的代码输出什么，请说明？

```go
func main() {
    defer func() {
        fmt.Print(recover())
    }()
    defer func() {
        defer func() {
            fmt.Print(recover())
        }()
        panic(1)
    }()
    defer recover()
    panic(2)
}
```

**答：12**

**解析：**

152题与之类似

## 155. 下面的代码输出什么？

```go
type T struct {
    n int
}

func main() {
    ts := [2]T{}
    for i, t := range ts {
        switch i {
        case 0:
            t.n = 3
            ts[1].n = 9
        case 1:
            fmt.Print(t.n, " ")
        }
    }
    fmt.Print(ts)
}
```

**答：0 [{0} {9}]**

**解析：**

知识点：for-range 循环数组。

此时使用的是数组 ts 的副本，所以 t.n = 3 的赋值操作不会影响原数组。

## 156. 下面的代码输出什么？

```go
type T struct {
    n int
}

func main() {
    ts := [2]T{}
    for i, t := range &ts {
        switch i {
        case 0:
            t.n = 3
            ts[1].n = 9
        case 1:
            fmt.Print(t.n, " ")
        }
    }
    fmt.Print(ts)
}
```

**答：9 [{0} {9}]**

**解析：**

知识点：for-range 数组指针。

for-range 循环中的循环变量 t 是原数组元素的副本。如果数组元素是结构体值，则副本的字段和原数组字段是两个不同的值。

## 157. 下面的代码输出什么？

```go
type T struct {
    n int
}

func main() {
    ts := [2]T{}
    for i := range ts[:] {
        switch i {
        case 0:
            ts[1].n = 9
        case 1:
            fmt.Print(ts[i].n, " ")
        }
    }
    fmt.Print(ts)
}
```

**答：9 [{0} {9}]**

**解析：**

知识点：for-range 切片。

for-range 切片时使用的是切片的副本，但不会复制底层数组，换句话说，此副本切片与原数组共享底层数组。

## 158. 下面的代码输出什么？

```go
type T struct {
    n int
}

func main() {
    ts := [2]T{}
    for i := range ts[:] {
        switch t := &ts[i]; i {
        case 0:
            t.n = 3;
            ts[1].n = 9
        case 1:
            fmt.Print(t.n, " ")
        }
    }
    fmt.Print(ts)
}
```

**答：9 [{3} {9}]**

**解析：**

知识点：for-range 切片。参考前几道题的解析，这道题的答案应该很明显。

## 159. 下面代码有什么问题吗？

```go
func main()  {

    for i:=0;i<10 ;i++  {
    loop:
        println(i)
    }
    goto loop
}
```

**解析：**

goto 不能跳转到其他函数或者内层代码。编译报错：

```shell
goto loop jumps into block starting at
```

## 160. 下面代码输出什么，请说明。

```go
func main() {
    x := []int{0, 1, 2}
    y := [3]*int{}
    for i, v := range x {
        defer func() {
            print(v)
        }()
        y[i] = &v
    }
    print(*y[0], *y[1], *y[2])
}
```

**答：22222**

**解析：**

知识点：defer()、for-range。

for-range 虽然使用的是 :=，但是 v 不会重新声明，可以打印 v 的地址验证下。

## 161. 关于 slice 或 map 操作，下面正确的是？

* A

  ```go
  var s []int
  s = append(s,1)
  ```

* B

  ```go
  var m map[string]int
  m["one"] = 1 
  ```

* C

  ```go
  var s []int
  s = make([]int, 0)
  s = append(s,1)
  ```

* D

  ```go
  var m map[string]int
  m = make(map[string]int)
  m["one"] = 1 
  ```

**答：A C D**

## 162. 下面代码输出什么？

```go
func test(x int) (func(), func()) {
    return func() {
        println(x)
        x += 10
    }, func() {
        println(x)
    }
}

func main() {
    a, b := test(100)
    a()
    b()
}
```

**答：100 110**

**解析：**

知识点：闭包引用相同变量。

## 163. 关于字符串连接，下面语法正确的是？

- A. str := 'abc' + '123'
- B. str := "abc" + "123"
- C. str ：= '123' + "abc"
- D. fmt.Sprintf("abc%d", 123)

**答：B D**

**解析：**

知识点：单引号、双引号和字符串连接。

在 Go 语言中，双引号用来表示字符串 string，其实质是一个 byte 类型的数组，单引号表示 rune 类型。

## 164. 下面代码能编译通过吗？可以的话，输出什么？

```go
func main() {

    println(DeferTest1(1))
    println(DeferTest2(1))
}

func DeferTest1(i int) (r int) {
    r = i
    defer func() {
        r += 3
    }()
    return r
}

func DeferTest2(i int) (r int) {
    defer func() {
        r += i
    }()
    return 2
}
```

**答：43**

## 165. 判断题：对变量x的取反操作是 ~x？

**答：错**

**解析：**

Go 语言的取反操作是 `^`，它返回一个每个 bit 位都取反的数。作用类似在 C、C#、Java 语言中中符号 ~，对于有符号的整数来说，是按照补码进行取反操作的（快速计算方法：对数 a 取反，结果为 -(a+1) ），对于无符号整数来说就是按位取反。

## 166. 下面代码输出什么，请说明原因。

```go
type Slice []int

func NewSlice() Slice {
    return make(Slice, 0)
}
func (s *Slice) Add(elem int) *Slice {
    *s = append(*s, elem)
    fmt.Print(elem)
    return s
}
func main() {
    s := NewSlice()
    defer s.Add(1).Add(2)
    s.Add(3)
}
```

**答：132**

**解析：**

这一题有两点需要注意：

1. Add() 方法的返回值依然是指针类型 *Slice，所以可以循环调用方法 Add()；
2. defer 函数的参数（包括接收者）是在 defer 语句出现的位置做计算的，而不是在函数执行的时候计算的，所以 s.Add(1) 会先于 s.Add(3) 执行。

## 167. 下面的代码输出什么，请说明。

```go
type Slice []int

func NewSlice() Slice {
    return make(Slice, 0)
}
func (s *Slice) Add(elem int) *Slice {
    *s = append(*s, elem)
    fmt.Print(elem)
    return s
}
func main() {
    s := NewSlice()
    defer func() {
        s.Add(1).Add(2)
    }()
    s.Add(3)
}
```

**答：312**

**解析：**

对比昨天的第`166`题，本题的 s.Add(1).Add(2) 作为一个整体包在一个匿名函数中，会延迟执行。

## 168. 下面的代码输出什么，请说明？

```go
type Orange struct {
    Quantity int
}

func (o *Orange) Increase(n int) {
    o.Quantity += n
}

func (o *Orange) Decrease(n int) {
    o.Quantity -= n
}

func (o *Orange) String() string {
    return fmt.Sprintf("%#v", o.Quantity)
}

func main() {
    var orange Orange
    orange.Increase(10)
    orange.Decrease(5)
    fmt.Println(orange)
}
```

**答：{5}**

**解析：**

这道题容易忽视的点是，String() 是指针方法，而不是值方法，所以使用 Println() 输出时不会调用到 String() 方法。

可以这样修复：

```go
func main() {
    orange := &Orange{}
    orange.Increase(10)
    orange.Decrease(5)
    fmt.Println(orange)
}
```

## 169. 下面代码输出什么？

```go
func test() []func() {
    var funs []func()
    for i := 0; i < 2; i++ {
        funs = append(funs, func() {
            println(&i, i)
        })
    }
    return funs
}

func main() {
    funs := test()
    for _, f := range funs {
        f()
    }
}
```

**答：**

```shell
10xc000018058 2
20xc000018058 2
```

**解析：**

知识点：闭包延迟求值。for 循环局部变量 i，匿名函数每一次使用的都是同一个变量。（说明：i 的地址，输出可能与上面的不一样）。

## 170. 下面的代码能编译通过吗？可以的话输出什么，请说明？

```go
var f = func(i int) {
    print("x")
}

func main() {
    f := func(i int) {
        print(i)
        if i > 0 {
            f(i - 1)
        }
    }
    f(10)
}
```

**答：10x**

**解析：**

这道题一眼看上去会输出 109876543210，其实这是错误的答案，这里不是递归。假设 main() 函数里为 f2()，外面的为 f1()，当声明 f2() 时，调用的是已经完成声明的 f1()。

看下面这段代码你应该会更容易理解一点：

```go
var x = 23

func main() {
    x := 2*x - 4
    println(x)    // 输出:42
}
```

## 171. 下面代码有什么问题，请说明？

```go
func main() {
    runtime.GOMAXPROCS(1)

    go func() {
        for i:=0;i<10 ;i++  {
            fmt.Println(i)
        }
    }()

    for {}
}
```

**答：** [讨论 #11](https://github.com/yqchilde/Golang-Interview/issues/11)

以上代码在go1.14版本之前(不含1.14版本): for {} 独占 CPU 资源导致其他 Goroutine 饿死，

在go1.14版本之后(包含go1.14): 会打印0123456789, 并且主程会进入死循环

**解析：**

可以通过阻塞的方式避免 CPU 占用，修复代码：

```go
func main() {
    runtime.GOMAXPROCS(1)

    go func() {
        for i:=0;i<10 ;i++  {
            fmt.Println(i)
        }
        os.Exit(0)
    }()

    select {}
}
```

## 172. 假设 x 已声明，y 未声明，下面 4 行代码哪些是正确的。错误的请说明原因？

```go
x, _ := f()  // 1
x, _ = f()  // 2
x, y := f()  // 3
x, y = f()  // 4
```

**答：2、3正确**

**解析：**

知识点：简短变量声明。使用简短变量声明有几个需要注意的地方：

- 只能用于函数内部；
- 短变量声明语句中至少要声明一个新的变量；

## 173. 下面的代码有什么问题，请说明？

```go
func main() {
    f, err := os.Open("file")
    defer f.Close()
    if err != nil {
        return
    }

    b, err := ioutil.ReadAll(f)
    println(string(b))
}
```

**答：defer 语句应该放在 if() 语句后面，先判断 err，再 defer 关闭文件句柄。**

**解析：**

修复代码：

```go
func main() {
    f, err := os.Open("file")
    if err != nil {
        return
    }
    defer f.Close()

    b, err := ioutil.ReadAll(f)
    println(string(b))
}
```

## 174. 下面代码输出什么，为什么？

```go
func f() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("recover:%#v", r)
        }
    }()
    panic(1)
    panic(2)
}

func main() {
    f()
}
```

**答：recover:1**

**解析：**

知识点：`panic`、`recover()`。

当程序 panic 时就不会往下执行，可以使用 recover() 捕获 panic 的内容。

## 175. 下面这段代码输出什么？

```go
type S1 struct{}

func (s1 S1) f() {
    fmt.Println("S1.f()")
}
func (s1 S1) g() {
    fmt.Println("S1.g()")
}

type S2 struct {
    S1
}

func (s2 S2) f() {
    fmt.Println("S2.f()")
}

type I interface {
    f()
}

func printType(i I) {

    fmt.Printf("%T\n", i)
    if s1, ok := i.(S1); ok {
        s1.f()
        s1.g()
    }
    if s2, ok := i.(S2); ok {
        s2.f()
        s2.g()
    }
}

func main() {
    printType(S1{})
    printType(S2{})
}
```

**答：**

```shell
main.S1
S1.f()
S1.g()
main.S2
S2.f()
S1.g()
```

**解析：**

知识点：类型断言，结构体嵌套。

结构体 S2 嵌套了结构体 S1，S2 自己没有实现 g() ，调用的是 S1 的 g()。

## 176. 下面的代码有什么问题？

```go
func main() {
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        fmt.Println("1")
        wg.Done()
        wg.Add(1)
    }()
    wg.Wait()
}
```

**解析：**

协程里面，使用 wg.Add(1) 但是没有 wg.Done()，导致 panic()。

## 177. 关于 cap 函数适用下面哪些类型？

- A. 数组；
- B. channel;
- C. map；
- D. slice；

**答：A B D**

**解析：**

`cap()`函数的作用是：

* array 返回数组的元素个数
* slice 返回slice的最大容量
* channel 返回 channel的容量

## 178. 下面代码输出什么？

```go
func hello(num ...int) {
    num[0] = 18
}

func Test13(t *testing.T) {
    i := []int{5, 6, 7}
    hello(i...)
    fmt.Println(i[0])
}

func main() {
    t := &testing.T{}
    Test13(t)
}
```

- A. 18
- B. 5
- C. Compilation error

**答：A**

**解析：**

可变函数是指针传递

## 179. 关于 switch 语句，下面说法正确的是？

- A. 单个 case 中，可以出现多个结果选项；
- B. 需要使用 break 来明确退出一个 case;
- C. 只有在 case 中明确添加 fallthrought 关键字，才会继续执行紧跟的下一个 case;
- D. 条件表达式必须为常量或者整数；

**答：A C**

## 180. 下面代码能编译通过吗？可以的话，输出什么？

```go
func alwaysFalse() bool {
    return false
}

func main() {
    switch alwaysFalse()
    {
    case true:
        println(true)
    case false:
        println(false)
    }
}
```

**答：可以编译通过，输出：true**

**解析：**

Go 代码断行规则。