array&slice

AlexNovoross87

May 9th, 2025 (edited)

Never

Add comment

Not a member of Pastebin yet? Sign Up, it unlocks many cool features!

Go 7.58 KB | None | 0 0

raw download clone embed print report

МАССИВЫ
===============================================
Массивы представляют собой способ хранения нескольких элементов одного типа данных
| Данные хранятся последовательно в "массиве" данных.
| Каждый отдельный фрагмент данных называется элементом
Для доступа к элементам в массиве используется индекс массива
| Индекс начинается с 0, что означает, что первый элемент массива имеет индекс О
Массивы имеют фиксированный размер и их нельзя изменить
var myArray [3]int //неинициализированный массив
myArray := [3]int{7, 8, 9} //массив на 3 элемента все инициализированы
myArray := [...]int{7, 8, 9} // ... при инициализации сам вычислит длину
myArray := [4]int{7, 8, 9} // первые 3 инициализированны , 4 - значенние по умолчанию.
Элементы, которым не присвоены значения при создании массива, будут
Доступ к элементам массива
var myArray [3]int
myArray [0] = 7
myArray [1] = 8
myArray [2] = 9
//присвоение переменной
iteml := myArray[0]
-------------------------------------------------------------------------
Цикл
Хорошей практикой является присваивание элемента переменной во время итерации
|Это упрощает чтение в больших функциях или вложенных циклах
myArray := [...] int{7, 8, 9}
for i := 0; 1 < len(myArray); i++ {
item := myArray[i]
fmt.Prinfln(item)
}
СРЕЗЫ
===========================================================================
Срезы (slices) - это специальный тип данных, который работает с массивами
в языке программирования Go. Они позволяют "просматривать" (получать вид)
массива
| Представления (views) динамичны и не имеют фиксированного размера.
Функции в Go могут принимать срезы в качестве параметров функции.
С помощью срезов можно работать с массивами любого размера
Создание среза
--------------
В Go можно одновременно создавать срезы (slices) и базовые массивы
mySlice := []int{l, 2, 3}
[в срезе ничего не указываем внутри квадратных скобок]
Доступ к элементам в срезе (slice) осуществляется так же, как и в массиве
item1 := mySlice[0]
Синтаксис срезов
-----------------
В синтаксисе срезов (slice) можно создавать срезы из конкретных элементов
массива или другого среза.
Индекс начала (a) Индекс конца (b)
slice[а:Ь]
Пропуск символа "а" означает "начинать с О".
Пропуск символа "b" означает "до конца".
Пример синтаксиса среза
-----------------------
numbers := [...]int{l, 2, 3, 4}
slicel := numbers[:] // [1, 2, 3, 4]
slice2 := numbers[l:] // [2, 3, 4]
//Тут берем срез от среза
slice3 := slice2[:l] // [2]
slice# := numbers [:2] // [1, 2]
slices := numbers [1:3] // [2, 3]
Ошибка - попытка создатъ срез за пределами длины массива
Динамические массивы
--------------------
С помощью срезов можно создавать массивы, которые могут быть расширены
I Функция appendO может добавлять дополнительные элементы.
numbers := []int{l, 2, 3}
numbers = append(numbers, 4, 5, 6) // [1, 2, 3, 4, 5, 6]
Три точки могут быть использованы для расширения среза с помощью другого среза
parti := []int{l, 2, 3}
part2 := []int{4, 5, 6}
combined := append(part1, part2...)
Предварительное выделение памяти:
---------------------------------
Срезы могут быть предварительно выделены с указанием определенной ёмкости.
Функция make() используется для предварительного выделения памяти для среза
Это полезно, когда известно количество элементов, но их значения пока неизвестны
1 2 3
slice := make([]int,5, 10)
1) Тип слайса
2) Длина слайса
3) Емеость слайса
Передача срезов в функции
-------------------------
Параметры функций, которым требуется срез, могут работать с срезами любого размера
func iterate(slice []int)
{
for i := 0; i < len(slice); i++ { //}
}
small := []int{1}
big := []int{1, 2, 3, 4, 5, 6, 7}
iterate(small) iterate(big)
Многомерные срезы
------------------
board := [][] string{
// type declaration is optional
[]string{"_", "_", "_"},
{"_", "_", "_"},
{"_", "_", "_"},
}
board[0][0] = "X"
board[2][2] = "0"
board[l][2] = "X"
board[1][0] = "0"
board[0][2] = "X"
Подводные камни
----------------------
func some() {
var list []{} //будет Nil
list = []int{}//в этом случае list не будет nil
*Проверку слайса на пустоту нужно проверять len(list)
*Если мы хотим изменнть слайс, но не хотим затрагивать исходный массив -
создаем копию.
Случай1:
list := make([]int, 4,4)
//list2 создаст нвый массив
list2 := append(list, 1)
list[0] = 5
list[2] = 9
list1 [5,0,0,0]
list2 [9,0,0,1]
Случай2:
list := make([]int, 4,5!!!!!!!!<-- емкость 5)
//list2 НЕ создаст новый массив так как емкость соответствует..
list2 := append(list, 1)
list[0] = 5
list[2] = 9
list1 [9,0,0,0]
list2 [9,0,0,0,1]
*Результат функции append нужно присваивать одной и той же переменной
}
var digitRegxp = regexp.MustCompile("[0-9]+")
***** func FindDigits(filename string) []byte {
//Здесь потенциально может быть большой размер слайса
b, _ := os.ReadFile(filename)
//Здесь функция выполнит свою работу, но исходный слайс
// может остаться огромным
b = digitRegxp.Find(b)
//Создадим новый слайс рабочей длины
res := make([]byte, len(b))
//Скопируем результат из b в новый слайс
copy(res, b)
return res
}

Add Comment

Please, Sign In to add comment