Go в примерах: Срезы (Slices)

Срезы являются ключевым типом данных в Go, предоставляя более мощный интерфейс для последовательностей, чем массивы.

package main
import "fmt"
func main() {

В отличии от массивов, длина среза зависит от содержащихся в срезе элементов, а не определена при инициализации. Создать пустой срез в ненулевой длиной можно используя оператор make. В этом пример мы создаем слайс строк длиной 3 (заполненный нулевыми значениями).

    s := make([]string, 3)
    fmt.Println("emp:", s)

Мы можем устанавливать и получать значения, как в массивах.

    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("set:", s)
    fmt.Println("get:", s[2])

len возвращает длину среза, как и ожидалось.

    fmt.Println("len:", len(s))

В дополнение к базовой функциональности, срезы имеют несколько дополнительных особенностей по сравнению с массивыми. Одна из них - append, которая возвращает срезу содержащий одно или более новых значений. Обратите внимание, что результат функции append необходимо присвоить в переменную, т.к. это уже будет новый срез.

    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println("apd:", s)

Срезы могут быть скопированы с помощью copy. В данном примере мы создаем пустой срез c такой же длины как и s и копируем данные из s в c.

    c := make([]string, len(s))
    copy(c, s)
    fmt.Println("cpy:", c)

Срезы поддерживают оператор slice (синтаксис использование slice[low:high]). Для примера, тут мы получаем срез состоящий из элементов s[2], s[3], и s[4].

    l := s[2:5]
    fmt.Println("sl1:", l)

Тут мы получаем срез до элемента s[5] (исключая его).

    l = s[:5]
    fmt.Println("sl2:", l)

А тут получаем срез от s[2] (включая его) и до конца исходного среза.

    l = s[2:]
    fmt.Println("sl3:", l)

Мы можем объявить и заполнить срез значениями в одну строку.

    t := []string{"g", "h", "i"}
    fmt.Println("dcl:", t)

Срезы можно объединять в многомерные структуры данных. Длина внутренних срезов может варьироваться, в отличии от многомерных массивов.

    twoD := make([][]int, 3)
    for i := 0; i < 3; i++ {
        innerLen := i + 1
        twoD[i] = make([]int, innerLen)
        for j := 0; j < innerLen; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

Обратите внимание, несмотря на то что срезы являются отдельным типом данных, отображаются они так же как массивы командой fmt.Println.

$ go run slices.go
emp: [  ]
set: [a b c]
get: c
len: 3
apd: [a b c d e f]
cpy: [a b c d e f]
sl1: [c d e]
sl2: [a b c d e]
sl3: [c d e f]
dcl: [g h i]
2d:  [[0] [1 2] [2 3 4]]

Посмотрите этот отличный пост, написаный командой Go, чтобы узнать больше о разработке и использовании срезов в Go.

Теперь, когда мы рассмотрели массивы и срезы, мы посмотрим другую ключевую встроенную структуру данных Go: карты.

Следующий пример: Карты (Maps).