关于go:Go-面试题收集持续charge

 一个函数内 defer 的执行程序与其申明程序相同
呈现 panic 语句时，会先执行 defer 后执行 panic
呈现 panic 语句时，申明在 panic 前面的任何代码不再执行

package main

import("fmt")

func main(){defer func(){fmt.Println("打印前")}()
    defer func(){fmt.Println("打印中")}()
    defer func(){fmt.Println("打印后")}()
    panic("完结")
}

$ go run main.go 
打印后
打印中
打印前
panic: 完结

for range 循环的时候会创立每个元素的正本，而不是元素的援用
所以 m[key] = &val 取的都是变量 val 的地址
所以最初 map 中的所有元素的值都是变量 val 的地址，因为最初 val 被赋值为 3，所有输入都是 3

package main

import("fmt")

func main(){slice := []int{0,1,2,3}
     m := make(map[int]*int)
     for key,val := range slice {m[key] = &val
     }

    for k,v := range m {fmt.Println(k,"->",*v)
    }
    
}

$ go run main.go 
0 -> 3
1 -> 3
2 -> 3
3 -> 3

// 上面两段代码输入什么

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

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

// 上面这段代码有什么缺点

func funcMui(x,y int)(sum int,error){return x+y,nil}
// 第二个返回值没有命名

// 正确写法
func funcMui(x,y int)(sum int, err error){return x+y,nil}

// new() 与 make() 的区别
package main

import("fmt")
    
func main(){s1 := new([]int)
    s2 := make([]int, 0)

    fmt.Println(s1)
    fmt.Println(s2)
}
// 输入:

$ go run main.go      
&[]
[]

// 上面这段代码是否通过编译，不能的话起因是什么；如果能，输入什么。func main() {list := new([]int)
    list = append(list, 1)
    fmt.Println(list)
}

// 不能通过编译，new([]int) 之后的 list 是一个 *[]int 类型的指针，// 不能对指针执行 append 操作。// 能够改写为:
func main() {list := new([]int)
    *list = append(*list, 1)
    fmt.Println(*list)
}

// 上面这段代码是否通过编译，如果能够，输入什么？func main() {s1 := []int{1, 2, 3}
    s2 := []int{4, 5}
    s1 = append(s1, s2)
    fmt.Println(s1)
}

// 不能通过编译。// append() 的第二个参数不能间接应用 slice，需应用 … 操作符，将一个切片追加到另一个切片上：append(s1,s2…)。或者间接跟上元素，形如：append(s1,1,2,3)。// 上面这段代码是否通过编译，如果能够，输入什么？var(
    size := 1024
    max_size = size*2
)

func main() {fmt.Println(size,max_size)
}

// 不能通过编译。变量申明的简短模式，形如：x := 100。有限度：// 只能在函数外部应用简短模式

// 上面这段代码是否通过编译
package main

import("fmt")
    
func main() {
    sn1 := struct {
        age  int
        name string
    }{age: 11, name: "qq"}
    sn2 := struct {
        age  int
        name string
    }{age: 11, name: "qq"}

    if sn1 == sn2 {fmt.Println("sn1 == sn2")
    }

    sm1 := struct {
        age int
        m   map[string]string
    }{age: 11, m: map[string]string{"a": "1"}}
    sm2 := struct {
        age int
        m   map[string]string
    }{age: 11, m: map[string]string{"a": "1"}}

    if sm1 == sm2 {fmt.Println("sm1 == sm2")
    }
}
// 不能通过编译, 因为
// invalid operation: sm1 == sm2 (struct containing map[string]string cannot be compared)
// 什么是可比拟的呢，常见的有 bool、数值型、字符、指针、数组等，像切片、map、函数等是不能比拟的

关于go:Go-面试题收集持续charge

01

02

03

04

05