Серия учебных курсов DevOps in Go

В своей прошлой статье DevOps в Go — Переменные я рассказал о разных способах объявления переменных Go и о том, почему переменная Go должна иметь четкую границу памяти, указав тип переменной. Давайте сегодня рассмотрим основные типы данных Go.

Перейти к типам данных

Типы данных Go можно условно разделить на три типа:

  • Основные типы данных
  • Сложные типы данных
  • Типы данных интерфейса

Базовые типы данных чаще всего используются один из трех.

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

Перейти к целочисленному типу

Целочисленный тип в основном используется для выражения целого числа в реальном мире, такого как возраст, год и т. д. Его можно разделить на независимые от платформы целочисленные типы и зависимые от платформы целые типы. сильные> целочисленные типы.

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

В следующей таблице показаны независимые от платформы целочисленные типы Go:

Для целочисленных типов, зависящих от платформы, у нас есть int , uint и uintptr :

Поскольку int , uint и uintptr зависят от платформы, поэтому, когда мы пишем код, требующий переносимости, мы не должны полагаться на длину этих типов. Если вы не знаете длину этих трех типов на целевой операционной платформе, вы можете получить ее с помощью функции SizeOf, предоставляемой пакетом unsafe. Например, на платформе x86–64 их длина равна 8:

var a, b = int(5), uint(6)
var p uintptr = 0x12345678
fmt.Println("signed integer a's length is", unsafe.Sizeof(a)) // 8
fmt.Println("unsigned integer b's length is", unsafe.Sizeof(b)) // 8
fmt.Println("uintptr's length is", unsafe.Sizeof(p)) // 8

Целочисленный литерал

Go унаследовал грамматическую форму языка программирования C от числового литерала (Number Literal). Ранние версии Go поддерживают десятичные, восьмеричные и шестнадцатеричные числовые формы, такие как:

a := 53        // Decimal
b := 0700      // Octal，"0" prefix
c1 := 0xaabbcc // Hex，"0x" prefix
c2 := 0Xddeeff // Hex，"0X" prefix

После Go v1.13 было добавлено следующее:

d1 := 0b10000001 // binary，"0b" prefix
d2 := 0B10000001 // binary，"0B" prefix
e1 := 0o700      // Octal，"0o" prefix
e2 := 0O700      // Octal，"0O" prefixa := 5uintptr7          // Decimal: 537
b := 0b_1000_0111   // Binary 10000111 
c1 := 0_700         // Octal: 0700
c2 := 0o_700        // Octal: 0700
d1 := 0x_5c_6d      // Hex：0x5c6d

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

var a int8 = 59
fmt.Printf("%b\n", a) // binary：111011
fmt.Printf("%d\n", a) // decimal：59
fmt.Printf("%o\n", a) // octal：73
fmt.Printf("%O\n", a) // octal with 0o prefix：0o73
fmt.Printf("%x\n", a) // Hex：3b
fmt.Printf("%X\n", a) // Hex：3B

Плавающая запятая

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

float32 против float64

Go предоставляет два типа с плавающей запятой, float32 и float64, которые соответственно соответствуют числовым типам с плавающей запятой одинарной и двойной точности в IEEE 754.

Однако здесь следует отметить, что тип float не предусмотрен в языке Go. Это не похоже на целые типы. Go предоставляет как int16, int32, так и другие типы, а также типы int. Другими словами, типы с плавающей запятой, предоставляемые Go, независимы от платформы.

Будь то float32 или float64, значение их переменных по умолчанию равно 0,0. Разница в том, что объем памяти, который они занимают, и диапазон/точность чисел с плавающей запятой.

Разговор float с binary довольно сложен, я не буду здесь вдаваться в подробности, но если вам интересно, вы можете обратиться к «Конвертер с плавающей запятой IEEE-754».

Опять же, вы можете просто использовать пакет fmt для удобства.

func main() {
    var f float32 = 139.8125
    bits := math.Float32bits(f)
    fmt.Printf("%b\n", bits)
}Output:
1000011000010111101000000000000

Литерал числа с плавающей запятой

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

3.1415
.15
81.80
82.

Другая форма научной записи:

6674.28e-2 // 6674.28 * 10^(-2) = 66.742800
.12345E+5  // 0.12345 * 10^5 = 12345.000000

Как и int, пакет fmt также обеспечивает вывод с плавающей запятой:

var f float64 = 123.45678
fmt.Printf("%f\n", f) // 123.456780fmt.Printf("%e\n", f) // 1.234568e+02
fmt.Printf("%x\n", f) // 0x1.edd3be22e5de1p+06

Сложный тип данных

Числа вида z=a+bi называются комплексными числами. Язык Go изначально поддерживает типы комплексных чисел. Однако по сравнению с целочисленными типами и типами с плавающей запятой применение типов комплексных чисел в Go более ограничено и в основном используется для вычислений в профессиональных областях, таких как векторные вычисления.

Go предоставляет два типа комплексных чисел: complex64 и complex128. Если комплексный номер не имеет назначенного типа, то его тип по умолчанию — complex128.

В Go есть три способа представления комплексных чисел:

  • Непосредственно инициализируйте переменную комплексного числа:
var c = 5 + 6i
var d = 0o123 + .12345E+5i // 83+12345i
  • Используйте функцию complext
var c = complex(5, 6) // 5 + 6i
var d = complex(0o123, .12345E+5) // 83+12345i
  • Используйте real и imag :
var c = complex(5, 6) // 5 + 6i
r := real(c) // 5.000000
i := imag(c) // 6.000000