golang 时间循环、流程控制条件

迷南。 2022-12-08 12:53 225阅读 0赞

### 条件控制 ###

package process_control
    
    import (
    	"fmt"
    	"os"
    )
    
    /*
    流程控制
    条件	if else
    选择 switch case select
    循环 for for range
    跳转 goto
    	break continue fallthrough
    */
    func RunIf() {
    	//条件控制
    	nun := 5
    	if nun > 5 {
    		fmt.Println("1", nun)
    	} else if nun < 5 {
    		fmt.Println("2", nun)
    	} else {
    		fmt.Println("3", nun)
    	}
    
    	if fileData, err := os.Open("hello.txt"); err != nil {
    		fmt.Println(err.Error())
    	} else {
    		fmt.Println(fileData)
    	}
    
    	chose()
    }
    
    /*
    选择
    */
    func chose() {
    	switch value := 99; {
    	case value < 100:
    		fmt.Println(100)
    		fallthrough //会继续向下查找一个答案
    	case value < 200:
    		fmt.Println(200)
    	case value < 300:
    		fmt.Println(300)
    	default:
    		fmt.Println(0)
    	}
    
    	//通过接口获取类型
    	var interfaceVal interface{}
    	num := 3.1415
    	interfaceVal = num
    	switch types := interfaceVal.(type) {
    	case int32:
    		fmt.Println("int32", types)
    	case string:
    		fmt.Println("string")
    	case float64:
    		fmt.Println("float64")
    	default:
    		fmt.Println("nil")
    	}
    }

### 1.普通时间  ###

package base016
    
    import (
    	"fmt"
    	"math/rand"
    	"strconv"
    	"time"
    )
    
    func BaseTime()  {
    	now := time.Now()
    	fmt.Println("时间戳(秒)：", now.Unix())
    	fmt.Println("时间戳(纳秒):", now.UnixNano())
    	fmt.Println("时间戳(毫秒)：", now.UnixNano()/1e6)
    	fmt.Println("时间戳(纳秒转毫秒)：", now.UnixNano()/1e9)
    
    	d := time.Now().Add(50 * time.Millisecond)
        fmt.Println("时间戳(当前时间50秒后的时间)：", d.Unix())
    
    	//时间格式化
    	fmt.Println(now.Format("02/1/2006 15:04"))
    	fmt.Println(now.Format("2006/1/02 15:04"))
    	//显示时分秒
    	fmt.Println(now.Hour(),now.Minute(),now.Second())
    
    	//条件判断
    	if now.Unix() > 200000 {
    		fmt.Println("搞笑1")
    	}else if now.Unix() > 300000 {
    		fmt.Println("搞笑2")
    	}else {
    		fmt.Println("搞笑3")
    	}
    
    	//循环
    	forFun()
    }
    
    func forFun(){
    	//switch 循环
    	var num = rand.Intn(10)
    	switch num {
    	case 1,2,3,4,5:
    		fmt.Println("switch1")
    	case 6:
    		fmt.Println("switch2")
    	case 7,8,9:
    		fmt.Println("switch3")
    	default:
    		fmt.Println("switch4")
    	}
    	switch {
    	case num < 5:
    		fmt.Println("switch if 1")
    	case num == 5:
    		fmt.Println("switch if 2")
    	case num < 8:
    		fmt.Println("switch if 3")
    	default:
    		fmt.Println("switch if 4")
    	}
    
    	//for 代替while
    	for i := 0; i <= 4; i++ {
    		if i == 2 {
    			continue
    		}else if i == 4 {
    			break
    		}
    
    		str := strconv.Itoa(i)
    		fmt.Println("for",str)
    	}
    
        for {
            fmt.Println("死循环")
        }
    
    	var n = 2
    	for n > 0 {
    		str := strconv.Itoa(n)
    		fmt.Println("while",str)
    		n --
    	}
    
    	//遍历数组
    	var mm = []int{66, 20, 30, 40}
    	for key, value := range mm {
    		fmt.Printf("key:%d  value:%d\n", key, value)
    	}
    
    	//可以指定跳回之前的地方
    	i := 8
    FIRST: //这里大小写无所谓
    	fmt.Println(i)
    	i --
    	if i == 4 {
    		return
    	}
    	goto FIRST
    }

func BreakRun() {
    	//1
    FORBREAK: //下面直接跳出所有循环
    	for num := 0; num < 10; num++ {
    		for value := 0; value < 4; value++ {
    			fmt.Println(num, value)
    			break FORBREAK //不指定只跳出一层循环
    		}
    	}
    
    	//2
    	max := 0
    HOUTO:
    	max++
    	if max < 6 {
    		goto HOUTO //goto 跳转到需要的地方
    	}
    	fmt.Println(max)
    
    	//3
    	for value := 0; value < 4; value++ {
    		fmt.Println("top")
    		continue //忽略循环剩余代码
    		fmt.Println("end")
    	}
    
    }

### 2.定时器 ###

time.After() 超时一次之后，就不再使用的定时器
    time.Tick() 每隔一段时间，就需要使用一次的定时器
    time.Sleep()  阻塞住goroutinue的定时器，准确来说这个不算一个定时器\
    time.Ticker() 可以自由控制定时器启动和关闭的定时器

func after()  {
    	tchan := time.After(time.Second * 3)
    	fmt.Println(time.Now().String(),"tchan type:%T", tchan)
    	fmt.Println(time.Now().String(),"mark 1")
    	fmt.Println(time.Now().String(),"tchan=", <-tchan) // channel里取出数据之后，会发现超时间是3秒
    	fmt.Println(time.Now().String(),"mark 2")
    }
    
    func tick(){
    	c := time.Tick(2 * time.Second)   //就是每隔2秒就能从这个channel获取一个数据
    	for next := range c {
    		fmt.Printf("%v \n", next)
    	}
    }
    
    func ticker(){
    	ticker := time.NewTicker(time.Second)
    	defer ticker.Stop()
    	done := make(chan bool)
    	go func() {
    		time.Sleep(5 * time.Second) // 5s后触发time.Stop，关闭ticker
    		done <- true
    	}()
    	for {
    		select {
    		case <-done:
    			fmt.Println("Done!")
    			return
    		case t := <-ticker.C:  //获取这个定时器的channel,然后取出数据
    			fmt.Println("Current time: ", t)
    		}
    	}
    }