Day02：Go语言基础语法速过02 ｜青训营nil 在Go语言中，nil 是一个特殊的值，用于表示一个无效或不存在的

nil

在Go语言中，nil 是一个特殊的值，用于表示一个无效或不存在的指针、接口、映射、切片、函数、通道或数组。可以将 nil 视为一个空值或空引用。

在声明一个指针变量时，如果不给它指定一个具体的内存地址，它将被默认赋值为 nil，表示指针不指向任何有效的内存地址。

如果一个接口变量未被初始化，它将被赋值为 nil，表示接口不持有任何具体的值。

切片、映射和函数类型：在未进行初始化操作时，它们的零值都是 nil。

错误处理

错误处理是一种重要的编程技术，用于处理程序运行中可能出现的错误情况。Go语言提供了一种简单而有效的错误处理机制，使用内置的错误类型 error 和关键字 defer, panic 和 recover。

错误类型 error：error 是 Go 语言内置的接口类型，用于表示错误状态。标准库中的许多函数和方法都会返回一个包含错误信息的 error 值。我们可以使用条件判断来检查函数调用返回的错误，并采取相应的处理措施。

result, err := SomeFunction()
if err != nil {
    // 处理错误
} else {
    // 使用返回值
}

defer 关键字：defer 关键字用于延迟执行函数调用，无论函数是否正常返回或发生异常，都会在函数退出之前执行。defer 通常用于释放资源、关闭文件句柄等操作。在一个函数中可以设置多个 defer 语句，它们按照后进先出的顺序执行。

func SomeFunction() error {
    file, err := OpenFile("file.txt")
    if err != nil {
        return err
    }
    defer file.Close() // 在函数退出前关闭文件

    // 其他操作...
    return nil
}

panic 和 recover：panic 用于在程序发生严重错误时引发异常，而 recover 用于捕获并处理这些异常。一般情况下，应该避免使用 panic 和 recover，而是使用错误类型进行正常的错误处理。

func SomeFunction() {
    defer func() {
        if r := recover(); r != nil {
            // 处理异常
        }
    }()

    // 其他操作...
    if somethingWrong {
        panic("出现严重错误！")
    }
}

字符串操作

Go语言提供了一些内置函数和标准库方法来处理和操作字符串。

字符串长度：可以使用内置函数 len() 来获取字符串的长度。

str := "Hello, World!"
length := len(str)
fmt.Println(length) // 输出 13

字符串拼接：可以使用 + 运算符或 strings.Join() 函数来拼接字符串。

str1 := "Hello"
str2 := "World"

// 使用 + 运算符拼接字符串
result := str1 + ", " + str2
fmt.Println(result) // 输出 "Hello, World"

// 使用 strings.Join() 函数拼接字符串
strs := []string{str1, str2}
result = strings.Join(strs, ", ")
fmt.Println(result) // 输出 "Hello, World"

字符串分割：可以使用 strings.Split() 函数将一个字符串分割成子串。

str := "one,two,three,four"
parts := strings.Split(str, ",")
fmt.Println(parts) // 输出 ["one", "two", "three", "four"]

可以使用 strings.Contains() 函数判断一个字符串是否包含另一个子串。

str := "Hello, World!"
contains := strings.Contains(str, "World")
fmt.Println(contains) // 输出 true

可以使用 strings.Replace() 函数将一个字符串中的指定子串替换为另一个字符串。

str := "Hello, World!"
newStr := strings.Replace(str, "World", "Golang", -1)
fmt.Println(newStr) // 输出 "Hello, Golang!"

字符串格式化

字符串格式化是一种常见的操作，可以使用 fmt.Sprintf() 函数或者 fmt.Printf() 函数来进行字符串格式化输出。

使用占位符进行基本的格式化：

name := "Alice"
age := 25
fmt.Printf("Name: %s, Age: %d\n", name, age)

控制浮点数的精度和宽度：

pi := 3.14159265359
fmt.Printf("Value of pi: %.2f\n", pi)

格式化日期和时间：

import "time"

now := time.Now()
fmt.Printf("Current time: %s\n", now.Format("2006-01-02 15:04:05"))

使用 %v 占位符进行自动类型推断：

num := 42
str := "Hello"
fmt.Printf("Number: %v, String: %v\n", num, str)

时间操作

在Go语言中，时间处理是非常常见的操作。Go语言提供了time包来处理时间和日期。

获取当前时间：

import "time"

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

格式化时间为字符串：

import "time"

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

解析字符串为时间：

import "time"

str := "2023-07-26 06:12:59"
parsedTime, _ := time.Parse("2006-01-02 15:04:05", str)
fmt.Println(parsedTime)

时间加减运算：

import "time"

currentTime := time.Now()
newTime := currentTime.Add(24 * time.Hour) // 加一天
fmt.Println(newTime)

获取特定时间单位的值：

import (
	"fmt"
	"time"
)

func main() {
	currentTime := time.Now()
	year := currentTime.Year()
	month := currentTime.Month()
	day := currentTime.Day()
	hour := currentTime.Hour()
	minute := currentTime.Minute()
	second := currentTime.Second()
	fmt.Println(year, month, day, hour, minute, second) // 输出结果作为注释：2023 July 26 6 18 45
}

计算时间差：

import "time"

startTime := time.Now()
time.Sleep(2 * time.Second) // 假设经过了2秒
endTime := time.Now()

duration := endTime.Sub(startTime)
fmt.Println(duration)//2.0035266s

2.sub()


package main

import (
	"fmt"
	"time"
)

func main() {
	startTime := time.Now()
	time.Sleep(2 * time.Second) // 假设经过了2秒
	endTime := time.Now()

	duration := endTime.Sub(startTime)
	fmt.Println(duration)
}

数字解析

strconv.ParseInt() 函数用于将字符串解析为整数。它的语法如下：

func ParseInt(s string, base int, bitSize int) (i int64, err error)

s：需要解析的字符串。
base：进制，取值范围为 0 到 36。当 base 为 0 时，会根据字符串的前缀来确定进制（0x 表示十六进制，0 表示八进制，无前缀表示十进制）。
bitSize：结果类型的位数，取值为 0、8、16、32 或 64。通常使用 0，表示根据字符串内容自动选择合适的位数。

函数返回两个值：

i：解析后的整数值。
err：可能出现的错误。

实例

package main

import (
	"fmt"
	"strconv"
)

func main() {
	str := "12345"

	if intValue, err := strconv.ParseInt(str, 10, 64); err == nil {
		fmt.Println("解析后的整数：", intValue)
	} else {
		fmt.Println("解析整数错误：", err)
	}
}

strconv.Atoi() 函数用于将字符串解析为整数。它的语法如下：

func Atoi(s string) (int, error)

参数说明：

s：需要解析的字符串。

函数返回两个值：

int：解析后的整数值。
error：可能出现的错误。

package main

import (
	"fmt"
	"strconv"
)

func main() {
	str := "12345"

	if intValue, err := strconv.Atoi(str); err == nil {
		fmt.Println("解析后的整数：", intValue)
	} else {
		fmt.Println("解析整数错误：", err)
	}
}

进程消息

`os.Args()`

os.Args 是一个字符串切片，用于获取命令行参数。它包含了程序名称和在程序名称之后传递的所有参数。

示例代码如下所示：

package main

import (
	"fmt"
	"os"
)

func main() {
	// 获取命令行参数
	args := os.Args

	// 打印程序名称
	fmt.Println("程序名称:", args[0])

	// 打印其他参数
	if len(args) > 1 {
		fmt.Println("其他参数:")
		for i := 1; i < len(args); i++ {
			fmt.Println(args[i])
		}
	}
}

假设将上述代码保存为 args_example.go，然后在命令行中执行以下命令：

go run args_example.go param1 param2 param3

输出结果将会是：

程序名称: args_example.go
其他参数:
param1
param2
param3

可以看到，os.Args[0] 存储了程序名称，而其他的参数则依次存储在 os.Args 的后续位置。

通过 os.Getenv() 函数可以获取环境变量的值。

示例：

package main

import (
	"fmt"
	"os"
)

func main() {
	// 获取环境变量的值
	value := os.Getenv("PATH")

	// 打印环境变量的值
	fmt.Println("PATH 环境变量的值:", value)
}

上述代码演示了如何获取名为 "PATH" 的环境变量的值。os.Getenv() 函数接收一个字符串参数，表示要获取的环境变量的名称。如果环境变量存在，则返回其值；如果环境变量不存在，则返回空字符串。

`os.Setenv()`

在 Go 语言中，通过 os.Setenv() 函数可以设置环境变量的值。

示例代码如下所示：

package main

import (
	"fmt"
	"os"
)

func main() {
	// 设置环境变量的值
	err := os.Setenv("MY_VARIABLE", "my_value")
	if err != nil {
		fmt.Println("设置环境变量失败:", err)
		return
	}

	// 获取环境变量的值
	value := os.Getenv("MY_VARIABLE")

	// 打印环境变量的值
	fmt.Println("MY_VARIABLE 环境变量的值:", value)
}

上述代码演示了如何设置名为 "MY_VARIABLE" 的环境变量的值为 "my_value"，然后获取该环境变量的值并进行打印。

os.Setenv() 函数接收两个参数，第一个参数是要设置的环境变量的名称，第二个参数是要设置的环境变量的值。如果设置环境变量成功，则返回 nil，否则返回相应的错误。

请注意，在程序结束后，设置的环境变量将不再存在。

`exec.Command()`

exec.Command() 是 Go 语言中的一个函数，用于创建并返回一个 *Cmd 对象，该对象代表要执行的外部命令。

函数签名如下所示：

func Command(name string, arg ...string) *Cmd

name 参数表示要执行的命令的名称，而 arg 参数是可选的命令参数列表。

示例代码如下所示：

package main

import (
	"fmt"
	"log"
	"os/exec"
)

func main() {
	// 创建并配置一个命令对象
	cmd := exec.Command("echo", "Hello, World!")

	// 执行命令并获取输出
	output, err := cmd.Output()
	if err != nil {
		log.Fatal(err)
	}

	// 打印输出结果
	fmt.Println(string(output))
}

上述代码演示了如何使用 exec.Command() 创建一个执行 echo "Hello, World!" 命令的命令对象，并将其输出打印到控制台。

在创建命令对象后，可以通过设置 Cmd 结构体的其他属性，如 Stdin、Stdout、Stderr 来配置命令的输入、输出和错误处理方式。

Day02：Go语言基础语法速过02 ｜ 青训营

nil

错误处理

字符串操作

字符串格式化

时间操作

数字解析

进程消息

os.Args()

os.Setenv()

exec.Command()

Day02：Go语言基础语法速过02 ｜青训营

`os.Args()`

`os.Setenv()`

`exec.Command()`