Типы данных в Go

Go (Golang) — это многопоточный язык программирования, разработанный компанией Google. Он был создан для того, чтобы ускорить процесс разработки программного обеспечения. Язык Go сочетает в себе высокую производительность и простоту использования. Его используют для разработки веб-приложений, микросервисов, облачных приложений, обработки данных и многого другого.

Особенности языка Go:

В этой статье мы расскажем о наиболее важных типах данных в Go.

Объявление переменных

Переменные в Go — это именованные области памяти для хранения данных. Они могут содержать значения различных типов данных, например, чисел или строк.

Объявление переменной в Go происходит с помощью ключевого слова var, за которым следует имя переменной и ее тип данных:

var имя_переменной тип_данных

Пример объявления переменной:

var name string

В этом примере переменная называется name и имеет тип string, то есть строка.

После объявления переменной ей можно присвоить значение с помощью оператора присваивания «=». Этот прием называется инициализацией. Синтаксис будет выглядеть следующим образом:

var имя_переменной тип_данных = значение

Пример:

var name string = "John"

Также существует краткий способ объявления переменной сразу с присвоением значения. Для этого используется оператор «:=». Синтаксис будет выглядеть следующим образом:

имя_переменной := значение

Например:

name := "John"

В этом примере переменная называется name и имеет тип string. Оператор «:=» автоматически определяет тип переменной на основе присвоенного значения.

Основные типы данных

Целочисленные типы данных

Целочисленные типы данных в Go используются для хранения целых чисел. Они могут быть положительными, отрицательными или нулевыми. В языке Go определены следующие целочисленные типы:

Наиболее распространенным считается тип данных int. Помимо перечисленных, существуют еще типы:

Примеры объявления целочисленных переменных:

var a int64 = 32000
var b uint = 40000
var c rune = -7

Вещественные типы данных

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

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

Примеры объявления вещественных переменных:

var a float32 = 3.05
var b float64 = 3.1484205843

Строковые типы данных

Строковые типы данных в Go используются для хранения строк. Строка — это последовательность символов, заключенных в кавычки. Например:

var s string = "Hello, world!"

В Go строки являются неизменяемыми, то есть после создания нельзя изменять содержимое строки.

Помимо обычных символов, строка в Go может содержать специальные последовательности. Все последовательности начинаются с обратного слеша. Например:

Также строка может содержать Unicode-символы. Для этого необходимо задать последовательность символов в формате \uXXXX, где XXXX — значение символа Unicode. Например, чтобы добавить знак ₽, нужно ввести \u20BD.

Примеры объявления строковой переменной:

var name string = "John"
hello := "Hello, username!"

Логический тип данных

Логический тип данных в Go обозначается словом bool и может принимать только два значения: true (истина) и false (ложь).

Логические переменные используются для хранения булевых значений, которые могут быть использованы для принятия решений в программе. Например, логический тип данных может использоваться для проверки условий в операторах if и switch, а также для хранения результата логических операций, таких как && (логическое И), || (логическое ИЛИ), ! (логическое НЕ).

Пример использования логической переменной:

var isTrue bool = true

if isTrue {
    fmt.Println("Переменная isTrue равна true")
} else {
    fmt.Println("Переменная isTrue равна false")
}

Составные типы данных

Массивы

Массивы в Go — это упорядоченные последовательности элементов одного типа. Массивы имеют фиксированную длину, которая задается при их объявлении. После объявления длину массива нельзя изменить.

Для объявления массива необходимо указать количество элементов в квадратных скобках и тип элемента. Например, следующий код объявляет массив a из пяти элементов типа int:

var a [5]int

По умолчанию все элементы массива инициализируются нулем. Чтобы инициализировать элементы массива другими значениями, их нужно указать в фигурных скобках через запятую:

var а [5]int = [5]int{1,2,3,4,5}

Для обращения к элементам массива используются индексы. Нумерация элементов начинается с нуля, поэтому у первого элемента будет индекс 0:

var a [5]int = [5]int{1,2,3,4,5}
fmt.Println(a[0])     // первый элемент
fmt.Println(a[4])     // пятый элемент

Кроме того, массивы поддерживают итерацию с помощью цикла for:

for i := 0; i < len(a); i++ {
    fmt.Println(a[i])
}

Срезы

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

Пример объявления среза:

var a []string

Где:

Пустой срез объявляется следующим способом:

var a []int = []int{}

Для обращения к элементам среза используются индексы, как и в случае с массивами. Нумерация элементов начинается с нуля:

var a []string = []string{“John”, ”Alice”, ”Bob”}
fmt.Println(a[1])

Для создания среза заданной длины можно использовать функцию make():

var a []int = make([]int, 3)

Структуры

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

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

Пример объявления структуры:

type Person struct {
    Name    string
    Age     int
    Address string
}

Чтобы определить переменную, которая будет хранить значения структуры, необходимо указать ключевое слово var, имя переменной и имя структуры. Затем нужно указать набор значений в фигурных скобках:

var Tom Person = Person{"Tom", 23, "123 Broadway Street"}

Для обращения к полям структуры после имени переменной необходимо поставить точку и указать поле структуры. Пример:

Tom.Age

Карты

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

Создать карту можно следующим образом:

var m map[keyType]valueType

Где:

Например, для создания карты с ключами типа string и значениями типа int используется следующий код:

var m map[string]int

Для добавления элемента в карту используется следующий синтаксис:

m[key] = value

Где:

Например:

m["apple"] = 1
m["banana"] = 2
m["orange"] = 3

Для получения значения из карты используется следующий синтаксис:

value := m[key]

Например:

fmt.Println(m["apple"])

Чтобы проверить, существует ли ключ в карте, используется следующий синтаксис:

value, ok := m[key]

Если ключ существует в карте, переменная ok будет содержать значение true. Если ключа не существует, переменная ok будет содержать значение false.

Для удаления элемента из карты используется функция delete(). Например, чтобы удалить элемент с ключом banana, нужно добавить следующий код:

delete(m, "banana")

Указатели и интерфейсы

Указатели

Указатели в Go — это переменные, которые хранят адрес памяти другой переменной. Вместо того чтобы хранить значение переменной напрямую, указатель хранит адрес, по которому находится значение переменной.

Определить указатель можно следующим образом:

var p *type

Где type — тип данных, на который ссылается указатель.

Например, чтобы создать указатель на переменную int, можно использовать следующий код:

var p *int

Для получения адреса переменной используется оператор «&»:

var x int = 10
p := &x

Теперь указатель p содержит адрес переменной x.

Чтобы получить значение переменной, на которую ссылается указатель, используется оператор «*»:

var x int = 10
p := &x
fmt.Println(*p)

Интерфейсы

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

Пример:

type MyInterface interface {
    Method1([]byte) (int, error)
}

Здесь мы определили интерфейс MyInterface с методом Method1 и аргументом типа []byte. Он будет возвращать количество записанных байтов и ошибку.