一。切片之间通过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所以不是同一个类型,所以不能比较。

文章来源于互联网,如有雷同请联系站长删除:GO常见错误编程总结:第一篇

发表评论