Срезы (Slice) языка Go

В языке программирования Go резыМассивБолее мощный, гибкий, удобный и легковесный структур данных. Рез - это изменяемый размер последовательности, используемый для хранения элементов одного типа, не позволяющий хранить в одном резе элементы различных типов. Как и массив, у него есть индексные значения и длина, но размер реза можно изменять, в отличие от массива, который имеет фиксированный размер. Внутри рез и массив связаны друг с другом, рез является ссылкой на базовый массив. Позволяет хранить повторяющиеся элементы.Первый индекс реза всегда равен 0, а последний индекс равен (длина реза - 1).

Декларация реза

Декларация реза аналогична декларации массива, но не содержит размера реза. Таким образом, он может увеличиваться или уменьшаться по мере необходимости.

Грамматика:

[]T
или
[]T{}
или
[]T{value1, value2, value3, ...value n}

Здесь T - тип элемента. Например:

var my_slice[]int

Состав реза

Рез содержит три компонента:

• Пounter:Пounter используется для указания на первый элемент массива, который можно получить через рез

• Длина:Длина представляет собой общее количество элементов, существующих в массиве.

• Объем:Объем указывает на максимальный размер, который можно расширить.

Давайте обсудим все эти компоненты на примере:

//Реза
package main
import "fmt"
func main() {
　　　　// создание массива
　　　　arr := [7]string{"Это", "Это", "Golang", "Основа", "Учебник", "Онлайн", "ru.oldtoolbag.com"}
　　　　//Отображение массива
　　　　fmt.Println("Массив:", arr)
　　　　//Создание слайсов
　　　　myslice := arr[1:6]
　　　　//Отображение реза
　　　　fmt.Println("Реза:", myslice)
　　　　//Отображение длины реза
　　　　fmt.Printf("Длина реза: %d", len(myslice))
　　　　//Отображение объема реза
　　　　fmt.Printf("\nОбъем реза: %d", cap(myslice))
}

Вывод:

Массив: [Это это Golang основа учебник онлайн ru.oldtoolbag.com]
Срез: [да Golang базовый учебник онлайн]
Длина среза: 5
Объем среза: 6

Объяснение использования:В предыдущем примере мы создали срез из заданного массива. Здесь указатель среза指向 индекс 1, так как нижний предел среза установлен в 1, поэтому он начинает доступ к элементам, начинающимся с индекса 1. Длина среза составляет 5, что означает общее количество элементов в срезе 5, а объем среза 6 означает, что можно хранить до 6 элементов.

Как создать и инициализировать срез?

В языке Go срезы можно создавать и инициализировать следующим образом:

• Использование литерала среза:Вы можетеИспользование литерала срезаСоздание среза. Создание среза литерала аналогично созданию литерала массива, но есть одно различие: вам не разрешается указывать размер среза в квадратных скобках []. Например, правая часть следующего выражения является литералом среза.

  var my_slice_1 = []string{"w3codeboxs", "for", "w3codeboxs"}

  Внимание:Запомните, когда вы используете строковые литералы для создания среза, сначала создается массив, а затем возвращается ссылка на него.

  Пример

  // создание среза из литерала среза
  package main
  import "fmt"
  func main() {
  　　　　// использование ключевого слова var для создания среза
  　　　　var my_slice_1 = []string{"w3codeboxs", "for", "w3codeboxs"}
  　　　　fmt.Println("My Slice 1:", my_slice_1)
  　　　　//Создание слайсов
  　　　　// использование сокращенного объявления
  　　　　my_slice_2 := []int{12, 45, 67, 56, 43, 34, 45}
  　　　　fmt.Println("My Slice 2:", my_slice_2)
  }

  Вывод:

  My Slice 1: [w3codeboxs for w3codeboxs]
  My Slice 2: [12 45 67 56 43 34 45]

• Использование массива:Мы уже знаемСрез является ссылкой на массивТаким образом, вы можете создать срез из заданного массива. Для создания среза из заданного массива сначала необходимо указать нижний и верхний пределы, что означает, что срез может начинать извлекать элементы из массива с нижнего предела до верхнего предела. Он не включает элементы, начинающиеся с верхнего предела. Как показано в следующем примере:

  Грамматика:

  array_name[low:high]

  This syntax will return a new slice.

  Внимание:По умолчанию нижний предел равен 0, а верхний предел равен общему количеству элементов, существующих в заданном массиве.

• Пример

  // создание среза из массива
  package main　
  　　
  import "fmt"
  　　
  func main() {　
  　　
  　　　　// создание массива
  　　　　arr := [4]string{"w3codeboxs", "for", "w3codeboxs", "GFG"}　
  　　
  　　　　// от создания среза из заданного массива　
  　　　　var my_slice_1 = arr[1:2]　
  　　　　my_slice_2 := arr[0:]　
  　　　　my_slice_3 := arr[:2]　
  　　　　my_slice_4 := arr[:]　
  　　
  　　　　// 显示结果
  　　　　fmt.Println("我的数组:", arr)　
  　　　　fmt.Println("My Slice 1:", my_slice_1)　
  　　　　fmt.Println("My Slice 2:", my_slice_2)　
  　　　　fmt.Println("My Slice 3:", my_slice_3)　
  　　　　fmt.Println("My Slice 4:", my_slice_4)　
  }

  Вывод:

  我的数组: [w3codeboxs for w3codeboxs GFG]
  My Slice 1: [for]
  My Slice 2: [w3codeboxs for w3codeboxs GFG]
  My Slice 3: [w3codeboxs for]
  My Slice 4: [w3codeboxs for w3codeboxs GFG]

• 使用已经存在的切片：也可以从给定的切片创建切片。要从给定切片创建切片，首先需要指定下限和上限，这意味着slice可以从给定切片中从下限到上限开始获取元素。它不包括上面从上限开始的元素。如下例所示：

  Грамматика:

  slice_name[low:high]

  This syntax will return a new slice.

  Внимание:Default value for the lower limit is 0, and the default value for the upper limit is the total number of elements present in the given slice.

  Пример

  // 从切片创建切片
  package main
  import "fmt"
  func main() {
  　　　　//Создание слайсов
  　　　　oRignAl_slice := []int{90, 60, 40, 50, 34, 49, 30}
  　　　　// 从给定的切片创建切片
  　　　　var my_slice_1 = oRignAl_slice[1:5]
  　　　　my_slice_2 := oRignAl_slice[0:]
  　　　　my_slice_3 := oRignAl_slice[:6]
  　　　　my_slice_4 := oRignAl_slice[:]
  　　　　my_slice_5 := my_slice_3[2:4]
  　　　　// 显示结果
  　　　　fmt.Println("Исходный массив:", oRignAl_slice)
  　　　　fmt.Println("Новый массив 1:", my_slice_1)
  　　　　fmt.Println("Новый массив 2:", my_slice_2)
  　　　　fmt.Println("Новый массив 3:", my_slice_3)
  　　　　fmt.Println("Новый срез 4:", my_slice_4)
  　　　　fmt.Println("Новый срез 5:", my_slice_5)
  }

  Вывод:

  Оригинальный срез: [90 60 40 50 34 49 30]
  Новый срез 1: [60 40 50 34]
  Новый срез 2: [90 60 40 50 34 49 30]
  Новый срез 3: [90 60 40 50 34 49]
  Новый срез 4: [90 60 40 50 34 49 30]
  Новый срез 5: [40 50]

• Использование функции make():Вы также можете использовать библиотеку go:Функция make()Создание среза. Эта функция принимает три параметра: тип, длину и объем. Здесь объем является опциональным. Это размер базового массива, который равен заданному объему, и возвращается срез, который ссылается на базовый массив. Обычно функция make() используется для создания пустого среза. В данном случае пустой срез содержит ссылки на пустые массивы.

  Грамматика:

  func make([]T, len, cap) []T

  Пример

  // использовать функцию make
  package main
  import "fmt"
  func main() {
  　　　　// создать массив размером 7
  　　　　// разрезать этот массив на 4
  　　　　// и возвращать ссылку на срез
  　　　　// использовать функцию make
  　　　　var my_slice_1 = make([]int, 4, 7)
  　　　　fmt.Printf("Slice 1 = %v, \nlength = %d, \ncapacity = %d\n", my_slice_1, len(my_slice_1), cap(my_slice_1))
  　　　　// создать другой массив размером 7
  　　　　// и возвращать ссылку на срез
  　　　　// использовать функцию make
  　　　　var my_slice_2 = make([]int, 7)
  　　　　fmt.Printf("Slice 2 = %v, \nlength = %d, \ncapacity = %d\n", my_slice_2, len(my_slice_2), cap(my_slice_2))
  }

  Вывод:

  Slice 1 = [0 0 0 0],　
  length = 4,　
  capacity = 7
  Slice 2 = [0 0 0 0 0 0 0],　
  length = 7,　
  capacity = 7

Как итерировать срез?

Вы можете использовать следующий способ для итерации среза:

• Использование цикла for:Это самый простой способ итерации среза, как показано в следующем примере:

  Пример

  // итерация циклом for по срезу
  package main　
  　　
  import "fmt"
  　　
  func main() {　
  　　
  　　　　//Создание слайсов
  　　　　myslice := []string{"This", "is", "the", "tutorial", "of", "Go", "language"}　
  　　
  　　　　// использовать цикл for для итерации
  　　　　for e := 0; e < len(myslice); e++ {　
  　　　　　　　　fmt.Println(myslice[e])　
  　　　　}　
  }

  Вывод:

  This
  is
  the
  tutorial
  of
  Go
  language

• Использование диапазона в цикле for:Разрешается использовать диапазон в цикле for для итерации массива. В цикле for с использованием range можно получить индекс и значение элемента, как показано в примере:

  Пример

  // В цикле for с использованием range массива
  package main　
  　　
  import "fmt"
  　　
  func main() {　
  　　
  　　　　//Создание слайсов
  　　　　myslice := []string{"This", "is", "the", "tutorial", "of", "Go", "language"}　
  　　
  　　　　　　　　// Итерация массива
  　　　　　　　　// В цикле for с использованием range
  　　　　for index, ele := range myslice {　
  　　　　　　　　fmt.Printf("Индекс = %d и элемент = %s\n", index+3, ele)　
  　　　　}　
  }

  Вывод:

  Индекс = 3 и элемент = This
  Индекс = 4 и элемент = is
  Индекс = 5 и элемент = the
  Индекс = 6 и элемент = tutorial
  Индекс = 7 и элемент = of
  Индекс = 8 и элемент = Go
  Индекс = 9 и элемент = language

• Использование пустого идентификатора в цикле for:В пределах, если вы не хотите получать значение индекса элемента, вы можете использовать пробел (пустой идентификатор) вместо переменной индекса, как показано в следующем примере:
  

  Пример

  // В цикле for с использованием range массива без индекса　
  package main　
  　　
  import "fmt"
  　　
  func main() {　
  　　
  　　　　//Создание слайсов　
  　　　　myslice := []string{"This", "is", "the", "tutorial", "of", "Go", "language"}　
  　　
  　　　　　　　　// Итерация массива
  　　　　　　　　// В цикле for с использованием range
  　　　　　　　　// Без индекса
  　　　　for _, ele := range myslice {　
  　　　　　　　　fmt.Printf("Элемент = %s\n", ele)　
  　　　　}　
  }

  Вывод:

  Элемент = This
  Элемент = is
  Элемент = the
  Элемент = tutorial
  Элемент = of
  Элемент = Go
  Элемент = language

Основные моменты о массивах

1. Нулевой массив:В языке Go вам разрешается создать нулевой массив, который не содержит никаких элементов. Таким образом, его объем и длина равны 0. Нулевой массив не содержит ссылку на массив, как показано в следующем примере:

   Пример

   package main　
   　　
   import "fmt"
   　　
   func main() {　
   　　
   　　　　// Создание нулевого массива
   　　　　var myslice []string　
   　　　　fmt.Printf("Длина = %d\n", len(myslice))　
   　　　　fmt.Printf("Capacity = %d ", cap(myslice))　
   　　
   }

   Вывод:

   Length = 0
   Capacity = 0

2. Изменение Slice:Как мы уже знаем, slice является типом данных по ссылке, поэтому он может ссылаться на базовый массив. Таким образом, если мы изменяем某些 элементы в срезе, изменения также должны происходить в ссылке на массив. Иначе говоря, если вы производите какие-либо изменения в срезе, они также будут отражены в массиве, как показано в следующем примере:

   Пример

   //Как изменить срез
   package main　
   　　
   import "fmt"
   　　
   func main() {　
   　　
   　　　　//Создание нулевого среза
   　　　　arr := [6]int{55, 66, 77, 88, 99, 22}　
   　　　　slc := arr[0:4]　
   　　
   　　　　//До изменения
   　　
   　　　　fmt.Println("Original_Array: ", arr)　
   　　　　fmt.Println("Original_Slice: ", slc)　
   　　
   　　　　//Изменено　
   　　　　slc[0] = 100　
   　　　　slc[1] = 1000　
   　　　　slc[2] = 1000　
   　　
   　　　　fmt.Println("\nNew_Array: ", arr)　
   　　　　fmt.Println("New_Slice: ", slc)　
   }

   Вывод:

   Original_Array: [55 66 77 88 99 22]
   Original_Slice: [55 66 77 88]
   New_Array: [100 1000 1000 88 99 22]
   New_Slice: [100 1000 1000 88]

3. Сравнение срезов:В срезе можно использовать только==Оператор проверки наличия данного среза.==С помощью оператора сравнения можно сравнить два среза, и если попытаться это сделать, то возникнет ошибка, как показано в следующем примере:

   Пример

   //Проверка, является ли срез нулевым
   package main　
   　　
   import "fmt"
   　　
   func main() {　
   　　
   　　　　//Создание слайсов
   　　　　s1 := []int{12, 34, 56}　
   　　　　var s2 []int
   　　
   　　　　　　　　//Если вы попытаетесь запустить этот комментарий
   　　　　　　　　//Компилятор кода выдаст ошибку
   　　　　/*s3:= []int{23, 45, 66}*/　
   　　　　　　fmt.Println(s1 == s3)　
   　　　　*/
   　　
   　　　　//Проверка, является ли данная плоская структура nil
   　　　　fmt.Println(s1 == nil)　
   　　　　fmt.Println(s2 == nil)　
   }

   Вывод:

   false
   true

   Внимание:Если нужно сравнить два среза, используйте цикл для сопоставления каждого элемента или можно использоватьDeepEqualФункция.

4. Многоуровневые срезы:Многоуровневые срезы, как и многоуровневые массивы, но срез не содержит размера.

   Пример

   package main　
   　　
   import "fmt"
   　　
   func main() {　
   　　
   　　　　//Создание многоуровневого слайса
   　　　　s1 := [][]int{{12, 34},}}　
   　　　　　　　　{56, 47},　
   　　　　　　　　{29, 40},　
   　　　　　　　　{46, 78},　
   　　　　}　
   　　
   　　　　//Доступ к многоуровневому слайсу
   　　　　fmt.Println("Slice 1: ", s1)　
   　　
   　　　　//Создание многоуровневого слайса　
   　　　　s2 := [][]string{　
   　　　　　　　　[]string{"w3codeboxs", "for"},　
   　　　　　　　　[]string{"w3codeboxs", "GFG"},　
   　　　　　　　　[]string{"gfg", "w3codebox"},　
   　　　　}　
   　　
   　　　　//Доступ к многоуровневому слайсу
   　　　　fmt.Println("Slice 2: ", s2)　
   　　
   }

   Вывод:

   Slice 1:　[[12 34] [56 47] [29 40] [46 78]]
   Slice 2:　[[w3codeboxs for] [w3codeboxs GFG] [gfg w3codebox]]

5. Сортировка слайсов:В языке Go можно сортировать элементы, существующие в слайсе. Стандартная библиотека Go предоставляет пакет sort, который содержит различные типы методов сортировки для сортировки слайсов int, float64 и строк. Эти функции всегда сортируют элементы в слайсе в порядке возрастания.

   Пример

   //Элементы, существующие в слайсе
   package main　
   　　
   import (　
   　　　　"fmt"
   　　　　"sort"
   )　
   　　
   func main() {　
   　　
   　　　　//Создание слайсов
   　　　　slc1 := []string{"Python", "Java", "C#", "Go", "Ruby"}　
   　　　　slc2 := []int{45, 67, 23, 90, 33, 21, 56, 78, 89}　
   　　
   　　　　fmt.Println("Прежде чем отсортировать:")　
   　　　　fmt.Println("Slice 1: ", slc1)　
   　　　　fmt.Println("Slice 2: ", slc2)　
   　　
   　　　　//Использование функции сортировки для слайсов
   　　　　sort.Strings(slc1)　
   　　　　sort.Ints(slc2)　
   　　
   　　　　fmt.Println("\nОтсортировано:")　
   　　　　fmt.Println("Slice 1: ", slc1)　
   　　　　fmt.Println("Slice 2: ", slc2)　
   　　
   }

   Вывод:

   Прежде чем отсортировать:
   Slice 1:　[Python Java C# Go Ruby]
   Slice 2:　[45 67 23 90 33 21 56 78 89]
   Отсортировано:
   Slice 1:　[C# Go Java Python Ruby]
   Slice 2:　[21 23 33 45 56 67 78 89 90]