基础语法

1、Hello Word

package main

import "fmt"

func main() {
	fmt.Println("hello,world!")
        }

2、变量

常见的变量类型：字符串、整数、浮点数、布尔型

变量的声明有两种方式：1）var a = 值 2）b := 值变量值会自动推导变量类型，也可以自己进行定义变量类型
常量 const ，没有确认的类型，会根据上下文自动确认类型

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) //在go语言里如果未被引用的变量会报错
	fmt.Println(g)

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

3、if-else

if 语句条件是没有括号的，如果添加了括号编辑器会自动去掉
if 后面是大括号

package main

import "fmt"

func main() {
	if 7%2 == 0 {
		fmt.Println("7 is even")
	} else {
		fmt.Println("7 is odd")
	}

	if 8%4 == 0 {
		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")
	}
}

4、循环

for 如果没有任何条件代表死循环
可以使用continue继续循环 break跳出循环

package main

import "fmt"

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

5、Switch

switch 后面的变量名并不需要括号
case内中默认不需要加break，不会跑别的分支case
可以使用添加任意类型

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 is before noon")
	default:
		fmt.Println("It is after noon")
	}
}

6、数组

具有编号且长度固定的元素序列
由于长度固定，因此不常用，更常用的是切片

package main
import "fmt"
func main() {
	var a [5]int
	a[4] = 100
	fmt.Println(a[4], len(a))

	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
		}
	}
	fmt.Println("2d:", twoD)
}

7、切片（Slice）

不同于数组，不固定长度
一个slice是一个轻量级的数据结构，提供了访问数组子序列（或者全部）元素的功能，而且slice的底层确实引用一个数组对象。一个slice由三个部分构成：指针、长度和容量

package main

import "fmt"

func main() {
	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)
	fmt.Println(c)

	fmt.Println(s[2:5]) //左闭右开
	fmt.Println(s[:5])
	fmt.Println(s[2:])

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

8、map

在Go语言中，一个map就是一个哈希表的引用，map类型可以写为map[K]V，其中K和V分别对应key和value。map中所有的key都有相同的类型，所有的value也有着相同的类型，但是key和value之间可以是不同的数据类型。其中K对应的key必须是支持==比较运算符的数据类型，所以map可以通过测试key是否相等来判断是否已经存在。
不会按照顺序输出，而是偏随机

package main

import "fmt"

func main() {
	m := make(map[string]int)
	m["one"] = 1
	m["two"] = 2
	fmt.Println(m)
	fmt.Println(len(m))
	fmt.Println(m["one"])
	fmt.Println(m["unknow"])

	r, ok := m["unknow"]
	fmt.Println(r, ok)
	delete(m, "one")

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

9、range

Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。

package main

import "fmt"

func main() {
	nums := []int{2, 3, 4}
	sum := 0
	for i, num := range nums {
		sum += num
		if num == 2 {
			fmt.Println("index", i, "num", num)
		}
	}
	fmt.Println(sum)

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

10、函数

函数声明包括函数名、形式参数列表、返回值列表（可省略）以及函数体
形式参数列表描述了函数的参数名以及参数类型。这些参数作为局部变量，其值由参数调用者提供。返回值列表描述了函数返回值的变量名以及类型。如果函数返回一个无名变量或者没有返回值，返回值列表的括号是可以省略的。如果一个函数声明不包括返回值列表，那么函数体执行完毕后，不会返回任何值。

package main

import "fmt"

func add(a int, b int) int {   //add(a,b)+返回值类型
	return a + b
}
func add2(a, b int) int {
	return a + b
}
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)

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

11、指针

对主要的参数进行修改 FS 注意发现add2 不能正常添加

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
}

12、结构体

结构体是一种聚合的数据类型，是由零个或多个任意类型的值聚合成的实体。每个值称为结构体的成员。用结构体的经典案例是处理公司的员工信息，每个员工信息包含一个唯一的员工编号、员工的名字、家庭住址、出生日期、工作岗位、薪资、上级领导等等。所有的这些信息都需要绑定到一个实体中，可以作为一个整体单元被复制，作为函数的参数或返回值，或者是被存储到数组中，等等。
可以只指定一部分的值

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)
	fmt.Println(checkPasswrod(a, "haha"))
	fmt.Println(checkPasswrod2(&a, "haha"))
}
func checkPasswrod(u user, password string) bool {
	return u.password == password
}
func checkPasswrod2(u *user, password string) bool {
	return u.password == password
}

13、结构体方法

感觉跟java 面向对象那一块很像在比较和赋值中，将（u user）提前到函数名之前，成为类成员函数在赋值函数中，带指针就能对结构体进行修改

package main

import (
	"fmt"
)
type user struct {
	name     string
	password string
}
//进行比较
func (u user) checkPasswrod(password string) bool {
	return u.password == password
}
//赋值函数
func (u *user) restPassword(password string) {   
	u.password = password
}

func main() {
	a := user{name: "wang", password: "1024"}
	a.restPassword("2048")
	fmt.Println(a.checkPasswrod("1024"))
}

14、错误处理

go语言能够很清晰的表达出是哪一个函数出错

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")
}
func main() {
	u, err := findUser([]user{{"wang", "1024"}, {"xiaoqi", "1024"}}, "wang")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(u.name)

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

15、字符串操作

Contains（a,b）：a字符串是否包含b
Count（a,b）: 统计a字符串含有多少个b
HasPrefix(a,b): 判断a字符串是否以b字符串开头
HasSuffix(a,b): 判断a字符串是否以b字符串结尾
Index(a,b) : 读取a字符串b的索引以0开头
Join ：可以快速按照指定规则拼接字符串的工具，主要用于按照特定key顺序的数据拼接
Repeat(a,b) : 将a字符串重复b遍
Replace(s, old, new string, n int) ：返回将s中前n个不重叠old子串都替换为new的新字符串，如果n<0会替换所有old子串。
Split(s, sep) ：于将指定的分隔符切割字符串，并返回切割后的字符串切片
ToLower(a):将字符串a全换成小写
ToUpper(a):将字符串a全换成大写
len(a) :读出字符串大小注意一个中文长度为3

package main
import (
	"fmt"
	"strings"
)
func main() {
	a := "hello"
	fmt.Println(strings.Contains(a, "ll"))
	fmt.Println(strings.Count(a, "l"))
	fmt.Println(strings.HasPrefix(a, "he"))
	fmt.Println(strings.HasSuffix(a, "llo"))
	fmt.Println(strings.Index(a, "ll"))
	fmt.Println(strings.Join([]string{"he", "llo"}, "-"))
	fmt.Println(strings.Repeat(a, 2))
	fmt.Println(strings.Replace(a, "e", "E", -1))
	fmt.Println(strings.Split("a-b-c", "-"))
	fmt.Println(strings.ToLower(a))
	fmt.Println(strings.ToUpper(a))
	fmt.Println(len(a))
	b := "你好"
	fmt.Println(len(b))
}

16、字符串格式化

%v 可以表达出所有格式
%+v 表可以更加详细的结构
%#v 更更详细结构等都会表示出来
%.2f 小数点后两位

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)

	fmt.Printf("s=%v\n", s)
	fmt.Printf("n=%v\n", n)
	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}

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

17、JSON处理

json.Marshal(a) 将a进行序列化得到数组，需要进行字符串的强转换
程序异常被叫做panic，直译为运行时恐慌，当panic被抛出异常后，如果我们没有在程序中添加任何保护措施的话，程序就会打印出panic的详细情况之后，终止运行

package main

import (
	"encoding/json"
	"fmt"
)

type unserInfo struct {
	Name  string
	Age   int
	Hobby []string
}

func main() {
	a := unserInfo{Name: "小七", Age: 20, Hobby: []string{"Golang", "TypeScript"}}
	buf, err := json.Marshal(a)
	if err != nil {
		panic(err)
	}
	fmt.Println(buf)
	fmt.Println(string(buf))

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

	var b unserInfo
	err = json.Unmarshal(buf, &b)
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", b)
}

18、时间处理

time.Now():当前时间
time.Date(xxxx,xx,xx)：对时间进行操作
time.Unix() ：获取时间戳

package main

import (
	"fmt"
	"time"
)

func main() {
	now := time.Now()
	fmt.Println(now)
	t := time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)
	t2 := time.Date(2022, 3, 27, 1, 30, 36, 0, time.UTC)
	fmt.Println(t)
	fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute())
	fmt.Println(t.Format("2006-01-02 15:04:05"))
	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 {
		panic(err)
	}
	fmt.Println(t3 == t)
	fmt.Println(now.Unix())
}

19、数字解析

strconv.ParseInt(a,b,c) : a代表数，b代表进制，0代表自动推测，c精度 strconv.Atoi(a) : 将a转换成数字

func main() {
	f, _ := strconv.ParseFloat("1.234", 64)
	fmt.Println(f)

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

	n1, _ := strconv.ParseInt("0x1000", 0, 64)
	fmt.Println(n1)

	n2, _ := strconv.Atoi("123")
	fmt.Println(n2)

	n3, err := strconv.Atoi("AAA")
	fmt.Println(n3, err)

}

20、进程信息

package main

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

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

Go语言入门 ｜ 青训营笔记