go 判断元素是否在slice_go语言中的slice

package main;

import "fmt"

func main() {

//slice本身不是数组，指向底层的数组

//作为变长数组的替换方案

//slice是引用类型

//声明一个slice，这里不需要指定长度

var a []int;

//创建一个数组

var b = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

//通过数组来创建slice

c := b[1:len(b)];

//同上，简写

d := b[1:];

//从下标2开始，到4结束，不包括下标4的元素

e := b[2:4];

//从数组开始，取3个

f := b[:3];

//通过make创建slice

//长度为3，容量为10的slice

g := make([]int, 3, 10);

h := []byte{'a', 'b', 'c', 'd', 'e', 'f', 'g'};

i := h[2:5];

//注意这里的索引是相对i的索引，i现在是['c', 'd', 'e']

j := i[1:3];

//注意这里6已经超过了i的cap容量，会报错

//j := i[1:6];

//在slice的尾部追加元素

k := make([]int, 3, 6);

fmt.Printf("%p %v\n", &k, k);

k = append(k, 1, 2, 3);

fmt.Printf("%p %v\n", &k, k);

//这里当追加的元素超过了slice的cap时，会重新分配地址，并把值拷贝

k = append(k, 4, 5, 6);

fmt.Printf("%p %v\n", &k, k);

//slice是引用类型，修改某一个slice的值，其他也相应改变

m := []int{1, 2, 3, 4, 5};

l := m[2:5];

n := m[1:4];

fmt.Println(m, l, n);

//改变l中的值，m,n中也相应改变

l[0] = 6;

fmt.Println(m, l, n);

//如果当slice发生地址重新分配后，那相应改变是不生效的

o := []int{1, 2, 3, 4, 5};

p := o[2:5];

q := o[1:4];

fmt.Println(o, p, q);

//在改变p元素值之前，我们让q发生地址重新分配

q = append(q, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);

//再改变p的值，这时q的值不会发生改变，因为它已经指向新的地址

p[0] = 6;

fmt.Println(o, p, q);

//copy时以长度短的为准

r := []int{1, 2, 3, 4, 5};

s := []int{6, 7, 8};

//这里只会把s中的6,7,8拷贝到r中的1,2,3

copy(r, s);

fmt.Println(r, s);

fmt.Println(a);

fmt.Println(b);

fmt.Println(c);

fmt.Println(d);

fmt.Println(e);

fmt.Println(f);

fmt.Println(g, len(g), cap(g));

fmt.Println(string(h));

fmt.Println(string(i), cap(i));

fmt.Println(string(j), cap(j));

}