Перейти к содержимому
шпаргалка.
Esc
↑↓навигация↵открыть⌘Jпредпросмотр
На этой странице

Типы данных

Все темы Go Developer

Какие бывают типы в Go?

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

  1. Базовые типы:

    • Числовые:

      • Целые: int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr

      • С плавающей точкой: float32, float64

      • Комплексные: complex64, complex128

    • Логические: bool

    • Символьные: byte (alias для uint8), rune (alias для int32, используется для представления Unicode символов)

    • Строки: string

  2. Составные типы:

    • Массивы: [n]T (фиксированного размера)

    • Слайсы: []T (динамического размера)

    • Структуры: struct

    • Карты (map): map[K]V (ассоциативные массивы)

    • Каналы: chan T (для передачи данных между горутинами)

  3. Интерфейсы:

    • Интерфейсные типы: interface{} (позволяют определять методы, которые должен реализовывать тип)

  4. Указатели:

    • Указатели: *T (указатель на значение типа T).

Примеры:

  • Числовые:

    var i int = 42
var f float64 = 3.14

  • Строки и логические:

    var s string = "Hello, Go!"
var b bool = true

  • Составные:

    var arr [3]int = [3]int{1, 2, 3}
var slice []int = []int{1, 2, 3}
var m map[string]int = map[string]int{"a": 1, "b": 2}

  • Указатели:

    var p *int

Эти типы обеспечивают широкий спектр возможностей для разработки приложений в Go.

В чем отличие uint от int?

Основное отличие между uint и int:

  • int:

    • Знак: Знаковый тип данных, может содержать как положительные, так и отрицательные значения.

    • Диапазон: Диапазон значений зависит от разрядности платформы (32 или 64 бита). Например, для 32-битной платформы диапазон int составляет от -2,147,483,648 до 2,147,483,647.

    • Пример:

      var i int = -42

  • uint:

    • Знак: Беззнаковый тип данных, может содержать только неотрицательные значения.

    • Диапазон: Диапазон значений также зависит от разрядности платформы. Для 32-битной платформы диапазон uint составляет от 0 до 4,294,967,295.

    • Пример:

      var u uint = 42

Особенности:

  • Применение:

    • Используйте int, когда необходимы как положительные, так и отрицательные значения.

    • Используйте uint, когда значения не могут быть отрицательными (например, для счетчиков, индексов).

Пример сравнения:

package main

import "fmt"

func main() {
    var i int = -10
    var u uint = 10

    fmt.Println(i)  // Вывод: -10
    fmt.Println(u)  // Вывод: 10
}

Эти типы данных обеспечивают гибкость и эффективность работы с различными диапазонами значений в Go.

Что такое обычный int и какие есть нюансы его реализации?

Обычный int в Go:

  • Определение: int — это знаковый целочисленный тип данных, который может содержать как положительные, так и отрицательные значения.

  • Размер: Размер int зависит от платформы:

    • На 32-битных платформах: int имеет размер 32 бита.

    • На 64-битных платформах: int имеет размер 64 бита.

  • Диапазон значений:

    • На 32-битных платформах: от -2,147,483,648 до 2,147,483,647.

    • На 64-битных платформах: от -9,223,372,036,854,775,808 до 9,223,372,036,854,775,807.

Нюансы реализации:

  1. Платформозависимость:

    • Размер и диапазон int зависят от архитектуры платформы, что следует учитывать при переносе кода между 32-битными и 64-битными системами.

  2. Производительность:

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

  3. Использование:

    • Рекомендуется использовать int для общих случаев, если не требуется фиксированный размер или диапазон, поскольку это обеспечивает лучшую производительность и удобство.

Пример использования int:

package main

import "fmt"

func main() {
    var i int = 42
    fmt.Println(i)  // Вывод: 42
}

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

Как преобразовать строку в int и наоборот? Можно ли сделать int(string) и string(int) соответственно?

Преобразование строки в int:

Для преобразования строки в int используйте функцию strconv.Atoi из пакета strconv.

import (
    "fmt"
    "strconv"
)

func main() {
    str := "42"
    num, err := strconv.Atoi(str)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Converted to int:", num)
    }
}

Для преобразования int в строку используйте функцию strconv.Itoa.

import (
    "fmt"
    "strconv"
)

func main() {
    num := 42
    str := strconv.Itoa(num)
    fmt.Println("Converted to string:", str)
}

int(“123”) недопустимо. Преобразование string(123) допустимо, но возвращает строку с кодовой точкой U+007B, то есть “{”, а не десятичную запись “123”. Для десятичной записи используйте strconv.Itoa.

// int("123") — ошибка компиляции
s := string(123) // "{", кодовая точка U+007B
fmt.Println(s)

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

Сколько в памяти занимают реализации int32 и int64?

Размер в памяти для int32 и int64:

  • int32: Занимает 4 байта (32 бита) в памяти.

  • int64: Занимает 8 байт (64 бита) в памяти.

Пример:

  • int32: 4 байта = 32 бита

    var i int32 = 42

  • int64: 8 байт = 64 бита

    var j int64 = 42

Эти размеры фиксированы и не зависят от платформы, в отличие от обычного int, который может иметь разный размер на 32-битных и 64-битных системах.

Какие предельные значения int32 и int64?

Предельные значения int32 и int64:

  • int32:

    • Минимальное значение: −2 147 483 648 (−2^31).

    • Максимальное значение: 2,147,483,647 (2^31 - 1)

  • int64:

    • Минимальное значение: −9 223 372 036 854 775 808 (−2^63).

    • Максимальное значение: 9,223,372,036,854,775,807 (2^63 - 1)

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

package main

import "fmt"

func main() {
    var i32_min int32 = -2147483648
    var i32_max int32 = 2147483647
    var i64_min int64 = -9223372036854775808
    var i64_max int64 = 9223372036854775807

    fmt.Println("int32 min:", i32_min)
    fmt.Println("int32 max:", i32_max)
    fmt.Println("int64 min:", i64_min)
    fmt.Println("int64 max:", i64_max)
}

Эти предельные значения определяют диапазон значений, которые могут быть представлены типами int32 и int64.

Какой результат получим если разделить int на 0 и float на 0?

Деление на 0 в Go:

  • int на 0:

    • Деление целого числа на 0 вызывает панику во время выполнения.

    • Пример:

      var a int = 42
var b int = 0
// Результат: паника (runtime error: integer divide by zero)
c := a / b

  • float на 0:

    • Деление числа с плавающей точкой на 0 не вызывает панику, но возвращает специальные значения.

    • Пример:

      var x float64 = 42.0
var y float64 = 0.0
// Результат: +Inf (положительная бесконечность)
z := x / y
fmt.Println(z)  // Вывод: +Inf

Особенности:

  • int: деление на переменную со значением 0 вызывает панику. Константный нулевой делитель вызывает ошибку компиляции.

  • float: при вычислении во время выполнения возможны +Inf, −Inf или NaN. Деление констант на ноль запрещено компилятором.

Что такое константы и можно ли их изменять?

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

Основные характеристики:

  1. Объявление констант:

    • Используется ключевое слово const.

    • Пример:

      const Pi = 3.14

  2. Неизменяемость:

    • Константы не могут быть изменены после их определения.

    • Пример:

      const Pi = 3.14
// Pi = 3.1415  // Ошибка: попытка изменения константы

  3. Типы констант:

    • Константы могут быть числовыми (целыми и с плавающей точкой), строковыми или булевыми.

    • Примеры:

      const Greeting = "Hello, Go!"
const MaxValue = 100
const IsEnabled = true

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

package main

import "fmt"

const Pi = 3.14

func main() {
    fmt.Println("Value of Pi:", Pi)
}

Что такое iota?

iota — предопределенный идентификатор: внутри const он равен индексу текущего ConstSpec, начиная с нуля. Несколько констант в одной спецификации используют одинаковое значение iota.

Основные характеристики:

  1. Инициализация:

    • iota начинается с 0 внутри блока const и увеличивается на 1 для каждой последующей константы.

    • Пример:

      const (
    A = iota  // 0
    B         // 1
    C         // 2
)

  2. Использование:

    • Удобен для создания последовательностей иерархических значений, таких как дни недели, месяцы или типы состояний.

    • Пример:

      const (
    Sunday = iota  // 0
    Monday         // 1
    Tuesday        // 2
    Wednesday      // 3
    Thursday       // 4
    Friday         // 5
    Saturday       // 6
)

  3. Сброс в новых блоках:

    • iota сбрасывается на 0 при входе в новый блок const.

    • Пример:

      const (
    X = iota  // 0
    Y         // 1
)

const (
    Z = iota  // 0
    W         // 1
)

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

package main

import "fmt"

const (
    Red = iota  // 0
    Green       // 1
    Blue        // 2
)

func main() {
    fmt.Println(Red, Green, Blue)  // Вывод: 0 1 2
}

Что такое структура (struct) в Go? Зачем они нужны?

Структура ( struct ) — это пользовательский тип данных, который позволяет объединить несколько полей (переменных) под одним именем. Поля могут быть разного типа.

Основные характеристики:

  1. Объявление структуры:

    • Определяется с помощью ключевого слова type и struct.

    • Пример:

      type Person struct {
    Name string
    Age  int
}

  2. Инициализация и использование:

    • Создание экземпляра структуры и доступ к ее полям.

    • Пример:

      p := Person{Name: "Alice", Age: 30}
fmt.Println(p.Name)  // Вывод: Alice
fmt.Println(p.Age)   // Вывод: 30

Зачем нужны структуры:

  1. Группировка данных:

    • Структуры позволяют логически сгруппировать несколько значений разного типа в одном объекте.

    • Пример: Сведения о человеке, включая имя и возраст.

  2. Организация кода:

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

  3. Моделирование реальных сущностей:

    • Структуры используются для моделирования реальных объектов и сущностей в программе (например, клиент, продукт, заказ).

Пример использования структуры:

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "Bob", Age: 25}
    fmt.Println("Name:", p.Name)  // Вывод: Name: Bob
    fmt.Println("Age:", p.Age)    // Вывод: Age: 25
}

Что такое тип rune? Зачем их использовать?

rune — это алиас для типа int32 и используется для представления символов Unicode.

Основные характеристики:

  1. Размер:

    • rune занимает 4 байта (32 бита) в памяти, что позволяет хранить любой символ Unicode.

  2. Использование:

    • Применяется для работы с символами Unicode, обеспечивая поддержку международных символов и эмодзи.

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

package main

import "fmt"

func main() {
    var ch rune = '世'
    fmt.Println(ch)        // Вывод: 19990 (кодовая точка Unicode)
    fmt.Printf("%c\\n", ch) // Вывод: 世 (символ)
}

Зачем использовать rune:

  1. Поддержка Unicode:

    • Позволяет корректно обрабатывать символы различных языков и специальные символы.

  2. Явность кода:

    • Делает код более явным и читаемым при работе с символами, так как rune указывает на работу с символами Unicode, а не просто с числами.

Что такое тип byte?

byte — это алиас для типа uint8 и используется для представления данных в байтах.

Основные характеристики:

  1. Размер:

    • byte занимает 1 байт (8 бит) в памяти, со значениями от 0 до 255.

  2. Использование:

    • Применяется для работы с сырыми данными и байтовыми последовательностями, такими как файлы, сетевые пакеты и строки.

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

package main

import "fmt"

func main() {
    var b byte = 65
    fmt.Println(b)        // Вывод: 65
    fmt.Printf("%c\\n", b) // Вывод: A (символ с кодом ASCII 65)
}

Зачем использовать byte:

  1. Работа с сырыми данными:

    • Удобен для манипуляций с данными на низком уровне, такими как чтение и запись файлов, обработка сетевых пакетов.

  2. Представление строк:

    • В Go строки представляют собой последовательности байтов, поэтому byte часто используется при работе с символами ASCII и UTF-8.

Эта страница была полезной?