Go语言介绍

Go有哪些特征？

  1. go是静态类型语言，有非常封堵的内置类型
  2. 面向对象：使用类型、组合、接口来实现面向
  3. 使用简单，开发难度小，Go也借鉴了python的一些语法
  4. 执行速度快, C++是编译速度快
  5. 自动垃圾回收
  6. 静态编译语言：windows编译的程序可以在任何windows电脑运行，Linux也一样，不像python一样需要安装各种依赖

Golang配置国内代理加速

由于初学者使用vscode足够使用，但是下载一些自动补全的插件总是失败，需要配置国内代理加速命令行下载

Golang V1.13之后支持通过设置变量GOPROXY来修改代理地址，默认的代理服务器

1
2
3
$ go env -w GO111MODULE=on
$ go env -w GOPROXY=https://goproxy.cn,direct
$ go install -v golang.org/x/tools/gopls@latest

go 数组

go语言里面数组是长度是不可变的，

Go语言的数组是一种值类型，它由相同类型的元素组成的固定长度的有序集合。数组可以存储任何类型的数据，包括整数、浮点数、布尔值、字符串等。在声明数组时，需要指定数组元素的类型和长度。

Go数组有以下几个特点：

  1. 固定长度：数组的长度是在声明时确定的，且不可更改。
  2. 值类型：数组是一种值类型，将数组赋值给另一个数组时`，会将源数组复制一份，两个数组之间不存在任何关联。
  3. 连续内存空间：数组的元素在内存中是连续存储的，这也使得数组的访问速度非常快。
  4. 下标从0开始：Go数组的下标从0开始，即第一个元素的下标为0，最后一个元素的下标为length-1（length表示数组的长度）。
  5. 数组是不可变的：数组的大小不可动态改变，因此Go数组通常用于存储固定数量的元素。

可以使用以下语法来声明一个数组：

范例一

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main

import "fmt"

func main() {
	//字面变量
	nums := [3]int{1, 2, 3}
	fmt.Println(nums)

	//数组判断
	num01 := [2]int{1, 2}
	num02 := [2]int{3, 4}
	fmt.Println(num01 == num02) //返回false
	fmt.Println(num01 != num02) //返回true

	// 获取数组长度
	fmt.Println(len(num01)) //返回2,代表数组长度

	//获取索引(索引数都是从0开始计算)，如果超过索引数量就会报错
	fmt.Println(nums[0], nums[2])
}

范例2

1、通过循环遍历数组并求和

这个程序定义了一个名为main的包，导入了fmt包。在main函数中，定义了一个包含5个整数的数组a并初始化为{1, 2, 3, 4, 5}。还定义了一个整数变量sum并初始化为0。接下来使用for循环遍历数组a，将每个元素加到变量sum中。最后使用fmt.Println()函数打印输出"Sum:"和变量sum的值。

技术术语：

  • 包（package）：Go语言中用于组织和管理代码的基本单元。
  • 导入（import）：在Go程序中引入其他包中的代码。
  • 数组（array）：一种数据结构，可以存储多个相同类型的元素。
  • 循环（loop）：重复执行一段代码的结构。
  • 变量（variable）：用于存储数据的内存空间，在程序中可以被多次赋值。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

func main() {
    a := [5]int{1, 2, 3, 4, 5}
    sum := 0

    for i := 0; i < len(a); i++ {
        sum += a[i]
    }

    fmt.Println("Sum:", sum)
}

范例三： 求数组的最大值

主要定义了一个包含5个整数的数组a，并将其初始化为{1, 5, 3, 2, 4}。然后使用for循环遍历数组a，找到其中的最大值max。

在循环中，使用if语句比较a[i]和max的值，如果a[i]大于max，则将max的值更新为a[i]的值。最后，使用fmt包中的Println函数输出max的值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import "fmt"

func main() {
    a := [5]int{1, 5, 3, 2, 4}
    max := a[0]

    for i := 1; i < len(a); i++ {
        if a[i] > max {
            max = a[i]
        }
    }

    fmt.Println("Max:", max)
}

Go 切片

在 Go 中，切片(slice)是一种动态数组，它可以按需增长或缩小，并且支持指针和长度属性。切片的底层实现类似于数组，但是长度是可变的

这意味着你无需提前确定切片的长度，就可以在运行时动态地扩容或缩容数组。另外，由于切片本身并不存储任何数据，它只是一个对底层数组的引用，因此任何修改切片的操作都会直接影响到底层数组。

下面是一些切片常用的一些范例：

范例一： 创建切片

在这个例子中，我们先定义了一个空切片 a，然后通过 append() 函数向切片中添加元素。需要注意的是，在使用 append() 函数时，如果切片的容量不足，系统会自动进行扩容，并重新分配更大的底层数组 

1
2
3
4
5
6
7
8
9
10
11
package main

import "fmt"

func main() {
	var a []int // 定义一个空切片

	a = append(a, 1)       // 添加一个元素
	a = append(a, 2, 3, 4) // 添加多个元素
	fmt.Println("a:", a)
}

范例二：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

func main() {
	var nums []int
	fmt.Println(nums == nil) //不定义切片默认为nil

	// 字面量
	nums = []int{1, 2, 3, 4}
	fmt.Printf("%#v\n", nums)
	nums = []int{5, 6, 7}
	fmt.Printf("%#v\n", nums)

}

范例3：过make函数定义切片再赋值

make([]int, len(a)) 的作用是创建一个长度为 len(a) 的 int 类型切片 b，并将其初始化为零值。copy(b, a) 则是将切片 a 中的元素复制到切片 b 中，这样 b 就和 a 有着相同的元素序列。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package main

import "fmt"

func main() {
	a := []int{1, 2, 3, 4}
	b := make([]int, len(a))
	//1、 复制切片 a 到切片 b
	copy(b, a)
	fmt.Println(b)
	// 切片赋值
	var slice2 []int = make([]int, 3)
	fmt.Printf("%#v\n", slice2) //返回 {0, 0, 0}

	//2、 make定义两个参数的切片，第一个参数代表数据类型，第二个参数代表切片长度
	var names []string
	names = make([]string, 5)
	fmt.Printf("%#v", names) // 返回 []string{"", "", "", "", ""}

	// 3、make定义三个参数的切片
	var slice []string
	slice = make([]string, 5, 10)
	fmt.Printf("%#v", slice)
}

切片的增删改查

增： 在 Go 语言中，我们可以使用 append() 函数向切片中添加新元素。当切片容量不足时，它会自动扩展容量。

删： 删除依旧可以使用 append() 函数向切片中删除元素。 具体来说，我们可以通过分片语法将要删除的元素从原切片中删除，并使用 append() 函数将剩余元素重新组合成一个新的切片。

改： 在 Go 中，可以通过下标直接访问切片中的元素，并进行修改。

查： 在 Go 中，可以通过下标或循环遍历切片来查询切片中的元素。

范例1：切片增加（append）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package main

import "fmt"

func main() {

	//增(append)首先定义了一个切片a，然后使用 append() 函数向切片末尾添加一个元素 4，并最终输出结果。
	a := []int{1, 2, 3}
	a = append(a, 4)
	fmt.Println("a:", a)

	// 增加多个元素到切片未
	b := []int{1, 2, 3}
	c := []int{4, 5, 6}

	b = append(b, c...)
	fmt.Println("b :", b)

	// 在指定位置插入单个元素
	d := []int{1, 2, 3}

	d = append(d[:1], append([]int{4}, d[1:]...)...) // 在下标为 1 的位置插入元素 4
	fmt.Println("d:", d)
}

范例2：切片删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import "fmt"

func main() {
	// 范例1,删除元素
	a := []int{1, 2, 3, 4}

	a = append(a[:1], a[2:]...) // 删除下标为 1 的元素
	fmt.Println("a:", a)
	// 范例2,删除多元素
	slice := []int{1, 2, 3, 4, 5}
	i := 2 //删除第二个元素

	slice = append(slice[:i], slice[i+1:]...)
	fmt.Println("After delete:", slice)
}

范例3：切片修改

1
2
3
4
5
6
7
8
9
10
11
12
package main

import "fmt"

func main() {
	a := []int{1, 2, 3, 4, 5}
	i := 2 // 要修改第 i 个元素

	// 修改指定位置的元素
	a[i] = 10
	fmt.Println("After modify:", a)
}

范例4：切片查询 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import "fmt"

func main() {
	a := []int{1, 2, 3, 4, 5}
	i := 2 // 要查询第 i 个元素

	// 查询指定位置的元素
	fmt.Println("Element at index", i, "is", a[i])

	// 遍历切片并输出所有元素
	for i, v := range a {
		fmt.Printf("a[%d]=%d\n", i, v)
	}
}