这是我参与「第五届青训营」伴学笔记创作活动的第 1 天。

课程重点

Go语言基础-基础语法

0. hello world

go语言主体框架分为三个部分：

package 包名

说明属于哪个包，package包名和函数一一对应，常用package main
import “包名”

导入包

fmt常用包，做输出
func main(){}

代码示例：

// 文件属于main包的一部分（入口文件）
package main
//包
import (
	"fmt"
)
func main() {
	fmt.Println("hello world")
}

1. 变量

go定义变量的方式有两种：
1. var name = value
2. name := value
- 如果要限制特定的类型如定义一个整型，go语言通常把数据类型放在变量之后，等号之前：
  
  var name type
  
  var name type = value等
- 所有声明的变量默认值都为0或空
常量：

const name type = value，其中[type]可以省略
字符串变量可以用[+]直接拼接

2. 条件语句

判断条件不加括号，同时执行语句全部都要写在花括号内，哪怕只有一句

3. for循环

go中没有while和do…while，只有for循环
条件部分同样不加括号，需要花括号包括执行语句
当for循环没有写条件时，即是一个死循环
同样适用break和continue，和C语言差不多

4. switch语句

与其他常见语言的switch语句有两点不同

即使没有加break，默认也不会进入其他分支
case后面可以接判断条件，不再局限于数字

    a := 2
    //默认不会跑其他分支，不需要加break
    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("others")
    }
    t := time.Now()
    //取代if else
    switch {
    case t.Hour() < 12:
            fmt.Println("It is AM.")
    default:
            fmt.Println("It is PM.")
    }

5. 数组

声明或定义方式：
1. var a [5]int
2. b:=[5]int{1,2,3,4,5}
3. 二维数组：var twoD [2][3]int
像python一样可以使用len(array)直接求array的长度，可以直接打印二维数组
操作同C语言（如嵌套循环等）

6. 数组切片

go语言同python一样支持对数组进行切片操作

make和new是go语言中用来分配内存的原语。简单来说，new 只分配内存，make 用于初始化 slice、map 和 channel。

参考链接：go中new和make的区别

make初始化字符串：name :=make([]string,len)
可以使用append、copy和切片（注意索引值没有负数）
s.append(s,"d","e")
copy(newString, oldString)
s[:2]/s[1:3]/s[1:]

7. map

两种初始化方式：
1. name := make(map[typeOfKey]typeOfValue)
  
  m := make(map[string]int)
2. name := map[string]int{"key1":value1,"key2":value2……}
  
  m := map[string]int{"one":1,"two":2}
可以使用delete删除：delete(m,"key")
可以用两个变量接收查找的返回值，若key存在，返回value和true，若key不存在，返回0和false

8. range

用法同python

使用两个变量接收range的返回值时，第一个为索引下标，第二个为value，可以把其中一个替换为[_](下划线)如果不需要

9. 函数

定义方式：

func name(parameter type,…) returnType{}

不写返回类型时即其他语言的void

10. 指针

同C语言，数据类型依旧后置

11. 结构体

格式：

type name struct{
  key1 type1
  key2 type2
  ……
}

初始化结构体把结构体名称后置，同样使用[.]进行操作

12. 结构体方法

相当于是函数中的一个参数是结构体或结构体指针时，可以把结构体提到函数名前，后续使用方式即：

structure.functionName(parameters)

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{"zhangsan", "1234"}
	fmt.Println(a.checkPassword("haha"))
	a.resetPassword("haha")
	fmt.Println(a.checkPassword("haha"))
}

13. 错误处理

参考链接：【Go】Go错误处理

14. string

Go中的strings包功能很多

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

15. 格式化字符串

Go中所有的格式化字符串输出只需使用[%v]

格式	描述
%v	按值的本来值输出
%+v	在 %v 基础上，对结构体字段名和值进行展开
%#v	输出 Go 语言语法格式的值
%T	输出 Go 语言语法格式的类型和值
%%	输出 % 本体
%b	整型以二进制方式显示
%o	整型以八进制方式显示
%d	整型以十进制方式显示
%x	整型以十六进制方式显示
%X	整型以十六进制、字母大写方式显示
%U	Unicode 字符
%f	浮点数
%p	指针，十六进制方式显示

同时支持%.2f这样的指定保留小数位数的输出方式

16. json处理

主要是一些序列化和反序列化

当结构内的所有变量首字母都是大写时即可进行json处理

package main

import (
	"encoding/json"
	"fmt"
)

type userInfo struct {
	Name  string
	Age   int `json:"age"` //加json的tag可以使输出为age而不是Age
	Hobby []string
}

func main() {
	a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "Typescript"}}
	buf, err := json.Marshal(a) //序列化
	if err != nil {
		panic(err)
	}
	fmt.Println(string(buf)) //{"Name":"wang","age":18,"Hobby":["Golang","Typescript"]}
	fmt.Println(buf)         //[123 34 78 97 109 101 34 58 34 119 97 110 103 34 44 34 97 103 101 34 58 49 56 44 34 72 111 98 98 121 34 58 91 34 71 111 108 97 110 103 34 44 34 84 121 112 101 115 99 114 105 112 116 34 93 125]

	buf, err = json.MarshalIndent(a, "", "\t")
	if err != nil {
		panic(err)
	}
	fmt.Println(buf) //[123 10 9 34 78 97 109 101 34 58 32 34 119 97 110 103 34 44 10 9 34 97 103 101 34 58 32 49 56 44 10 9 34 72 111 98 98 121 34 58 32 91 10 9 9 34 71 111 108 97 110 103 34 44 10 9 9 34 84 121 112 101 115 99 114 105 112 116 34 10 9 93 10 125]

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

17. time

t:=time.Now()

获取当前时间
t:=time.Date(year, month, day, hour, minute, second, nsec, timelocation)

构造一个带时区的时间
t.Format("2006-01-02 15:04:05"))

格式化事件，上面的时间为固定值
diff:=t2.Sub(t1)

用t2的时间减t1的时间，求时间差
now.Unix()

设置时间戳

18. 字符串转整型

strconv
- f, _ := strconv.ParseFloat("12.34", 64)
  
  n, _ := strconv.ParseInt("111", 10, 64)
  
  n, _ = strconv.ParseInt("0x1000", 0, 64)
  
  参数：(字符串，进制，返回精度)
- Atoi
  
  n2, _ := strconv.Atoi("123")

19. 进程

主要是一些命令行的操作

总结

这些是本节Go基础课程的一些基础知识点，其实总体来说运用方法和其他的语言也没什么区别，在一些地方，如switch也表现出了Go的灵活性。

如果能熟练运用C语言和python的话，那么Golang的基础运用应该也不在话下，只需要记住奇奇怪怪的，比如数据类型后置等特点即可。

实践部分等下次整理好了再发上来。

Go语言基础-基础语法 | 青训营笔记