基础

package main

import "fmt"

var myfloat01 float32 = 100000182
var myfloat02 float32 = 100000187
var myfloat03 float32 = 10000018
var myfloat04 float32 = 10000023

func main() {
    fmt.Println("myfloat01: ", myfloat01)
    fmt.Println("myfloat02: ", myfloat02)

    //  因为 float32 只有6位精度，只保证小数点后第7位计算结果精确，第8位开始回不精确
    fmt.Println(myfloat02 == myfloat01+5)

    fmt.Println("myfloat03 = ", myfloat03)
    fmt.Println("myfloat04 = ", myfloat04)
    fmt.Println(myfloat04 == myfloat04+5)
}

//  输出结果
//  myfloat01 =  1.00000184e+08
//  myfloat02 =  1.00000184e+08
//  false

//  myfloat03 =  1.0000018e+07
//  myfloat04 =  1.0000023e+07
//  true

//  Go是 强类型，所以要求你条件表达式必须严格返回布尔型的数据【nil 和 0 和 1 都不行】
if (age > 18 && gender == "male") {
  分支 1
//  if 里可以允许先运行一个表达式，取得变量后
} else if age := 20;age > 18 {
  fmt.Println("已经成年了")
//   else if （或 else）和 两边的花括号，必须在同一行  
} else {
  分支 else
}

switch month {
    //  case 后可以接多个多个条件，多个条件之间是 或 的关系，用逗号相隔。
    case 3, 4, 5:
        fmt.Println("春天")
    //  case 条件常量不能重复,否则 在编译时会报错： duplicate case "value" in switch
    case 6, 7, 8:
        fmt.Println("夏天")
    case 9, 10, 11:
        fmt.Println("秋天")
    case 12, 1, 2:
        fmt.Println("冬天")
    default:
        fmt.Println("输入有误...")
}

//  switch 可不接表达式， 就相当于 if - elseif - else
score := 30
switch {
    case score >= 95 && score <= 100:
        fmt.Println("优秀")
    //   case 使用关键字 fallthrough 开启穿透能力
        fallthrough
    case score >= 80:
        fmt.Println("良好")
    case score >= 60:
        fmt.Println("合格")
    case score >= 0:
        fmt.Println("不合格")
    default:
        fmt.Println("输入有误...")
}

//  1 一个表达式：a := 1  for a <= 5 {do sth}
//  2 for i := 1; i <= 5; i++ {do sth}
//  3 for-range 遍历一个可迭代的对象  for key, value := range myarr {do sth}
//  4 无限循环
for [一个表达式 |  ( init; condition; increment ) | Range表达式 | 不接表达式]
{
   statement(s);
}

//  goto 可以打破原有代码执行顺序，直接跳转到某一行执行代码
//  通常与条件语句配合使用。可用来实现条件转移， 构成循环，跳出循环体等功能
//  goto语句与标签之间不能有变量声明，否则编译错误
if condition {
    do sth A
    goto flag1;
    do sth B
}

flag1: 表达式;
do sth C

//  defer 能实现将这个 xxx 函数的调用延迟到当前函数执行完后再执行
func xxx() {
    fmt.Println("B")
}

func main() {
    defer xxx()
    fmt.Println("A")
}
//  输出： A B 

//  使用 defer 只是延时调用函数，此时传递给函数里的变量，不应该受到后续程序的影响
func main() {
    name := "go"
    defer fmt.Println(name) // 输出: go

    name = "python"
    fmt.Println(name)      // 输出: python
}
//  输出： python go

//  如果 defer 后面跟的是匿名函数，情况会有所不同， defer 会取到最后的变量值
func main() {
    name := "go"
    fmt.Println(name) // 输出: go

    defer func() {
        fmt.Println(name) // 输出: python
    }()

    name = "python"
    fmt.Println(name)      // 输出: python
}

//  多个defer 反序调用,有点类似栈一样，后进先出。
func main() {
    name := "go"
    defer fmt.Println(name) // 输出: go

    name = "python"
    defer fmt.Println(name) // 输出: python

    name = "java"
    fmt.Println(name)
}
//  输出 java python go

//  defer 是return 后才调用, 用途：当一个函数里有多个 return 时，你得多调用好多次这个函数，代码就臃肿起来了。
import "fmt"

var name string = "go"

func myfunc() string {
    defer func() {
        name = "python"
    }()

    fmt.Printf("myfunc 函数里的name：%s\n", name)
    return name
}

func main() {
    myname := myfunc()
    fmt.Printf("main 函数里的name: %s\n", name)
    fmt.Println("main 函数里的myname: ", myname)
}
//  输出如下
//  myfunc 函数里的name：go
//  main 函数里的name: python
//  main 函数里的myname:  go

package main

import (
    "fmt"
)

func main() {
    c1 := make(chan string, 1)
    c2 := make(chan string, 1)

    c2 <- "hello"

    //  在运行 select 时，会遍历所有（如果有机会的话）的 case 表达式，只要有一个信道有接收到数据，那么 select 就结束，所以输出如下
    select {
    case msg1 := <-c1:
      fmt.Println("c1 received: ", msg1)
    case msg2 := <-c2:
      fmt.Println("c2 received: ", msg2)
    //  不写default 可能导致死锁
    default:
      fmt.Println("No data received.")
    }
}