搭建mongo副本集

• 数组
• 基本操作
• 二维数组
• 数组支持比较
• 同类型且同长度的数组可以赋值
• 随机数的使用
• 冒泡排序代码的实现
• 数组作函数参数
• 数组指针作函数参数
• 数组与切片的区别
• 切片的创建
• 切片截取
• append函数的使用
• copy函数的使用
• 切片作函数参数
• 取出数字的每一位

数组

数组是同一个类型的数据集合

基本操作

初始化与遍列

func main() {
	var a [10]int //只是声明，未初始化，未初始化的数组元素默认为0
	fmt.Println("a = ", a)

	var b [6]int = [6]int{10, 20, 30, 40} // 部份初始化
	fmt.Println("b = ", b)
	c := [6]int{10, 20, 30, 40} // 部份初始化
	fmt.Println("c = ", c)

	d := [5]int{1, 2, 3, 40, 50} // 全部初始化
	fmt.Println("d = ", d)

  e := [5]int{0: 100, 2: 'a', 4: 10} // 指定下标为0,2,4的元素初始化
	fmt.Println("e = ", e)

	//通过下标获取元素
	for i := 0; i < len(b); i++ {
		fmt.Printf("index:b[%d] = %d\n", i, b[i])
	}

	// 通过range遍列数组
	for i, data := range b {
		fmt.Printf("range:b[%d] = %d\n", i, data)
	}
}

二维数组

func main() {
	// 有多少个[]，就是多少维
  // 有多少个[],就用多少个循环
	var a [3][4]int //只是声明，未初始化，未初始化的数组元素默认为0
	fmt.Println("a = ", a)
	data := 0
	for i := 0; i < 3; i++ {
		for j := 0; j < 4; j++ {
			data++
			a[i][j] = data
		}
	}
	fmt.Println("a = ", a)

  // 二维数组初始化部分元素
  b := [3][4]int{{1, 2, 3, 4}}
  fmt.Println("b = ", b)

  // 二维数组指定元素初始化
  c := [3][4]int{2: {1, 2, 3: 100}}
  fmt.Println("c = ", c)
}

数组支持比较

只支持：==，！=

同类型且同长度的数组可以赋值

a := [5]int{2, 3, 3}
var b [5]int
b = a
fmt.Println("b = ", b)

随机数的使用

package main

import (
	"fmt"
	"math/rand"
	"time"
)
func main() {
  // 设置随机种子，只需要设置一次
// 设置随机的种子，如果种子不变，则每次产生的随机数都一样
// 所以以时间的变化设置变化的种子，以产生不同的随机数
	rand.Seed(time.Now().UnixNano())
	for i := 0; i < 5; i++ {
		fmt.Println("rand = ", rand.Intn(100)) // 产生100以内的随机整数
		fmt.Println("rand = ", rand.Int())  // 产生很大的随机整数
	}

}

冒泡排序代码的实现

func main() {
	a := []int{10, 12, 34, 330, 56, 7, 2, 23}
	fmt.Println(a)
	for i := 0; i < len(a)-1; i++ {
		for j := 0; j < len(a)-i-1; j++ {  //每一轮把最大的最到放到后面
			if a[j] > a[j+1] {
				a[j], a[j+1] = a[j+1], a[j]
				fmt.Println("a = ", a)
			}
		}

	}
}

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	rand.Seed(time.Now().UnixNano())
	var a [10]int
	for i := 0; i < len(a); i++ {
		a[i] = rand.Intn(100)
	}

	fmt.Println(a)
	for i := 0; i < len(a)-1; i++ {
		for j := i + 1; j < len(a); j++ {
			if a[i] < a[j] {
				a[i], a[j] = a[j], a[i]
				fmt.Println(a)
			}
		}
	}
	fmt.Println(a)
}

数组作函数参数

数组作为函数参数，是值拷贝

func modify(a [5]int) {
	a[0] = 666
	fmt.Println("modify: a= ", a)
}

func main() {
	var a [5]int = [5]int{11, 12, 13, 14}
	fmt.Println("main:a = ", a)
	modify(a)
	fmt.Println("main:a = ", a)
}

数组指针作函数参数

// p代表指针所指的内存地址，就是实参a
func modify_pointer(p *[5]int) {
	(*p)[0] = 888
	fmt.Println("modify_pointer: p= ", *p)
}

func main() {

	var a [5]int = [5]int{11, 12, 13, 14}
	fmt.Println("main:a = ", a)
	modify_pointer(&a)
	fmt.Println("main modify_pointer:a = ", a)
}

数组与切片的区别

数组[]是是固定的一个常量，数组不能修改长度(len)和容量(cap)
切片[]中为空时，或者为…时，切片的长度（len）或容量（cap）可以不固定

func main() {
	a := [5]int{11, 12, 13, 14}
	fmt.Printf("a:len(a)=%d,cap(a)=%d\n", len(a), cap(a))

	s := []int{23, 2, 5, 6}
	fmt.Printf("s:len(s)=%d,cap(s)=%d\n", len(s), cap(s))

  //给切片追加一个成员，长度自动加1,容量自动增加到原来的2倍
	s = append(s, 1000)
	fmt.Printf("s:s=%v\n", s)
	fmt.Printf("s:len(s)=%d,cap(s)=%d\n", len(s), cap(s))
}

切片的创建

func main() {
  // 自动推导类型，创建并初始化
	s1 := []int{1, 2, 3}
	fmt.Println("s1=", s1)

  // 使用make创建切片,格式：make([]类型，长度，容量)
	s2 := make([]int, 5, 10)
	fmt.Printf("len=%d,cap = %d\n", len(s2), cap(s2))

  // 没有指定容量，那么容量长度一样
	s3 := make([]int, 5)
	fmt.Printf("len=%d,cap = %d\n", len(s3), cap(s3))
}

切片截取

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

	fmt.Println("s[n]: s1[1] = ", s1[1])   // 截取索引位置为n的成员
	fmt.Println("s1[:]: s1[:] = ", s1[:])  // 从0到最后一个索引成员的截取
	fmt.Println("s1[low:]: s1[1:] = ", s1[1:]) // 从low到len(s1)-1处所获得的切片
	fmt.Println("s1[:high]: s1[:3] = ", s1[:3])  // 从0到high所获得的切片:len=high
	fmt.Println("s1[low:high]: s1[2:4] = ", s1[2:4])  // 从low到high获取的切片：len=high-low
	fmt.Println("s1[low:high:max]: s1[2:4:5] = ", s1[2:4:5]) // 从low到high获取的切片:len=high-low,cap = max-low
	// 切片长度总是 <= 切片容量： len(s) < cap(s)
  // 切片容量总是 >= 切片长度: cap(s) >= len(s)
}

不管切片如何操作，最终都是操作的底层数组

func main() {
	s := []int{0, 1, 2, 3, 4, 5}
	fmt.Println("s = ", s)
	s1 := s[2:4]
	fmt.Println("s[2:4] = s1 = ", s1)
	s1[0] = 666
	fmt.Println("s1 = ", s1)
	fmt.Println("s = ", s)
}

append函数的使用

var s [] int
s = append(s,1) // 追加一个元素
s = append(s,2,3,4) // 追加3个元素
// append会智能的增加底层数组的容量：一旦超过原底层数组容量，通常以2倍的容量重新分配底层数组，并复制原来的数据

copy函数的使用

func main() {
	src_slice := []int{1, 2}
	dst_slice := []int{6, 6, 6, 6, 6}
	copy(dst_slice, src_slice)  //注意目标在前，源在后
	fmt.Println(dst_slice)  // 只是相同索引的 目标成员 被替换为 源切片成员
}

切片作函数参数

切片作函数参数，传递的是引用,函数中对传入的变量的修改会作用于函数之外的变量值

func slice_args(s []int) {
	s[0] = 666
}

func main() {
	s := make([]int, 1)
	slice_args(s) // 切片作函数参数，传递的是引用，所以值会被调用函数改变
	fmt.Println(s)
}

取出数字的每一位

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func GetNum(s []int, num int) {
	s[0] = num / 1000            // 取千位
	s[1] = num % 1000 / 100      // 取百位
	s[2] = num % 1000 % 100 / 10 // 取百位
	s[3] = num % 1000 % 100 % 10 // 取百位

}
func main() {
	rand.Seed(time.Now().UnixNano())
	num := rand.Intn(1000) //创建一个1000以内的随机数
	fmt.Println("main:num =", num)
	s := make([]int, 4)  //创建一个保存4个成员的切片
	GetNum(s, num)       //将切片与数字传入函数
	fmt.Println("s=", s) // 得到随机数的每一位，保存到切片之中
}

---

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 rootid@126.com