Go语言流程控制、时间和日期处理及深入理解nil

目录

• 流程控制
• 时间和日期处理
• 深入理解nil

流程控制

// if
package main

import "fmt"

func main() {
   /* 局部变量定义 */
   var a int = 100
   /* 判断布尔表达式 */
   if a < 20 {
       /* 如果条件为 true 则执行以下语句 */
       fmt.Printf("a 小于 20\n" )
   } else {
       /* 如果条件为 false 则执行以下语句 */
       fmt.Printf("a 不小于 20\n" )
   }
   fmt.Printf("a 的值为 : %d\n", a)
}

// switch 语句
package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var grade string = "B"
   var marks int = 90

   switch marks {
      case 90: grade = "A"
      case 80: grade = "B"
      case 50,60,70 : grade = "C"
      default: grade = "D"  
   }

   switch {
      case grade == "A" :
         fmt.Printf("优秀!\n" )     
      case grade == "B", grade == "C" :
         fmt.Printf("良好\n" )      
      case grade == "D" :
         fmt.Printf("及格\n" )      
      case grade == "F":
         fmt.Printf("不及格\n" )
      default:
         fmt.Printf("差\n" )
   }
   fmt.Printf("你的等级是 %s\n", grade )
}

// select 语句
/**
  select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。

  select 是Go中的一个控制结构，类似于用于通信的switch语句。每个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")
   }    
} 

//比如在下面的场景中，使用全局resChan来接受response，如果时间超过3S,resChan中还没有数据返回，则第二条case将执行
var resChan = make(chan int)
// do request
func test() {
    select {
    case data := <-resChan:
        doData(data)
    case <-time.After(time.Second * 3):
        fmt.Println("request time out")
    }
}

func doData(data int) {
    //...
}

// Golang for支持三种循环方式，包括类似 while 的语法。
package main
import "fmt"
func main() {

   var b int = 15
   var a int

   numbers := [6]int{1, 2, 3, 5}

   /* for 循环 */
   for a := 0; a < 10; a++ {
      fmt.Printf("a 的值为: %d\n", a)
   }

   for a < b {
      a++
      fmt.Printf("a 的值为: %d\n", a)
      }

   for i,x:= range numbers {
      fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
   }   
} 

// 循环语句range
package main
import "fmt"
func main() {
  a := [3]int{0, 1, 2}

  for i, v := range a { // index、value 都是从复制品中取出。
    if i == 0 { // 在修改前，我们先修改原数组。
        a[1], a[2] = 999, 999
        fmt.Println(a) // 确认修改有效，输出 [0, 999, 999]。
    }

    a[i] = v + 100 // 使用复制品中取出的 value 修改原数组。
  }
  fmt.Println(a) // 输出 [100, 101, 102]。
}

// 循环控制Goto、Break、Continue
// 1. 三个语句都可以配合标签(label)使用
// 2. 标签名区分大小写，定以后若不使用会造成编译错误
// 3. `continue`、`break`配合标签(label)可用于多层循环跳出
// 4. `goto`是调整执行位置，与`continue`、`break`配合标签(label)的结果并不相同  

时间和日期处理

时间和日期的基本操作

获取当前时间：

import "time"

now := time.Now()
fmt.Println(now)

时间格式化：

formattedTime := now.Format("2006-01-02 15:04:05")
fmt.Println(formattedTime)

解析时间：

parsedTime, err := time.Parse("2006-01-02 15:04:05", "2023-08-29 12:34:56")
if err != nil {
    fmt.Println("Error parsing time:", err)
} else {
    fmt.Println(parsedTime)
}

时间间隔：

t1 := time.Date(2023, 8, 29, 12, 0, 0, 0, time.UTC)
t2 := time.Date(2023, 8, 29, 13, 0, 0, 0, time.UTC)
duration := t2.Sub(t1)
fmt.Println("Duration:", duration)

时间加减：

oneHour := time.Hour
futureTime := now.Add(oneHour)
pastTime := now.Add(-oneHour)
fmt.Println("Future time:", futureTime)
fmt.Println("Past time:", pastTime)

时间戳：

timestamp := now.Unix()
fmt.Println("Timestamp:", timestamp)

时间本地化：

loc, _ := time.LoadLocation("Asia/Shanghai")
localTime := now.In(loc)
fmt.Println("Local time:", localTime)

示例代码 下面是一个完整的示例代码，展示了上述基本操作：

package main

import (
    "fmt"
    "time"
)

func main() {
    // 获取当前时间
    now := time.Now()
    fmt.Println("Current time:", now)

    // 时间格式化
    formattedTime := now.Format("2006-01-02 15:04:05")
    fmt.Println("Formatted time:", formattedTime)

    // 解析时间
    parsedTime, err := time.Parse("2006-01-02 15:04:05", "2023-08-29 12:34:56")
    if err != nil {
        fmt.Println("Error parsing time:", err)
    } else {
        fmt.Println("Parsed time:", parsedTime)
    }

    // 时间间隔
    t1 := time.Date(2023, 8, 29, 12, 0, 0, 0, time.UTC)
    t2 := time.Date(2023, 8, 29, 13, 0, 0, 0, time.UTC)
    duration := t2.Sub(t1)
    fmt.Println("Duration:", duration)

    // 时间加减
    oneHour := time.Hour
    futureTime := now.Add(oneHour)
    pastTime := now.Add(-oneHour)
    fmt.Println("Future time:", futureTime)
    fmt.Println("Past time:", pastTime)

    // 时间戳
    timestamp := now.Unix()
    fmt.Println("Timestamp:", timestamp)

    // 时间本地化
    loc, _ := time.LoadLocation("Asia/Shanghai")
    localTime := now.In(loc)
    fmt.Println("Local time:", localTime)
}

深入理解nil

在Go语言中，nil 是一个特殊值，表示“没有值”或“空引用”。它主要用于指针、接口、函数、切片、映射、通道等类型。

nil 的常见用途

指针：

var p *int
fmt.Println(p) // 输出: <nil>

切片：

var s []int
fmt.Println(s) // 输出: []
fmt.Println(s == nil) // 输出: true

映射：

var m map[string]int
fmt.Println(m) // 输出: map[]
fmt.Println(m == nil) // 输出: true

通道：

var c chan int
fmt.Println(c) // 输出: <nil>

函数：

func add(a, b int) int {
    return a + b
}

var f func(int, int) int
fmt.Println(f == nil) // 输出: true

接口：

type MyInterface interface {
    DoSomething()
}

var i MyInterface
fmt.Println(i == nil) // 输出: true

nil 的检测

指针：

var p *int
if p == nil {
    fmt.Println("p is nil")
}

切片：

var s []int
if s == nil {
    fmt.Println("s is nil")
}

映射：

var m map[string]int
if m == nil {
    fmt.Println("m is nil")
}

通道：

var c chan int
if c == nil {
    fmt.Println("c is nil")
}

函数：

var f func(int, int) int
if f == nil {
    fmt.Println("f is nil")
}

接口：

var i MyInterface
if i == nil {
    fmt.Println("i is nil")
}

示例代码 下面是一个完整的示例代码，展示了如何使用和检测 nil：

package main

import (
    "fmt"
)

type MyInterface interface {
    DoSomething()
}

func add(a, b int) int {
    return a + b
}

func main() {
    // 指针
    var p *int
    fmt.Println("Pointer p:", p)

    // 切片
    var s []int
    fmt.Println("Slice s:", s)

    // 映射
    var m map[string]int
    fmt.Println("Map m:", m)

    // 通道
    var c chan int
    fmt.Println("Channel c:", c)

    // 函数
    var f func(int, int) int
    fmt.Println("Function f:", f)

    // 接口
    var i MyInterface
    fmt.Println("Interface i:", i)
}

// 输出:
// Pointer p: <nil>
// Slice s: []
// Map m: map[]
// Channel c: <nil>
// Function f: <nil>
// Interface i: <nil>