Go最新Golang面试题——基础知识_golang基础试题(1)，2024年最新太赞了

最新推荐文章于 2024-07-25 22:24:14 发布

2401_84911020

最新推荐文章于 2024-07-25 22:24:14 发布

阅读量448

点赞数 23

分类专栏：程序员文章标签： go 学习面试

本文链接：https://blog.csdn.net/2401_84911020/article/details/138765363

版权

程序员专栏收录该内容

60 篇文章 0 订阅

订阅专栏

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

第二个go协程中i是函数参数，会发生值拷贝，地址会变，内部每次指向新的地址。

func main() {
	var wg sync.WaitGroup
	wg.Add(10) 
	
	// 错误
	for i := 0; i < 10; i++ {
		go func() {
			fmt.Println(i)
			wg.Done()
		}()
	}
	
	// 正确
	for i := 0; i < 10; i++ {
		go func(i int) {
			fmt.Println(i)
			wg.Done()
		}(i)
	}
	wg.Wait()
}

4、select随机性

select会随机选择一个可用通道做收发操作。所以代码是有肯触发异常，也有可能不会。select可以在多个chan间等待执行，有三点原则：

select 中只要有一个case能return，则立刻执行。
当如果同一时间有多个case均能return则伪随机方式抽取任意一个执行。
如果没有一个case能return则可以执行”default”块。

func main() {
    runtime.GOMAXPROCS(1)
    int_chan := make(chan int, 1)
    string_chan := make(chan string, 1)
    int_chan <- 1
    string_chan <- "hello"
    select {
    case value := <-int_chan:
        fmt.Println(value)
    case value := <-string_chan:
        panic(value)
    }
}

5、make默认值和append

make初始化是有默认值的，默认值为0。append函数执行完后，返回的是一个全新的 slice，并且对传入的 slice 并不影响。

func main() {
    s := make([]int, 5)
    s = append(s, 1, 2, 3)
    fmt.Println(s)
}
//[0 0 0 0 0 1 2 3]

func main() {
    s := []int{5}
    s = append(s, 7)
    s = append(s, 9)
    x := append(s, 11)
    y := append(s, 12)
    fmt.Println(s, x, y)
}
//[5 7 9] [5 7 9 12] [5 7 9 12]

6、结构体比较

结构体是可以比较的，但前提是结构体成员字段全部可以比较，并且结构体成员字段类型、个数、顺序也需要相同，当结构体成员全部相等时，两个结构体相等。

特别注意的点，如果结构体成员字段的顺序不相同，那么结构体也是不可以比较的。如果结构体成员字段中有不可以比较的类型，如map、slice、function 等，那么结构体也是不可以比较的。

func main() {
	sn1 := struct {
		age  int
		name string
	}{age: 11, name: "Zhang San"}
	sn2 := struct {
		age  int
		name string
	}{age: 11, name: "Zhang San"}

	fmt.Println(sn1 == sn2) // 输出 true


	sn3 := struct {
		name string
		age  int
	}{age: 11, name: "Zhang San"}

	fmt.Println(sn1 == sn3)
	// 错误提示：Invalid operation: sn1 == sn3 (mismatched types struct {...} and struct {...})
	

	sn4 := struct {
		name string
		age  int
		grade map[string]int
	}{age: 11, name: "Zhang San"}
	sn5 := struct {
		name string
		age  int
		grade map[string]int
	}{age: 11, name: "Zhang San"}

	fmt.Println(sn4 == sn5)
	// 错误提示：Invalid operation: sn4 == sn5 (the operator == is not defined on struct {...})
}

7、type

编译失败，因为type只能使用在interface类型。

//错误
func main(key int) {
	switch key.(type) {
	case int:
		println("int")
	case interface{}:
		println("interface")
	default:
		println("unknown")
	}
}
//正确
func main(key interface{}) {
	switch t := key.(type) {
	case int:
		println("int")
	case float64:
		println("float64")
	case string:
		println("string")
	default:
		println("unknown")
	}
	return
}

8、iota

iota是go语言的常量计数器，只能在常量的表达式中使用，只能用于int类型的常量。使用iota能简化定义，在定义枚举时很有用。

iota在const关键字出现时将被重置为0
const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)
可以通过下划线跳过不想要的值
可以表示左移和右移动
iota以行位单位，同一行的iota数值一样
iota可以实现插队，中间有别的常量会打断iota的递增，要想实现插队则在别的变量后面在加入iota

const (
	m = iota // m = 0
	\_
	\_
	n 		 // n = 3
)
const (
	y = 2 >> iota // y = 2，y右移0位
	x             // x = 1，x右移1位
)
const (
	\_ = iota
	l = 1 << iota // l = 2，l左移1位
	h             // h = 4，h左移2位
)
const (
	\_  = iota
	KB = 1 << (10 \* iota) // KB = 1024，表示1向左移动10\*1位
	MB                    // MB = 1024\*1024，表示向左移动10\*2位
)
const (
	t, r = iota + 1, iota + 2 // t = 1,r = 2 (iota = 0)
	v, u                      // v = 2,u = 3 (iota = 1)
	p, q                      // p = 3,q = 4 (iota = 2)
)
const (
	frist   = iota // frist = 0
	sencond = 5
	thr     = iota // thrid = 2
	last           // last = 3
)

9、常量

常量不同于变量的在运行期分配内存，常量通常会被编译器在预处理阶段直接展开，作为指令数据使用，无法获取常量的地址。

package main
const cl  = 100

var bl    = 123

func main()  {
    println(&bl,bl)
    println(&cl,cl)
}
// Cannot take the address of 'cl'
// 编译错误，无法获取常量的地址

如果是批量声明的常量，除了第一个外其它的常量右边的初始化表达式都可以省略，如果省略初始化表达式则表示使用前面常量的初始化表达式，对应的常量类型也是一样的。

const (
    a = 1
    b
    c = 2
    d
)
fmt.Println(a, b, c, d) // "1 1 2 2"

10、有方向的channel不可被关闭

data := make(chan int)
data := make(chan<- int)    // 定义单向信道，定义只写数据的信道，<-指向chan
data := make(<-chan int)    // 定义单向信道，定义只读数据的信道
只写通道：chan<- T
只读通道：<-chan T
func main(){    
    data := make(chan int)
    go func(out chan<- int){
        time.Sleep(2\* time.Second)
        out <- 1
    }(data)
    <- data
    fmt.Println("Receive data, first")
    go func(out <-chan int){
        time.Sleep(2 \* time.Second)


![img](https://img-blog.csdnimg.cn/img_convert/ba1f1963fb83829f02192e85a9c38200.png)
![img](https://img-blog.csdnimg.cn/img_convert/b311699addfa96db652b387d5d3a5a75.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618658159)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

1715515370012)]
[外链图片转存中...(img-fLg4d3rk-1715515370012)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618658159)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**