go基础面试题汇总第一弹

已于 2024-10-01 18:02:51 修改
阅读量473 收藏 11
点赞数 5
文章标签： golang 开发语言 后端
于 2024-10-01 17:42:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43683432/article/details/142671463
版权

init函数是什么时候执行的?

init的函数的作用是什么？

通常作为程序执行前包的初始化，例如mysql redis 等中间件的初始化

init函数的执行顺序是怎样的？

分不同情况来回答：

  1. 在同一个go文件里面如果有多个init方法，它们会按照代码依次执行。
  2. 同一个package文件里面，它们会按照文件名的顺序执行。
  3. 不同的package且不是相互依赖的情况下，按照Import导入的顺序执行。
  4. 不同的package是相互依赖的情况，会优先执行最后被依赖的init函数。

go文件的初始化顺序是怎样的？

  1. 执行引入的包。
  2. 当前包里面的常量变量。
  3. 执行init函数。
  4. 执行main函数。

注意点：

  1. 包相互依赖避免循环导入问题。
  2. 所有文件的init函数都是在一个goroutine内执行的。
  3. 如果一个包在不同的地方被引入多次，但是它的Init函数只会执行一次。

go如何获取项目根目录

可以通过os go内置函数库来获取 os.Getwd()
os.Args[0]
os.Executable
也可以通过环境变量自定义根路径

go中new和make有什么区别?

go和new的区别

meke分配内存的同时会初始化，new只会分配零值填充。
make主要用来给slice,map,channel来初始化，new万能没有限制。
make返回的是原始类型，new返回的是类型的指针*T。
new 申请的值均为零值，对创建映射和切片没有意义。
new可以为任何类型的值开辟内存并返回此值的指针。

数组和切片的区别?

数组和切片的相同点

数组和切片 全部元素类型都必须相同。
数组和切片 所有元素都是连续存储在一块内存中，并且是紧挨着的。

数组和切片的不同点

数组的零值是每个元素类型的零值。
切片的零值为nil。
指针类型的数组和切片直接用类型声明后是nil,不能直接使用。

slice和map有什么区别

map中的元素所在内存不一定是连续的
访问元素的时间复杂度都是O1，但相对于slice来说map更慢。
map的优势
map的key值的类型是任何可以比较的类型。
对于大多数元素为零值的情况，map可以节省大量内存。

切片的底层数据结构是什么？有什么特性？

它的底层主要有三个部分

  1. array 是一个指向底层数组的指针
  2. len 切片的长度，是指当前切片包含元素数量
  3. cap 切片的容量，是指底层数组能够容纳的元素数量
    切片的动态特性
    当切片的len到达cap时，切片需要扩容，在这个扩容的过程中，go内存机制会分配一个新的更大的底层数组，并且将原数组的内容复制到新数组里面，这个过程是runtime包的growlice函数实现的。

切片是如何扩容的？

1.7和1.8后截然不同

切片是否并发安全

需要手动管理并发安全可以用sync.Mutex来确保切片在追加元素的时候避免并发问题。

如何判断两个切片是否相等

在Go语言中，判断两个切片是否相等，需要考虑切片的元素值是否相等以及顺序是否一致。可以使用reflect.DeepEqual函数来进行比较，它能够深度比较两个值是否相等

package main

import (
   "reflect"
   "fmt"
)

func main() {
   slice1 := []int{1, 2, 3}
   slice2 := []int{1, 2, 3}
   slice3 := []int{3, 2, 1}

   // 使用reflect.DeepEqual比较两个切片
   if reflect.DeepEqual(slice1, slice2) {
   	fmt.Println("slice1 and slice2 are equal")
   } else {
   	fmt.Println("slice1 and slice2 are not equal")
   }

   // 使用reflect.DeepEqual比较两个切片
   if reflect.DeepEqual(slice1, slice3) {
   	fmt.Println("slice1 and slice3 are equal")
   } else {
   	fmt.Println("slice1 and slice3 are not equal")
   }
}

package main

import (
	"fmt"
)

func main() {
	slice1 := []int{1, 2, 3}
	slice2 := []int{1, 2, 3}
	slice3 := []int{3, 2, 1}

	// 比较元素值是否相等
	equal := len(slice1) == len(slice2) && len(slice1) == len(slice3)
	if equal {
		for i := range slice1 {
			if slice1[i] != slice2[i] {
				equal = false
				break
			}
		}
	}

	if equal {
		fmt.Println("slice1 and slice2 have the same elements")
	} else {
		fmt.Println("slice1 and slice2 do not have the same elements")
	}

	equal = len(slice1) == len(slice3) && len(slice1) == len(slice3)
	if equal {
		for i := range slice1 {
			if slice1[i] != slice3[i] {
				equal = false
				break
			}
		}
	}

	if equal {
		fmt.Println("slice1 and slice3 have the same elements")
	} else {
		fmt.Println("slice1 and slice3 do not have the same elements")
	}
}

slice作为参数传递是传值还是传指针

，切片（slice）作为参数传递时，实际上是传递了切片的副本，而不是原始切片的指针。
切片作为参数传递时，传递的是切片的副本。
对切片副本的修改不会影响原始切片，除非通过函数返回值获取新的切片。
切片副本和原始切片共享底层数组，直到副本进行了导致底层数组扩容的操作。

package main

import "fmt"

func modifySlice(s []int) {
   s[0] = 100 // 修改切片副本的第一个元素
}

func modifyAndAppend(s []int) []int {
   s = append(s, 4) // 追加元素，如果容量不够，会重新分配底层数组
   return s
}

func main() {
   original := []int{1, 2, 3}
   modifySlice(original)
   fmt.Println("After modifySlice:", original) // 输出: After modifySlice: [1 2 3]

   newSlice := modifyAndAppend(original)
   fmt.Println("After modifyAndAppend:", original, newSlice) // 输出: After modifyAndAppend: [1 2 3] [1 2 3 4]
}

切片的优化技巧

  1. 预先分配足够的容量
  2. 避免在循环中使用append
  3. 使用copy来复制切片
  4. 注意切片的并发还用 用锁机制保证它的并发安全

strings.TrimRight和strings.TrimSuffix有什么区别

strings.TrimRight(s string, cutset string) string
s := "!!!Hello, World!!!"
result := strings.TrimRight(s, "!")
fmt.Println(result) // 输出 "!!!Hello, World"

strings.TrimSuffix(s string, suffix string) string
s := "Hello, World!"
result := strings.TrimSuffix(s, "!")
fmt.Println(result) // 输出 "Hello, World"

区别:
TrimRight关注的是去除尾部的特定字符集，而TrimSuffix关注的是去除尾部的特定后缀字符串。
TrimRight需要两个参数：原始字符串和要去除的字符集；TrimSuffix只需要两个参数：原始字符串和要去除的后缀。
TrimRight会去除尾部所有指定的字符，直到遇到不在cutset中的字符为止；TrimSuffix则只会去除尾部的特定后缀字符串，如果字符串不是以这个后缀结尾的，那么原始字符串不会被修改。

go语言值溢出会发生什么?

在 Go 语言中，数值类型溢出是指当数值超出类型所能表示的范围时，结果会被截断，从而产生不正确的值。Go 语言中的整型（如 int, int8, int16, int32, int64, uint8, uint16, uint32, uint64）都会受到这种限制。

var x uint8 = 255 // uint8 的最大值是 255
x += 1
fmt.Println(x) // 输出 0

避免值溢出
使用适当的数据类型：确保选择的数值类型可以容纳你所需的数值范围。例如，如果你需要存储大整数，应使用 int64 或者 big.Int 而不是较小的整型。
手动检查值是否溢出：在执行操作前检查数值是否接近类型的最大值或最小值。如果快要溢出，可以采取相应的措施。

var x uint8 = 255
if x == math.MaxUint8 {
    fmt.Println("溢出警告")
} else {
    x += 1
}

发生溢出后解决方案
检测到错误并抛出异常或警告：通过条件语句来捕捉溢出场景，并采取相应措施。
选择更大范围的类型：在代码中可以考虑将类型更改为 int64、uint64，或者对特别大的数值使用 math/big 包中的 big.Int 类型，这个类型没有固定的大小限制。

import "math/big"
a := big.NewInt(1)
b := big.NewInt(1)
result := new(big.Int).Mul(a, b) // 执行大数乘法
fmt.Println(result)

go语言中每个值 在内存中只分布在一个内存块上的类型有哪些?

总结来说，Go 语言中每个值只分布在一个内存块上的类型主要包括基本类型（如整型、浮点型、布尔型等）、数组和结构体。
有一些类型的值在内存中并不只占据一个连续的内存块，它们涉及到指向其他内存区域的指针或引用：
切片（slice）：切片本身是一个描述符，包含指向底层数组的指针、长度和容量，切片描述符存储在一块内存中，但底层数组的元素可能分布在不同的内存块上。
映射（map）：映射是一种引用类型，键值对并不会存储在一个连续的内存块中。
字符串（string）：字符串是一个包含指向底层字节数组的指针和长度的结构，字符串的底层数据可能不在连续的内存块中。
接口（interface）：接口是一个复杂的类型，包含两个部分：类型信息和数据指针。这两部分的内存布局通常不是连续的。

go语言中哪些类型可以使用cap和和len?

len 可用于：array、slice、string、map、channel。
cap 可用于：slice、array、channel。

go语言的指针有哪些限制？

  1. go指针不支持直接进行算术运算。
  2. 一个指针类型的值不能随意转换为另一个指针类型。
  3. 一个指针的值不能随意跟其他类型指针的值进行比较的。
  4. 一个指针的值不能随意被赋值给其它任意类型的指针值。

指针比较需要满足两个条件

  1. 这两个指针类型相同。
  2. 这两个指针之间可以隐式转换。

go语言中哪些类型的零值可以用nil表示

指针、切片、映射、通道、接口类型、函数都可以用nil表示
不同数据类型的nil值的尺寸是不同的。
nil值不一定是可以相互比较的，主要取决于该类型是否可以比较。
可以比较的两个Nil值不一定相等。

go调用函数传入结构体时，是传值还是传指针？

函数的传递参数只有值传递，且传递的实参都是原始数据的一份拷贝
在go语言中赋值操作和函数调用传参都是将原始值的直接部分赋值给了目标值

如何判断两个对象是否完全相同

  1. 基本类型的比较
    对于基本类型（如整型、布尔型、浮点型、字符、字符串等），你可以直接使用 == 运算符比较两个对象的值是否相同。
a := 10
b := 10
fmt.Println(a == b) // true
str1 := "hello"
str2 := "hello"
fmt.Println(str1 == str2) // true
  1. 数组的比较
    Go 语言中的数组支持使用 == 直接比较，前提是数组的元素类型必须是可比较的（如基本类型）。
arr1 := [3]int{1, 2, 3}
arr2 := [3]int{1, 2, 3}
fmt.Println(arr1 == arr2) // true
  1. 结构体的比较
    结构体可以使用 == 进行比较，但前提是结构体的所有字段都是可比较的类型。如果结构体包含了不可比较的字段（如切片、映射、函数等），直接比较会引发编译错误。
type Person struct {
    Name string
    Age  int
}
p1 := Person{Name: "Alice", Age: 25}
p2 := Person{Name: "Alice", Age: 25}
fmt.Println(p1 == p2) // true
    1. 切片（slice）、映射（map）和通道（channel）的比较
      切片、映射、通道 不能直接使用 == 进行比较，除非与 nil 进行比较。要比较两个切片或映射是否完全相同，可以手动遍历每个元素或使用第三方库（如 reflect.DeepEqual）。
var s1 []int = nil
var s2 []int = nil
fmt.Println(s1 == s2) // true, 因为都为 nil

s1 = []int{1, 2, 3}
s2 = []int{1, 2, 3}
// fmt.Println(s1 == s2) // 编译错误，切片不能直接比较
  1. 接口的比较
    接口可以用 == 进行比较，只有当两个接口的动态类型和动态值都相同的时候，才会被认为是相同的。
var i1 interface{} = 123
var i2 interface{} = 123
fmt.Println(i1 == i2) // true
  1. 使用 reflect.DeepEqual 进行深度比较
    对于无法直接用 == 比较的复杂类型（如切片、映射等），你可以使用 Go 标准库中的 reflect.DeepEqual 进行深度比较。它会递归地比较对象的每个字段和元素，适用于结构体、切片、映射等复杂数据结构。
import (
    "fmt"
    "reflect"
)

s1 := []int{1, 2, 3}
s2 := []int{1, 2, 3}
fmt.Println(reflect.DeepEqual(s1, s2)) // true

m1 := map[string]int{"a": 1, "b": 2}
m2 := map[string]int{"a": 1, "b": 2}
fmt.Println(reflect.DeepEqual(m1, m2)) // true

总结
基本类型、数组、结构体（可比较字段）可以使用 == 直接比较。
切片、映射、通道等引用类型不能直接比较，需要使用 reflect.DeepEqual 或手动比较。
接口类型可以使用 == 比较，前提是其动态类型和动态值相同

用两种方法判断一个对象是否拥有某个方法

  1. 利用类型断言（Type Assertion）判断对象是否实现某个接口
    Go 是静态类型语言，但它通过接口提供了动态的特性。通过定义一个接口，并使用类型断言，能够判断某个对象是否实现了该接口（即是否拥有某个方法）。
    示例代码：
    假设要判断某个对象是否有 Speak() 方法：
type Speaker interface {
    Speak()
}

type Person struct{}

func (p Person) Speak() {
    fmt.Println("I can speak!")
}

func main() {
    var obj interface{} = Person{}

    if speaker, ok := obj.(Speaker); ok {
        fmt.Println("This object has the Speak method.")
        speaker.Speak() // 调用该方法
    } else {
        fmt.Println("This object does not have the Speak method.")
    }
}
  1. 使用 reflect 包进行反射判断
    Go 的 reflect 包允许在运行时检查和操作对象的类型和方法。通过反射可以检查一个对象是否拥有某个方法。
import (
    "fmt"
    "reflect"
)

type Person struct{}

func (p Person) Speak() {
    fmt.Println("I can speak!")
}

func main() {
    var obj = Person{}

    method := reflect.ValueOf(obj).MethodByName("Speak")
    if method.IsValid() {
        fmt.Println("This object has the Speak method.")
        method.Call(nil) // 调用该方法
    } else {
        fmt.Println("This object does not have the Speak method.")
    }
}

总结：
类型断言：通过接口类型断言来判断对象是否实现某个接口（从而拥有对应的方法）。
反射（reflect）：利用反射在运行时动态检查对象是否具有指定名称的方法。

悟空丶123
关注
最新golang语言面试题总结（一）
IT_ziliang的博客
03-15 1万+
new: 分配内存。内存里存的值是对应类型的零值。 只有一个参数。参数是分配的内存空间所存储的变量类型，Go语言里的任何类型都可以是new的参数，比如int， 数组，结构体，甚至函数类型都可以。 返回的是指针。 make: 分配和初始化内存。 只能用于slice, map和chan这3个类型，不能用于其它类型。如果是用于slice类型，make函数的第2个参数表示slice的长度，这个参数必须给值。 返回的是原始类型，也就是slice, map和chan，
Golang 面试题总结
sumatch的博客
01-06 2538
GO面试
Golang面试题整理（持续更新...）
lp15929801907的博客
07-17 1279
Golang面试题整理（持续更新...）
golang—面试题大全
qq_51537858的博客
08-13 5058
Go中Map是一个KV对集合。底层使用hash table，用链表来解决冲突 ，出现冲突时，不是每一个Key都申请一个结构通过链表串起来，而是以bmap为最小粒度挂载，一个bmap可以放8个kv。每个map的底层结构是hmap，是有若干个结构为bmap的bucket组成的数组。每个bucket底层都采用链表结构。bmap 就是我们常说的“桶”，桶里面会最多装 8 个 key，这些 key之所以会落入同一个桶，是因为它们经过哈希计算后，哈希结果是“一类”的，关于key的定位我们在map的查询和赋值中详细说明。
golang 面试题(从基础到高级)
热门推荐
Bel_Ami_n的博客
03-08 1万+
Golang面试问题汇总： 1.Golang中除了加Mutex锁以外还有哪些方式安全读写共享变量？ Golang中Goroutine 可以通过 Channel 进行安全读写共享变量。 2.无缓冲 Chan 的发送和接收是否同步? ch := make(chan int)     无缓冲的channel由于没有缓冲发送和接收需要同步。 ch := make(chan int, 2) 有缓冲channel不要求发送和接收操作同步。 channel无缓冲时，发送阻塞直到数据被接收
Java面试题基础（第一弹）
猿人启示录
03-19 760
1、面向对象的特征有哪些方面？ 面向对象的特征主要有以下几个方面： 抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。 继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继...
Go语言面试题合集（2022）
jeremy_ke的博客
11-26 2567
强三色不变式：不存在黑色对象引用白色对象的情况了， 因为白色会强制变成灰色。当全部三色标记扫描之后,栈上有可能依然存在白色对象被引用的情况，所以要对栈重新进行三色标记扫描, 但这次为了对象不丢失, 要对本次标记扫描启动STW暂停. 直到栈空间的三色标记结束。如果有个goroutine一直占用资源，那么GMP模型会从正常模式转变为饥饿模式（类似于mutex），允许其它goroutine使用work stealing抢占（禁用自旋锁）。
最新golang语言面试题总结（二）
IT_ziliang的博客
04-13 3829
1、向nil通道（channel）读写数据会panic吗？ package main 1、//从一个nil通道读取报fatal error: all goroutines are asleep - deadlock! func main1() { //var receiveChan <-chan interface{} //var sendChan chan<- interface{} //dataStream := make(chan interface{})
知识点整理，Java基础面试题（一）
BoCong-Deng的博客
03-15 1万+
写在前面 整理了一些互联网大厂的面试题，这些面试题经常会被问到，也是作为Java工程师需要掌握的一些知识点，毕竟理论和实践的结合，才是王道，分片整理，每天嗑些知识点，快乐每一天，如果对你有帮助，记得点个关注和点个赞哦。 相关系列文章 知识点整理，MyBatis面试题 知识点整理，ZooKeeper面试题 知识点整理，Dubbo面试题 知识点整理，Elasticsearch面试题 知识点整理，Red...
【面向校招】Golang 常考面试题汇总 持续更新中...
Jing_Hua
10-09 652
一些常见的go面试题，基础和底层汇总
Java基础面试题系列
jamesluozhiwei的博客
06-20 9107
本文收集了一些经典的Java面试题 1、面向对象的特征有哪些方面？ 答：面向对象的特征主要有以下几个方面： 抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。 继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中...
前端面试题汇总 - 基础
将心_的博客
10-18 1900
前端面试基础题目汇总
Vue基础知识点汇总【附基础面试题】
qq_43293778的博客
06-02 2382
文章目录什么是Vue如何使用VueMVVM设计模式绑定语法: 同模板字符串中的${}指令(directive)v-bindv-showv-if高频笔试题(手写) 观察者模式v-forsplice:key=“i”绑定HTML片段内容v-html防止用户短暂看到{{}}v-cloakv-text事件绑定vue中如何获得事件对象 (vue中如何获得鼠标位置)$eventv-oncev-pre双向绑定v-model监控函数 watch绑定样式绑定内联样式绑定class自定义指令计算属性过滤器axios组件组件化开发
精选SpringCloud面试题
　　不气馁的博客
04-18 5905
SpringCloud Netflix & Sprin gCloud Alibaba 什么是 Spring Cloud ？ Spring Cloud 是构建在 Spring Boot 基础之上，用于快速构建分布式系统的通用模式的工具集。或者说，换成大家更为熟知的，用于构建微服务的技术栈。 而后，不同厂商结合自身的中间件，提供自身的SpringCloud套件，例如： Netflix 结合自己的 Eureka、Ribbon、Hystrix 等开源中间件，实现了 spring-cloud-netflix
GO语言环境搭建和字符说明
qq_43556680的博客
09-28 1281
Go的三种安装方式Go有多种安装方式，你可以选择自己喜欢的。：这是一种标准的软件安装方式。对于经常使用Unix类系统的用户，尤其对于开发者来说，从源码安装是最方便而熟悉的。：Go提供了方便的安装包，支持Windows、Linux、Mac等系统。这种方式适合初学者，可根据自己的系统位数下载好相应的安装包，一路next就可以轻松安装了。：目前有很多方便的第三方软件包工具，例如Ubuntu的apt-get、Mac的homebrew等。这种安装方式适合那些熟悉相应系统的用户。
golang rpc
最新发布
weixin_44575660的博客
10-01 524
RPC（Remote Procedure Call）远程过程调用，简单的理解是一个节点请求另一个节点提供的服务，对应rpc的是本地过程调用，函数调用是最常用的本地过程调用，将本地过程调用变成远程调用会面临着各种问题。函数调用过程：（1）将1和2压入函数的栈中（2）进入add函数，从栈中取出1和2分别赋值给a和b（3）执行a+b将结果压栈（4）将栈中的结果取出打印1.原本的本地函数放到另外一个服务器上去运行，但是引入了很多新问题2.Call的id映射。
Golang | Leetcode Golang题解之第445题两数相加II
weixin_66442839的博客
09-29 342
Golang | Leetcode Golang题解之第445题两数相加II
golang学习笔记26-管道（Channel）【重要】
技术卷的博客
09-28 834
本节也是GO核心部分，很重要。介绍了管道的读数据，写数据，关闭，遍历操作，协程和管道如何协同工作，管道的只读/只写声明，select多路复用，for监听管道。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值