Understanding Data Types in Go Programming (Blog 4 of the Go Series)


5 min read

Understanding Data Types in Go Programming (Blog 4 of the Go Series)

Data types play a crucial role in programming by defining the nature of the data we work with. They provide essential information about how the data is stored, manipulated, and operated upon. In this blog, we'll explore the concept of data types, and their significance, and delve into memory allocation โ€“ an integral aspect of data management in programming. We'll also take a closer look at the various data types supported by the Go programming language.

What are Data Types and Why Are They Needed?

At its core, a data type is a classification that identifies the type of data a particular variable or value holds. Data types serve as a foundation for defining operations that can be performed on the data, conveying its meaning, and dictating its storage structure. In simpler terms, data types enable us to better manage and manipulate information within a program.

Common data types encompass integers, strings, booleans, floats, arrays, and slices, each with distinct attributes like size, value range, and permissible operations. These attributes ensure that data is appropriately handled and processed.

๐Ÿ“Œ What is Memory Allocation?

  • Memory allocation refers to the process of reserving a portion of memory for storing data.

  • When a variable is declared in a program, the system allocates a certain amount of memory to store the value of that variable.

  • The size of the memory block depends on the data type of the variable.

For example, if you declare an int variable, the system will allocate 4 bytes of memory to store the integer value. Similarly, if you declare a float32 variable, the system will allocate 4 bytes of memory to store the floating-point value.

It's important to note that the amount of memory required by different data types can vary between different computer architectures and operating systems. However, Go provides a standardized way of allocating memory to different data types on all platforms.

Data Types in Go

Go programming boasts a rich array of data types, encompassing numeric, boolean, and string types, along with composite types like arrays, slices, maps, and structures.

Numeric Types

The numeric spectrum in Go encompasses an assortment of types, from int and uint variations to float32, float64, complex64, and complex128. The 'uint' type, signifying an unsigned integer, is exclusively for non-negative values, including zero.

For instance:

// Declare variables with int type
var age int = 22

// Declare variables with float type
var pi float32 = 3.14

// Declare variables with complex type
var c complex64 = 2.3 + 2.4i

Boolean Types

The boolean type, 'bool,' is an integral part of Go, embodying only two possible values: true or false.

// Declare a boolean variable
var isValid bool = false

String Types

Strings, represented by 'string,' are well-supported in Go.

// Declare a string variable
var name string = "John"

Array Types

Arrays, denoted as [size]T, where 'size' signifies the array's length and 'T' denotes the element type, are another key feature of Go.

// Declare an array of type int
var numbers [3]int = [3]int{1, 2, 3}

An alternative syntax for array declaration uses ellipsis to allow Go to automatically determine the size:

marks := [...]float64{93, 86, 78.99, 87}

Slice Types

Go also embraces slices, defined as []T, where 'T' represents the element type.

// Declare a slice of type int
var numbers []int = []int{1, 2, 3}

Map Types

The Go language incorporates map types, specified as map[K]V, where 'K' stands for the key type, and 'V' stands for the value type.

// Declare a map of type int and string
var numbersMap map[int]string = make(map[int]string)
numbersMap[1] = "John"
numbersMap[2] = "Mary"

Struct Types

Structures, denoted by 'struct,' offer a way to organize related data within a program.

// Declare a struct of type Person
type Person struct {
    name string
    age  int

// Declare a variable of type Person
var john Person = Person{name: "John", age: 22}

All datatypes in one simple program

package main

import "fmt"

func main() {
    // bool
    var flag bool = true
    var zeroFlag bool
    fmt.Printf("bool: %v, zero value: %v\n", flag, zeroFlag)  //bool: true, zero value: false

    // numeric types
    var i8 int8 = -128
    var i16 int16 = -32768
    var i32 int32 = -2147483648
    var i64 int64 = -9223372036854775808
    var u8 uint8 = 255
    var u16 uint16 = 65535
    var u32 uint32 = 4294967295
    var u64 uint64 = 18446744073709551615
    var f32 float32 = 3.14
    var f64 float64 = 3.141592653589793
    var c64 complex64 = 1 + 2i
    var c128 complex128 = 3 + 4i

    fmt.Printf("int8: %v\n", i8)  //int8: -128
    fmt.Printf("int16: %v\n", i16) //int16: -32768
    fmt.Printf("int32: %v\n", i32) //int32: -2147483648
    fmt.Printf("int64: %v\n", i64)  //int64: -9223372036854775808
    fmt.Printf("uint8: %v\n", u8)  //uint8: 255
    fmt.Printf("uint16: %v\n", u16)  //uint16: 65535
    fmt.Printf("uint32: %v\n", u32)  //uint32: 4294967295
    fmt.Printf("uint64: %v\n", u64)  //uint64: 18446744073709551615
    fmt.Printf("float32: %v\n", f32)  //float32: 3.14
    fmt.Printf("float64: %v\n", f64)  //float64: 3.141592653589793
    fmt.Printf("complex64: %v\n", c64)  //complex64: (1+2i)
    fmt.Printf("complex128: %v\n", c128)  //complex128: (3+4i)

    // string
    var str string = "Hello, World!"
    var emptyStr string
    fmt.Printf("string: %v, zero value: %v\n", str, emptyStr)  //string: Hello, World!, zero value:

    // arrays
    var arr [3]int = [3]int{1, 2, 3}
    var zeroArr [3]int
    fmt.Printf("array: %v, zero value: %v\n", arr, zeroArr)  //array: [1 2 3], zero value: [0 0 0]

    // slices
    var slice []int = []int{1, 2, 3}
    var emptySlice []int
    fmt.Printf("slice: %v, zero value: %v\n", slice, emptySlice)  //slice: [1 2 3], zero value: []

    // maps
    var m map[string]int = map[string]int{"one": 1, "two": 2, "three": 3}
    var emptyMap map[string]int
    fmt.Printf("map: %v, zero value: %v\n", m, emptyMap)  //map: map[one:1 three:3 two:2], zero value: map[]

    // structs
    type person struct {
        name string
        age  int
    var p person = person{"John", 30}
    var emptyPerson person
    fmt.Printf("struct: %v, zero value: %v\n", p, emptyPerson)  //struct: {John 30}, zero value: { 0}


In conclusion, data types and memory allocation are foundational concepts in programming, facilitating efficient data handling and processing. Go programming provides a comprehensive range of data types, empowering developers to create robust and flexible applications that can effectively manage diverse data elements. By understanding these fundamental concepts, developers can harness the full potential of the Go language to build powerful and efficient software solutions.

Did you find this article valuable?

Support Chetan Thapliyal by becoming a sponsor. Any amount is appreciated!