Go Series Part 7: Conversion in Go - Examples

Introduction

Conversion is a crucial concept in any programming language, including Go. It allows you to change the type of a variable to another type, which can be essential for various operations such as mathematical calculations, string manipulations, and interoperability between different data types. Understanding how to perform conversions effectively ensures that your code is more flexible and less prone to errors.

Why Conversion is Important

1. Type Safety: Go is a statically-typed language, which means that the type of a variable is known at compile time. Conversion ensures that operations between different types are performed correctly, preventing type-related errors.

2. Interoperability: Sometimes you need to work with different types together. For instance, converting an integer to a float for division or converting a number to a string for display purposes.

3. Memory Efficiency: Converting data types appropriately can help manage memory usage more efficiently, especially when dealing with large datasets.

Step-by-Step Guide with Examples

Example 1: Integer to Float Conversion

package main

import (
    "fmt"
)

func main() {
    var intVar int = 42
    var floatVar float64

    // Conversion
    floatVar = float64(intVar)

    fmt.Printf("Integer: %d, Float: %f\n", intVar, floatVar)
}

Output:

Integer: 42, Float: 42.000000

Explanation:

• We declare an integer variable intVar with a value of 42.

• We declare a float variable floatVar.

• We convert intVar to float64 using float64(intVar) and assign it to floatVar.

• Finally, we print both the integer and the float values.

Example 2: Float to Integer Conversion

package main

import (
    "fmt"
)

func main() {
    var floatVar float64 = 42.89
    var intVar int

    // Conversion
    intVar = int(floatVar)

    fmt.Printf("Float: %f, Integer: %d\n", floatVar, intVar)
}

Output:

Float: 42.890000, Integer: 42

Explanation:

• We declare a float variable floatVar with a value of 42.89.

• We declare an integer variable intVar.

• We convert floatVar to int using int(floatVar) and assign it to intVar.

• Finally, we print both the float and the integer values.

Note that converting a float to an integer truncates the decimal part.

Example 3: String to Integer Conversion

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var strVar string = "123"
    var intVar int
    var err error

    // Conversion
    intVar, err = strconv.Atoi(strVar)
    if err != nil {
        fmt.Println("Conversion error:", err)
    } else {
        fmt.Printf("String: %s, Integer: %d\n", strVar, intVar)
    }
}

Output:

String: 123, Integer: 123

Explanation:

• We declare a string variable strVar with a value of "123".

• We declare an integer variable intVar and an error variable err.

• We use strconv.Atoi to convert the string to an integer. If the conversion fails, err will hold the error.

• We check for errors and print the results if the conversion is successful.

Example 4: Integer to String Conversion

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var intVar int = 123
    var strVar string

    // Conversion
    strVar = strconv.Itoa(intVar)

    fmt.Printf("Integer: %d, String: %s\n", intVar, strVar)
}

Output:

Integer: 123, String: 123

Explanation:

• We declare an integer variable intVar with a value of 123.

• We declare a string variable strVar.

• We use strconv.Itoa to convert the integer to a string.

• Finally, we print both the integer and the string values.

Example 5: User Input Conversion

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
    "strings"
)

func main() {
    fmt.Println("Let's learn about conversion in Golang")
    fmt.Println("What is your age?")

    reader := bufio.NewReader(os.Stdin)

    input, _ := reader.ReadString('\n')

    fmt.Println("Your age is", input)

    addedAge, err := strconv.ParseFloat(strings.TrimSpace(input), 64)

    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println("Added 1 to your age:", addedAge+1)
    }
}

Output:

Let's learn about conversion in Golang
What is your age?
30
Your age is 30
Added 1 to your age: 31

Explanation:

• We prompt the user to enter their age.

• We read the input using bufio.NewReader and ReadString.

• We print the inputted age.

• We convert the input string to a float using strconv.ParseFloat after trimming any whitespace with strings.TrimSpace.

• If the conversion is successful, we add 1 to the age and print the result.

Conclusion

Conversions in Go are straightforward but essential for writing flexible and robust programs. By understanding and utilizing type conversion, you can ensure that your programs handle data correctly and efficiently. The examples provided cover basic conversions between common data types, which form the foundation for more complex operations in Go.

In the next part of our series, we will delve into more advanced topics, enhancing your Go programming skills further. Stay tuned!