• Типы данных Go
• Преобразование чисел
  • Изменение типа целого числа в число с плавающей точкой
  • Преобразование числа с плавающей точкой в целое число
  • Преобразование числа в строку и наоборот
  • Преобразование числа с помощью метода «strconv.Itoa»
  • Преобразование чисел с помощью деления
  • Преобразование строк и байтов

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

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

Однако перед тем, как мы рассмотрим процесс конвертации типов данных, давайте рассмотрим, какие типы данных есть в Go.

Типы данных Go

В Go существует несколько основных типов данных. Вот некоторые из них:

Это основные типы данных в 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 преобразование чисел – это операция изменения значения переменной из одного числового типа в другой.

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

Вот несколько примеров преобразования чисел:

1. Изменение типа целого числа в число с плавающей точкой:

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

2. Преобразоание числа с плавающей точкой в целое число:

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

3. Преобразование числа в строку и наоборот:

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

4. Преобразование числа с помощью метода «strconv.Itoa». 

В 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 рублей»:

5. Преобразование чисел с помощью деления

В 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 результат зависит от типов операндов. Более того, приведение типов для чисел с плавающей точкой происходит автоматически, если один из операндов такой же.

6. Преобразование строк и байтов

Строки в языке программирования 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, которые взаимодействуют с данными из разных источников, вы сможете применять эти методы преобразования для корректного выполнения операций с вашими данными.

​