【Go 语言】核心特性、基础语法及面试题

目录

若对您有帮助的话，请点赞收藏加关注哦，您的关注是我持续创作的动力！有问题请私信或联系邮箱：funian.gm@gmail.com

Go（Golang）是 Google 设计的静态强类型语言，主打简洁、高效、并发友好，广泛用于微服务、云原生、中间件开发。

一、Go 核心特性

二、Go 基础语法

1. 变量声明（3种方式）

Go 推荐“短变量声明”（:=），但仅用于函数内；全局变量需用var。

packagemainimport"fmt"// 1. 全局变量（函数外只能用 var）varglobalVarint=100varglobalVar2=200// 类型推断funcmain(){// 2. 函数内：短变量声明（:=），自动推断类型localVar:="hello"fmt.Println(localVar)// 输出：hello// 3. 显式声明类型varexplicitVarstring="world"fmt.Println(explicitVar)// 输出：world// 多变量声明a,b:=1,2fmt.Println(a,b)// 输出：1 2}

2. 函数（多返回值+匿名函数）

Go 函数支持多返回值（常用于返回结果+错误），且支持匿名函数和闭包。

packagemainimport"errors"import"fmt"// 多返回值函数（结果+错误）funcdivide(a,bint)(int,error){ifb==0{return0,errors.New("除数不能为0")}returna/b,nil}funcmain(){// 调用多返回值函数res,err:=divide(10,2)iferr!=nil{fmt.Println("错误：",err)return}fmt.Println("结果：",res)// 输出：结果：5// 匿名函数（立即执行）func(msgstring){fmt.Println("匿名函数：",msg)// 输出：匿名函数：hello go}("hello go")// 闭包（捕获外部变量）counter:=func()func()int{i:=0returnfunc()int{i++returni}}()fmt.Println(counter())// 输出：1fmt.Println(counter())// 输出：2}

3. 接口（隐式实现）

Go 接口是“行为契约”，无需显式绑定，结构体实现接口所有方法即自动适配，灵活性极高。

packagemainimport"fmt"// 定义接口（仅声明方法，无实现）typeAnimalinterface{Speak()string}// 结构体 Dog 实现 Animal 接口（无需 implements 关键字）typeDogstruct{Namestring}func(d Dog)Speak()string{returnfmt.Sprintf("汪！我是%s",d.Name)}// 结构体 Cat 实现 Animal 接口typeCatstruct{Ageint}func(c Cat)Speak()string{returnfmt.Sprintf("喵！我%d岁了",c.Age)}// 接收 Animal 接口的函数（多态）funcLetItSpeak(a Animal){fmt.Println(a.Speak())}funcmain(){dog:=Dog{Name:"旺财"}cat:=Cat{Age:3}LetItSpeak(dog)// 输出：汪！我是旺财LetItSpeak(cat)// 输出：喵！我3岁了}

4. 并发（Goroutine + Channel）

Go 原生支持并发，通过go关键字启动 Goroutine，channel实现 Goroutine 间通信。

packagemainimport"fmt"import"time"// Goroutine 间通过 channel 通信funcproducer(chchan<-int){// 只写 channelfori:=1;i<=5;i++{ch<-i// 向 channel 写入数据time.Sleep(100*time.Millisecond)}close(ch)// 关闭 channel（告知接收方无数据）}funcconsumer(ch<-chanint){// 只读 channelfornum:=rangech{// 循环读取 channel，直到关闭fmt.Println("收到数据：",num)}}funcmain(){// 创建无缓冲 channel（同步通信）ch:=make(chanint)// 启动 2 个 Goroutinegoproducer(ch)goconsumer(ch)// 主 Goroutine 等待 1 秒（避免提前退出）time.Sleep(1*time.Second)// 输出：// 收到数据： 1// 收到数据： 2// 收到数据： 3// 收到数据： 4// 收到数据： 5}

5. defer 延迟执行

defer用于函数退出前执行（如关闭文件、释放锁），多个 defer 按“后进先出（LIFO）”顺序执行。

packagemainimport"fmt"funcmain(){deferfmt.Println("defer 1")// 最后执行deferfmt.Println("defer 2")// 中间执行fmt.Println("主逻辑")// 先执行// 输出顺序：// 主逻辑// defer 2// defer 1// 进阶：defer 中修改返回值（仅当返回值有命名时生效）fmt.Println(add(1,2))// 输出：4}funcadd(a,bint)(resint){// 命名返回值 resdeferfunc(){res+=1// 延迟修改返回值}()returna+b// 实际返回：3 + 1 = 4}

三、Go 高频面试题及答案（含代码+解析）

面试题 1：Goroutine 和 OS 线程的区别？

题目分析：

考察对 Go 并发模型的核心理解，是面试必问考点。

答案对比表：

代码验证：

packagemainimport("fmt""runtime""time")funcmain(){// 设置最大 OS 线程数（默认等于 CPU 核心数）runtime.GOMAXPROCS(2)// 启动 10000 个 Goroutine（无压力）fori:=0;i<10000;i++{gofunc(nint){time.Sleep(1*time.Second)fmt.Println("Goroutine",n)}(i)}time.Sleep(2*time.Second)}

面试题 2：defer 的执行顺序是什么？return 和 defer 的执行逻辑？

题目分析：

考察 defer 底层机制，容易踩坑，高频考点。

核心结论：

1. 多个 defer 按「后进先出（LIFO）」执行；
2. return 执行逻辑：先计算返回值 → 执行 defer → 真正返回；
3. 若返回值是命名变量，defer 可修改返回值；若为匿名返回值，修改无效。

代码示例：

packagemainimport"fmt"// 1. 多个 defer 执行顺序（LIFO）funcdeferOrder(){deferfmt.Println("a")deferfmt.Println("b")deferfmt.Println("c")// 输出：c → b → a}// 2. 命名返回值：defer 可修改funcnamedReturn()(resint){deferfunc(){res=100// 修改返回值}()return50// 先赋值 res=50，再执行 defer 改为 100，最终返回 100}// 3. 匿名返回值：defer 无法修改funcanonymousReturn()int{varresint=50deferfunc(){res=100// 仅修改局部变量 res，返回值已拷贝为 50}()returnres}funcmain(){deferOrder()fmt.Println(namedReturn())// 输出：100fmt.Println(anonymousReturn())// 输出：50}

面试题 3：slice 和 array 的区别？slice 扩容机制是什么？

题目分析：

slice 是 Go 中最常用的数据结构，扩容机制是高频考点。

核心结论：

1. array：固定长度（var arr [5]int），值类型，拷贝时复制整个数组；
2. slice：动态长度（var s []int），引用类型（底层是「数组指针+长度+容量」），拷贝时复制指针；
3. 扩容机制（Go 1.18+ 规则）：
   • 当切片长度 < 256 时，扩容后容量 = 原容量 × 2；
   • 当切片长度 ≥ 256 时，扩容后容量 = 原容量 × 1.25（向上取整）；
   • 若扩容后容量仍小于所需长度，则直接扩容到所需长度。

代码示例：

packagemainimport"fmt"funcmain(){// 1. array vs slice 声明vararr[3]int=[3]int{1,2,3}// 固定长度 3vars[]int=arr[0:2]// slice 引用 arr 的前 2 个元素（长度 2，容量 3）fmt.Println("arr:",arr)// 输出：arr: [1 2 3]fmt.Println("s:",s)// 输出：s: [1 2]// 2. slice 修改会影响原 array（引用类型）s[0]=100fmt.Println("arr:",arr)// 输出：arr: [100 2 3]fmt.Println("s:",s)// 输出：s: [100 2]// 3. slice 扩容验证s=append(s,4,5)// 原容量 3，长度 2 → 追加 2 个元素，长度 4，触发扩容fmt.Println("s 扩容后：",s)// 输出：[100 2 4 5]fmt.Println("s 容量：",cap(s))// 输出：6（原容量 3 < 256 → 3×2=6）}

面试题 4：nil 接口和 nil 结构体的区别？

题目分析：

考察接口的底层结构，是 Go 面试的“坑题”之一。

核心结论：

1. 接口（interface{}）的底层结构包含两部分：type（类型）和value（值）；
2. 只有当type和value都为 nil 时，接口才等于 nil；
3. 当把nil *int赋值给接口时，接口的type是*int，value是 nil → 因此接口不等于 nil。

代码示例：

packagemainimport"fmt"funcmain(){// 1. 接口的 type 和 value 都为 nil → 等于 nilvari1interface{}=nilfmt.Println(i1==nil)// 输出：true// 2. 接口的 type 是 *int，value 是 nil → 不等于 nilvarp*int=nilvari2interface{}=p fmt.Println(i2==nil)// 输出：false// 验证接口的底层结构（通过反射）import"reflect"fmt.Printf("i2 类型：%v，值：%v\n",reflect.TypeOf(i2),reflect.ValueOf(i2))// 输出：i2 类型：*int，值：<nil>}

面试题 5：channel 无缓冲和有缓冲的区别？关闭 channel 后读写会发生什么？

题目分析：

考察 channel 的核心特性，是并发模块的高频考点。

核心结论：

关闭 channel 后的行为：

1. 读取：已写入的数据可正常读取，读完后返回该类型的零值（如 int 返回 0），可通过val, ok := <-ch判断 channel 是否关闭（ok 为 false 表示关闭）；
2. 写入：会触发panic（关闭后的 channel 不能写入）；
3. 多次关闭：会触发panic（channel 只能关闭一次）。

代码示例：

packagemainimport"fmt"funcmain(){// 1. 无缓冲 channel（同步）ch1:=make(chanint)gofunc(){ch1<-100// 无接收方则阻塞，直到主 Goroutine 读取}()fmt.Println(<-ch1)// 无发送方则阻塞，直到子 Goroutine 写入 → 输出：100// 2. 有缓冲 channel（异步）ch2:=make(chanint,2)// 缓冲区大小 2ch2<-200ch2<-300// ch2 <- 400 // 缓冲区满，阻塞fmt.Println(<-ch2)// 输出：200fmt.Println(<-ch2)// 输出：300// 3. 关闭 channel 后读取close(ch2)val1,ok1:=<-ch2// 缓冲区空，返回零值和 false → val1=0，ok1=falsefmt.Println(val1,ok1)// 输出：0 false// 4. 关闭 channel 后写入（触发 panic）// ch2 <- 500 // 报错：panic: send on closed channel// 5. 遍历读取 channel（直到关闭）ch3:=make(chanint,3)ch3<-1ch3<-2ch3<-3close(ch3)fornum:=rangech3{fmt.Println(num)// 输出：1、2、3（读完后退出循环）}}

四、面试复习总结

Go 面试的核心考点集中在：

1. 并发模型：Goroutine 调度、Channel 通信、GOMAXPROCS；
2. 语法特性：defer 执行逻辑、接口隐式实现、值类型 vs 引用类型；
3. 数据结构：slice 扩容、map 底层实现（哈希表）、channel 缓冲机制；
4. 工程实践：错误处理（error接口）、GC 优化、逃逸分析。