Go 语言入门指南：基础语法和常用特性解析|豆包MarsCode AI刷题

Go 语言上手 - 基础语法 .pptx

走进 Go 语言基础语法 - 掘金

01简介

1.1什么是Go语言

1. 高性能，高并发
2. 语法简单、学习曲线平缓
3. 静态链接
4. 快速编译
5. 跨平台

交叉编译

6. 垃圾回收

1.2哪些公司使用Go

1.3为什么用Go

性能

02入门

2.1开发环境

安装GoLang

集成开发环境：GoLand，VSCode，基于云的开发环境gitpod.io/#github.com…

2.2 Hello World

package main
import{
    "fmt"
}
func main(){
    fmt.Println("hello world")
    }

注：

• import导入包后面是括号
• fmt 包提供了格式化输入和输出的函数，即Format

2.3 变量

package main

import (
    "fmt"
    "math"
)

func main() {

    var a = "initial"

    var b, c int = 1, 2

    var d = true

    var e float64

    f := float32(e)

    g := a + "foo"
    fmt.Println(a, b, c, d, e, f) // initial 1 2 true 0 0
    fmt.Println(g)                // initialapple

    const s string = "constant"
    const h = 500000000
    const i = 3e20 / h
    fmt.Println(s, h, i, math.Sin(h), math.Sin(i))
}

变量

• (1)var 变量名 = 值
• (2)变量名 := 值
• var关键字用于声明变量，一般会自动推导变量类型
• var b, c int = 1, 2声明两个名为b和c的整数类型变量
• float32表示单精度浮点数，float64表示双精度浮点数

常量：

• const表示常量
• 3e20表示$3\times10^{20}$
• fmt.Println(a, b) 将参数 a 和 b 转换为字符串并在控制台输出。在多个参数之间会自动插入一个空格，即使它们不是字符串类型也能正常输出。

代码练习

这个程序主要展示了 Go 语言中变量和常量的基本用法。首先，在 main 函数中，我们声明了一些变量并对它们进行了初始化。a 是一个字符串类型的变量，初始值为 "initial"。b 和 c 是整数类型的变量，分别被初始化为 1 和 2。d 是一个布尔类型的变量，初始值为 true。e 是一个浮点类型的变量，没有被显式初始化，因此它的初始值为 0。f 是通过将 e 强制转换为 float32 类型得到的。g 是通过将 a 和 "foo" 拼接得到的字符串。

接着，我们使用 fmt.Println 函数打印了这些变量的值。然后，我们定义了一些常量，s 是一个字符串常量，h 是一个整数常量，i 是通过将 3e20 除以 h 得到的一个常量。最后，我们再次使用 fmt.Println 函数打印了这些常量的值，以及 math.Sin 函数对 h 和 i 的计算结果。

• var e float64 定义未赋初值的变量
• 包间没有逗号
• 导了包必须用
• 常量是const

2.4 if else

if后没有括号

package _4_if

import "fmt"

func main() {
    //判断 7 是奇数还是偶数，奇数是odd，偶数是even
if 7%2 == 0 {
       fmt.Println("7 is even")
    } else {
       fmt.Println("7 is odd")
    }
    if 8%4 == 0 {
       // 判断 8 是否能被 4 整除
fmt.Println("8 is divisible by 4")
    }
    if num := 9; num < 0 {
       //是负数
fmt.Println(num, "is negative")
    } else if num < 10 {
       //是一位数
fmt.Println(num, "has 1 digit")
    } else {
       //是多位数
fmt.Println(num, "has multiple digits")
    }
}

2.5 循环

只有for，没有while,do...while，for后没有括号

package main

import "fmt"

func main() {
    i := 1
    for {
       fmt.Println("loop")
       break
    }
    for j := 7; j < 9; j++ {
       fmt.Println(j) // 7 , 8
}
    for n := 0; n < 5; n++ {
       if n%2 == 0 {
          continue
       }
       // 打印奇数 1 , 3
fmt.Println(n)
    }
    for i <= 3 {
       fmt.Println(i) // 1 , 2 , 3
i = i + 1
    }
}

2.6 switch

不需要break

package main

import (
    "fmt"
    "time"
)

func main() {
    a := 2
    switch a {
    case 1:
       fmt.Println("one")
    case 2:
       fmt.Println("two")
    case 3:
       fmt.Println("three")
    case 4, 5:
       fmt.Println("four or five")
    default:
       fmt.Println("other")
    }
    t := time.Now()
    switch {
    case t.Hour() < 12:
       fmt.Println("It's before noon")
    default:
       fmt.Println("It's after noon")
    }
}

• 可以一个case有两个条件，表示或，用逗号隔开
• 其他情况用defalut表示

2.7 数组

数组的长度在定义之后无法再次修改

创建：

var a [5]int长度为5的整型数组，数组名为a

b := [5]int{1, 2, 3, 4, 5}

package main

import "fmt"

func main() {
    var a [5]int
    a[4] = 100
    fmt.Println("get:", a[2])   // 0
fmt.Println("len:", len(a)) // 5
b := [5]int{1, 2, 3, 4, 5}
    fmt.Println(b)
    var twoD [2][3]int
    for i := 0; i < 2; i++ {
       for j := 0; j < 3; j++ {
          twoD[i][j] = i + j
          // [[ 0 , 1 , 2 ][ 1 , 2 , 3 ]]
}
    }
    fmt.Println("2d:", twoD)
}

2.8 切片

可变长数组，有点像python中的list

1. 创建：

声明切片和声明array一样，只是少了长度，此为空(nil)切片

也可以用make：s := make([]string, 3)，创建一个长度为3的字符串切片

2. 追加

s = append(s, "d")

3. 复制

c := make([]string, len(s))
copy(c, s) //把s复制给c

package main

import "fmt"

func main() {
    // 创建一个长度为3的字符串切片
s := make([]string, 3)
    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("get:", s[2])
    fmt.Println("len:", len(s))
    //追加
s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println(s)
    //复制
c := make([]string, len(s))
    copy(c, s) //把s复制给c
fmt.Println(c)
    //切片
fmt.Println(s[2:5]) //cde
fmt.Println(s[:5])  //abcde
fmt.Println(s[2:])  //cdef

good := []string{"g", "o", "o", "d"}
    fmt.Println(good)
}

2.9 map

类似字典

1. 创建

m := make(map[string]int)

使用make函数创建一个名为m的map，键的类型是string，值的类型是int

2. 访问

m["unknow"]用来访问键unknow对应的值，如果键不存在，会返回当前类型的0值，但这样我们并不知道是键不存在还是键存在，但是对应的是0值，所以用r, ok := m["unknow"]安全地访问mapm中的值。如果键"unknow"存在，则ok为true，否则为false。

3. 删除

delete(m, "one")

4. 使用字面量语法初始化两个mapm2和m3

在编程中，字面量（literal）是指直接在代码中表示固定值的符号。字面量语法就是用来表示这些固定值的语法规则。不同类型的数据有不同的字面量表示方式。

字面量语法使得代码更加直观和易于理解，因为你可以直接看到值，而不需要通过变量来引用它们。在你的代码中，var e float64 和 var e = float64 这两行代码都是声明了一个名为 e 的浮点型变量，但是第二行代码是错误的，因为它试图将一个类型（float64）赋值给一个变量，而不是一个具体的值。正确的写法应该是 var e float64 = 0.0 或者 e := 0.0，这样就使用了字面量语法来给变量 e 赋初值。

m2 := map[string]int{"one": 1, "two": 2}
var m3 = map[string]int{"one": 1, "two": 2}

注意：=：这是一个普通的赋值操作符，用于将一个值赋给一个已经声明的变量。:=：这是一个短变量声明操作符，它可以在声明一个新变量的同时为其赋值。

package main

import "fmt"

func main() {
    m := make(map[string]int)
    m["one"] = 1
    m["two"] = 2
    fmt.Println(m) //map[one:1 two:2]
fmt.Println(len(m))
    fmt.Println(m["one"])
    fmt.Println(m["unknow"]) //该键不存在，返回该类型的零值，即0。
r, ok := m["unknow"]
    fmt.Println(r, ok)
    delete(m, "one") //map[two:2]

m2 := map[string]int{"one": 1, "two": 2}
    var m3 = map[string]int{"one": 1, "two": 2}
    fmt.Println(m2, m3) //map[one:1 two:2] map[one:1 two:2]
}

2.10 range

在Go语言中，range 关键字用于迭代数组、切片、字符串、映射（map）或通道（channel）中的元素。它提供了一种便捷的方式来遍历这些数据结构，而不需要显式地使用索引或迭代器。

range 语句的语法如下：

for 循环变量, 元素 := range 集合 {
    // 循环体
}

这里，循环变量 是一个迭代过程中用于接收集合中元素的变量，而 元素 则是集合中的当前元素。在每次迭代中，range 会自动更新 循环变量 和 元素 的值，以便继续下一次迭代。

对于不同类型的集合，range 的行为略有不同：

• 数组和切片：range 返回索引和元素值。
• 字符串：range 返回字符的索引和Unicode码点。
• 映射：range 返回键和值。
• 通道：range 从通道中接收值，直到通道关闭。

感觉这样的迭代更加方便。

迭代数组：

nums := []int{2, 3, 4}
sum := 0
// i：索引 num：元素值
for i, num := range nums {
    sum += num
    //输出2的索引
if num == 2 {
       fmt.Println("index:", i, "num:", num) //index: 0 num: 2
}
}
fmt.Println("sum:", sum) //sum: 9

迭代map:

m := map[string]string{"a": "A", "b": "B"}
for k, v := range m {
    fmt.Println(k, v) //a A ; b B
}
for k := range m {
    fmt.Println("key:", k) //key: a ; key: b
}

在第一个循环中，k表示键，v表示对应的值。代码打印出映射中的所有键值对。在第二个循环中，只遍历了键，并打印出所有的键。

2.11 函数

func 函数名(参数列表) (返回值列表) {
    // 函数体
}

package main

import "fmt"

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

// 检查给定的键是否存在于给定的映射（map）中
func exists(m map[string]string, k string) (v string, ok bool) {
    v, ok = m[k]
    return v, ok
}
func main() {
    res := add(1, 2)
    fmt.Println(res) //3

v, ok := exists(map[string]string{"a": "A"}, "a")
    fmt.Println(v, ok) //A true
}

返回两个值：真正的值 ok

2.12 指针

package main

import "fmt"

func add2(n int) {
    n += 2
}
func add2ptr(n *int) {
    *n += 2
}
func main() {
    n := 5
    add2(n)
    fmt.Println(n) //5
add2ptr(&n)
    fmt.Println(n) //7
}

add2 函数接受一个整数参数 n，并将 n 的值加2。由于整数是值类型，所以在 add2 函数内部对 n 的修改不会影响到函数外部的 n 变量。因此，当调用 add2(n) 后，n 的值仍然是5，所以打印出来的结果是5。

而 add2ptr 函数接受一个指向整数的指针 n，并通过解引用操作 *n 将指针所指向的整数的值加2。由于指针是引用类型，所以在 add2ptr 函数内部对 *n 的修改会影响到函数外部的 n 变量。因此，当调用 add2ptr(&n) 后，n 的值被修改为7，所以打印出来的结果是7。

2.13 结构体

结构体声明：

type 结构体名 struct {
    字段1 类型
    字段2 类型
    //...
}

创建结构体实例：

实例名 := 结构体名{字段1值, 字段2值,...}

访问结构体字段：

实例名.字段名

---

package main

import "fmt"

type user struct {
    name     string
    password string
}

func main() {
    a := user{name: "wang", password: "1024"}
    b := user{"wang", "1024"}
    c := user{name: "wang"}
    c.password = "1024"
    var d user
    d.name = "wang"
    d.password = "1024"
    fmt.Println(a, b, c, d) //{wang 1024} {wang 1024} {wang 1024} {wang 1024}
fmt.Println(checkPassword(a, "haha")) //false
fmt.Println(checkPassword2(&a, "haha")) //false
}
func checkPassword(u user, password string) bool {
    return u.password == password
}
func checkPassword2(u *user, password string) bool {
    return u.password == password
}

checkPassword 函数接受一个结构体实例作为参数，而 checkPassword2 函数接受一个结构体指针作为参数。这意味着 checkPassword2 函数可以修改传入的结构体实例的字段值，而 checkPassword 函数只能读取结构体实例的字段值，不能修改它们。

2.14 结构体方法

func (结构体实例名 结构体名) 方法名(参数列表) 返回值列表 {
    // 方法体
}

指针接收者：

func (结构体指针名 *结构体名) 方法名(参数列表) 返回值列表 {
    // 方法体
}

方法调用：

实例名.方法名(参数)

---

package main

import "fmt"

type user struct {
    name     string
    password string
}

func (u user) checkPassword(password string) bool {
    return u.password == password
}
func (u *user) resetPassword(password string) {
    u.password = password
}
func main() {
    a := user{name: "wang", password: "1024"}
    a.resetPassword("2048")
    fmt.Println(a.checkPassword("2048")) //ture
}

2.15 错误处理

Go语言中的错误是通过返回一个值来表示的，这个值通常是一个error类型的接口。

package main

import (
    "errors"
    "fmt"
)

type user struct {
    name     string
    password string
}
func findUser(users []user, name string) (v *user, err error) {
    for _, u := range users {
        if u.name == name {
            return &u, nil
        }
    }
    return nil, errors.New("not found")
}

• for _, u := range users 是一个循环语句，用于遍历切片 users 中的每个元素。这里的 _ 是一个占位符，表示我们不关心当前迭代的索引值，而 u 则是切片中当前迭代的元素。
• 在Go语言中，nil 是一个预定义的标识符，用于表示指针、接口、切片、映射、通道和函数类型的零值。
• 如果没有找到指定名称的用户，则返回一个 nil 指针和一个自定义的错误对象 errors.New("not found")

func main() {
    u, err := findUser([]user{{"wang", "1024"}}, "wang")
    //没找到
if err != nil {
       fmt.Println(err)
       return
    }
    fmt.Println(u.name) //wang
if u, err := findUser([]user{{"wang", "1024"}}, "li"); err != nil {
       fmt.Println(err) // not found
return
    } else {
       fmt.Println(u.name)
    }
}

2.16 字符串操作

package main

import (
    "fmt"
    "strings"
)

func main() {
    a := "hello"
    fmt.Println(strings.Contains(a, "ll")) //true
fmt.Println(strings.Count(a, "l"))     //2
 //检查字符串a是否以子串"he"开头
fmt.Println(strings.HasPrefix(a, "he"))               //true
fmt.Println(strings.HasSuffix(a, "llo"))              //true
fmt.Println(strings.Index(a, "ll"))                   //2
fmt.Println(strings.Join([]string{"he", "llo"}, "-")) //he-llo
 //函数将字符串a重复指定次数2，并打印结果
fmt.Println(strings.Repeat(a, 2)) //hellohello
 //-1表示替换所有匹配的字符
fmt.Println(strings.Replace(a, "e", "E", -1)) //hEllo
 //将字符串按照指定的分隔符"-"分割成字符串切片
fmt.Println(strings.Split("a-b-c", "-")) //[a b c]
fmt.Println(strings.ToLower(a))          //hello
fmt.Println(strings.ToUpper(a))          //HELLO
fmt.Println(len(a))                      //5
 /*
在Go语言中，字符串的长度是按照字节数来计算的，而不是字符数。对于UTF-8编码的字符串，一个中文字符通常占用3个字节。因此，当你打印字符串b的长度时，输出结果是6
*/
b := "你好"
    fmt.Println(len(b)) //6
}

2.17 字符串格式化

在Go语言中，字符串格式化是一种将变量的值插入到字符串中的方法。这通常用于输出语句，以便将变量的值显示给用户。Go语言提供了多种格式化动词，用于控制输出的格式。

以下是一些常见的格式化动词：

• %v：用于打印任何类型的值。这是一个通用的格式化动词，它会根据值的类型自动选择合适的格式。
• %T：用于打印值的类型。
• %d：用于打印整数。
• %f：用于打印浮点数。
• %s：用于打印字符串。
• %p：用于打印指针的值。
• %t：用于打印布尔值。
• %c：用于打印字符。
• %b：用于打印二进制表示。
• %o：用于打印八进制表示。
• %x：用于打印十六进制表示（小写字母）。
• %X：用于打印十六进制表示（大写字母）。
• %e：用于打印科学计数法表示（小写字母）。
• %E：用于打印科学计数法表示（大写字母）。

此外，还可以使用%+v来打印结构体时包含字段名，使用%#v来打印结构体时包含完整的类型信息。

fmt.printf("%v")

package main

import "fmt"

type point struct {
    x, y int
}

func main() {
    s := "hello"
    n := 123
    p := point{1, 2}
    fmt.Println(s, n)
    fmt.Println(p)

    //%v：用于打印任何类型的值
fmt.Printf("s=%v\n", s) //s=hello
fmt.Printf("n=%v\n", n)
    fmt.Printf("p=%v\n", p)
    //%+v:打印结构体时包含字段名
fmt.Printf("p=%+v\n", p) //p={x:1 y:2}
 //%#v:打印结构体时包含完整的类型信息
fmt.Printf("p=%#v\n", p) //p=main.point{x:1, y:2}

f := 3.141292653
    fmt.Println(f)
    fmt.Printf("%.2f\n", f) //3.14
}

2.18 JSON操作

在Go语言中，encoding/json包提供了对JSON数据的编码和解码功能。可以使用json.Marshal函数将Go语言中的数据结构编码成JSON格式的字节切片，也可以使用json.Unmarshal函数将JSON格式的字节切片解码成Go语言中的数据结构。

type userInfo struct {
    Name  string
    Age   int `json:"age"`
    Hobby []string
}

Age int json:"age" 定义了一个名为Age的整型字段，并指定在JSON编码时使用"age"作为该字段的名称。

将一个 userInfo 结构体实例编码成JSON格式:

func main() {
    a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "TypeScript"}}
    buf, err := json.Marshal(a)
    if err != nil {
        panic(err)
    }
    fmt.Println(buf)         // [123 34 78 97...]
    fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]}

• json.Marshal(a)：将a（一个userInfo结构体实例）编码成JSON格式，并返回一个字节切片。
• panic函数用于抛出一个运行时异常
• 字节切片中的每个元素都是一个字节，而字节在Go语言中是用整数表示的。

buf, err = json.MarshalIndent(a, "", "\t")
    if err != nil {
        panic(err)
    }
    fmt.Println(string(buf))

{
        "Name": "wang",
        "age": 18,
        "Hobby": [
                "Golang",
                "TypeScript"
        ]
}

• 将结构体 a 编码为 JSON 格式，并且使用缩进格式进行格式化输出。
• "" 是前缀字符串，用于在每一行的开始处添加前缀。该例子中前缀为空。
• "\t" 是缩进字符串，用于在每一行的开始处添加缩进。
• 若前缀为"a"，效果为：

{
a        "Name": "wang",
a        "age": 18,
a        "Hobby": [
a                "Golang",
a                "TypeScript"
a        ]
a}

将JSON格式的字节切片解码成Go语言中的数据结构：

var b userInfo
err = json.Unmarshal(buf, &b)
if err != nil {
    panic(err)
}
fmt.Printf("%#v\n", b) //main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang", "TypeScript"}} 

2.19 时间处理

time.Now()

用特定时间格式化

time.parse

在Go语言中，time包提供了时间的显示和测量用的函数。时间类型代表自公元1年1月1日0时以来的秒数。

以下是一些常见的时间处理操作：

1. 获取当前时间： 使用time.Now()函数可以获取当前的时间。
2. 格式化时间： 使用time.Format()方法可以将时间格式化为指定的字符串格式。例如，2006-01-02 15:04:05是一个常用的格式化模板，它表示年月日时分秒。
3. 解析时间字符串： 使用time.Parse()函数可以将一个格式化的时间字符串解析为time.Time类型。
4. 时间的加减： 可以使用time.Add()和time.Sub()方法对时间进行加减操作。
5. 时间的比较： 可以使用==、<、>等操作符对时间进行比较。
6. 获取时间戳： 使用time.Unix()方法可以获取自1970年1月1日以来的秒数。

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println(now)
    //第七个参数 0 表示纳秒。
 //time.UTC 表示时区，这里指定为 UTC 时区
t := time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)
    t2 := time.Date(2022, 3, 27, 2, 30, 36, 0, time.UTC)
    fmt.Println(t)                                                  //2022-03-27 01:25:36 +0000 UTC
fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute()) //2022 March 27 1 25
fmt.Println(t.Format("2006-01-02 15:04:05"))
    diff := t2.Sub(t)                           //diff=t2-t
fmt.Println(diff)                           //1h5m0s
fmt.Println(diff.Minutes(), diff.Seconds()) //会转换成分钟和秒 65 3900
 //将字符串"2022-03-27 01:25:36"解析为time.Time类型，并且使用的格式化字符串是"2006-01-02 15:04:05"
t3, err := time.Parse("2006-01-02 15:04:05", "2022-03-27 01:25:36")
    if err != nil {
       panic(err)
    }
    fmt.Println(t3 == t)    //true
fmt.Println(now.Unix()) //获取时间戳
}

2.20 数字解析

strconv 是 Go 语言标准库中的一个包，它提供了字符串和基本数据类型之间的类型转换功能。这个包包含了多个函数，用于将字符串转换为整数、浮点数、布尔值等，以及将这些类型转换回字符串。

以下是一些 strconv 包中常用的函数：

• ParseBool：将字符串转换为布尔值。
• ParseFloat：将字符串转换为浮点数。
• ParseInt：将字符串转换为整数。
• FormatBool：将布尔值转换为字符串。
• FormatFloat：将浮点数转换为字符串。
• FormatInt：将整数转换为字符串。
• Atoi：将字符串转换为整数。

ParseInt("111", 10, 64) //10进制，64位

package main

import (
    "fmt"
    "strconv"
)

func main() {
    //ParseFloat函数的返回值是一个浮点数和一个可能的错误，使用了_来忽略错误返回值
 //64表示占用64位的存储空间
f, _ := strconv.ParseFloat("1.234", 64)
    fmt.Println(f) //1.234

n, _ := strconv.ParseInt("111", 10, 64)
    fmt.Println(n) //111

 //如果base为0，则根据字符串的前缀来确定进制，前缀"0x"或"0X"表示16进制，"0"表示8进制，否则默认为10进制。
n, _ = strconv.ParseInt("0x1000", 0, 64)
    fmt.Println(n) //4096

 //用于将字符串转换为整数
n2, _ := strconv.Atoi("123")
    fmt.Println(n2) //123

n2, err := strconv.Atoi("AAA")
    fmt.Println(n2, err) //0 strconv.Atoi: parsing "AAA": invalid syntax

}

strconv.Atoi 和 strconv.ParseInt 都是 Go 语言标准库 strconv 包中的函数，用于将字符串转换为整数。但是它们之间有一些区别：

1. 返回值类型：

   1. strconv.Atoi 返回的是 int 类型。
   2. strconv.ParseInt 返回的是 int64 类型。

2. 错误处理：

   1. strconv.Atoi 返回的错误类型是 error。
   2. strconv.ParseInt 返回的错误类型是 *NumError，它是一个结构体，包含了更多的错误信息，比如错误发生的函数名、输入的字符串以及错误类型。

3. 进制支持：

   1. strconv.Atoi 只支持十进制。
   2. strconv.ParseInt 支持从 2 到 36 进制的转换，可以通过第二个参数指定进制。

4. 位大小限制：

   1. strconv.Atoi 没有明确的位大小限制，但是它返回的是 int 类型，所以实际上受到 int 类型的限制。
   2. strconv.ParseInt 可以通过第三个参数指定位大小，比如 8、16、32、64 等。

2.21 进程信息

os.Args 是一个切片（slice），在 Go 语言中用于存储命令行参数。当你运行一个 Go 程序时，你可以在命令行中传递参数给程序，这些参数会被存储在 os.Args 中。

os.Args 的第一个元素是程序的名称，其余元素是传递给程序的参数。例如，如果你运行以下命令：

go run example/20-env/main.go a b c d

os.Args 将包含以下元素：

[/var/folders/8p/n34xxfnx38dg8bv_x8l62t_m0000gn/T/go-build3406981276/b001/exe/main a b c d]

在这个例子中，os.Args[0] 是程序的完整路径，os.Args[1] 是 "a"，os.Args[2] 是 "b"，以此类推。

---

运行：go run 01-BasicGrammar/20-env/main.go a b c d

[C:\Users\Lenovo\AppData\Local\JetBrains\GoLand2024.1\tmp\GoLand___go_build_main_go.exe]

package main

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

func main() {
    //go run 01-BasicGrammar/20-env/main.go a b c d
fmt.Println(os.Args) //[C:\Users\Lenovo\AppData\Local\JetBrains\GoLand2024.1\tmp\GoLand___go_build_main_go.exe]
 //打印出环境变量 PATH 的值
fmt.Println(os.Getenv("PATH")) //C:\Program Files (x86)\Common Files\Oracle\Java\javapath;E:\Program_Files\VMWare\bin;...
 //设置环境变量，名为"AA"，其值为"BB"，如果设置成功，os.Setenv函数会返回一个nil错误
fmt.Println(os.Setenv("AA", "BB")) //<nil>

buf, err := exec.Command("grep", "127.0.0.1", "/etc/hosts").CombinedOutput()
    if err != nil {
       panic(err)
    }
    fmt.Printf(string(buf))

}

exec.Command("grep", "127.0.0.1", "/etc/hosts").CombinedOutput()

• exec.Command("grep", "127.0.0.1", "/etc/hosts") 创建了一个新的命令对象，该对象代表了要执行的命令。

  • "grep" 是要执行的命令的名称，这里是 grep 命令，它通常用于在文本文件中搜索指定的模式。
  • "127.0.0.1" 是传递给 grep 命令的第一个参数，即要搜索的模式。
  • "/etc/hosts" 是传递给 grep 命令的第二个参数，即要搜索的文件名。
  • 该命令在/etc/hosts 文件中搜索包含 127.0.0.1 的行。

• .CombinedOutput() 方法执行这个命令，并将命令的标准输出和标准错误输出合并在一起作为返回值。

这句代码是在Linux操作系统下运行的，Windows 系统中没有预装 grep，也没有路径/etc/hosts，所以运行会报错：panic: exec: "grep": executable file not found in %PATH%

体会

首先，第一次体验在AI的帮助下学习一门语言，感觉是比较高效的，读不懂的地方问它，能给出比较好的解释，但是，用到后面出现了无法回答问题的情况。

此外，我想要自己写一下代码，不仅仅是想看代码，想看它运行，但是当我想要自己写去练习的时候，自动补全已经把答案都给我了。

---

后期装了本地的Go语言环境，体验会好一点，有什么问题用AI练中学直接问AI很方便。但是选中一段代码/expain，它会解释更多的代码，想要解释一句代码需要复制这句代码发给AI。

资料

【GO语言入门到精通】-CSDN博客