Введение

Добро пожаловать обратно в Часть 5 серии Go lang. В Часть 2: мы увидели, что такое типы данных и сколько типов в Go. Это примитивные типы данных, что означает, что они являются базовыми. В этом, давайте посмотрим о массивы а также ломтики которые непримитивные типы данных в Го.


Непримитивные типы данных

Тип данных, представляющий собой группу переменных любого примитивный или же непримитивный типы данных называется непримитивный тип данных. Пересмотрите эту строку после прочтения ниже непримитивный типы данных. Тогда вы получите четкое представление об этой линии.

Есть 4 непримитивные типы данных в Go. Они есть:

  1. Массивы.
  2. Срезы.
  3. Карты.
  4. Структуры.

Посмотрим карты а также структуры в следующей статье.


1. Массивы

Ан множество представляет собой набор или группу значений, где каждое значение принадлежит такой же тип. Другими словами, все переменные или элементы, присутствующие в массиве, должны иметь один и тот же тип данных.

Массив в Go имеет исправленный размер который указывается во время объявления или инициализации. И его размер фиксирован и не может быть изменен во время выполнения программы.


Программа для иллюстрации объявления и инициализации массивов

package main

import "fmt"

func main() {
    var arr1 [10]int // Declaring an array of size 10
    arr2 := [10]int{1, 2, 3, 4, 5} // Initialising an array of size 10 with {1, 2, 3, 4, 5} values.
    fmt.Printf("This is array 1: %v", arr1)
    fmt.Printf("This is array 2: %v", arr2)
}
Войти в полноэкранный режим

Выйти из полноэкранного режима

Выход:
Выход

Поскольку мы не указали никаких значений в arr1, он принимает все значения в качестве значений по умолчанию, что равно 0 в случае int. В arr2 первые 5 значений задаются нами, а остальные 5 являются значениями по умолчанию.


Программа для добавления элемента на 6-ю позицию в массив размером 10

Мы можем указать конкретную позицию массива, используя индекс ([]) оператор. Внутри этих []мы даем номер индекса. Index number = Position - 1. Итак, чтобы указать 6-ю позицию массива, мы используем [5] согласно приведенному выше выражению. Мы используем этот оператор индекса сразу после имени массива.

package main

import "fmt"

func main() {
    arr := [10]int{1, 2, 3, 4, 5} // Initialising array
    fmt.Println(arr) 
    arr[5] = 6 // Adding an item at position 6, a.k.a index 5
    fmt.Println(arr)
}
Войти в полноэкранный режим

Выйти из полноэкранного режима

Выход:

Выход

Отрицательным моментом массива является то, что его размер фиксирован и не может автоматически увеличиваться или уменьшаться в зависимости от ситуации. Например, в приведенном выше массиве размером 10 вы не можете добавить в него 11-й элемент. Выдает ошибку. Итак, нам нужно знать максимальную длину массива, который нам нужен в этой программе.

Что делать, если невозможно заранее узнать максимальную длину массива? Что, если мы хотим, чтобы наш массив увеличивался или уменьшался в соответствии с потребностями? Вот где ломтики пригодиться.


2. Ломтики

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

Объявление или инициализация среза аналогичны массиву, за исключением того, что мы не указываем размер, как в случае с массивом.


Программа для объявления и инициализации слайса

package main

import "fmt"

func main() {
    var slice1 []string // Declaring a slice of type string
    slice2 := []string{"chiranjeevi", "golang"}
    fmt.Println(slice1)
    fmt.Println(slice2)
}
Войти в полноэкранный режим

Выйти из полноэкранного режима

Выход:

Выход


Программа для добавления новой строки в конец среза

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

package main

import "fmt"

func main() {
    slice1 := []string{"chiranjeevi", "golang"}
    fmt.Println(slice1)
    slice1 = append(slice1, "devops") // Assigning it to the old slice again
    // Bcoz the append function only return new slice
    // It doesn't change the old slice.
    fmt.Println(slice1)
}
Войти в полноэкранный режим

Выйти из полноэкранного режима

Выход:

Выход


Обновление значения в позиции в массиве и срезе

Мы можем обновить уже существующее значение в массиве и срезе. Укажите эту позицию с помощью оператора индекса и присвойте ей значение. Мы сделали это при добавлении элемента в массив. Там мы назначили элемент на позицию, где уже ничего не назначено. Итак, это добавление элемента. Если мы попытаемся сделать то же самое, когда там уже есть элемент, это обновит элемент.


Программа для обновления значения в позиции в массиве


package main

import "fmt"

func main() {
    arr := [5]int{1, 2, 3, 4, 5}
    fmt.Println(arr)
    arr[3] = 400 // Updating value of 4 (index 3) to 400
    fmt.Println(arr)
    // arr[5] = 500 //Trying to assign value to position not present
    // This throws an error if uncommented above line.
}
Войти в полноэкранный режим

Выйти из полноэкранного режима

Выход

Описание изображения

Вывод, если раскомментирована строка ошибки

Описание изображения

Мы не использовали оператор индекса при добавлении элемента в срез. Это потому, что мы не можем получить доступ к позиции, которая не является частью массива или среза. В случае массива мы знаем его размер при объявлении, поэтому мы можем добавить любой элемент, насколько мы добавляем в позицию, которая присутствует в массиве. Но когда дело доходит до среза, мы не знаем размер, которым в данный момент обладает срез. Если мы попытаемся обновить или получить доступ к позиции, которой еще нет в массиве или срезе, выдается ошибка. Мы можем получить размер или текущую длину массива или среза, используя Лен функция.


Программа для обновления значения в срезе

package main

import "fmt"

func updateSlice(slc []int, pos int, val int) []int {
    if (pos >= len(slc)) {
        fmt.Println("Slice index out of bound")
    } else {
        slc[pos] = val
    }
    return slc
}

func main() {
    slc := []int{1, 2, 3, 4}
    fmt.Println(slc)
    slc = updateSlice(slc, 1, 500)
    fmt.Println(slc)
    slc = updateSlice(slc, 5, 1000)
    fmt.Println(slc)
}
Войти в полноэкранный режим

Выйти из полноэкранного режима

Выход:

Описание изображения


Функция — аргументы и возвращаемый тип

Мы обсуждали о функции в первой статье этой серии, посмотрите, если пропустили: в ней мы видели, что такое заголовок, аргументы и тело функции. Теперь давайте посмотрим, как мы на самом деле объявляем аргументы из приведенного выше примера кода.

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

В приведенном выше примере нам нужен срез, позиция, в которой мы обновляем, и значение, которое мы хотим обновить, в качестве аргументов. Итак, нам нужно объявить всего 3 аргумента. Первый имеет тип slice с целыми числами, поэтому мы объявляем его как []int предшествует имя. Во-вторых, это позиция, которая является целым числом, поэтому int предшествует его имя. Третье — это значение, которое также является целым числом, поэтому int предшествует его имя. Следовательно, дело сводилось к (slc []int, pos int, val int). Вот почему, когда мы вызываем функцию, мы использовали updateSlice(slc, 1, 500). Количество аргументов и порядок должны быть такими же, как и в объявлении.

Кроме того, есть что-то после этих аргументов за скобками. Это называется возвращаемый тип функции. Это означает, что значение, которое возвращает функция, имеет этот тип. В нашем примере мы возвращаем целочисленный срез, поэтому мы дали []int как возвращаемый тип. Куда возвращается? Значение возвращается в место вызова функции. Мы вызываем его внутри основной функции, поэтому он возвращает значение там. Вот почему мы повторно назначаем его исходному фрагменту.


Вывод

Вот именно для этого. В следующей статье рассмотрим карты и структуры.

Скоро появится больше информации о Go lang, и подписывайтесь на меня, чтобы увидеть их. Не забудьте поставить лайк и поделиться, если вам было так хорошо.

Подключаемся дальше: Твиттер LinkedIn Витрина