乐趣区

关于go:Go-快速入门指南-切片

jiezi

概述

浏览本大节之前，倡议先浏览 数组 大节。

切片 是对数组的一个间断片段的援用。片段能够是整个数组，也能够是数组的一部分 (例如数组的第 3 个元素到第 8 个元素)。
所以 切片 是一个援用类型，扭转切片的值也就扭转了底层数组的值。

一个数组能够被多个 切片 援用，它们之间共享数组的数据。 当数组或者任一 切片 数据扭转时，会影响到其余切片的数据。
切片的长处在于节俭了存储数据的空间 (当然切片自身还是须要占用存储空间的)，只需援用数据即可，所以应用频率十分高。

长度和容量

切片有两个属性，别离是 长度 和 容量。

长度示意切片以后有多少个元素，容量示意切片最多能够有多少容量，两者的关系是: 长度 <= 容量。

语法规定

申明

var 变量名称 []数据类型

# 例子
var sli []int

能够看到，和数组的语法规定简直统一，惟一的差别在于切片不须要指明长度。

申明及初始化

var 变量名 = make([]int, 长度, 容量)   // 容量参数能够省略

# 例子
var sli = make([]int, 5, 10)

获取值 / 扭转值

package main

import "fmt"

func main() {var s []int // 申明一个整型切片

    fmt.Printf("切片长度 = %d, 容量 = %d\n", len(s), cap(s))

    var s2 = make([]int, 3, 10) // 申明并初始化一个整型切片

    fmt.Printf("切片长度 = %d, 容量 = %d\n", len(s2), cap(s2))

    s2[0] = 100 // 为切片第 1 个元素赋值
    s2[1] = 200 // 为切片第 2 个元素赋值
    s2[2] = 300 // 为切片第 3 个元素赋值

    println(s2[0]) // 输入切片第 1 个元素
    println(s2[1]) // 输入切片第 2 个元素
    println(s2[2]) // 输入切片第 3 个元素
}

// $ go run main.go
// 输入如下 
/**
  切片长度 = 0, 容量 = 0
  切片长度 = 3, 容量 = 10
  100
  200
  300
*/

多个切片援用一个数组

package main

import "fmt"

func main() {arr := [...]int{1, 2, 3, 4, 5}
    s := arr[0:5]  // 切片 1
    s2 := arr[0:3] // 切片 2

    fmt.Println("批改前")
    fmt.Println(arr) // 输入数组所有元素
    fmt.Println(s)   // 输入切片 1 所有元素
    fmt.Println(s2)  // 输入切片 2 所有元素

    s[0] = 100  // 批改切片 1 第一个元素
    s2[1] = 200 // 批改切片 2 第二个元素

    fmt.Println("批改后")
    fmt.Println(arr) // 输入数组所有元素
    fmt.Println(s)   // 输入切片 1 所有元素
    fmt.Println(s2)  // 输入切片 2 所有元素
}

// $ go run main.go
// 输入如下 
/**
  批改前
  [1 2 3 4 5]
  [1 2 3 4 5]
  [1 2 3]
  批改后
  [100 200 3 4 5]
  [100 200 3 4 5]
  [100 200 3]
*/

追加值

调用 append 函数

package main

import "fmt"

func main() {var s []int // 申明一个整型切片

    fmt.Printf("切片长度 = %d, 容量 = %d\n", len(s), cap(s))

    s = append(s, 100)
    s = append(s, 200)

    fmt.Printf("切片长度 = %d, 容量 = %d\n", len(s), cap(s))
}

// $ go run main.go
// 输入如下 
/**
  切片长度 = 0, 容量 = 0
  切片长度 = 2, 容量 = 2
*/

区间数据

通过 索引 地位，能够灵便地获取切片的区间数据。

package main

import "fmt"

func main() {var s = make([]int, 3, 10)

    s[0] = 100 // 为切片第 1 个元素赋值
    s[1] = 200 // 为切片第 2 个元素赋值
    s[2] = 300 // 为切片第 3 个元素赋值

    fmt.Printf("%v\n", s[1:3])      // 输入切片的第 2 个和第 3 个元素
    fmt.Printf("%v\n", s[2:5])      // 输入切片的第 3 个到第 5 个元素
    fmt.Printf("%v\n", s[:])        // 输入切片的所有元素, 以 len() 为准
    fmt.Printf("%v\n", s[0:cap(s)]) // 输入切片的所有元素, 以 cap() 为准}

// $ go run main.go
// 输入如下 
/**
  [200 300]
  [300 0 0]
  [100 200 300]
  [100 200 300 0 0 0 0 0 0 0]
*/

上述只列出了简略的用法，读者能够调整 [] 中的索引地位，体验更多的用法。

遍历切片

一般循环

package main

import "fmt"

func main() {var s = make([]int, 3, 10)

    s[0] = 100 // 为切片第 1 个元素赋值
    s[1] = 200 // 为切片第 2 个元素赋值
    s[2] = 300 // 为切片第 3 个元素赋值

    for i := 0; i < len(s); i++ {fmt.Printf("index = %d, val = %d\n", i, s[i])
    }
}

// $ go run main.go
// 输入如下 
/**
  index = 0, val = 100
  index = 1, val = 200
  index = 2, val = 300
*/

range 循环

package main

import "fmt"

func main() {var s = make([]int, 3, 10)

    s[0] = 100 // 为切片第 1 个元素赋值
    s[1] = 200 // 为切片第 2 个元素赋值
    s[2] = 300 // 为切片第 3 个元素赋值

    for i, v := range s {fmt.Printf("index = %d, val = %d\n", i, v)
    }
}

// $ go run main.go
// 输入如下 
/**
  index = 0, val = 100
  index = 1, val = 200
  index = 2, val = 300
*/

小结

  • 切片是对数组的一个间断片段的援用
  • 一个数组能够被多个切片援用，它们之间共享数组的数据，当数组或者任所有片数据扭转时，会影响到其余切片的数据

分割我

退出移动版