目录流程控制时间和日期处理深入理解nil流程控制//ifpackagemainimport"fmt"funcmain(){/局部变量定义/varaint=100/判断布尔表达式/ifa<20{
// 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)
}
在Go语言中,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
指针:
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>
如果觉得我的文章对您有用,请随意打赏。你的支持将鼓励我继续创作!