从初面到Offer，你花了多久？

王中阳AI编程

发布于 2026-03-17 18:04:42

740

文章被收录于专栏：Go语言学习专栏Go语言学习专栏

欢迎点击下方👇关注我，记得星标哟~

组织内部的朋友从初面到拿到Offer，最快的只花了一周的时间，而且是两个Offer：

据我所知现在大厂从投简历到录用到坐到办公桌上，最快也要三个月，想问问大家在找工作的时候最快的用了多长时间？

今天分享几个面试常考的代码题，点赞收藏不迷路。

01 实现使用字符串函数名，调用函数。

思路：采用反射的Call方法实现。

package main
import (
        "fmt"
    "reflect"
)

type Animal struct{
    
}

func (a *Animal) Eat(){
    fmt.Println("Eat")
}

func main(){
    a := Animal{}
    reflect.ValueOf(&a).MethodByName("Eat").Call([]reflect.Value{})
}

02 有三个函数，分别打印"cat", "fish","dog"要求每一个函数都用一个goroutine，按照顺序打印100次。

此题目考察channel，用三个无缓冲channel，如果一个channel收到信号则通知下一个。

package main

import (
        "fmt"
        "time"
)

var dog = make(chanstruct{})
var cat = make(chanstruct{})
var fish = make(chanstruct{})

func Dog() {
        <-fish
        fmt.Println("dog")
        dog <- struct{}{}
}

func Cat() {
        <-dog
        fmt.Println("cat")
        cat <- struct{}{}
}

func Fish() {
        <-cat
        fmt.Println("fish")
        fish <- struct{}{}
}

func main() {
        for i := 0; i < 100; i++ {
                go Dog()
                go Cat()
                go Fish()
        }
        fish <- struct{}{}

        time.Sleep(10 * time.Second)
}

03 两个协程交替打印10个字母和数字

思路：采用channel来协调goroutine之间顺序。

主线程一般要waitGroup等待协程退出，这里简化了一下直接sleep。

package main

import (
        "fmt"
        "time"
)

var word = make(chanstruct{}, 1)
var num = make(chanstruct{}, 1)

func printNums() {
        for i := 0; i < 10; i++ {
                <-word
                fmt.Println(1)
                num <- struct{}{}
        }
}
func printWords() {
        for i := 0; i < 10; i++ {
                <-num
                fmt.Println("a")
                word <- struct{}{}
        }
}

func main() {
        num <- struct{}{}
        go printNums()
        go printWords()
        time.Sleep(time.Second * 1)
}

04 启动 2个groutine 2秒后取消，第一个协程1秒执行完，第二个协程3秒执行完。

思路：采用ctx, _ := context.WithTimeout(context.Background(), time.Second*2)实现2s取消。协程执行完后通过channel通知，是否超时。

package main

import (
        "context"
        "fmt"
        "time"
)

func f1(in chan struct{}) {

        time.Sleep(1 * time.Second)
        in <- struct{}{}

}

func f2(in chan struct{}) {
        time.Sleep(3 * time.Second)
        in <- struct{}{}
}

func main() {
        ch1 := make(chanstruct{})
        ch2 := make(chanstruct{})
        ctx, _ := context.WithTimeout(context.Background(), 2*time.Second)

        gofunc() {
                go f1(ch1)
                select {
                case <-ctx.Done():
                        fmt.Println("f1 timeout")
                        break
                case <-ch1:
                        fmt.Println("f1 done")
                }
        }()

        gofunc() {
                go f2(ch2)
                select {
                case <-ctx.Done():
                        fmt.Println("f2 timeout")
                        break
                case <-ch2:
                        fmt.Println("f2 done")
                }
        }()
        time.Sleep(time.Second * 5)
}

05 当select监控多个chan同时到达就绪态时，如何先执行某个任务？

可以在子case再加一个for select语句。

func priority_select(ch1, ch2 <-chan string) {
        for {
          select {
          case val := <-ch1:
                  fmt.Println(val)
          case val2 := <-ch2:
          priority:
              for {
                select {
                case val1 := <-ch1:
                   fmt.Println(val1)
         default:
                break priority
                        }
                 }
          fmt.Println(val2)
        }
    }

}