GO常见错误编程总结:第一篇

一。切片之间通过append追加

• 常见错误编码

func main(){
  a:=[]int{1,2,3}
  b:=[]int{4,5,6}
//这个是错误的编程
  a=append(a, b) 
//正确的编程应该是
  a=append(a, b...)
}
//原因：切片之间通过append追加时要用 ... 符号，表示将b中的内容追加的a中。
//也可以通过 a=append(a, 4, 5, 6)这种方式追加

二。全局变量定义

• 常见错误编码

var(
  a:=10 //错误编码
  b=a*2
)
func main(){
  fmt.println(b)
}
//原因：简写方式的定义变量只能在函数内部使用，全局变量不能使用。
//扩展：变量在定义时就初始化时，如果没有说明类型，编译器会根据所赋的值，自动推导

三。 结构体比较

• 常见错误代码

type sn3 struct {
  name string
  age int
}
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")
    }
}

• 知识点总结
  1. 结构体之间只能比较是否相等，不能比较大小
  2. 相同类型的结构体之间才能比较，结构体类型是否相同不仅于属性类型有关，还与定义的属性顺序有关。例如：sn1和sn2就可以比较，和sn3就不可以比较
  3. 如果 struct 的所有成员都可以比较，则该 struct 就可以通过 == 或 != 进行比较是否相等，比较时逐个项进行比较，如果每一项都相等，则两个结构体才相等，否则不相等。那什么是可比较的呢，常见的有 bool、数值型、字符、指针、数组等，像切片、map、函数等是不能比较的

四。类型别名和重新定义新的类型

type  MyType1  int
type MyType2 = int
func main(){
  var a int = 10
  var b MyType1 = a //此处代码编译不过
  var c MyType2 = a
}

• 考察知识点
  1. 类型别名与类型定义的区别
  2. 类型别名的定义用 = 符号
  3. 第 1 行代码是基于类型 int 创建了新类型 MyType1，第 2 行代码是创建了 int 的类型别名 MyType2。所以，第 5行代码相当于是将 int 类型的变量赋值给 MyType1类型的变量，Go 是强类型语言，编译当然不通过；而 MyType2只是 int 的别名，本质上还是 int，可以赋值
  4. 可以通过类型转换赋值 例如：var b MyType1 = MyType1(a)

五。go中iota的使用

const (
     x = iota
     _
     y
     z = "zz"
     k 
     p = iota
 )

func main()  {
    fmt.Println(x,y,z,k,p)  //打印的结果值为：0, 2, zz, zz, 5
}

• 考察知识点
  1. iota是golang语言的常量计数器,只能在常量的表达式中使用
  2. iota在const关键字出现时将被重置为0(const内部的第一行之前)
  3. const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)

六。go类型选择(type)

func GetValue() int{
  return 1
}
func main(){
  i:= GetValue()
  switch i.(type){  //此处报错
    case int:
      fmt.Println("int")
    case string:
      fmt.Println("string")
  }
}

• 考察知识点
  1. 类型选择的语法为：i.(type)
  2. type是固定的关键字，但是i类型必须是interface{} 接口类型，才能使用 i.(type)来判断类型

七。切片和数组细节

func test(i...int){
  i[0]=18
}
func mian(){
  a:=[]int{1,2,3}
  test(a...)
  fmt.println(a[0])
  //输出结果为，A. 1  B. 18   C.Compilation error
}

• 考察知识点
  1. 答案为B
  2. 首先a的类型是一个切片。由于定义的切片是通过中括号的方式定义的而不是通过make方式定义的，所以切片的len和cap都为切片的长度，本例中为3 。
  3. 如果如果中括号中有数值指定长度，例如 a:=[3]int{1,2,3},则定义的是数组类型，而不是切片类型
  4. 切片类型属于引用类型，所以结果为B
  5. 如果函数参数的类型为可变参数，那么只有切片类型的可以通过 a...三个点的方式传递参数，数组是不可以的，会报错

八。 数组比较

func main(){
  a:=[2]int{1,2}
  b:=[3]int{1,2}
  fmt.println(a==b)
}

• 考察知识点
  1. 编译报错
  2. 数组是值类型可以进行比较
  3. 但是是否是同一个数组的值类型，除了类型之外，还需要长度相同。只要有一个不同就是不同的类型，就不能比较。所以a的长度为2，b的长度为3所以不是同一个类型，所以不能比较。