当前位置:   article > 正文

golang常见面试题_golang 面试题

golang 面试题

基础篇


1. golang 中 make 和 new 的区别

make和new是两个内置函数,主要用来创建并分配内存。

make只用于分配或初始化map、slice、 channel的数据类型,返回不是指针类型。

new用来分配内存,new函数只接受一个参数,这个参数是一个类型,并且返回一个指向该类型内存地址的指针。同时new函数会把分配的内存置为零,也就是类型的零值。

区别

  1. make只能用来分配及初始化类型slice、map、channel、的数据,new可以分配任意类型;

  2. make返回是该类型的引用,new返回指向该类型内存地址的指针;

  3. make分配空间后,会进行初始化,new分配的空间为被置为零;

2. 数组和切片的区别

数组是一组同类型数据的集合,它是值类型,通过下标从0开始访问元素。在初始化后长度固定,无法修改。当作为方法的参数传入时是复制一份数据而不是引用的指针。数组的长度也是其类型的一部分,通过内置函数len()获取。有两种类型初始化方式 [2]T{“a”, “b”}, […]T{“a”,“b”}

切片是不定长数组,可以追加元素,追加容量不够时,会进行扩容。切片有两个概念:一是len长度,二是cap容量;长度是指赋值最大下标+1,容量是指切片目前可容纳的最多元素个数。切片是引用类型,传递时将引用指针进行传递的,修改会影响其他的对象。

区别

  1. 声明数组,需要指定数组的长度,切片可看成动态的数组;
  2. 数组是值类型,切片是引用类型
  3. 切片比数组多个容量属性
  4. 切片低层是数组
3. for range的时候它的地址会发生变化么

不会,for range创建每个元素的副本,而不是返回每个元素的引用

func main(){
  slice := []int{1,2,3}
  myMap := make(map[int]*int, len(slice))
  for idx, v := range slice{
    fmt.Printf("%p\n",&v)
    myMap[idx]=&v
  }
  fmt.Println("=======")
  for k, v := range myMap{
    fmt.Println("index=",k, "===>", "value="v)
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
0xc0000ae008
0xc0000ae008
0xc0000ae008
=======
index= 0 ===> value= 3
index= 1 ===> value= 3
index= 2 ===> value= 3

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

原因分析: for range每次产生的key,value是对应遍历对象里面值的拷贝,不是对应遍历对象的值引用。v是slice在for循环申请的局部变量,迭代遍历之后,v每次都会被重新赋值,而在myMap这个map中记录的value是v的内存地址。

4. go defer,多个 defer 的顺序,defer 在什么时机会修改返回值
  • 多个defer执行顺序是后进先出
  • defer、return、返回值三者的执行逻辑是:return最先执行,结果写入返回值中,接着defer,最后函数携带返回值退出

A. 有名返回值的情况

func c()(i int){
  defer func(){i++}()
  return 1
}
  • 1
  • 2
  • 3
  • 4

输出结果2 defer是在return调用之后执行。这段代码defer的作用域是在c函数之内,可以读取c函数内的变量,当执行return 1之后,i的值就是1,defer代码块执行,对i自增操作,输出2

B. 无名返回值的情况

func n() int{
  var i int
  defer func(){
    i++ 
    fmt.Println("i=", i)
  }()
  return i
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

**输出结果0 **

**原因分析:**n函数的返回值没有被提前声明,其值来自其他变量的赋值,而defer修改也是其他变量,而非返回值本身,因此函数退出时返回值并没有改变;c函数的返回值提前声明,defer可以调用真实返回值,defer在return赋值返回值i之后,再一次修改了i的值,函数退出后的返回值时defer修改之后的。

C. 声明一个指针返回值

func prt() *int{
  var i int
  defer func(){
    i++
    fmt.Println("i=",i)
  }()
  return &i
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

**输出结果:1 ** prt函数没有提前声明,但是返回的是指针变量,return将变量i的地址赋值给返回值后,defer再次修改了i在内存中的实际值,函数退出时返回值时原来的指针的地址,但其指向的内存实际值已被修改。

5. uint类型溢出
func main(){
  //a, b uint8 = 0, 1
  //fmt.Println(a - b)
  
  c := uint8(0) - uint8(1)
  fmt.Println(c)
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

输出结果:constant -1 overflows uint

uint类型溢出会报错,中止服务的进行。但在赋值的时候会做隐适类型转换,会转成有符号整型。

6. 介绍rune类型

int32的别名,几乎在所有方面等同于int32

它是用来区分字符值和整数值

例如:

var str = "hello 您好"
fmt.Println("len=",len(str))  # len=12
fmt.Println("len=",len([]rune(str))) # len=8
  • 1
  • 2
  • 3
  1. golang中string底层时通过byte数组实现的,中文字符在unicode占2个字节,在utf-8占3个字节,golang默认utf-8
  2. rune与byte相似,用来表示字符的变量类型。它们区别:
    • byte等同int8,处理ascii字符
    • rune等同int32,处理unicode和utf-8字符
7. golang中解析tag是怎么实现的?反射原理是什么
  1. 获取字段field

    field := reflect.TypeOf(obj).FieldByName("Name结构体属性名称")
    field := reflect.ValueOf(obj).Type().Field(i)  // i 表示第几个字段
    field := reflect.ValueOf(&obj).Elem().Type().Field(i)  // i 表示第几个字段
    
    • 1
    • 2
    • 3
  2. 获取标签tag

    tag := field.Tag
    
    • 1
  3. 获取键值对key:value

    labelValue := tag.Get("label")
    labelValue,ok := tag.Lookup("label")
    
    • 1
    • 2

反射原理:是在运行时,能够动态知道给定数据对象的类型和结构,并有机会修改它

  • 给定一个数据对象,可以将数据对象转化为反射对象Type和Value。
  • 给定的反射对象,可以转化为某种类型的数据对象
  • 通过反射对象,可以修改原数据中的内容。
8. 调用函数传入结构体时,应该传值还是指针

传值会拷贝整个对象,而传指针只会拷贝指针地址,指向的对象是同一个。传指针可以减少值的拷贝,但是会导致内存分配逃逸到堆中,增加垃圾回收(GC)的负担。在对象频繁创建和删除的场景下,传递指针导致的 GC 开销可能会严重影响性能。

一般情况下,对于需要修改原对象值,或占用内存比较大的结构体,选择传指针。对于只读的占用内存较小的结构体,直接传值能够获得更好的性能。

声明:本文内容由网友自发贡献,转载请注明出处:【wpsshop博客】
推荐阅读
相关标签
  

闽ICP备14008679号