golang小结 3

常量

• 声明

  var a = 1
  const (
  b float32 = 2
  d         = 13
  c
  //e = a
  )
  a = a
  fmt.Println("aa")
  fmt.Println(d)
  fmt.Println(c)
  //fmt.Println(&d)
  

  1. 常量声明后可以不被使用（不同于变量和包）
  2. 初始化时类型可以自动推断，但不能由变量赋值
  3. 常量不能取地址
  4. 变量和常量都不能隐式转换类型，但数字可以
  5. 在括号内，常量未赋值时默认为上一个常量的类型和值

• 特殊常量iota

  const (
      a = 3
      b = "good"
      c = iota
      d = "ok"
      e
      f = iota
      g
  )
  const h, i int = iota, iota
  fmt.Println(c, e, f, g, h)
  //2 ok 5 6 0 0
  

  1. iota值为 当前常量声明的行数值
  2. 每出现一次const， iota从0开始计算
  3. 同一行iota 值相同
  4. iota只能用于常量赋值中

函数变参

func avg(x ...int) float32 {
    size := len(x)
    sum := 0
    for i := 0; i < size; i++ {
        sum += x[i]
    }
    return float32(sum) / float32(size)
}
arr = []int{2, 3, 4, 5}
fmt.Println(avg(arr...))
fmt.Println(avg(3, 4, 5, 6))

1. 函数变参本质上是一个slice
2. 变参必须放在最后
3. 可以用slice作为参数但必须展开,(array不行)

结构体与方法

package main

type Foo struct {
    I int //不打逗号
    A int
}
type Good struct {
    Foo //可包含匿名字段
    J int
}

type File struct {
    name string
    size int
    attr struct {
        perm  int
        owner int
    }//匿名结构体
}

func (f *Foo) Hello() int {
    return f.I
}
func (f Foo) Test() {//等价于Test(f)
    f.I = 1997
}
func (f *Foo) TestB() {//等价于TestB(&f)
    f.I = 1997
}
func main() {
    var f = Foo{
        I: 12,
    }//部分赋值，赋值要打逗号
    var g = Good{
        Foo: Foo{
            I: 123,
        },
    }//内含结构体必须写出结构体的名称
    var k = Good{
        Foo{
            456,
            789,
        },
        4,
    }//全部赋值，不用写出字段名称，按顺序给出即可
    var file = File{
        attr: struct {
            perm  int
            owner int
        }{
            0,
            555,
        },
    }//若内含结构体未命名，赋值要给出定义方式
    println(f.Hello())//成员方法的调用
    println(g.I)//匿名字段的成员默认作为一级成员，但命了名的不行
    println(k.Foo.Hello())//匿名字段也可显示指出，适用于有冲突的情况
    println(file.attr.owner)
    f.Test()//不改变f里的值
    println(f.I)
    f.TestB()//要改变
    println(f.I)
}