Go语言错题整理(一)????

1. 【初级】定义一个包内全局字符串变量，下面语法正确的是（ ABD ）

   A. var str string

   B. str := ""

   C. str = ""

   D. var str = ""

忘了还有一种形式 var str = "" ,导致下边还有别的题错

2 【初级】通过指针变量 p 访问其成员变量 name，下面语法正确的是（ AB ）

A. p.name

B. (*p).name

C. (&p).name

D. p->name

3 【初级】关于字符串连接，下面语法正确的是（ BD ）

A. str := ‘abc’ + ‘123’

B. str := "abc" + "123"

C. str ：= '123' + "abc"

D. fmt.Sprintf("abc%d", 123)

4. 【中级】关于init函数，下面说法正确的是（ AB ）

   A. 一个包中，可以包含多个init函数

   B. 程序编译时，先执行导入包的init函数，再执行本包内的init函数

   C. main包中，不能有init函数

   D. init函数可以被其他函数调用

一个包中，可以包含多个init函数,竟然可以包含多个

5 【初级】关于循环语句，下面说法正确的有（ CD ）

A. 循环语句既支持for关键字，也支持while和do-while

B. 关键字for的基本使用方法与C/C++中没有任何差异

C. for循环支持continue和break来控制循环，但是它提供了一个更高级的break，可以选择中断哪一个循环

D. for循环不支持以逗号为间隔的多个赋值语句，必须使用平行赋值的方式来初始化多个变量

6. 【中级】对于函数定义：

func add(args ...int) int {

 sum :=0

for _,arg := range args {

 sum += arg

 }

 return sum

}

下面对add函数调用正确的是（ ABD ）

A. add(1, 2)

B. add(1, 3, 7)

C. add([]int{1, 2})

D. add([]int{1, 3, 7}...)

一是看错参数了，二是C选项和D选项的区别

[C]解释:laughing:

7. 【初级】关于局部变量的初始化，下面正确的使用方式是（ ABC ）

   A. var i int = 10

   B. var i = 10

   C. i := 10

   D. i = 10

错的原因如1

8【初级】关于const常量定义，下面正确的使用方式是（ ABD ）

A.

21. const Pi float64 = 3.14159265358979323846

const zero= 0.0

B.

const (

size int64= 1024

eof = -1

)

C.

const (

ERR_ELEM_EXISTerror = errors.New("element already exists")

ERR_ELEM_NT_EXISTerror = errors.New("element not exists")

)

D.

const u, vfloat32 = 0, 3

const a,b, c = 3, 4, "foo"

9. 【初级】关于switch语句，下面说法正确的有（ BD ）

   A. 条件表达式必须为常量或者整数

   B. 单个case中，可以出现多个结果选项

   C. 需要用break来明确退出一个case

   D. 只有在case中明确添加fallthrough关键字，才会继续执行紧跟的下一个case

10. 【中级】 golang中的引用类型包括（ ABD ）

    A. 数组切片

    B. map

    C. Struct//zhi

    D. Interface //引用类型

切片，map,channel ，interface都是引用类型

11. 【中级】 golang中的指针运算包括（```BC``）

    A. 可以对指针进行自增或自减运算

    B. 可以通过“&”取指针的地址

    C. 可以通过“*”取指针指向的数据

    D. 可以对指针进行下标运算

12. 【中级】关于整型切片的初始化，下面正确的是（ BCD ）

    A. s := make([]int)

    B. s := make([]int, 0)

    C. s := make([]int, 5, 10)

    D. s := []int{1, 2, 3, 4, 5}

没敢选B,是对的

13. 【中级】关于函数声明，下面语法错误的是（ C ）

    A. func f(a, b int) (value int, err error)

    B. func f(a int, b int) (value int, err error)

    C. func f(a, b int) (value int, error)

    D. func f(a int, b int) (int, int, error)

14:下面的代码输出什么内容

package main

import "fmt"

type People struct{}

func (p *People) ShowA() {
    fmt.Println("showA")
    p.ShowB()
}
func (p *People) ShowB() {
    fmt.Println("showB")
}

type Teacher struct {
    People
}

func (t *Teacher) ShowB() {
    fmt.Println("teacher showB")
}

func main() {
    t := Teacher{}
    t.ShowA()
}
//输出 showA showB

15:下面代码能编译吗，如果不能将其修改为正确的

import (
    "fmt"
)
type People interface {
    Speak(string) string
}
type Stduent struct{}
func (stu *Stduent) Speak(think string) (talk string) {
    if think == "bitch" {
        talk = "You are a good boy"
    } else {
        talk = "hi"
    }
    return
}
func main() {
    var peo People = Stduent{}
    think := "bitch"
    fmt.Println(peo.Speak(think))
}

修改一

import (
    "fmt"
)

type People interface {
    Speak(string) string
}

type Stduent struct{}

func (stu *Stduent) Speak(think string) (talk string) {
    if think == "bitch" {
        talk = "You are a good boy"
    } else {
        talk = "hi"
    }
    return
}
func main() {
    var peo People = &Stduent{}
    think := "bitch"
    fmt.Println(peo.Speak(think))
}

修改二

package main
import (
    "fmt"
)
type People interface {
    Speak(string) string
}

type Stduent struct{}

func (stu Stduent) Speak(think string) (talk string) {
    if think == "bitch" {
        talk = "You are a good boy"
    } else {
        talk = "hi"
    }
    return
}
func main() {
    var peo People = Stduent{}
    think := "hi"
    fmt.Println(peo.Speak(think))
}

总结：指针类型的结构体对象可以同时调用结构体值类型和指针类型对应的方法。而值类型的结构体对象只能调用值类型对应的接口方法。

16:Golang实现冒泡排序

package main

import "fmt"

func main() {
    Arr := [5]int{2, 1, 4, 2, 6}
    for i := 0; i < len(Arr)-1; i++ {
        for j := 0; j < len(Arr)-1-i; j++ {
            if Arr[j] > Arr[j+1] {
                Arr[j], Arr[j+1] = Arr[j+1], Arr[j]
            }
        }
    }
    fmt.Println(Arr)
}

18:Golang判断机器大小端

func IsLittleEndian() bool {
    var i int32 = 0x01020304
    u := unsafe.Pointer(&i)
    pb := (*byte)(u)
    b := *pb
    return (b == 0x04)
}

20:使用递归求解n的阶乘

func GetN(n int) int{
if n == 1 || n == 0{
   return 0
  }
  return(n*GetN(n-1))
}

:sparkles:下边补加 Go 语言实现快速 排序 和选择排序

:microphone: 投稿人主页

选择排序

package main

import (
    "fmt"
)
// 选择排序
func sSort(a []int) {
    // 第一个循环,对每一个元素制定一个冒泡
    for i := 0; i < len(a); i++ {
        // 定义一个最小值的下标
        // 拿到一个i,认为是最小的,然后给后面的剩余的数进行比较
        var min int = i
        for j := i + 1; j < len(a); j++ {
            // 如果发现,a[min]这一项是小的,那么交换位置,把小的放到后面,因为j是随着i越来越大的,
            if a[min] < a[j] {
                min = j
            }
        }
        // 每次都要交换一下数
        a[min], a[i] = a[i], a[min]
    }
}
func main() {
    Arr := []int{1,4,3,9,5,22, 23, 24}
    sSort(Arr)
    fmt.Println(Arr)
}

快速排序

//快速排序
func qSort(arr []int) {
    //当只有一个元素的数组的时候,那么就算该位置结束了
    if len(arr) <= 1 {
        return
    }
    //left为要排序的数组下标开始的位置，right要排序的数组下标结束的位置
    left, right := 0, len(arr)-1
    //value为第一个下标对应的值。
    value := arr[left]
    //k为第一个下标
    k := left
    // 确定value所在的位置
    for i := left + 1; i <= right; i++ {
        if arr[i] < value {
            arr[k] = arr[i]
            arr[i] = arr[k+1]
            k++
        }
    }
    arr[k] = value
    //递归调用左面 k为第一次排序后的值中间的值，左面全比k下标对应的值小
    qSort(arr[:k])
    //递归调用右面 k为第一次排序后的值中间的值，左面全比k下标对应的值大
    qSort(arr[k+1:])
}