Understanding All Data Types in Golang: A Complete Guide

Data types help a programming language understand the type of data it works with. Golang has different built-in data types to handle different types of information.

When you use appropriate data types for your variables or functions, the compiler will be able to optimize your application properly. This will also increase performance.

In this guide, we will take you on a journey through the various data types in Golang, including numeric types, strings, boolean, aggregates like arrays and maps, and more.

You'll have a deep understanding of Golang's type system and in which situation you should use which data type to create powerful and flexible applications.

Different Types of Data in Golang

Golang provides multiple data types for different types of data. Some data types also have multiple variants. Each variant can hold different sizes of data and therefore also take various amounts of memory space.

Golang data types can be divided into these groups:

• Numeric Data Types – Include integers (real numbers without a fractional component), floating-point numbers, and complex numbers.
• String Data Type – Represents a sequence of characters. It is used to store and manipulate textual data.
• Boolean Data Type – Represents logical values and can have two possible values: true or false.

Let's learn more about these groups and their data types in detail with examples.

Also Read: Golang Variable - Different Ways to Create Variables in Golang

Numeric Data Types

In Golang, we use numeric data types for numbers. When you declare a variable and set its type as an int, this means you can only store numbers in that variable.

Golang offers a rich set of numeric types to fulfill different needs. We can divide numeric data types into 3 groups: integer, float, and complex types.

Integer Type

Integers are whole numbers without a fractional component. Golang provides both signed and unsigned integer types, with varying sizes and ranges.

Signed integers can represent both positive and negative numbers. On the other hand, unsigned integers can only represent non-negative numbers (zero and positive values).

For an integer type, you can use the following keywords:

• Signed integer: int8, int16, int32, int64
• Unsigned integer: uint8, uint16, uint32, uint64

As you can see, there are many keywords to represent integer types. To use them properly, it is important to know their differences.

Signed Integer Types:

• int8 – Signed 8 bits integer. It can hold numbers from -128 to 127.
• int16 – Signed 16 bits integer. It can hold numbers from -32,768 to 32,767.
• int32 – Signed 32 bits integer. It can hold numbers from -2,147,483,648 to 2,147,483,647.
• int64 – Signed 64 bits integer. It can hold numbers from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.

Unsigned Integer Types:

• uint8 – Unsigned 8 bits integer. It can hold numbers from 0 to 255.
• uint16 – Unsigned 16 bits integer. It can hold numbers from 0 to 65,535.
• uint32 – Unsigned 32 bits integer. It can hold numbers from 0 to 4,294,967,295.
• uint64 – Unsigned 64 bits integer. It can hold numbers from 0 to 18,446,744,073,709,551,615.

All of them can hold whole numbers but they are different in range. More bits can store bigger numbers and also take up more memory space.

          // Signed integers
var a int32 = 1439
var b int64 = -492874

// Unsigned integers
var x uint32 = 4293
var y uint64 = 4294967
        

Therefore, you can use these specific integer types if you want to optimize the memory consumption of your application. Otherwise, simply use int or uint as the integer type.

These int and uint types are machine-dependent. If you are using a 32-bit CPU in your computer, they will represent int32 and uint32. But if you have a 64-bit CPU in your computer, they will behave like int64 and uint64.

          // Default type of this "age" variable will be int
var age = 26
        

If you initialize a variable with a number without setting the type, it will be int by default.

Float Type

Floating-point numbers represent real numbers with a fractional component. It represents both positive and negative numbers.

Golang provides two float types: float32 and float64

The choice between these types depends on the required precision and range of values. The float32 is a single-precision floating-point number, while float64 is a double-precision floating-point number.

          var a float32 = -53.45
var b float64 = 540432.49342
        

The choice between float32 and float64 depends on the specific needs of your application. Here are some considerations:

• Precision: float64 provides a higher precision than float32 due to its larger size. If your calculations require more accurate results with a higher number of decimal places, float64 is the recommended choice.
• Range: float64 also has a wider range, allowing you to represent larger or smaller values without losing precision. If you need to handle extremely large or small numbers, float64 is more suitable.
• Memory: float32 consumes less memory than float64 since it has a smaller size. If memory usage is a concern, or if you're working with a large number of floating-point values, float32 can be more efficient.

          var price = 37.99
        

When you don't set the type of a floating-point number, Golang will consider it as a float64 type by default.

Complex Type

In Golang, the complex type is used to represent complex numbers, which consist of a real part and an imaginary part. The complex type in Golang includes two sizes: complex64 and complex128

The complex64 is a single-precision number and complex128 is a double-precision number. If you don't specify the type of a complex variable, it will be complex128 by default.

To create a complex number in Golang, you can use the complex function or directly assign values to the complex variable. We separate the real part and imaginary part are separated by the + or - sign, followed by the i (imaginary unit).

          package main

import "fmt"

func main() {
	// complex number with real part 2 and imaginary part 3
	var z1 complex128 = complex(2, 3)

	// shorthand declaration of a complex number
	z2 := 1 + 2i

	// Performing arithmetic operations on complex numbers
	sum := z1 + z2
	difference := z1 - z2
	product := z1 * z2
	quotient := z1 / z2

	// Printing the results
	fmt.Println("Sum:", sum)
	fmt.Println("Difference:", difference)
	fmt.Println("Multiplication:", product)
	fmt.Println("Division:", quotient)
}
        

Output:

          Sum: (3+5i)
Difference: (1+1i)
Multiplication: (-4+7i)
Division: (1.6-0.2i)
        

In the example, we create two complex numbers, z1 and z2, using different syntaxes. We then perform various arithmetic operations like addition, subtraction, multiplication, and division on these complex numbers.

Complex numbers are useful in mathematical and scientific computations that involve real and imaginary components.

String Data Type

We use the string data type is used to represent a sequence of characters. You need to use double quotes ("") or backticks (``) to create strings. For example, "Hello World"

          var title string

title = "Learn Golang"
        

Boolean Data Type

The boolean data type is a fundamental type that represents logical values. We use the boolean values in conditional statements, logical operations, and decision-making within Golang programs.

It can have two possible values: true or false. To declare boolean data types, you have to use the bool keyword in Golang.

          package main

import "fmt"

func main() {
	// Declaring boolean variables
	var isPresent bool

	isPresent = true

	// Conditional statements
	if isPresent {
		fmt.Println("It is present!")
	} else {
		fmt.Println("It isn't present!")
	}
}
        

Also Read: Mastering Constant in Golang: Declare and Use It Like a Pro