type slice struct {
    // 底層數(shù)組指針（指向一塊連續(xù)內(nèi)存空間的起點）
    array unsafe.Pointer
    // 切片長度
    len   int
    // 切片容量   
    cap   int
}

//通過字面量創(chuàng)建

	/**
	創(chuàng)建字符串切片，長度和容量都是3
	 */
	slice1 := []string{"aaa","bbb","ccc"}
	fmt.Println(slice1)  //[aaa bbb ccc]

	/**
	創(chuàng)建整形切片，長度和容量都是4
	 */
	slice2 := []int{10,20,30,40}
	fmt.Println(slice2) //[10 20 30 40]

	//當使用切片字面量創(chuàng)建切片時，還可以設(shè)置初始長度和容量。

	/**
	創(chuàng)建一個長度和容量都是100的切片 索引0 = 10，索引99 = 1
	 */
	slice3 := []int{0:10,99:1}
	fmt.Println(slice3) //[10 0 0 ... 1]

	//通過 make() 函數(shù)創(chuàng)建切片


	/**
	創(chuàng)建長度和容量都是5的切片
	 */
	slice4 := make([]int,5)
	fmt.Println(slice4)  //[0 0 0 0 0] 默認對應(yīng)類型的零值

	/**
	創(chuàng)建長度=3，容量=5的切片
	 */
	slice5 := make([]string,3,5)
	fmt.Println(slice5)  //[  ]

	/**
	不允許創(chuàng)建容量小于長度的切片
	 */
	slice6 := make([]int,5,3)
	fmt.Println(slice6)  //invalid argument: length and capacity swapped

func makeslice(et *_type, len, cap int) unsafe.Pointer {

    mem, overflow := math.MulUintptr(et.size, uintptr(cap))
    if overflow || mem > maxAlloc || len < 0 || len > cap {

        mem, overflow := math.MulUintptr(et.size, uintptr(len))
        if overflow || mem > maxAlloc || len < 0 {
            panicmakeslicelen()
        }
        panicmakeslicecap()
    }

    return mallocgc(mem, et, true)
}

func main() {
	sl := []int{1,2,3,4,5}
	fmt.Println(sl)  //[1 2 3 4 5]
	change(sl)
	fmt.Println(sl)  //[10 2 3 4 5]
}
func change(sl []int) {
	sl[0] = 10
}

slice[start:end]
//slice要截取的原始切片
//start截取切片的開始位置，不填默認為0
//end截取切片的結(jié)束位置，不填默認為切片長度

s := []int{1, 2, 3, 4, 5}
	// 截取整個切片
	subS1 := s[:]
	fmt.Println(subS1) // 輸出: [1 2 3 4 5]

	// 截取索引1到4（不包含4）的元素
	subS2 := s[1:4]
	fmt.Println(subS2) // 輸出: [2 3 4]

	// 從索引0開始截取到索引4（不包含4）
	subS3 := s[:4]
	fmt.Println(subS3) // 輸出: [1 2 3 4]

	// 從索引2開始截取到切片末尾
	subS4 := s[2:]
	fmt.Println(subS4) // 輸出: [3 4 5]

 s := []int{2,3,4,5}
  s1 := s[1:]

func main() {  
    s := []int{1, 2, 3}  
    // 使用 append 函數(shù)在切片末尾添加元素 4  
    s = append(s, 4)  
    fmt.Println(s) // 輸出: [1 2 3 4]  
}

func main() {  
    s := []int{1, 2, 3}  
    // 使用 append 函數(shù)在切片末尾添加多個元素  
    s = append(s, 4, 5, 6)  
    fmt.Println(s) // 輸出: [1 2 3 4 5 6]  
}

func main() {  
    s1 := []int{1, 2, 3}  
    s2 := []int{4, 5, 6}  
    // 使用 append 函數(shù)將 s2 添加到 s1 的末尾  
    s1 = append(s1, s2...) // 注意 s2 后的 ... 用于將 s2 展開為元素序列  
    fmt.Println(s1) // 輸出: [1 2 3 4 5 6]  
}

func main() {  
    s := []int{1, 3, 4, 5}  
    // 在索引 1 的位置插入元素 2  
    // 首先，將索引 1 及其之后的元素向后移動一位  
    s = append(s[:1], append([]int{2}, s[1:]...)...)  
    fmt.Println(s) // 輸出: [1 2 3 4 5]  
}

//使用切片操作刪除元素（適用于刪除末尾元素）
s := []int{1, 2, 3, 4, 5}  
// 刪除切片末尾的元素  
s = s[:len(s)-1]  
fmt.Println(s) // 輸出: [1 2 3 4]


//使用append和切片操作刪除任意位置的元素
s := []int{1, 2, 3, 4, 5}  
// 假設(shè)我們要刪除索引為2的元素（值為3）  
index := 2  
// 將index之后的元素（不包括index）復制到前面，然后截斷切片  
s = append(s[:index], s[index+1:]...)  
fmt.Println(s) // 輸出: [1 2 4 5]

//使用循環(huán)和條件語句刪除滿足條件的元素
s := []int{1, 2, 3, 4, 5}  
// 刪除所有值為3的元素  
var newS []int  
for _, value := range s {  
    if value != 3 {  
        newS = append(newS, value)  
    }  
}  
s = newS  
fmt.Println(s) // 輸出: [1 2 4 5]

s := []int{1, 2, 3}  
// 分配一個新的切片，長度和容量與s相同  
sCopy := make([]int, len(s))  
// 使用copy函數(shù)復制元素  
copy(sCopy, s)  
  
// 現(xiàn)在sCopy是s的一個獨立拷貝  
fmt.Println(sCopy) // 輸出: [1 2 3]