近期面试总结

项目经历

主要讲做过那些项目,分别的内容是什么。

  • 重新设计的话如何设计。
  • 项目的难点在那里。
  • 数据库如何设计。
  • 项目的架构。

数据库

数据库主要问了

  • MySQl 事务的隔离级别。
  • 如何建索引,怎么样建索引。
  • 对那些数据建索引。
  • 联合索引在什么情况下用不到索引。
  • 内连接,左连接,右连接的区别
  • 还写了一个复杂的查询。
  • MySQl 事务使用的时候会有什么问题(?), 很奇怪能有什么问题呢?
  • 数据库索引的实现方式(BTREE), B是什么意思(这都问)

Golang

  • slice和数组的区别
  • slice 的长度和容量的区别
  • slice 容量增长规则
  • slice make完成之后,在append元素,那这个slice张啥样.
  • Golang 传参是值传递还是引用传递(值传递)
  • Golang 和 Python 相比较(开放话题)
  • 对 goroutine的认识
  • golang 的接口和其他语言的接口的区别(golang是隐式实现的,其他的是显式实现的)
  • 往一个空的channel里面发送数据会怎么样(阻塞)
  • 往一个关闭了的channel发送数据会怎么样(panic)
  • 关闭一个已经关闭的channel会怎么样(panic)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// fatal error: all goroutines are asleep - deadlock!
func testSendEmptyChan() {
var ch chan string
ch <- "ha"
}

// panic: send on closed channel
func testSendClosedChan() {
var ch = make(chan string, 1)
close(ch)
ch <- "ha"
}

// panic: close of closed channel
func testCloseClosedChan() {
var ch = make(chan string, 1)
close(ch)
close(ch)
}
  • protobuf 的优势

数据结构与算法

  • 二叉堆的调整,siftDown, siftUp
  • 二叉堆的用处(当时没想起来,我想应该是优先级队列)
  • 排序算法知道哪些。。。
  • 连个链表相交,找出这个相交的节点(我的做法是两重循环找节点)
  • 反转字符串,但是保持子串顺序不变
  • 门票5块,n个人有10块, n个人有5块,如何排列使那些人一次性买到票

设计模式

常用设计模式

  • 单例Golang如何实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package design

import "sync"

type singleton struct {
}

var instance *singleton
var once sync.Once

func NewSingleton() *singleton {
once.Do(func() {
instance = &singleton{}
})

return instance
}

代码题

  • Golang struct 实现接口的问题
    如果struct的值接受者实现了接口,那这个struct的值和指针实例都实现了这个接口。

    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
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
     package main

    import (
    "fmt"
    )

    type MyInterface interface {
    Do()
    }

    type s1 struct {
    }

    func (s s1) Do() {

    }

    type s2 struct {
    }

    func (s *s2) Do() {

    }

    func updateArray(arr []int32) {
    arr[0] = 100 * 100
    }

    func appendArr(arr []int32) {
    arr = append(arr, 100000000)
    }

    func main() {
    s11 := s1{}
    s11.Do()

    var v MyInterface
    v = s11
    _, ok := v.(MyInterface)
    fmt.Println(ok) // true

    var x interface{}
    s12 := &s1{}
    s12.Do()
    x = s12

    _, ok = x.(MyInterface)
    fmt.Println(ok) // true

    s21 := s2{}
    x = s21
    _, ok = x.(MyInterface)
    fmt.Println(ok) // false

    s22 := &s2{}
    x = s22
    _, ok = x.(MyInterface)
    fmt.Println(ok) // true

    a := []int32{1000}
    updateArray(a)
    fmt.Println(a)

    b := []int32{0, 1, 2}
    appendArr(b)
    fmt.Println(b)
    }
  • 有一个通道 slice, 当这些通道中的某一个通道准备好值之后,需要将这个通道返回.

    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
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
       package main

    import (
    "fmt"
    "math/rand"
    "runtime"
    "time"
    )

    func getSignal(chs ...chan string) chan string {
    var ch = make(chan string, 1)
    go func() {
    defer close(ch)
    Loop:
    for {
    for _, ich := range chs {
    select {
    case v := <-ich:
    ch <- v
    break Loop
    default:
    }
    }
    }
    }()

    return ch
    }

    func main() {
    runtime.GOMAXPROCS(8)
    rand.Seed(time.Now().Unix())

    sig1 := make(chan string)
    sig2 := make(chan string)
    sig3 := make(chan string)

    go func() {
    v := rand.Intn(3)

    switch v {
    case 0:
    sig1 <- "sig1"
    case 1:
    sig2 <- "sig2"
    case 2:
    sig3 <- "sig3"
    }
    }()

    sig := getSignal(sig1, sig2, sig3)
    fmt.Println(<-sig)
    }

    总结

    总体感觉就是有的问题能回答上有的回答的不好或者就是不会。
    算法问题基本不怎么会,这方面确实也是薄弱环节。golang 知识有些细节的东西忽略了,一般写代码的时候·会去验证,不会特意去记这些。
    数据库方面的东西感觉问到的都不是太难,基本都了解过。项目方面的主要考察项目代码结构和设计,这个因为项目自己做的也比较熟悉没有啥问题。但是项目的难点其实就是业务复杂。技术并没有复杂的。感觉简单的项目做的再好,也是简单的项目。
    设计模式平时用的不多,只了解过单例。真的是看过是不会了解的,只有实际去用了才会有体会,有理解。