Статическая типизация служит защитой от ошибок, когда программа ожидает один тип данных, а получает другой. Однако жесткая привязка может ограничивать выполнение определенных операций.
Для преодоления этого ограничения в Go предусмотрено преобразование типов данных, или конвертация данных. Это формализованная процедура, которая позволяет разработчикам преобразовывать целочисленные значения в числа с плавающей точкой, строки в числа и наоборот. Эта статья поможет вам разобраться в том, как это делается.
Однако перед тем, как мы рассмотрим процесс конвертации типов данных, давайте рассмотрим, какие типы данных есть в Go.
Типы данных Go
В Go существует несколько основных типов данных. Вот некоторые из них:
|
Тип |
Описание |
Пример |
|---|---|---|
|
int (integer) |
Целочисленный тип данных, который предназначен для хранения целых чисел. Он может хранить как положительные, так и отрицательные значения, включая ноль. |
var x int = 5 |
|
uint |
Представляет собой беззнаковый целочисленный тип данных. Он может хранить только положительные целые числа и ноль. |
var y uint = 10 |
|
uintptr |
Целочисленный тип данных, который используется для представления беззнакового целого числа достаточного размера для хранения указателей в памяти. |
var ptr uintptr value := 42 ptr = uintptr(unsafe.Pointer(&value)) |
|
float (float32, float64) |
Тип данных с плавающей точкой. Используется для представления чисел с плавающей точкой. |
var y float64 = 3.14 |
|
string |
Строковый тип данных, который предназначен для хранения последовательности символов (строк). |
var str string = "Hello, World! |
|
bool |
Логический тип данных, который может принимать значения true или false. |
var isTrue bool = true |
|
byte |
Тип данных, который предназначен для хранения байтов. Идентичен uint8. |
var b byte = 'A' |
|
rune |
Тип данных, который предназначен для хранения символов Unicode. Идентичен int32. |
var r rune = 'C' |
|
array |
Статический массив фиксированного размера, содержащий элементы одного типа. |
var arr [3]int = [3]int{1, 2, 3} |
|
slice |
Динамический массив, который может изменять свой размер. |
var s []int = []int{1, 2, 3} |
|
map |
Коллекция пары «ключ-значение», предназначенная для эффективного поиска по ключу. |
var m map[string]int = map[string]int{"one": 1, "two": 2} |
|
struct |
Пользовательский тип данных, объединяющий различные типы данных под одной структурой. |
type Person struct { Name string Age int } |
|
pointer |
Тип данных, который содержит адрес в памяти другого значения. |
var x int = 42 var ptr *int = &x |
|
interface |
Абстрактный тип данных, представляющий собой набор методов. Реализуется неявно. |
type Shape interface { Area() float64 } |
|
channel |
Тип данных для обмена данными между горутинами. |
ch := make(chan int) go func() { ch <- 42 }() value := <-ch |
Это основные типы данных в Go. Каждый из них предназначен для решения определенных задач и имеет свои уникальные свойства и применения в программировании. Разработчики могут создавать собственные типы данных с использованием структур и интерфейсов.
Типы данных «int», «uint» и «uintptr» в Go имеют ширину в 32 бита на 32-битных системах и 64 бита на 64-битных системах. Когда вам нужно использовать целочисленное значение, мы рекомендуем использовать «int», если нет конкретной причины выбирать размерный или беззнаковый целочисленный тип.
В Go отсутствует отдельный тип данных «char». Вместо него для представления символов используются «byte» и «rune». Тип «byte» используется для представления символов ASCII, а тип «rune» – для более широкого набора символов Unicode, закодированных в формате UTF-8.
Для определения символов в Go используются одинарные кавычки, например: 'a'. По умолчанию типом данных для символьных значений является «rune».
Если тип не указан явно при объявлении переменной с символьным значением, язык Go автоматически определит тип как «rune»:
var firstLetter = 'A'
Вы также можете явно указать тип переменной «byte»:
var lastLetter byte = 'Z'
Оба типа, – и «byte», и «rune», – это целые числа. Например, «byte» с символом 'X' преобразуется в целое число 88. Аналогично, «rune» с символом Unicode '★' преобразуется в соответствующую кодовую точку Юникода U+2605. Здесь U+ обозначает Юникод, а числа представлены в шестнадцатеричной системе, что, по сути, и есть целые числа.
package main
import "fmt"
func main() {
var myByte byte = 'X'
var myRune rune = '★'
fmt.Printf("%c = %d and %c = U+%04X\n", myByte, myByte, myRune, myRune)
}
Вывод:
х = 88 and ★= U+2605
Когда вам требуется выполнить преобразование между типами данных «int» и «string» в языке программирования Go (Golang), значит, вам необходимо изменить тип переменной с одного на другой. Преобразование числа в строку или строки в число подразумевает взятие изначально заданного типа переменной и приведение его к другому типу.
Важно! В Go эти операции строго формализованы и требуют явного указания типа.
Приведенные в статье примеры помогут вам освоить основы таких преобразований и объяснят, как выполнять эти операции в рамках синтаксиса Go.
Преобразование чисел
В языке программирования Go преобразование чисел – это операция изменения значения переменной из одного числового типа в другой.
Преобразование (или конвертирование) необходима, например, когда вы хотите выполнить операции между значениями разных типов или когда требуется совместное использование переменных различных типов в выражениях.
Вот несколько примеров преобразования чисел:
package main
import "fmt"
func main() {
var integerNumber int = 77
var floatNumber float64 = float64(integerNumber)
fmt.Printf("Integer: %d, Float: %f\n", integerNumber, floatNumber)
}
Вывод:
Integer: 77, Float: 77.000000
package main
import "fmt"
func main() {
var floatNumber float64 = 73.8
var integerNumber int = int(floatNumber)
fmt.Printf("Float: %f, Integer: %d\n", floatNumber, integerNumber)
}
Вывод:
Float: 73.800000, Integer: 73
package main
import (
"fmt"
"strconv"
)
func main() {
// Число в строку
numberAsString := strconv.Itoa(42)
fmt.Printf("Number as string: %s\n", numberAsString)
// Строка в число
stringNumber := "123"
number, err := strconv.Atoi(stringNumber)
if err == nil {
fmt.Printf("String as number: %d\n", number)
} else {
fmt.Println("Error converting string to number")
}
}
Вывод:
Number as string: 42
String as number: 123
В Go можно преобразовывать числа в строки с использованием метода «strconv.Itoa», который входит в состав стандартной библиотеки языка в пакете «strconv».
Пример кода:
package main
import (
"fmt"
"strconv"
)
func main() {
a := strconv.Itoa(99)
fmt.Printf("%q\n", a)
}
Результат выполнения этого кода – строка "99". Кавычки в выводе указывают на то, что это уже не число:
Вы воспользовались оператором `:=` для объявления новой переменной с именем `a` и присвоения ей значения, возвращаемого функцией «strconv.Itoa()». Так, вы установили значение переменной `a` в «99». Кроме того, вы использовали `%q` в функции «fmt.Printf», чтобы функция процитировала предоставленную строку.
Используя переменные, вы поймете удобство преобразования целых чисел в строки. Допустим, вы хотите отслеживать ежедневный прогресс пользователя в программировании и фиксировать, сколько строк кода он написал на данный момент.
На практике такие преобразования часто применяются для отображения полезной информации пользователям. Например, при разработке интернет-магазина, где пользователи могут видеть свои расходы.
Однако, если вам нужно объединить строки и числа, то в Go необходимо явно конвертировать числовые значения в строки, чтобы избежать ошибок.
Например:
package main
import (
"fmt"
"strconv"
)
func main() {
user := "Анна"
sum := 150
fmt.Println("Вау! " + user + "! Вы потратили на нашей платформе уже " + strconv.Itoa(sum) + " рублей.")
}
Вывод:
Вау! Анна! Вы потратили на нашей платформе уже 150 рублей.
Здесь преобразование переменной «sum» в строку выполняется с помощью «strconv.Itoa», что позволяет избежать ошибок при связывании строки и числа.
Если нужно отобразить точную сумму с дробной частью, то лучше использовать метод «fmt.Sprint» для преобразования числа с плавающей точкой в строку.
Например:
package main
import "fmt"
func main() {
f := 789.12
fmt.Println("Анна потратила " + fmt.Sprint(f) + " рублей.")
}
Теперь программа сообщит, что «Анна потратила 789.12 рублей»:
В Go при делении целочисленных типов результат также будет представлен целым числом, и любая десятичная часть, или остаток, будет отброшена:
package main
import "fmt"
func main() {
a := 10 / 3
fmt.Println(a)
}
Вывод:
3
Здесь переменная `a` содержит результат деления 10 на 3, и так как это целочисленное деление, остается только целая часть, то есть 3.
Если при делении мы используем числовые типы с плавающей точкой, тогда и все остальные операнды будут автоматически преобразованы в числа с плавающей точкой:
package main
import "fmt"
func main() {
b := 7.5 / 2
fmt.Println(b)
}
Вывод:
3.75
В этом случае число с плавающей точкой 7.5 делится на целое число 2. Результат «3.75» представляет собой число с плавающей точкой, которое сохраняет десятичную часть деления.
Таким образом, мы видим, что при делении с использованием числовых типов в Go результат зависит от типов операндов. Более того, приведение типов для чисел с плавающей точкой происходит автоматически, если один из операндов такой же.
Строки в языке программирования Go хранятся в виде срезов байтов. В Go можно осуществлять преобразование между строками и срезами байтов, используя соответствующие преобразования «[]byte()» и «string()»:
package main
import (
"fmt"
)
func main() {
originalString := "Моя строка"
byteSlice := []byte(originalString)
convertedString := string(byteSlice)
fmt.Println(originalString)
fmt.Println(byteSlice)
fmt.Println(convertedString)
}
Здесь строковое значение сохранено в переменной «originalString», затем оно преобразовано в срез байтов «byteSlice», и после этого срез байтов успешно восстановлен в строку под именем «convertedString». Затем выводятся значения «originalString», «byteSlice» и «convertedString»:
Моя строка
[208 188 208 186 209 130 208 176 32 209 129 209 130 208 176]
Моя строка
Где:
- Первая строка вывода представляет собой исходную строку «Моя строка».
- Вторая строка вывода – это срез байтов, из которых состоит исходная строка.
- Третья строка демонстрирует, что срез байтов может быть успешно преобразован обратно в строку и выведен на экран.
Такие базовые операции помогают избежать ошибок при работе с данными в Go.
Заключение
В этом руководстве по Go мы продемонстрировали, как осуществить преобразование различных типов данных.
Возможность преобразовывать типы данных в Go предоставляет функциональность для выполнения различных операций: например, для обработки ввода пользователя и выполнения математических операций с различными числовыми типами.
В будущем, при написании программ на Go, которые взаимодействуют с данными из разных источников, вы сможете применять эти методы преобразования для корректного выполнения операций с вашими данными.