Go语言基础篇

:= 赋值操作

• 在函数体内，系统可以自动推断类型，所有可以使用 := 简化变量的出事话

var a int = 1;       
a := 1;

var str string = "abc" 
str := "abc"

• 简写形式仅限函数体内，而全局的变量申明不能采用简体

package main

import "fmt"

//标准形式
var a int = 1
var b,c int = 2,3
var str string = "abc"
var str1,str2 string = "bcd","cde"

func main()  {
    //简写形式
    d := 4
    e, f := 5, 6
    str3 := "abcd"
    str4,str5 := "aaa", "bbb"
    fmt.Println(a, b, c, d, e, f);
    fmt.Println(str, str1, str2, str3, str4, str5)
}

常量

package main

import "fmt"

func main() {

    //常量一般定义
    const a int = 10

    //常量可以省略类型
    const b = 20
    fmt.Println(a, b)

    //常量可以用作枚举
    const (
        TYPE1 = 0
        TYPE2 = 1
    )
    fmt.Println(TYPE1, TYPE2)

    //特殊常量 iota
    /**
     * 可以被编译器修改的常量
     * 在const关键字出现时，会被设置为0 const中每一行都会使iota自增1
     */
    const (
        aa = iota
        bb
        cc = iota
    )
    fmt.Println(aa, bb, cc)

    const aaa = iota
    const bbb = iota
    fmt.Println(aaa, bbb)

}

switch语法

package main

import "fmt"

func main() {

    mark := "A"
    num := 0

    //不需要加break
    switch mark {
        case "A":
            num = 1;
        case "B":
            num = 2;
        default:
    }
    fmt.Println(mark, num)

    //type-switch判断interface变量中实际存储的变量类型
    var x interface{}
    switch x.(type) {
        case nil:
            fmt.Println("x is nil")
        case int:
            fmt.Println("x is int")
        default:
            fmt.Println("x type is unknow")
    }

    //fallthrought 会强制执行匹配case后面的一个case语句，不会判断表达式是否成立
    switch mark {
        case "A":
            fmt.Println("mark is A")
            fallthrough
        case "B":
            fmt.Println("mark is B")
            fallthrough
        case "C":
            fmt.Println("mark is C")
        case "":
            fmt.Println("mark is C")
        default:
            fmt.Println("mark is default")
    }
}

select

每个case 必须是一个通信操作，要么是发送，要么是接收
select会随机执行一个case。如果没有case可执行，将阻塞知道有case可运行

package main

import "fmt"

func main() {
   var c1, c2, c3 chan int
   var i1, i2 int
   select {
      //接收
      case i1 = <-c1:
         fmt.Printf("received ", i1, " from c1\n")
      //发送
      case c2 <- i2:
         fmt.Printf("sent ", i2, " to c2\n")
      //包含状态判断
      case i3, ok := (<-c3):  // same as: i3, ok := <-c3
         if ok {
            fmt.Printf("received ", i3, " from c3\n")
         } else {
            fmt.Printf("c3 is closed\n")
         }
      default:
         fmt.Printf("no communication\n")
   }    
}

package main

import (
    "fmt"
    "time"
)

func Chann(ch chan int, stopCh chan bool) {
    var i int
    i = 10
    for j:=0; j<10; j++ {
        ch <- i;
        t := time.Second
        time.Sleep(t)
    }
    stopCh <- true
}

func main() {
    ch := make(chan int)
    c := 0
    stopCh := make(chan bool)

    go Chann(ch, stopCh)
    for {
        select {
            case c = <-ch:
                fmt.Println("Receive 1: ", c)
                //fmt.Println("channel")
            case s := <-ch:
                fmt.Println("Receive 2:", s)
            case t := <-ch:
                fmt.Println("Receive 3:", t)
            case _ = <-stopCh:
                goto end
        }
    }
end:
}

循环相关

• 跳出循环break

package main

import "fmt"

func main() {

    // 不使用标记
    fmt.Println("---- break ----")
    for i := 1; i <= 3; i++ {
        fmt.Printf("i: %d\n", i)
                for i2 := 11; i2 <= 13; i2++ {
                        fmt.Printf("i2: %d\n", i2)
                        break
                }
        }

    // 使用标记
    fmt.Println("---- break label ----")
    re:
        for i := 1; i <= 3; i++ {
            fmt.Printf("i: %d\n", i)
            for i2 := 11; i2 <= 13; i2++ {
                fmt.Printf("i2: %d\n", i2)
                break re
            }
        }
}

• continue

package main

import "fmt"

func main() {

    // 不使用标记
    fmt.Println("---- continue ---- ")
    for i := 1; i <= 3; i++ {
        fmt.Printf("i: %d\n", i)
            for i2 := 11; i2 <= 13; i2++ {
                fmt.Printf("i2: %d\n", i2)
                continue
            }
    }

    // 使用标记
    fmt.Println("---- continue label ----")
    re:
        for i := 1; i <= 3; i++ {
            fmt.Printf("i: %d\n", i)
                for i2 := 11; i2 <= 13; i2++ {
                    fmt.Printf("i2: %d\n", i2)
                    continue re
                }
        }
}
---- continue ---- 
i: 1
i2: 11
i2: 12
i2: 13
i: 2
i2: 11
i2: 12
i2: 13
i: 3
i2: 11
i2: 12
i2: 13
---- continue label ----
i: 1
i2: 11
i: 2
i2: 11
i: 3
i2: 11