Go на примерах: Срезы

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

 
package main
 
import (
    "fmt"
    "slices"
)
 
func main() {

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

 
    var s []string
    fmt.Println("uninit:", s, s == nil, len(s) == 0)

Чтобы создать срез ненулевой длины, используй встроенную функцию make. Здесь мы создаём срез строк длиной 3 (у элементов будут нулевые значения). По умолчанию ёмкость нового среза равна его длине; если заранее известно, что срез будет расти, можно явно указать ёмкость дополнительным параметром make.

 
    s = make([]string, 3)
    fmt.Println("emp:", s, "len:", len(s), "cap:", cap(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, и копируем в c содержимое s.

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

Срезы поддерживают оператор среза с синтаксисом 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)

Пакет slices содержит множество полезных функций для работы со срезами.

 
    t2 := []string{"g", "h", "i"}
    if slices.Equal(t, t2) {
        fmt.Println("t == t2")
    }

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

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

Обрати внимание, что хотя срезы и массивы — разные типы, fmt.Println отображает их похожим образом.

 
$ go run slices.go
uninit: [] true true
emp: [  ] len: 3 cap: 3
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]
t == t2
2d:  [[0] [1 2] [2 3 4]]

Подробнее о дизайне и реализации срезов в Go читай в статье от команды Go.

Далее: .

by Mark McGranaghan, Eli Bendersky and kuduzow | source | license