focus848 / note Goto Github PK

 a0 := [...]int{1,2,3}
 a1 := a0 // 复制整个数组
 a1[0] = 99
 fmt.Println(a0,a1)
 // 输出[1,2,3] [99,2,3]

a0 := [3]{1,2,3}  //长度为3的数组
a1 :=[...]{1,2,3} // 根据初始化的元素个数决定数组的长度
a2 := [4]{0:1986,2:826} // 通过索引指定元素的值
type person struct {
        name string 
        age uint8
    }

    a := [...]person {
        person{"LiHong",29},
        person{"WangQinQin",26},//别忘了,号
    }

a0 := [3]int{} //[0 0 0]
a1 := [3]int{1,2,3} //[1 2 3]
a2 := [...]int{1,2,3}//[1,2,3] [...]表示数组的元素由初始元素个数决定
a3 :=[5]int{1:99,3:98}//[0,99,0,98,0] 通过索引指定对应的值，其他没有设置的初始化为0

v := i.(T) //如果i的动态类型是T，那么v的值是i的动态值。否则发生panic
v,ok := i.(T)//如果i的动态类型是T，那么v的值是i的动态值，ok为true。否则ok为false，v是T类型的零值.

v := i.(T) //如果i的动态类型实现了接口T，那么v的值是i的动态值。否则发生panic
v,ok := i.(T)//如果i的动态类型现了接口T，那么v的值是i的动态值，ok为true。否则ok为false，v为nil.

//是go中用来做类型断言的特殊switch语法
switch x.(type) {
   case *QQ: //注意case语句中的类型必须是实现了IM接口的类型，否则编译会报错
   case *Weixn:
   default:
}

import (
    "fmt"
    "testing"
)

type IM interface {
    Send()
}

//QQ
type QQ struct {}

func (*QQ) Send() {}

//微信
type WeiXin struct {}

func (*WeiXin) Send() {}

//陌陌
type MoMo struct {}

func (*MoMo) Send() {}

// 微博
type WeiBo struct {}

func (*WeiBo) Send() {}

// 阿里旺旺
type WanWan struct {}

func (*WanWan) Send() {}

// 京东
type JinDong struct {}

func (*JinDong) Send(){}

/*输出:
Dynamic type of im is WanWan or JinDong
WanWan or JinDong:*word.WanWan &{}
PASS
ok */
func TestRun(t *testing.T) {
    var im IM = &WanWan{}

    // 第一种形式
    switch im.(type) {
        case *QQ://注意case语句中的类型必须是实现了IM接口的类型，否则编译会报错
            fmt.Println("Dynamic type of im is QQ")
        case *WeiXin:
            fmt.Println("Dynamic type of im is WeiXin")
        case *MoMo:
            fmt.Println("Dynamic type of im is MoMo")
        case *WeiBo:
            fmt.Println("Dynamic type of im is WeiBo")
         case *WanWan,*JinDong:
             fmt.Println("Dynamic type of im is WanWan or JinDong")
        default:
            fmt.Println("Not found excepted type")
    }

    // 第二种形式.v为im的动态值
    switch v := im.(type) {
        case *QQ:
            fmt.Printf("QQ:%T %V\n",v,v)
        case *WeiXin:
            fmt.Printf("WeiXin:%T %V\n",v,v)
        case *MoMo:
            fmt.Printf("MoMo:%T %V\n",v,v)
        case *WeiBo:
            fmt.Printf("WeiBo:%T %V\n",v,v)
         case *WanWan,*JinDong:
            fmt.Printf("WanWan or JinDong:%T %V\n",v,v)
        default:
            fmt.Printf("NotFound:%T %V\n",v,v)
    }
}

// 声明
func (receiver type) methodName(...arg list) (return value..)
//调用
receiver.selector(...arg list)

type NewType struct{}
// receiver类型为T
func (NewType) M(){fmt.Println("call M()")}

func main() {
   t := NewType{}
   p := new(NewType)
   t.M()
   p.M() //编译器做了隐试转换，实际是(*p).M()
}

type NewType struct{}
//receiver类型为*T
func (*NewType) M(){fmt.Println("call M()")}

func main() {
   t := NewType{}
   p := new(NewType)
   t.M()////编译器做了隐试转换，实际是(&p).M()
   p.M() 
}

type NewType struct{
    Name string
}
func (n *NewType) M(){fmt.Println(n.Name)}

func main() {
   t := &NewType{"LiHong"}
//返回一个方法值,可直接调用methodValue而不用指定receiver
   methodValue := t.M  
/* 方法表达式：返回一个函数值,函数值使用第一个参数作为method的receiver
如果receiver是T那么表达式为T.Selector,如果receiver是*T那么表达式为(*T).Selector
*/
   methodExpr := (*NewType).M 
   methodValue()
   methodExpr(t)
}

var rmdirs []func()
for _, d := range tempDirs() {
    dir := d // NOTE: necessary!
    os.MkdirAll(dir, 0755) // creates parent directories too
    rmdirs = append(rmdirs, func() {
        os.RemoveAll(dir)
    })
}
// ...do some work…
for _, rmdir := range rmdirs {
    rmdir() // clean up
}

var rmdirs []func()
for _, dir := range tempDirs() {
    os.MkdirAll(dir, 0755)
    rmdirs = append(rmdirs, func() {
        os.RemoveAll(dir) // NOTE: incorrect!
    })
}

for _, dir := range tempDirs() {
    dir := dir // declares inner dir, initialized to outer dir
    // ...
}

var rmdirs []func()
dirs := tempDirs()
for i := 0; i < len(dirs); i++ {
    os.MkdirAll(dirs[i], 0755) // OK
    rmdirs = append(rmdirs, func() {
        os.RemoveAll(dirs[i]) // NOTE: incorrect!
    })
}

type Name interface {
   funcName(ArgList...) ReturnType
   ...
}

package io

type Writer interface {
    Write(p []byte) (n int, err error)
}

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Closer interface {
    Close() error
}

// 接口内嵌（类似接口内嵌)
type ReadWriter interface {
    Reader
    Writer
}

type ReadWriteCloser interface {
    Reader
    Writer
    Closer
}

import "testing"

type IM interface {
    IM() string
}

type QQ struct {}

func (_ *QQ) IM() string {return `QQ`}

func TestQQ(t *testing.T) {
    qq := QQ{}
    qq.IM() //编译器做了转换，实际是这样的:(&qq).IM()
}

package word

import "testing"

type IM interface {
    IM() string
}

type QQ struct {}

func (_ *QQ) IM() string {return `QQ`}

type WeiXin struct {}

func (_ WeiXin) IM() string{ return `WeiXin`}

var im IM

/* 这个测试将会失败,因为类型QQ上没有实现IM()方法，所以不能赋值给接口IM
  cannot use qq (type QQ) as type IM in assignment:
 QQ does not implement IM (IM method has pointer receiver*/
func TestQQ(t *testing.T) {
    qq := QQ{}
    im = qq
}

func TestQQ2(t *testing.T) {
    qq := &QQ{}
    im = qq
}

func TestWeiXin(t *testing.T) {
    wx := WeiXin{}
    im = wx
}

/*这个测试会成功，因为类型*WeiXin的方法集包括了类WeiXin方法，所以实现了IM接口*/
func TestWeiXin2(t *testing.T) {
    wx := &WeiXin{}
    im = wx
}

// runtime/slice.go
type slice struct {
    array unsafe.Pointer // 指向底层数组
    len   int // 长度.通过索引访问元素不能超过这值
    cap   int // 容量
}

/*零值的slice等于nil。一个nil值的slice并没有底层数组。一个nil值的slice的长度和容量都是0，但是也
有非nil值的slice的长度和容量也是0的.与任意类型的nil值一样，我们可以用[]int(nil)类型转换表达式来生
成一个对应类型slice的nil值。*/
var s1 []int //  len=0 cap=0 s1 == nil
s2 := []int(nil) //true len=0 cap=0 s2==nil
s3 := []int{} //false len=0 cap=0 s3 != nil

var a [10]int
s0 := a[:] // 从数组中创建slice
s1 := s[0:cap(s0)-2] // 从切片中创建切片

/*内置的make函数创建一个指定元素类型、长度和容量的slice。容量部分可以省略，
在这种情况下，容量将等于长度。*/
make([]T, len)
make([]T, len, cap) // same as make([]T, cap)[:len]

func appendInt(x []int, y int) []int {
    var z []int
    zlen := len(x) + 1
    if zlen <= cap(x) {
        // There is room to grow.  Extend the slice.
        z = x[:zlen]
    } else {
        // There is insufficient space.  Allocate a new array.
        // Grow by doubling, for amortized linear complexity.
        zcap := zlen
        if zcap < 2*len(x) {
            zcap = 2 * len(x)
        }
        z = make([]int, zlen, zcap)
        copy(z, x) // a built-in function; see text
    }
    z[len(x)] = y
    return z
}

runes = append(runes, r)

type A struct  {
    Name string
}
func (this A) P(){
    fmt.Println(this.Name)
}
type B struct  {
    A
}
type C struct  {
    B
}

func main() {
   b := C{B{A{"Li Hong"}}}
   b.P()
   fmt.Println(b.Name)
}

type A struct  {
    Name string
}
func (this A) P(){
    fmt.Println(this.Name)
}
type B struct  {
    *A
}

func main() {
   b := B{&A{"Li Hong"}}
   b.P()
   fmt.Println(b.Name)
}

type A struct  {
    Name string
}
func (this A) P(){
    fmt.Println(this.Name)
}
type B struct  {
    A
}

func main() {
   b := B{A{"Li Hong"}}
   b.P()  /// output "LiHong"
}

func (this B) P() {
    this.A.P()
}

type A struct  {
    Name string
}
func (this A) P(){
    fmt.Println(this.Name)
}
type B struct  {
    A
}

func (this B) P() {
    fmt.Println("SoS!!")
}

func main() {
   b := B{A{"Li Hong"}}
   b.P() //  输出SoS!!而不是"Li Hong"
}

// Flag表示一个命令行标签 -name=value对
type Flag struct {
    Name     string // name as it appears on command line
    Usage    string // help message
    Value    Value  // value as set
    DefValue string // default value (as text); for usage message
}

//Value表示一个命令行标签值
type Value interface {
    String() string
    Set(string) error
}

// FlagSet表示一个命令行标签的结合
type FlagSet struct {
    Usage func()

    name          string
    parsed        bool
    actual        map[string]*Flag //存放实际解析出来的标签（时命令行标签集和formal的交集)
    formal        map[string]*Flag // 存放用户设置的标签
    args          []string // 存放命令行参数
    errorHandling ErrorHandling
    output        io.Writer // nil means stderr; use out() accessor
}

// 这些类型都实现了Value接口，所以都可以赋值给Flag中的Value字段
type boolValue bool
type intValue int
type int64Value int64
type uintValue uint
type uint64Value uint64
type stringValue string
type float64Value float64
type durationValue time.Duration

/* 这个函数使用传入的参数生存一个Flag实列并放到FlagSet的formal数组中
所有绑定标签的接口在底层都是调用这个函数*/
func (f *FlagSet) Var(value Value, name string, usage string)

// 这个函数解析一个命令行标签
func (f *FlagSet) parseOne()