181-210.md

> 目录
>
> * [181\. interface\{\} 是可以指向任意对象的 Any 类型，是否正确？](#181-interface-%E6%98%AF%E5%8F%AF%E4%BB%A5%E6%8C%87%E5%90%91%E4%BB%BB%E6%84%8F%E5%AF%B9%E8%B1%A1%E7%9A%84-any-%E7%B1%BB%E5%9E%8B%E6%98%AF%E5%90%A6%E6%AD%A3%E7%A1%AE)
> * [182\. 下面的代码有什么问题？](#182-%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)
> * [183\. 定义一个包内全局字符串变量，下面语法正确的是？](#183-%E5%AE%9A%E4%B9%89%E4%B8%80%E4%B8%AA%E5%8C%85%E5%86%85%E5%85%A8%E5%B1%80%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%8F%98%E9%87%8F%E4%B8%8B%E9%9D%A2%E8%AF%AD%E6%B3%95%E6%AD%A3%E7%A1%AE%E7%9A%84%E6%98%AF)
> * [184\. 下面的代码有什么问题？](#184-%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)
> * [185\. 下面的代码输出什么？](#185-%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)
> * [186\. 下面代码中的指针 p 为野指针，因为返回的栈内存在函数结束时会被释放？](#186-%E4%B8%8B%E9%9D%A2%E4%BB%A3%E7%A0%81%E4%B8%AD%E7%9A%84%E6%8C%87%E9%92%88-p-%E4%B8%BA%E9%87%8E%E6%8C%87%E9%92%88%E5%9B%A0%E4%B8%BA%E8%BF%94%E5%9B%9E%E7%9A%84%E6%A0%88%E5%86%85%E5%AD%98%E5%9C%A8%E5%87%BD%E6%95%B0%E7%BB%93%E6%9D%9F%E6%97%B6%E4%BC%9A%E8%A2%AB%E9%87%8A%E6%94%BE)
> * [187\. 下面这段代码输出什么？](#187-%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)
> * [188\. 下面代码输出什么？](#188-%E4%B8%8B%E9%9D%A2%E4%BB%A3%E7%A0%81%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88)
> * [189\. 同级文件的包名不允许有多个，是否正确？](#189-%E5%90%8C%E7%BA%A7%E6%96%87%E4%BB%B6%E7%9A%84%E5%8C%85%E5%90%8D%E4%B8%8D%E5%85%81%E8%AE%B8%E6%9C%89%E5%A4%9A%E4%B8%AA%E6%98%AF%E5%90%A6%E6%AD%A3%E7%A1%AE)
> * [190\. 下面的代码有什么问题，请说明。](#190-%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)
> * [191\. 函数执行时，如果由于 panic 导致了异常，则延迟函数不会执行。这一说法是否正确？](#191-%E5%87%BD%E6%95%B0%E6%89%A7%E8%A1%8C%E6%97%B6%E5%A6%82%E6%9E%9C%E7%94%B1%E4%BA%8E-panic-%E5%AF%BC%E8%87%B4%E4%BA%86%E5%BC%82%E5%B8%B8%E5%88%99%E5%BB%B6%E8%BF%9F%E5%87%BD%E6%95%B0%E4%B8%8D%E4%BC%9A%E6%89%A7%E8%A1%8C%E8%BF%99%E4%B8%80%E8%AF%B4%E6%B3%95%E6%98%AF%E5%90%A6%E6%AD%A3%E7%A1%AE)
> * [192\. 下面代码输出什么？](#192-%E4%B8%8B%E9%9D%A2%E4%BB%A3%E7%A0%81%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88)
> * [193\. 下面这段代码输出什么？请简要说明。](#193-%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%E8%AF%B7%E7%AE%80%E8%A6%81%E8%AF%B4%E6%98%8E)
> * [194\. 下面代码输出什么？](#194-%E4%B8%8B%E9%9D%A2%E4%BB%A3%E7%A0%81%E8%BE%93%E5%87%BA%E4%BB%80%E4%B9%88)

## 181. interface{} 是可以指向任意对象的 Any 类型，是否正确？

- A. false
- B. true

**答：B**

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

```go
type ConfigOne struct {
    Daemon string
}

func (c *ConfigOne) String() string {
    return fmt.Sprintf("print: %v", c)
}

func main() {
    c := &ConfigOne{}
    c.String()
}
```

**答：无限递归循环，栈溢出。**

**解析：**

知识点：类型的 String() 方法。如果类型定义了 String() 方法，使用 Printf()、Print() 、 Println() 、 Sprintf() 等格式化输出时会自动使用 String() 方法。

## 183. 定义一个包内全局字符串变量，下面语法正确的是？

- A. var str string
- B. str := ""
- C. str = ""
- D. var str = ""

**答：A D**

**解析：**

全局变量要定义在函数之外，而在函数之外定义的变量只能用 var 定义。短变量声明 := 只能用于函数之内。

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

```go
func main() {

    wg := sync.WaitGroup{}

    for i := 0; i < 5; i++ {
        go func(wg sync.WaitGroup, i int) {
            wg.Add(1)
            fmt.Printf("i:%d\n", i)
            wg.Done()
        }(wg, i)
    }

    wg.Wait()

    fmt.Println("exit")
}
```

**解析：**

知识点：WaitGroup 的使用。存在两个问题：

- 在协程中使用 wg.Add()；
- 使用了 sync.WaitGroup 副本；

修复代码：

```go
func main() {

    wg := sync.WaitGroup{}

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(i int) {
            fmt.Printf("i:%d\n", i)
            wg.Done()
        }(i)
    }

    wg.Wait()

    fmt.Println("exit")
}
```

或者：

```go
func main() {

    wg := &sync.WaitGroup{}

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(wg *sync.WaitGroup,i int) {
            fmt.Printf("i:%d\n", i)
            wg.Done()
        }(wg,i)
    }

    wg.Wait()

    fmt.Println("exit")
}
```

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

```go
func main() {
    var a []int = nil
    a, a[0] = []int{1, 2}, 9
    fmt.Println(a)
}
```

**答：运行时错误**

**解析：**

知识点：多重赋值。

多重赋值分为两个步骤，有先后顺序：

- 计算等号左边的索引表达式和取址表达式，接着计算等号右边的表达式；
- 赋值；

## 186. 下面代码中的指针 p 为野指针，因为返回的栈内存在函数结束时会被释放？

```go
type TimesMatcher struct {
    base int
}

func NewTimesMatcher(base int) *TimesMatcher  {
    return &TimesMatcher{base:base}
}

func main() {
    p := NewTimesMatcher(3)
    fmt.Println(p)
}
```

- A. false
- B. true

**答：A**

**解析：**

Go语言的内存回收机制规定，只要有一个指针指向引用一个变量，那么这个变量就不会被释放（内存逃逸），因此在 Go 语言中返回函数参数或临时变量是安全的。

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

```go
func main() {
    count := 0
    for i := range [256]struct{}{} {
        m, n := byte(i), int8(i)
        if n == -n {
            count++
        }
        if m == -m {
            count++
        }
    }
    fmt.Println(count)
}
```

**解析：**

知识点：数值溢出。当 i 的值为 0、128 是会发生相等情况，注意 byte 是 uint8 的别名。

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

```go
const (
    azero = iota
    aone  = iota
)

const (
    info  = "msg"
    bzero = iota
    bone  = iota
)

func main() {
    fmt.Println(azero, aone)
    fmt.Println(bzero, bone)
}
```

**答：0 1 1 2**

**解析：**

知识点：iota 的使用。这道题易错点在 bzero、bone 的值，在一个常量声明代码块中，如果 iota 没出现在第一行，则常量的初始值就是非 0 值。

## 189. 同级文件的包名不允许有多个，是否正确？

- A. true
- B. false

**答：A**

**解析：**

一个文件夹下只能有一个包，可以多个.go文件，但这些文件必须属于同一个包。

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

```go
type data struct {
    name string
}

func (p *data) print() {
    fmt.Println("name:", p.name)
}

type printer interface {
    print()
}

func main() {
    d1 := data{"one"}
    d1.print()

    var in printer = data{"two"}
    in.print()
}
```

**答：编译报错**

```shell
cannot use data literal (type data) as type printer in assignment:
data does not implement printer (print method has pointer receiver)
```

**解析：**

结构体类型 data 没有实现接口 printer。知识点：接口。

## 191. 函数执行时，如果由于 panic 导致了异常，则延迟函数不会执行。这一说法是否正确？

- A. true
- B. false

**答：B**

**解析：**

由 panic 引发异常以后，程序停止执行，然后调用延迟函数（defer），就像程序正常退出一样。

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

```go
func main() {
    a := [3]int{0, 1, 2}
    s := a[1:2]

    s[0] = 11
    s = append(s, 12)
    s = append(s, 13)
    s[0] = 21

    fmt.Println(a)
    fmt.Println(s)
}
```

**答：**

```go
[0 11 12]
[21 12 13]
```

## 193. 下面这段代码输出什么？请简要说明。

```go
func main() {
    fmt.Println(strings.TrimRight("ABBA", "BA"))
}
```



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

```go
func main() {
    var src, dst []int
    src = []int{1, 2, 3}
    copy(dst, src) 
    fmt.Println(dst)
}
```



## 195. 

## 196. 

## 197. 

## 198. 

## 199. 

## 200. 

## 201. 

## 202. 

## 203. 

## 204. 

## 205. 

## 206. 

## 207. 

## 208. 

## 209. 

## 210.