文章目录

一.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

运行结果如下：