Go语言学习(Day2)

今日晴空万里

已于 2023-01-15 21:10:09 修改

阅读量178

点赞数

文章标签：学习 go golang

于 2023-01-15 21:07:10 首次发布

本文链接：https://blog.csdn.net/m0_69631269/article/details/128694300

版权

一.map

map即为python中的字典

声明方式

             //key数据类型//value数据类型
m := make(map[string]int)

当map中不存某key，values的数据类型为int或者float时，输出会为0，value数据类型为string时，输出会为空，value数据类型为bool时，返回会为false

    m := make(map[string]bool)
	m["one"] = true
	m["two"] = false
	fmt.Println(m["one"])
	fmt.Println(m["two"])
	fmt.Println(len(m))
	fmt.Println(m["unknow"])
运行结果
true
false
2    
false
    m := make(map[string]int)
	m["one"] = 1
	m["two"] = 1
	fmt.Println(m["one"])
	fmt.Println(m["two"])
	fmt.Println(len(m))
	fmt.Println(m["unknow"])
运行结果
1
1
2
0

用一个r,ok := m["unknow"],当m中不存在unknow这个Key时，返回的Value r为0（当r为int时），ok返回的是false,如果m中有unknown这个key时, 就会返回true，Value r就为这个key的value

    m := make(map[string]int)
	m["one"] = 1
	m["two"] = 2
	r, ok := m["one"]
	fmt.Println(r, ok)
运行结果
1 true
    m := make(map[string]int)
	m["one"] = 1
	m["two"] = 2
	r, ok := m["unknow"]
	fmt.Println(r, ok)
运行结果
0 false

map删除某键值对

    m := make(map[string]int)
	m["one"] = 1
	m["two"] = 2
    delete(m, "one")
	fmt.Println(m["one"])
运行结果
0

初始化创建，map遍历输出是无序的，不会按照字母顺序或者插入顺序

    m1 := map[string]string{"one": "1", "two": "2"}
	//_ = m1
	fmt.Println(m1)
	m1["three"] = "3"
	fmt.Println(m1)
运行结果
map[one:1 two:2]
map[one:1 three:3 two:2]

二.range遍历

数组遍历，返回索引和数组中该索引对应的元素

    nums := []int{1, 2, 3}
	for i, num := range nums {
		fmt.Println("index:", i, "num:", num)
	}
运行结果
index: 0 num: 1
index: 1 num: 2
index: 2 num: 3

map遍历，返回key, value

    m := map[string]int{"one": 1, "two": 2}
	for k, v := range m {
		fmt.Println("key:", k, "value:", v)
	}
运行结果
key: one value: 1
key: two value: 2

直接k遍历map的话，k所得到的是key

    for k := range m {
		fmt.Println(k)
	}
运行结果
one              
two

三.函数

基本构成

go中函数支持返回多个值，但在基本业务中第一个值返回真正的结果，第二个值返回错误信息

当只有一个返回值时

func 函数名(变量1 变量1的数据类型，变量2，变量2的数据类型) 返回值的数据类型{

return 返回值

}

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

当有多个返回值时

func 函数名(变量1 变量1的数据类型，变量2，变量2的数据类型) (返回值1 返回值1的数据类型，返回值2 返回值2的数据类型,返回值3 返回值3的数据类型){

return 返回值1, 返回值2,返回值3

}

func add(a int, b int) (sum int, sum2 int, c int) {
	sum = a + b
	sum2 = a - b
	sum3 := a
	return sum, sum2, sum3
}
func main() {
	a := 1
	b := 2
	sum, sum1, sum2 := add(a, b)
	fmt.Println(sum, sum1, sum2)
}
运行结果
3 -1 1

返回值变量声明区已经声明了这些变量，在函数中就不需要再声明了

                                           //此处已经声明了v ,ok
func exists(m map[string]string, k string) (v string, ok bool) {
	//此处就不需要再进行:=声明，直接=即可
    v, ok = m[k]
	return v, ok
}

func exists(m map[string]string, k string) (v string, ok bool) {
	v, ok = m[k]
	return v, ok
}
func main() {
	m := make(map[string]string)
	m["one"] = "1"
	k := "one"
	value, ok := exists(m, k)
	fmt.Println(value, ok)
}
运行结果
1 true

四.指针

go语言中指针功能十分有限，指针的作用是对传入的参数进行修改

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

}

五.结构体

创建结构体

type user struct {
	name     string
	password string
}

给结构体赋值的几种方法

    a := user{
		name:     "zwt",
		password: "123456"}
	b := user{
		"zwt",
		"123456",
	}
	c := user{name: "zwt"}
	c.password = "123456"
	var d user
	d.name = "zwt"
	d.password = "123456"

函数中传入结构体或者用结构体指针修改结构体内容

func checkPassword(u user, password string) bool {
	return u.password == password
}
func checkPassword2(u *user, password string) {
	(*u).password = password

}
func main() {
a := user{
		name:     "zwt",
		password: "123456"}
	b := user{
		"zwt",
		"123456",
	}
	c := user{name: "zwt"}
	c.password = "123456"
	var d user
	d.name = "zwt"
	d.password = "123456"
	var password string
	fmt.Print("请输入密码:")
	fmt.Scan(&password)
	judge := checkPassword(a, password)
	fmt.Println(judge)
	checkPassword2(&a, password)
	fmt.Println(a)
	fmt.Println(a, b, c, d)

}
运行结果
请输入密码:123
false
{zwt 123}
{zwt 123} {zwt 123456} {zwt 123456} {zwt 123456}

结构体方法，类似于类中方法，可以直接结构体.结构体方法使用，区别就是 u user写在函数名前面，代表是结构体方法，不用再传结构体进去了，只要传函数名后面的值就可以了

func (u user) checkPassword(password string) bool {
	return u.password == password
}
func (u *user) checkPassword2(password string) {
	(*u).password = password

}
func main() {
a := user{
		name:     "zwt",
		password: "123456"}
	b := user{
		"zwt",
		"123456",
	}
	c := user{name: "zwt"}
	c.password = "123456"
	var d user
	d.name = "zwt"
	d.password = "123456"
	var password string
	fmt.Print("请输入密码:")
	fmt.Scan(&password)
	judge := a.checkPassword("123")
	fmt.Println(judge)
	a.checkPassword2(password)
	fmt.Println(a)
	fmt.Println(a, b, c, d)

}
运行结果
请输入密码:1231263
false
{zwt 1231263}
{zwt 1231263} {zwt 123456} {zwt 123456} {zwt 123456}

结构体数组

声明

a := []user{{"zwt", "123456"}, {"zz", "123456"}}

结构体数组传入函数

                                         //结构体指针 //声明错误信息对象          
func findUser(users []user, name string) (v *user, err error) {
	// 遍历结构体数组
    for _, u := range users {
    //如果有一个结构体的name 与传入的name 相等就返回此结构体的地址，nil
		if u.name == name {
			return &u, nil
		}
	}
    // 返回报错信息
	return nil, errors.New("没有找到该的用户")
}
func main() {
    a := []user{{"zwt", "123456"}, {"zz", "123456"}}
	var name string
	fmt.Print("请输入需要查找的用户名:")
	fmt.Scan(&name)
	v, err := findUser(a, name)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println("找到用户名为", v.name, "的用户")
	}
}
运行结果1
请输入需要查找的用户名:zwt 
找到用户名为 zwt 的用户

运行结果2
请输入需要查找的用户名:zzz
没有找到该的用户

六.字符串操作

func main() {
    a := "hello"
	b := "Hello"
	// 判断a字符串中是否包含"ll", 返回bool值
	fmt.Println(strings.Contains(a, "ll"))
	// 比较两个字符串是否相同, 相同返回0, 不相同返回1
	fmt.Println(strings.Compare(a, b))
	// 获取"o"在a中的索引，字符串在go中也可以切片，跟python类似
	fmt.Println(strings.Index(a, "o"))
	// 将所有字符串用"-"连接起来
	fmt.Println(strings.Join([]string{"he", "llo", "66"}, "-"))
	// 将a 字符串重复输出3遍
	fmt.Println(strings.Repeat(a, 3))
	// 将字符串用都好分隔开，存入slice中
	fmt.Println(strings.Split("a,b,c", ","))
	// 转小写
	fmt.Println(strings.ToLower(b))
	// 转大写
	fmt.Println(strings.ToUpper(a))
	// 中文字符的长度不是1
	c := "你好"
	fmt.Println(len(c))

}
运行结果
true
1
4
he-llo-66
hellohellohello
[a b c]
hello
HELLO
6

七.字符串格式化

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

	fmt.Printf("s=%v\n", s)
	fmt.Printf("n=%v\n", n)
	fmt.Printf("p=%v\n", p)
	fmt.Printf("p=%+v\n", p)
	fmt.Printf("p=%#v\n", p)

	f := 3.1415926
	fmt.Println(f)
	fmt.Printf("%0.2f", f)

}
运行结果
hello 123
{1 2}                 
s=hello               
n=123                 
p={1 2}               
p={x:1 y:2}           
p=main.point{x:1, y:2}
3.1415926             
3.14

八.JSON处理

map与json之间的转换，就是python中字典与json的转换

func main() {
    a := make(map[string]string)
	a["name"] = "zwt"
	a["age"] = "19"
	// 转成json格式
	buf, err := json.Marshal(a)
	if err != nil {
		fmt.Println(err)
	}
    // 如果不加string强制类型转换，输出的buf是一个16进制的编码
	fmt.Println(buf)
	fmt.Println(string(buf), reflect.TypeOf(string(buf)))
	var b map[string]string
	// json格式转换成map, 要传一个map指针进去，将buf转成map直接传给map,
	err = json.Unmarshal(buf, &b)
	fmt.Println(b, reflect.TypeOf(b))
}
运行结果
[123 34 97 103 101 34 58 34 49 57 34 44 34 110 97 109 101 34 58 34 122 119 116 3
4 125]
{"age":"19","name":"zwt"} string      
map[age:19 name:zwt] map[string]string

结构体与json之间的转换，结构体中的变量名首字母必须大写才可以转json，否则不行

type UserInfo struct {
	Name string `json:"name"` // 加入这个之后，在json格式中，Name的首字母就会小写
	Age  string `json:"age"`
}
func main() {
    user := UserInfo{
		"zwt",
		"19",
	}
	buf, err := json.Marshal(user)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(buf)
	fmt.Println(string(buf), reflect.TypeOf(string(buf)))

	var b UserInfo
	err = json.Unmarshal(buf, &b)
	fmt.Println(b, reflect.TypeOf(b))

}
运行结果
[123 34 110 97 109 101 34 58 34 122 119 116 34 44 34 97 103 101 34 58 34 49 57 3
4 125]
{"name":"zwt","age":"19"} string
{zwt 19} main.UserInfo

九.时间模块处理

func main() {
    now := time.Now()
	fmt.Println(now)
	t := time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)
	fmt.Println(t)
	fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second())
	t2 := time.Date(2022, 3, 27, 2, 30, 36, 0, time.UTC)
	fmt.Println(t2)
	// 两个时间之差
	diff := t2.Sub(t)
	fmt.Println(diff)
	fmt.Println(diff.Minutes(), diff.Seconds())
	t3, err := time.Parse("2006-01-02 15:04:05", "2022-03-27 01:25:36")
	if err != nil {
		fmt.Println(t3)
	}
	fmt.Println(t3 == t)
	// 当前时间的时间戳
	fmt.Println(now.Unix())
}

十.数字解析

func main() {    
    f, _ := strconv.ParseFloat("1.123", 64)
	fmt.Println(f)
	// 10进制，64精度
	n, _ := strconv.ParseInt("123", 10, 64)
	fmt.Println(n, reflect.TypeOf(n))
	// 0 自动判断进制
	m, _ := strconv.ParseInt("123", 0, 64)
	fmt.Println(m, reflect.TypeOf(m))
	// Atoi字符串转 整形
	n1, err := strconv.Atoi("132")
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(n1, reflect.TypeOf(n1))
	// 整形转字符串
	n2 := strconv.Itoa(123)
	fmt.Println(n2, reflect.TypeOf(n2))
}
运行结果
1.123
123 int64 
123 int64 
132 int   
123 string

十一.进程信息

搞不太懂

func main() {
    fmt.Println(os.Args)
	fmt.Println(os.Getenv("PATH"))
	fmt.Println(os.Setenv("AA", "BB"))

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