GO语言开篇-Go语言急速入门（基础知识点）｜ 青训营笔记
文章目录
- 一.GO语言应用场景
- 1.1 前言
- 1.2 什么是GO语言
- 1.3 仅仅10行完成高并发的服务器
- 二.入门
- 2.1 基础语法-HelloWorld
- 2.2 基础语法-变量类型
- 2.2.1 变量
- 2.2.2 if else
- 2.2.3 循环
- 2.2.4 switch
- 2.2.5 数组
- 2.2.6 切片
- 2.2.7 map
- 2.2.8 range
- 2.2.9 函数
- 2.2.10 指针
- 2.2.11 结构体
- 2.2.12 结构体方法
- 2.2.13 错误处理
- 2.2.14 字符串操作
- 2.2.15 字符串格式化
- 2.2.16 json处理
- 2.2.17 时间处理
- 2.2.18 数字解析
- 2.2.19 进程信息
- 三.本文总结
一.GO语言应用场景
这是我参与「第五届青训营 」伴学笔记创作活动的第 1 天
1.1 前言
在学习GO语言的过程中会出一系类的go由浅入深的系列文章，敬请期待！
1.2 什么是GO语言
Go语言是一门现代编程语言，规则简单，统一，优雅，吸收了若干编程语言的优点，解决了C，C++, Python等语言一些固有的难点问题
Go是一种过程编程语言，可用于快速机器代码编译。它是一种静态类型的编译语言。它提供了并发机制，可以轻松开发多核和联网的机器级程序。它是快速，动态类型和解释语言；它提供对接口和类型嵌入的支持。
Go语言是由Google的Robert Griesemer，Rob Pike和Ken Thompson 于2007年开发，但于2009年作为开源编程语言推出。
注： go语言源代码文件的扩展名必须是.go 。
GO语言的优点：
1高性能、高并发
2语法简单、学习曲线平缓
3丰富的标准库
Go具有强大的标准库，以包的形式分发。
4完善的工具链
5静态链接
Go是静态类型语言。因此，在这个编译器中，不仅可以成功编译代码，还可以确保类型转换和兼容性。由于这个特性，Go避免了我们在动态类型语言中遇到的所有问题。
6快速编译
7跨平台
Go语言就像Java语言一样，支持平台独立。由于其模块化设计和模块化，即代码被编译并转换为尽可能小的二进制形式，因此，它不需要依赖性。它的代码可以在任何平台上编译，也可以在任何服务器和应用程序上编译。
8垃圾回收
Go语言的设计者有意识地保持语言简单易懂。整个细节都在少量（一部分）页面中，并且通过语言中的面向对象支持做出了一些有趣的设计决策。对此，语言是固执的，并推荐一种实现事物的惯用方法。它更喜欢组合而不是继承。在Go语言中，“少花钱多办事”就是口头禅。
一个有开发经验的程序员，仅仅耗费一周就可以由学习阶段转到真正的开发阶段，完成一个高并发的应用开发。
1.3 仅仅10行完成高并发的服务器
如下图
哪些公司在使用Go语言：
二.入门
使用Goland，学生可以申请教育免费版:
2.1 基础语法-HelloWorld
Hello World：
package main
import (
"fmt"
)
func main() {
fmt.Println("hello world，上进小菜猪")
}
上述代码解释：
package main：程序的入口包。入口文件
import 的fmt控制输入输出文件：
import ( “fmt” )
main函数调用了fmt的Println
运行结果：
2.2 基础语法-变量类型
2.2.1 变量
声明变量：
1.使用var。
var a = "initial"
var b, c int = 1, 2
var d = true
2.使用变量名:=值。
f := float32(e)
g := a + "foo"
GO会更具上下文的类型来自动确定类型。
3.例子
引用：fmt和math
import (
"fmt"
"math"
)
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))
运行结果如下：
2.2.2 if else
1.if后面不需要写括号的：例如
if 7%2 == 0 {
fmt.Println("7 is even")
} else {
fmt.Println("7 is odd")
}
2.import的简单写法：
import "fmt"
3.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")
}
运行结果如下：
2.2.3 循环
go里面只有for循环，没有while循环，没有do while循环。
简单的for循环如下：
for {
fmt.Println("loop")
break
}
可以使用经典的c语言里的for循环：
for j := 7; j < 9; j++ {
fmt.Println(j)
}
也可以使用continue跳出循环：
for n := 0; n < 5; n++ {
if n%2 == 0 {
continue
}
fmt.Println(n)
}
运行结果如下：
2.2.4 switch
分支结构和c、c++类似。
不同点：
c/c++如果没有break还会跑下面的同级分支，go则不会。
例子：
1.引入time时间库：
import (
"fmt"
"time"
)
2.源码：
先给a赋值为2，然后循环下面的值，运行fmt.Println(“two”)，没有break语句也会跳出这个switch。
t := time.Now()使用time库，将现在的系统时间赋值给t，然后进行case条件分支，否则抛出It’s after noon。
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")
}
运行结果如下：
2.2.5 数组
先定义一个5个长度的数组，然后对第三个位置进行一个赋值，为100.
然后输出a[2]和a的数组长度。
var a [5]int
a[2] = 100
fmt.Println("get:", a[2])
fmt.Println("len:", len(a))
运行结果如下：
定义数组的时候就给其赋值。然后输出b数组看一眼：
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)
输出结果如下：
2.2.6 切片
定义一个数组，指定其类型为字符。3个空间大小。然后对其进行赋值，然后输出第3个位置，和数组长度，代码如下：
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
代码运行结果如下：
数组追加，和pyrhon一样，使用append，但是注意，语法略微不同。
s = append(s, "d")
s = append(s, "e", "f")
fmt.Println(s) // [a b c d e f]
输出结果如下：
数组的拷贝，使用copt函数，我们先创建一个空的c数组，申请一个大小。然后使用copy函数，将s数组拷贝到c数组。然后输出c数组查看一下效果：
c := make([]string, len(s))
copy(c, s)
fmt.Println(c) // [a b c d e f]
输出结果如下：
切片：s[2:5]：第3个元素开始，到第5个之前（不包括第五个元素）
[:5]：开头到到第5个之前（不包括第五个元素）
s[2:]：第3个元素开始，到最后一个元素。代码如下：
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]
输出结果如下：
2.2.7 map
创建一个map。使用make函数，键值对：string：int。对其进行赋值。
然后输出查看效果，打印长度。指定键，查看值。如下代码：
m := make(map[string]int)
m["one"] = 1
m["two"] = 2
fmt.Println(m) // map[one:1 two:2]
fmt.Println(len(m)) // 2
fmt.Println(m["one"]) // 1
fmt.Println(m["unknow"]) // 0
输出结果如下：
加入ok来看看是否有键存在。如下代码：
r, ok := m["unknow"]
fmt.Println(r, ok) // 0 false
输出结果如下：
删除键值对。使用delete函数，代码如下。
delete(m, "one")
赋值案例：
m2 := map[string]int{"one": 1, "two": 2}
var m3 = map[string]int{"one": 1, "two": 2}
fmt.Println(m2, m3)
输出结果如下：
2.2.8 range
for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。
首先定义一个numw数组，对其赋值。定义sum用于统计累加和。使用for 循环的 range 格式对其进行迭代循。具体如下：
nums := []int{2, 3, 4}
sum := 0
for i, num := range nums {
sum += num
if num == 2 {
fmt.Println("index:", i, "num:", num) // index: 0 num: 2
}
}
fmt.Println(sum) // 9
输出结果如下：
for 循环的 range 格式对map的遍历案例如下：
m := map[string]string{"a": "A", "b": "B"}
for k, v := range m {
fmt.Println(k, v) // b 8; a A
}
for k := range m {
fmt.Println("key", k) // key a; key b
}
输出结果如下：
2.2.9 函数
go语言的函数，有一些区别。变量名在后面。
先看一下主函数：
res := add(1, 2)
fmt.Println(res) // 3
然后看一下add函数，这个add函数的作用是返回俩个值相加的结果。
func add(a int, b int) int {
return a + b
}
然后我们看一下返回多值的情况：
传入俩个参数，一个map，一个字符a。
v, ok := exists(map[string]string{"a": "A"}, "a")
fmt.Println(v, ok) // A True
看一下exists的函数。这里接受俩个函数，m[“a”]存在，ok的值为ture。返回给主函数。
func exists(m map[string]string, k string) (v string, ok bool) {
v, ok = m[k]
return v, ok
}
输出结果如下：
2.2.10 指针
go语言的指针功能非常有限，主要的功能是为了对传入的参数进行修改。
这里的传入的参数实际上是一个拷贝。拷贝+1是不起作用的。
func add2(n int) {
n += 2
}
想要起作用只能采用指针类型：
func add2ptr(n *int) {
*n += 2
}
为了类型匹配，调用的时候，需要加&：add2ptr(&n)
下面是main函数：
n := 5
add2(n)
fmt.Println(n) // 5
add2ptr(&n)
fmt.Println(n) // 7
运行结果如下：
2.2.11 结构体
先定义一个结构体user，定义两个变量：name和password：
type user struct {
name string
password string
}
定义结构体值的几个方法：
下面代码是4种对结构体类型的赋值方法，非常简单。如下：
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}
运行结果如下：
使用函数：
普通函数（不使用指针。）
func checkPassword(u user, password string) bool {
return u.password == password
}
使用指针：
func checkPassword2(u *user, password string) bool {
return u.password == password
}
主函数，调用：
fmt.Println(checkPassword(a, "haha")) // false
fmt.Println(checkPassword2(&a, "haha")) // false
运行结果如下：
2.2.12 结构体方法
这里先把a赋值一个user结构体类型，并且对其进行赋值。
a := user{name: "wang", password: "1024"}
a.resetPassword("2048")
然后直接a.调用方法：
使用指针才能改变其结构体里的值。
func (u *user) resetPassword(password string) {
u.password = password
}
检查一下结构体里的值是不是等于2048。
fmt.Println(a.checkPassword("2048")) // true
checkPassword函数的内容如下：
func (u user) checkPassword(password string) bool {
return u.password == password
}
运行结果如下：
2.2.13 错误处理
导入依赖包：errors，代码如下：
import (
"errors"
"fmt"
)
先看一下调用的findUser，我们先传入了应该数组，和一个字符串。
u, err := findUser([]user{{"wang", "1024"}}, "wang")
findUser如下：
这个函数作用是检查结构体的值，是不是我们规定的难搞值，如果是的话返回return &u, nil。否则就是出错了。返回return nil, errors.New(“not found”)，将not found 写到日志里，代码如下：
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")
}
在主函数里，如果err不是nil的话，说明出错了，我们输出错误日志看一眼。
if err != nil {
fmt.Println(err)
return
}
输出u的name
fmt.Println(u.name) // wang
来一个错误案例：
我们调用findUser，但是传入 “li”，上面的代码当然会u.name ！= name，就会有日志存入，err，然后下面进入判断，输出err，代码如下：
if u, err := findUser([]user{{"wang", "1024"}}, "li"); err != nil {
fmt.Println(err) // not found
return
} else {
fmt.Println(u.name)
}
运行结果如下：
2.2.14 字符串操作
导入依赖包：strings，代码如下：
import (
"fmt"
"strings"
)
方法列表：
主函数代码，对字符串操作案例：
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, "llo")) // 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.ToLower(a)) // hello
fmt.Println(strings.ToUpper(a)) // HELLO
fmt.Println(len(a)) // 5
b := "你好"
fmt.Println(len(b)) // 6
运行结果如下：
2.2.15 字符串格式化
先分别定义一个字符串，整数，指针。分别打印一下，代码如下：
s := "hello"
n := 123
p := point{1, 2}
fmt.Println(s, n) // hello 123
fmt.Println(p) // {1 2}
运行结果如下：
可以使用任意%v来输出任意的的数值。代码如下：
可以使用%+v来输出详细的数值。
可以使用%#v来输出更加详细的数值。
\n标识换行。
fmt.Printf("s=%v\n", s) // s=hello
fmt.Printf("n=%v\n", n) // n=123
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}
运行结果如下：
小数，规定位数，这里和c/c++一模一样。
f := 3.141592653
fmt.Println(f) // 3.141592653
fmt.Printf("%.2f\n", f) // 3.14
2.2.16 json处理
导入依赖包： “encoding/json”，代码如下：
import (
"encoding/json"
"fmt"
)
定义一个结构体userInfo。
type userInfo struct {
Name string
Age int `json:"age"`
Hobby []string
}
对其进行一个赋值操作。
a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "TypeScript"}}
使用json的Marshal方法。我们先看一下Marshal方法：
func Marshal(v interface{}) ([]byte, error)
从返回值我们可以看到，该函数有两个返回值，一个是传入参数v的json编码，类型为[]byte，另外一个就是error。
将结构体变量a转换为json，代码如下：
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"]}
运行结果如下：
使用MarshalIndent：
func MarshalIndent(v any, prefix, indent string)([]byte, error)
MarshalIndent 类似于 Marshal，但应用缩进来格式化输出。根据缩进嵌套，输出中的每个 JSON 元素都将在以前缀开头的新行开始，后跟一个或多个缩进副本。
buf, err = json.MarshalIndent(a, "", "\t")
if err != nil {
panic(err)
}
fmt.Println(string(buf))
输出如下：
JSON解码函数Unmarshal：
func Unmarshal(data []byte, v interface{}) error
Unmarshal函数解析json编码的数据并将结果存入v指向的值。
Unmarshal和Marshal做相反的操作，必要时申请映射、切片或指针，有如下的附加规则：
要将json数据解码写入一个指针，Unmarshal函数首先处理json数据是json字面值null的情况。此时，函数将指针设为nil；否则，函数将json数据解码写入指针指向的值；如果指针本身是nil，函数会先申请一个值并使指针指向它。
要将json数据解码写入一个结构体，函数会匹配输入对象的键和Marshal使用的键（结构体字段名或者它的标签指定的键名），优先选择精确的匹配，但也接受大小写不敏感的匹配。
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.2.17 时间处理
导入依赖包： “time”，代码如下：
import (
"fmt"
"time"
)
获取当前的时间并且输出：
now := time.Now()
fmt.Println(now)
运行结果如下：
还可以自己构造一个时间，如下代码：
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"))
我们指定输出格式，代码运行结果截图如下：
时间差：使用sub函数，可以得出俩个时间的时间差。
diff := t2.Sub(t)
fmt.Println(diff) // 1h5m0s
fmt.Println(diff.Minutes(), diff.Seconds()) // 65 3900
代码运行结果截图如下：
time.Parse()函数
Go语言中的Parse()函数用于解析格式化的字符串，然后查找它形成的时间值。
官方api：
func Parse(layout, value string) (Time, error)
在这里，layout通过以哪种方式显示参考时间(即定义为Mon Jan 2 15:04:05 -0700 MST 2006)来指定格式，如果它是该值的话。但是，先前定义的布局(例如UnixDate，ANSIC，RFC3339等)解释了标准时间以及参考时间的合适表示形式。并且value参数保存字符串。其中，从值中删除的元素假定为零，如果不可能为零，则假定为一。
返回值： 它返回它表示的时间值。并且如果不存在时区指示符，则它会返回UTC时间。
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()) // 1648738080
运行结果如下：
2.2.18 数字解析
导入依赖包：“strconv”，代码如下：
import (
"fmt"
"strconv"
)
可以使用ParseFloa或者ParseInt转换小数或者整数。
f, _ := strconv.ParseFloat("1.234", 64)
fmt.Println(f) // 1.234
n, _ := strconv.ParseInt("111", 10, 64)
fmt.Println(n) // 111
上面代码整数的第二个参数代表转换数字的进制，这里是10进制。
如果是0的话就是自动转换。代码如下；
n, _ = strconv.ParseInt("0x1000", 0, 64)
fmt.Println(n) // 4096
使用Atoi快速把字符串转换为数字：
n2, _ := strconv.Atoi("123")
fmt.Println(n2) // 123
数字不合法处理：
n2, err := strconv.Atoi("AAA")
fmt.Println(n2, err) // 0 strconv.Atoi: parsing "AAA": invalid syntax
运行结果如下：
2.2.19 进程信息
导入依赖包：“os"和"os/exec”，代码如下：
import (
"fmt"
"os"
"os/exec"
)
输出命令行参数：
fmt.Println(os.Args)
获取或者写入环境变量:
fmt.Println(os.Getenv("PATH")) // /usr/local/go/bin...
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)) // 127.0.0.1 localhost
运行结果如下：
三.本文总结
本文写了下面几大块：
- 什么是 G0语言
- Go 语言基本特征
- Go 语言应用优势
- G0语言入门
- 开发环境-安装 Golang
- G0语言基础语法
下篇我将撰写Go语言的实战应用的笔记，敬请期待！