【2024年-12月-续篇-开源社区openEuler实践记录】go-from-mod

前言

初学Go语言，下面仅为个人所学以及小结，若有错误之处，还请指教。
Go语言基础入门篇的一二节课，其中我对每个讲到的语法都重写或者本地测试运行过，
其中第二节课的第三个小项目尚未实现（本人对网络连接那块的脚本尚不熟悉，）
部分代码不能太多，所以贴图了有些。

Go基础语法

目前学过的Go语法只有课程内的，下面是一些小小的笔记。

导包和输出

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

fmt是与输出有关的包，需要import
输出方式Println和java语法很类似

多类型变量定义

下面是部分代码，详细代码可以从AI练中学处获取

	var a = "initial"
	var b, c int = 1, 2
	var d = true
	var e float
	f := float32(e)
	g := a + "foo"
	const s string = "constant"
	const h = 500000000
	const i = 3e20 / h

var 定义一个变量，后面可以直接复制字符，int，布尔类型，32/位浮点型
:=代表赋值操作
math.Sin()是求正弦值

循环for

	for j := 7; j < 9; j++ {
		fmt.Println(j)
	}

Go语言没有while或者do–while循环，只有for，条件不需要括号，和python的条件有点类似哈哈哈
难怪别人说Go是c和python的结合体

条件if

	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")
	}

if-else if-else语句老演员了。同样的，表达式判断不需要括号。

switch选择

a := 1

    switch a {
    case 1:
        fmt.Println("one")
    default:
        fmt.Println("other")
    }

switch语句不需要break也可以在选择完一个分支后直接跳出语句
其中的case后面也可以直接接一个表达式

    t := time.Now()
    case t.Hour() < 12:

数组

数组初始化，自定义初始化，以及二维数组定义如下

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

切片

	s := make([]string, 3)
	s[0] = "a"
	s[1] = "b"
	s[2] = "c"
	fmt.Println("get:", s[2])   // c
	fmt.Println("len:", len(s)) // 3
	s = append(s, "d")
	s = append(s, "e", "f")
	fmt.Println(s) // [a b c d e f]

	c := make([]string, len(s))
	copy(c, s)
	fmt.Println(s[2:5]) // [c d e]
	fmt.Println(s[:5])  // [a b c d e]
	fmt.Println(s[2:])  // [c d e f]

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

需要make出一个字符串
读取值感觉和数组一样，按索引读取
也能len()找长度
append()插入字符
copy()复制字符串
切片和python一样s[a:b]
[]string{}初始化自定义字符串

map字典

	m := make(map[string]int)
	m["one"] = 1
	m["two"] = 2
	r, ok := m["unknow"]
	fmt.Println(r, ok) // 0 false
	delete(m, "one")
	m2 := map[string]int{"one": 1, "two": 2}

map是键值对
也是make创建的，然后中括号[]内的是key的类型,如上面，int是值的类型，string的键的类型。
r,ok中的ok代表返回的正确或者错误信息；
delete根据键来删除键值对；
map[string]int{}自定义map字典；

range

	for i, num := range nums {
        }

i代表索引，num代表索引对应的值；这个语法功能很类似于python中的

       for i,num in enumerate(nums):

函数

func exists(m map[string]string, k string) (v string, ok bool) {
	v, ok = m[k]
	return v, ok
}

例如上面的例子，func是固定的函数定义格式，exists是函数名，括号内的m是形参，跟着的是形参的类型字典；
第二个括号里面是函数返回值的类型(v是返回值，string是字符类型);

指针point

func add2(n int) {
	n += 2
}

func add2ptr(n *int) {
	*n += 2
}
add2(n)
add2ptr(&n)

结构体struct

type user struct {

    name     string

    password string

}
a := user{name: "wang", password: "1024"}

对于结构体的定义，Go语言和c语言的基本一致；

错误error

	u, err := findUser([]user{{"wang", "1024"}}, "wang")
	if err != nil {
		fmt.Println(err)
		return
	}

打印报错的错误信息

格式化输出

	fmt.Printf("p=%v\n", p)  // p={1 2}
	fmt.Printf("p=%+v\n", p) // p={x:1 y:2}
	fmt.Printf("p=%#v\n", p) // p=main.point{x:1, y:2}

格式化输出，%v代表基本输出；
%+v代表输出键值对；
%#v代表更详细的输出；

json对象

	a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "TypeScript"}}
	buf, err := json.Marshal(a)
	fmt.Println(buf)         // [123 34 78 97...]
	fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]}
        
        
        buf, err = json.MarshalIndent(a, "", "\t")
        
        err = json.Unmarshal(buf, &b)

json.Marshal()序列化，将结构体转换为字节流，string()转化为json字符串对象；
json.MarshalIndent()将json字符串格式化对齐；
json.Unmarshal()将json字符串反序列化为结构体；

time时间属性

	now := time.Now()
        fmt.Println(now.Unix()) 
        fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute())
        fmt.Println(t.Format("2006-01-02 15:04:05"))

time.Now()获取当前时间
time.Unix()获取时间戳
t.Format()表示格式化、标准化，上面的那个时间是固定的；

ps

累了，下篇再更新实战例子一二以及改进作业版本。