1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

var verbs = []string{"T", "v", "#v"}
var a0 [3]int
var a1 = [3]int{1, 2, 3}
var a2 [3]int = [3]int{1, 2, 3}
var a3 = [...]int{1, 2, 3}
ad1 := [...]int{1, 2, 3}
mfp.PrintFmtVal("a0", a0, verbs)
mfp.PrintFmtVal("a1", a1, verbs)
mfp.PrintFmtVal("a2", a2, verbs)
mfp.PrintFmtVal("a3", a3, verbs)
mfp.PrintFmtVal("ad1", ad1, verbs)

1

a4 := make([3]int{1, 2, 3}) // 报错：[3]int{…} is not a type

1

a5 := new([3]int) 

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

fmt.Println("二维数组")
var a6 = [3][3]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}
var a7 [3][3]int = [3][3]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}
var a8 = [...][3]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}
//var a9 = [...][...]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} // 报错：invalid use of [...] array (outside a composite literal)
ad2 := [...][3]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}

fmt.Println("三维数组")
var a10 = [2][2][2]int{{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}}
var a11 [2][2][2]int = [2][2][2]int{{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}}
var a12 = [...][2][2]int{{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}}
//var a13 = [...][...][2]int{{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}} // 报错：invalid use of [...] array (outside a composite literal) 和 missing type in composite literal
ad3 := [...][2][2]int{{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}}

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

fmt.Println("一维数组")

a14 := [...]int{1, 2, 3}
mfp.PrintFmtVal("a14", a14, verbs)

a14[0] = 11
mfp.PrintFmtVal("a14", a14, verbs)

a14[len(a14)-1] = 33
mfp.PrintFmtVal("a14", a14, verbs)

pa141 := &a14[0]
*pa141 = 111
mfp.PrintFmtVal("a14", a14, verbs)
fmt.Println("二维数组")

a15 := [...][2]int{{1, 2}, {3, 4}}
a15[0][0] = 11
mfp.PrintFmtVal("a15", a15, verbs)

a15[len(a15)-1][0] = 33
mfp.PrintFmtVal("a15", a15, verbs)

pa151 := &a15[0][0]
*pa151 = 111
mfp.PrintFmtVal("a15", a15, verbs)
fmt.Println("三维数组和二维数组类似")

1
2
3
4
5
6

a16 := [...]int{1, 2, 3}
mfp.PrintFmtVal("a16", a16, verbs)
a16 = [...]int{2, 3, 4}
mfp.PrintFmtVal("赋值后 a16", a16, verbs)
//a16 = [...]int{2, 3, 4, 5} // 报错：cannot use [...]int{…} (value of type [4]int) as [3]int value in assignment
//a16 = [...]string{"a", "b", "c"} // 报错：cannot use [...]string{…} (value of type [3]string) as [3]int value in assignment	

1
2
3
4
5

a17 := [...]int{1, 2, 3}
fmt.Println("直接访问指定索引下标的元素")
fmt.Println(a17[0])
fmt.Println(a17[1])
fmt.Println(a17[len(a17)-1])

1
2
3
4
5
6
7
8
9

for k, v := range a17 {
    if k%2 == 0 {
        fmt.Println(k, "->", v)
    }
}
mfp.PrintHr()
for k, v := range a17 {
    fmt.Println(k, "->", v)
}

1
2
3

a22 := [...]int{1, 2, 3}
fmt.Println("a22数组的长度 len(a22)=", len(a22))
fmt.Println("a22数组的容量 cap(a22)=", cap(a22))

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

fmt.Println("数组指针")
a18 := [...]int{1, 2, 3}
a19 := [...]int{1, 2, 3, 4}
_ = a19
var ptrA181 *[3]int
ptrA181 = &a18
mfp.PrintFmtVal("ptrA181", ptrA181, []string{"T", "v", "#v"})
mfp.PrintFmtVal("*ptrA181", *ptrA181, []string{"T", "v", "#v"})
//ptrA181 = &a19 // 报错：cannot use &a19 (value of type *[4]int) as *[3]int value in assignment

mfp.PrintHr()
fmt.Println("指针数组")
xa201, xa202, xa203 := 1, 2, 3
a20 := [...]*int{&xa201, &xa202, &xa203}
mfp.PrintFmtVal("a20", a20, []string{"T", "v", "#v"})
for k, v := range a20 {
    fmt.Println(k, "->", *v)
}

1
2
3
4

fmt.Println("访问数组的最后一个元素")
a21 := [...]int{1, 2, 3}
//fmt.Println(a21[len(a21)]) // 报错：invalid argument: index 3 out of bounds [0:3]
fmt.Println(a21[len(a21)-1]) // 正确方式

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

type Person struct {
    name string
    age  int8
}

newVerbs := []string{"T", "%v", "+v", "#v"}
sl115 := []int{1, 2, 3}
sl116 := []float32{1.1, 2.2, 3.3}
sl117 := []string{"A", "B", "C"}
sl118 := []Person{{"Alice", 12}, {"Bob", 28}}
mfp.PrintFmtValWithLC("sl115", sl115, newVerbs)
mfp.PrintFmtValWithLC("sl116", sl116, newVerbs)
mfp.PrintFmtValWithLC("sl117", sl117, newVerbs)
mfp.PrintFmtValWithLC("sl118", sl118, newVerbs)

1
2
3
4
5
6
7
8

var sl1 []int
var sl2 []int = []int{1, 2, 3}
var sl3 = []int{1, 2, 3}
sl4 := []int{1, 2, 3}
mfp.PrintFmtValWithLC("sl1", sl1, verbs)
mfp.PrintFmtValWithLC("sl2", sl2, verbs)
mfp.PrintFmtValWithLC("sl3", sl3, verbs)
mfp.PrintFmtValWithLC("sl4", sl4, verbs

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

a1 := [...]int{1, 2, 3, 4, 5, 6}
mfp.PrintFmtValWithLC("a1", a1, verbs)
sl5 := a1[:]
sl6 := a1[0:]
sl7 := a1[:len(a1)]
sl8 := a1[0:len(a1)]
//sl9 := a1[0:3:2] // 报错：invalid slice indices: 2 < 3
sl10 := a1[0:3:3]
sl11 := a1[0:3:4]
sl12 := a1[0:3:5]
sl13 := a1[0:3:6]
//sl14 := a1[0:3:7] // 报错：invalid argument: index 7 out of bounds [0:7]
mfp.PrintFmtValWithLC("sl5", sl5, verbs)
mfp.PrintFmtValWithLC("sl6", sl6, verbs)
mfp.PrintFmtValWithLC("sl7", sl7, verbs)
mfp.PrintFmtValWithLC("sl8", sl8, verbs)
//mfp.PrintFmtValWithLC("sl9", sl9, verbs)
mfp.PrintFmtValWithLC("sl10", sl10, verbs)
mfp.PrintFmtValWithLC("sl11", sl11, verbs)
mfp.PrintFmtValWithLC("sl12", sl12, verbs)
mfp.PrintFmtValWithLC("sl13", sl13, verbs)
//mfp.PrintFmtValWithLC("sl14", sl14, verbs)

1
2
3
4
5
6
7
8

sl15 := make([]int, 3)
//sl16 := make([]int, 3, 2) // 报错：invalid argument: length and capacity swapped
sl17 := make([]int, 3, 3)
sl18 := make([]int, 3, 4)
mfp.PrintFmtValWithLC("sl15", sl15, verbs)
//mfp.PrintFmtValWithLC("sl16", sl16, verbs)
mfp.PrintFmtValWithLC("sl17", sl17, verbs)
mfp.PrintFmtValWithLC("sl18", sl18, verbs)

1
2
3
4
5
6
7
8

sl19 := *new([]int) // 注意此时 sl19 为空切片，其长度和容量都为0
mfp.PrintFmtValWithLC("sl19", sl19, verbs)
sl19 = append(sl19, 1)
mfp.PrintFmtValWithLC("sl19", sl19, verbs)
sl19 = append(sl19, 2)
mfp.PrintFmtValWithLC("sl19", sl19, verbs)
sl19 = append(sl19, 3)
mfp.PrintFmtValWithLC("sl19", sl19, verbs)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

a2 := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
mfp.PrintFmtValWithLC("已有数组 a2", a2, verbs)

sl20 := a2[0:6]
mfp.PrintFmtValWithLC("已有切片 sl20", sl20, verbs)

sl21 := sl20[:]
sl22 := sl20[0:]
sl23 := sl20[:len(sl20)]
sl24 := sl20[:cap(sl20)]
sl25 := sl20[0:len(sl20)]
sl26 := sl20[0:cap(sl20)]
//sl27 := sl20[0:cap(sl20)+1] // 报错：panic: runtime error: slice bounds out of range [:11] with capacity 10
sl28 := sl20[1:3]
sl29 := sl20[1:4]
sl30 := sl20[2:4]
//sl31 := sl20[2:4:2] // 报错：invalid slice indices: 2 < 4
//sl32 := sl20[2:4:3] // 报错：invalid slice indices: 3 < 4
sl33 := sl20[2:4:4]
sl34 := sl20[2:4:5]
sl35 := sl20[2:4:6]
sl36 := sl20[2:4:7]

mfp.PrintFmtValWithLC("sl21=sl20[:]", sl21, verbs)
mfp.PrintFmtValWithLC("sl22=sl20[0:]", sl22, verbs)
mfp.PrintFmtValWithLC("sl23=sl20[:len(sl20)]", sl23, verbs)
mfp.PrintFmtValWithLC("sl24=sl20[:cap(sl20)]", sl24, verbs)
mfp.PrintFmtValWithLC("sl25=[0:len(sl20)]", sl25, verbs)
mfp.PrintFmtValWithLC("sl26=[0:cap(sl20)]", sl26, verbs)
//mfp.PrintFmtValWithLC("sl27=sl20[0:cap(sl20)+1]", sl27, verbs)
mfp.PrintFmtValWithLC("sl28=sl20[1:3]", sl28, verbs)
mfp.PrintFmtValWithLC("sl29=sl20[1:4]", sl29, verbs)
mfp.PrintFmtValWithLC("sl30=sl20[2:4]", sl30, verbs)
//mfp.PrintFmtValWithLC("sl31=sl20[2:4:2]", sl31, verbs)
//mfp.PrintFmtValWithLC("sl32=sl20[2:4:3]", sl32, verbs)
mfp.PrintFmtValWithLC("sl33=sl20[2:4:4]", sl33, verbs)
mfp.PrintFmtValWithLC("sl34=sl20[2:4:5]", sl34, verbs)
mfp.PrintFmtValWithLC("sl35=sl20[2:4:6]", sl35, verbs)
mfp.PrintFmtValWithLC("sl36=sl20[2:4:7]", sl36, verbs)

1
2
3
4
5
6
7
8

sl37 := []int{1, 2, 3}
mfp.PrintFmtValWithLC("sl37", sl37, verbs)
sl37[0] = 11
mfp.PrintFmtValWithLC("sl37", sl37, verbs)
sl37[len(sl37)-1] = 33
mfp.PrintFmtValWithLC("sl37", sl37, verbs)
// 修改不存在的元素
//sl37[3] = 4 // 报错：panic: runtime error: index out of range [3] with length 3

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

sl38 := []int{1, 2, 3}
mfp.PrintFmtValWithLC("1 sl38", sl38, verbs)
sl38 = []int{1, 2, 3, 4}
mfp.PrintFmtValWithLC("2 sl38", sl38, verbs)
sl38 = make([]int, 5, 10)
mfp.PrintFmtValWithLC("3 sl38", sl38, verbs)
sl38 = *new([]int)
mfp.PrintFmtValWithLC("4 sl38", sl38, verbs)
sl39 := []int{1, 2, 3, 4, 5, 6}
mfp.PrintFmtValWithLC("5 sl39", sl39, verbs)
sl38 = sl39
mfp.PrintFmtValWithLC("6 sl38", sl38, verbs)

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

fmt.Println("从go1.21版本开始才可以使用")

sl109 := make([]int, 2, 3)
sl109 = slices.Replace(sl109, 0, 2, []int{1, 2}...)
mfp.PrintFmtValWithLC("1 sl109", sl109, verbs)
sl109 = slices.Insert(sl109, 0, []int{11, 22, 33}...)
mfp.PrintFmtValWithLC("2 sl109", sl109, verbs)

sl110 := make([]int, 2)
sl110 = slices.Replace(sl110, 0, 2, []int{1, 2}...)
mfp.PrintFmtValWithLC("1 sl110", sl110, verbs)
sl110 = slices.Insert(sl110, 0, []int{11, 22}...)
mfp.PrintFmtValWithLC("2 sl110", sl110, verbs)

sl111 := make([]int, 2)
sl111 = slices.Replace(sl111, 0, 2, []int{1, 2}...)
mfp.PrintFmtValWithLC("1 sl111", sl111, verbs)
sl111 = slices.Insert(sl111, 0, []int{11, 22, 33}...)
mfp.PrintFmtValWithLC("2 sl111", sl111, verbs)

1
2
3
4
5
6
7
8
9

fmt.Println("从go1.21版本开始才可以使用")

sl112 := make([]int, 2, 3)
sl112 = slices.Replace(sl112, 0, 2, []int{1, 2}...)
mfp.PrintFmtValWithLC("1 sl112", sl112, verbs)
sl112 = slices.Replace(sl112, 0, 0, 11)
mfp.PrintFmtValWithLC("2 sl112", sl112, verbs)
sl112 = slices.Replace(sl112, 0, 0, 111)
mfp.PrintFmtValWithLC("3 sl112", sl112, verbs)

1
2
3
4
5
6
7
8
9

sl73 := make([]int, 6, 10)
mfp.PrintFmtValWithLC("1 sl73", sl73, verbs)
// 将 sl73[0]~sl73[6]依次替换为 1~6
for k, _ := range sl73 {
    if k <= 6 {
        sl73[k] = k + 1
    }
}
mfp.PrintFmtValWithLC("2 sl73", sl73, verbs)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

fmt.Println("从go1.21版本开始才可以使用")
sl74 := make([]int, 6, 10)
mfp.PrintFmtValWithLC("1 sl74", sl74, verbs)
sl74 = slices.Replace(sl74, 0, 6, []int{1, 2, 3, 4, 5, 6}...)
mfp.PrintFmtValWithLC("2 sl74", sl74, verbs)
sl74 = slices.Replace(sl74, 0, 1, 111)
mfp.PrintFmtValWithLC("3 sl74", sl74, verbs)
//sl74 = slices.Replace(sl74, 0, 7, []int{1, 2, 3, 4, 5, 6}...) // 报错：panic: runtime error: slice bounds out of range [7:6]
//mfp.PrintFmtValWithLC("4 sl74", sl74, verbs)
//sl74 = slices.Replace(sl74, 0, 7, []int{1, 2, 3, 4, 5, 6, 7}...) // 报错：panic: runtime error: slice bounds out of range [7:6]
//mfp.PrintFmtValWithLC("5 sl74", sl74, verbs)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func reverseSlice(slice []int) {
	length := len(slice)
    for i := 0; i < length/2; i++ {
        j := length - 1 - i
        slice[i], slice[j] = slice[j], slice[i]
    }
}
sl76 := []int{1, 2, 3, 4, 5, 6}
mfp.PrintFmtValWithLC("1 sl76", sl76, verbs)
reverseSlice(sl76)
mfp.PrintFmtValWithLC("2 sl76", sl76, verbs)

1
2
3
4
5

fmt.Println("从go1.21版本开始才可以使用")
sl77 := []int{1, 2, 3, 4, 5, 6}
mfp.PrintFmtValWithLC("1 sl77", sl77, verbs)
slices.Reverse(sl77)
mfp.PrintFmtValWithLC("2 sl77", sl77, verbs)

1
2
3
4
5
6

fmt.Println("使用slices.Clip函数")
fmt.Println("从go1.21版本开始才可以使用")
sl78 := make([]int, 3, 6)
mfp.PrintFmtValWithLC("1 sl78", sl78, verbs)
sl78 = slices.Clip(sl78)
mfp.PrintFmtValWithLC("2 sl78", sl78, verbs)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

fmt.Println("从go1.21版本开始才可以使用")	
sl82 := []float64{0, 42.12, -10.123, 8, math.NaN()}
mfp.PrintFmtValWithL("1 sl82", sl82, verbs)
slices.Sort(sl82)
mfp.PrintFmtValWithL("2 sl82", sl82, verbs)

type Person struct {
    name string
    age  int8
}

sl83 := []Person{
    {"zlx2", 30},
    {"zlx1", 32},
    {"zlx3", 29},
}

mfp.PrintFmtValWithLC("1 sl83", sl83, verbs)
//slices.Sort(sl83) // 报错：Person does not satisfy cmp.Ordered (Person missing in ~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | ~float32 | ~float64 | ~string)
//mfp.PrintFmtValWithLC("2 sl83", sl83, verbs)

sl84 := []int{2, 4, 6, 8, 1, 3, 5, 7}
mfp.PrintFmtValWithLC("1 sl84", sl84, verbs)
slices.Sort(sl84)
mfp.PrintFmtValWithLC("2 sl84", sl84, verbs)

sl85 := make([]int, 3, 6)
sl85 = slices.Replace(sl85, 0, 3, []int{2, 1, 3}...)
mfp.PrintFmtValWithLC("1 sl85", sl85, verbs)
slices.Sort(sl85)
mfp.PrintFmtValWithLC("2 sl85", sl85, verbs)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

fmt.Println("从go1.21版本开始才可以使用")	
type Person struct {
    name string
    age  int8
}

sl86 := []Person{
    {"zlx2", 30},
    {"zlx1", 32},
    {"zlx3", 29},
}

mfp.PrintFmtValWithLC("1 sl86", sl86, verbs)
slices.SortFunc(sl86, func(a, b Person) int {
    return cmp.Compare(a.age, b.age)
})
mfp.PrintFmtValWithLC("2 sl86", sl86, verbs)

sl88 := []Person{
    {"Gopher", 13},
    {"Alice", 55},
    {"Bob", 24},
    {"Alice", 20},
}
mfp.PrintFmtValWithLC("1 sl88", sl88, verbs)
slices.SortFunc(sl88, func(a, b Person) int {
    if n := cmp.Compare(a.name, b.name); n != 0 {
        return n
    }
    // 如果 name 字段的值相等，则继续按 age 字段进行排序
    return cmp.Compare(a.age, b.age)
})
mfp.PrintFmtValWithLC("2 sl88", sl88, verbs)

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

fmt.Println("从go1.21版本开始才可以使用")	

sl89 := []Person{
    {"Gopher", 13},
    {"Alice", 55},
    {"Bob", 24},
    {"Alice", 30},
    {"Alice", 20},
}
mfp.PrintFmtValWithLC("1 sl89", sl89, verbs)
slices.SortStableFunc(sl89, func(a, b Person) int {
    return cmp.Compare(a.name, b.name)
})
mfp.PrintFmtValWithLC("2 sl89", sl89, verbs)

1
2
3
4

sl40 := []int{1, 2, 3}
fmt.Println("sl40[0]=", sl40[0])
fmt.Println("sl40[1]=", sl40[1])
fmt.Println("sl40[2]=", sl40[2])

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

for k, v := range sl40 {
    if k%2 == 0 {
        fmt.Println(k, "->", v)
    }
}
mfp.PrintHr()
for k, v := range sl40 {
    fmt.Println(k, "->", v)
}
mfp.PrintHr()
IamNaN5 := math.NaN()
sl40x := []float64{0, 42.12, -10.123, 8, IamNaN5}
for k, v := range sl40x {
    fmt.Println(k, "->", v)
}

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

slSrc43 := make([]int, 3, 6)
slSrc43 = slices.Replace(slSrc43, 0, 3, []int{1, 2, 3}...)
mfp.PrintFmtValWithLC("1 slSrc43", slSrc43, verbs)
slDst44 := make([]int, len(slSrc43))
mfp.PrintFmtValWithLC("2 slDst44", slDst44, verbs)

copy(slDst44, slSrc43) // func copy(dst []Type, src []Type) int
mfp.PrintFmtValWithLC("3 slDst44", slDst44, verbs)
slDst44[0] = 11
fmt.Println("slDst44[0] = 11 之后")
mfp.PrintFmtValWithLC("4 slDst43", slSrc43, verbs)
mfp.PrintFmtValWithLC("5 slDst44", slDst44, verbs)
slSrc43[1] = 22
fmt.Println("slSrc43[1] = 22 之后")
mfp.PrintFmtValWithLC("6 slDst43", slSrc43, verbs)
mfp.PrintFmtValWithLC("7 slDst44", slDst44, verbs)

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

fmt.Println("从go1.21版本开始才可以使用")	
sl107 := make([]int, 3, 6)
sl107 = slices.Replace(sl107, 0, 3, []int{1, 2, 3}...)
mfp.PrintFmtValWithLC("1 sl107", sl107, verbs)
sl108 := slices.Clone(sl107)
mfp.PrintFmtValWithLC("2 sl108", sl108, verbs)
sl108[0] = 11
fmt.Println("sl108[0] = 11 之后")
mfp.PrintFmtValWithLC("3 sl107", sl107, verbs)
mfp.PrintFmtValWithLC("4 sl108", sl108, verbs)

sl107[1] = 22
fmt.Println("sl107[1] = 22 之后")
mfp.PrintFmtValWithLC("5 sl107", sl107, verbs)
mfp.PrintFmtValWithLC("6 sl108", sl108, verbs)

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

fmt.Println("从go1.22版本开始才可以使用")
sl94 := []int{1, 2, 3}
sl95 := []int{4, 5, 6}
sl96 := make([]int, 3, 6)
sl96 = slices.Replace(sl96, 0, 3, []int{7, 8, 9}...)
sl97 := make([]int, 3, 7)
sl97 = slices.Replace(sl97, 0, 3, []int{7, 8, 9}...)
sl98 := make([]int, 3, 8)
sl98 = slices.Replace(sl98, 0, 3, []int{7, 8, 9}...)
sl99 := slices.Concat(sl94, sl95, sl96)
sl100 := slices.Concat(sl94, sl95, sl97)
sl101 := slices.Concat(sl94, sl95, sl98)
mfp.PrintFmtValWithLC("sl94", sl94, verbs)
mfp.PrintFmtValWithLC("sl95", sl95, verbs)
mfp.PrintFmtValWithLC("sl96", sl96, verbs)
mfp.PrintFmtValWithLC("sl97", sl97, verbs)
mfp.PrintFmtValWithLC("sl98", sl98, verbs)
mfp.PrintFmtValWithLC("sl99", sl99, verbs)
mfp.PrintFmtValWithLC("sl100", sl100, verbs)
mfp.PrintFmtValWithLC("sl101", sl101, verbs)

1
2
3

sl41 := []int{1, 2, 3}
fmt.Println("sl41切片的长度 len(sl41)=", len(sl41))
fmt.Println("sl41切片的容量 cap(sl41)=", cap(sl41))

1
2
3
4
5
6

fmt.Println("从go1.21版本开始才可以使用")

sl113 := []string{"hello", "golang", "China", "World"}
fmt.Println("golang在sl113中的索引是 ", slices.Index(sl113, "golang"))
fmt.Println("China在sl113中的索引是 ", slices.Index(sl113, "China"))
fmt.Println("xyz在sl113中的索引是 ", slices.Index(sl113, "xyz"))

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

fmt.Println("从go1.21版本开始才可以使用")
sl114 := []string{"hello", "golang", "China", "World"}
fmt.Println("未排序的sl114")
mfp.PrintFmtValWithLC("1 sl114", sl114, verbs)
i114, b114 := slices.BinarySearch(sl114, "golang")
fmt.Printf("golang 存在于sl114中？-> %t 所在索引是 %d\n", b114, i114)
i114, b114 = slices.BinarySearch(sl114, "China")
fmt.Printf("China 存在于sl114中？-> %t 所在索引是 %d\n", b114, i114)
i114, b114 = slices.BinarySearch(sl114, "xyz")
fmt.Printf("xyz 存在于sl114中？-> %t 所在索引是 %d\n", b114, i114)

mfp.PrintHr()
fmt.Println("已排序的sl114")
slices.Sort(sl114)
mfp.PrintFmtValWithLC("2 sl114", sl114, verbs)
i114, b114 = slices.BinarySearch(sl114, "golang")
fmt.Printf("golang 存在于sl114中？-> %t 所在索引是 %d\n", b114, i114)
i114, b114 = slices.BinarySearch(sl114, "China")
fmt.Printf("China 存在于sl114中？-> %t 所在索引是 %d\n", b114, i114)
i114, b114 = slices.BinarySearch(sl114, "xyz")
fmt.Printf("xyz 存在于sl114中？-> %t 所在索引是 %d\n", b114, i114)

1
2
3
4

sl46 := []int{1, 2, 3}
sl47 := []int{1, 2, 3}
//fmt.Println("sl46 == sl47 -> ", sl46 == sl47) // 报错：invalid operation: sl46 == sl47 (slice can only be compared to nil)
//fmt.Println("sl46 != sl47 -> ", sl46 != sl47)// 报错：invalid operation: sl46 != sl47 (slice can only be compared to nil)

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

fmt.Println("从go1.21版本开始才可以使用")
sl48 := []int{1, 2, 3}
sl49 := []int{1, 2, 3}
sl50 := []int{11, 2, 3}
sl51 := []int{1, 2, 3, 4}
sl48x1 := make([]int, 3, 6)
sl48x1 = slices.Replace(sl48x1, 0, 3, []int{1, 2, 3}...)
mfp.PrintFmtValWithLC("sl48x1", sl48x1, verbs)
fmt.Println("sl48 == sl49 -> ", slices.Equal(sl48, sl49))
fmt.Println("sl48 == sl50 -> ", slices.Equal(sl48, sl50))
fmt.Println("sl48 == sl51 -> ", slices.Equal(sl48, sl51))
fmt.Println("sl48 == sl48x1 -> ", slices.Equal(sl48, sl48x1))

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

sl52 := []int{1, 15, 8}
sl53 := []int{1, 15, 8}
sl54 := []int{11, 15, 8}
sl55 := []string{"01", "0x0f", "0o10"}
sl52x1 := make([]int, 3, 6)
sl52x1 = slices.Replace(sl52x1, 0, 3, []int{1, 15, 8}...)
mfp.PrintFmtValWithLC("sl52x1", sl52x1, verbs)
feq1 := func(e1, e2 int) bool {
    return e1 == e2
}
feq2 := func(e1 int, e2 string) bool {
    sn, err := strconv.ParseInt(e2, 0, 64)
    if err != nil {
        return false
    }
    return e1 == int(sn)
}
fmt.Println("sl52 == sl53 -> ", slices.EqualFunc(sl52, sl53, feq1))
fmt.Println("sl52 == sl54 -> ", slices.EqualFunc(sl52, sl54, feq1))
fmt.Println("sl52 == sl55 -> ", slices.EqualFunc(sl52, sl55, feq2))
fmt.Println("sl52 == sl52x1 -> ", slices.EqualFunc(sl52, sl52x1, feq1))

1
2
3
4
5
6
7

sl90 := []int{1, 2, 3}
sl91 := []int{1, 2, 3}
sl92 := []int{1, 2, 3, 4}
sl93 := []int{11, 2, 3}
fmt.Println("sl90 == sl91 ->", slices.Compare(sl90, sl91) == 0)
fmt.Println("sl90 == sl92 ->", slices.Compare(sl90, sl92) == 0)
fmt.Println("sl90 == sl93 ->", slices.Compare(sl90, sl93) == 0)

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

sl56 := []int{1, 2, 3}
forFunc := func(src []int, target int) bool {
    for _, v := range src {
        if v == target {
            return true
        }
    }
    return false
}

fmt.Println("1 在 sl56中 -> ", forFunc(sl56, 1))
fmt.Println("4 在 sl56中 -> ", forFunc(sl56, 4))

1
2
3
4

fmt.Println("从go1.21版本开始才可以使用")
sl57 := []int{1, 2, 3}
fmt.Println("1 在 sl57中 -> ", slices.Contains(sl57, 1))
fmt.Println("4 在 sl57中 -> ", slices.Contains(sl57, 4))

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

fmt.Println("从go1.21版本开始才可以使用")
sl58 := []int{0, 42, -10, 8}

fmt.Println("sl58中存在负数 -> ", slices.ContainsFunc(sl58, func(e int) bool {
    return e < 0
}))
fmt.Println("sl58中存在奇数 -> ", slices.ContainsFunc(sl58, func(e int) bool {
    return e%2 == 1
}))
fmt.Println("sl58中存在 8 -> ", slices.ContainsFunc(sl58, func(e int) bool {
    return e == 8
}))

1
2
3
4
5

fmt.Println("从go1.21版本开始才可以使用")
sl104 := []int{1, 2, 3}
sl105 := []int{1, 3, 2}
fmt.Println("sl104已排序？-> ", slices.IsSorted(sl104))
fmt.Println("sl105已排序？-> ", slices.IsSorted(sl105))

1
2
3
4
5

fmt.Println("从go1.21版本开始才可以使用")
sl106 := []string{"alice", "Bob", "VERA"}
fmt.Println("sl106已排序？-> ", slices.IsSortedFunc(sl106, func(a, b string) int {
    return cmp.Compare(strings.ToLower(a), strings.ToLower(b))
}))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

sl59 := []int{0, 42, -10, 8}

maxK := 0
maxV := sl59[0]
for k, v := range sl59 {
    if maxV < v {
        maxK = k
        maxV = v
    }
}
fmt.Printf("sl59中的最大值是sl59[%d]=%d\n", maxK, maxV)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

fmt.Println("从go1.21版本开始才可以使用")

sl60 := []int{0, 42, -10, 8}
IamNaN := math.NaN()
sl61 := []float64{0, 42.12, -10.123, 8, IamNaN}
//sl62 := []int{0, 42, -10, 8, IamNaN} // 报错：cannot use IamNaN (variable of type float64) as int value in array or slice literal
fmt.Printf("sl60中的最大值是%d\n", slices.Max(sl60))

maxV2 := slices.Max(sl61)
fmt.Printf("sl61中的最大值是%f（%T）\n", maxV2, maxV2)

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

fmt.Println("从go1.21版本开始才可以使用")
sl64 := []int{0, 42, -10, 8}
IamNaN2 := math.NaN()
sl65 := []float64{0, 42.12, -10.123, 8, IamNaN2}
fmt.Printf("sl64中最大值是%d\n", slices.MaxFunc(sl64, func(e1, e2 int) int {
    return cmp.Compare(e1, e2)
}))

fmt.Printf("sl65中最大值是%f\n", slices.MaxFunc(sl65, func(e1, e2 float64) int {
    return cmp.Compare(e1, e2)
}))

//sl66 := []int{}
//fmt.Printf("sl66中最大值是%d\n", slices.MaxFunc(sl66, func(e1, e2 int) int {
//	return cmp.Compare(e1, e2)
//})) // 报错：panic: slices.Max: empty list

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