DEV Community: Frihk Ian

Data Types In Go

Frihk Ian — Tue, 14 Apr 2026 08:23:50 +0000

This is the first in a series of articles exploring data types in Go. The main goal of this series of articles is to provide detailed explanations and practical examples to help you build a clear and strong understanding of the different data types in Go. All the topics will be subdivided into manageable sections, each focusing on a specific aspect of data types, to facilitate gradual learning.

There are many different data types in Go:
The two main data types include:

1. Basic(primitive) Types

This type of data is made up of :

Numbers(int, float64)
Strings(string)
Boolean(bool)
Composite Types

2. Composite Types

These include

Arrays
Slices
Maps
Structs

Other Important Types

These are other very powerful and commonly used data types.

Function types (functions are treated as values)
Pointer Types (used to work with memory)
Interfaces Types(used to define a certain behavior and simplifying flexibility)

In this article, I will focus on basic data types, as they are fundamental to understanding Go and provide a solid foundation for more complex types. While the other types, such as composite, are not necessarily difficult, they involve broader concepts and all depend on the basic types. For a better understanding of each, I cover each in greater depth in separate, dedicated articles.

Basic(primitive) Types

Let's delve directly into the details:

Numbers.

Numbers are divided into :

Integers

These are whole numbers. In Go, we use them in two main ways :
Int - This is the most commonly used, including both positive and negative whole numbers.
Uint - Used to represent only positive whole numbers.

Floating-point

These are real numbers (numbers with decimal points). They include both positive and negative numbers.

var age int = 25 // 25 is an integer 
var height float32 = 186.8 // 186.8 is a float

In Go, Floating-point can either be float32 or float64. The choice lies in the level of precision you need.

Strings

In Go, strings are immutable sequences of UTF-8 encoded bytes, meaning once created, they cannot be altered, which ensures data integrity and consistency.

Immutability

Once a string is created, it cannot be changed. Any attempt to change it creates a new string.

Indexing

The individual bytes can be accessed with a given index:

s := "Hello"
fmt.Println(s[0]) // 72 (byte value of 'H')

This will print 72 as the strings store bytes and H is equal to the ASCII (byte) code of 72.

Length

The number of bytes, not characters, is returned by the len() function:

fmt.Println(len("Hello")) // 5

Unicode and Runes

As the strings are UTF-8, some characters can occupy more than one byte. to act on characters (runes), use:

for _, r := range "Hello" {
    fmt.Println(r)
}

output
72 101 108 108 111

String Concatenation

The + operator can be used to add strings:

full := "Hello " + "World"  // Hello World

To Byte Slice.
You can convert a string to a slice of bytes:

b := []byte("Hello")

Boolean

In Go, boolean values represent truth values; they can only be written as either true or false. They are used mostly for comparison purposes and control a program flow in if, for, or switch statements. In Go, by default, an uninitialized boolean has the value false, making it predictable and easy to work with in decision-making logic.

The section has links to the data types used so far. A link to the next article will be added once it’s ready. When a link is not given on a given type of data, simply means that it is still in the process and it will be given shortly.
Maps

Additional learning materials.
Go Documentation
W3schools

Maps in Golang

Frihk Ian — Tue, 10 Mar 2026 07:23:29 +0000

Maps are one of the most flexible data types in Go. It might even be the most flexible compared to maps from other programming languages. And just as flexible as they are , they are also as simple to initialize.

Understanding Map Structure
A map in Go is composed of two main parts: the key and the value. The key is defined as a unique label used to store and find a specific
Maps are one of the main data structures in Go. Maps have two main parts : the key and the value. The key is like a word you are looking up in a dictionary. It is a unique label that stores and carries a specific type of data. Whilst the value is like the definition of the word you are looking up in a dictionary, it is the data that is stored in the key value. Unlike keys, which only accept comparable types, the value can be of any legal Go type.

In Go, there are two main ways to initialize maps. The first uses the Go built-in make function:

m := make(map[string]int)

The second one uses a map literal:

m := map[string]int{}

They initialize an empty map that takes in a string as the key and an integer as the value. The make method is more flexible because it allows you to specify an initial capacity. When the expected size is known, this preallocation can reduce map growth and rehashing during execution.

Accessing Values and Handling Missing Keys
Reading from a map in Go is quite simple. You access a value by indexing the map with its key, as shown below:
age := m["John"]
Sometimes you might call a key that is not in the map; this happens as a result of misspelling or during testing. Go does not display any error, nor does it crash. It instead displays the zero value of the map's value type.

package main

import "fmt"

func main() {
    m := make(map[string]int)
    value := m["missing_key"] // value is 0
    fmt.Print(value)
}

The program above displays:

0

The “Comma ok” Idiom
This can be misleading; if a key has a value of zero, it becomes difficult to know whether the key has a zero value or its value is a zero. Go handles this by introducing the “ok” to help solve this error. This helps distinguish the erroneous value and the correct value.

value, ok := m["missing_key"]
if !ok {
Return “Error” // The key does not exist in the map
}

Here, the value is the data in the map value. Whilst the “ok” is a boolean that is true. If the value exist then the ok becomes true, and the program executes without any error. If it does not exist, then the program returns an “error.”

Inserting and Updating Data
In Go, the syntax for inserting, updating, or deleting data in a map is consistent and straightforward. When adding/ updating a key, you simply assign a value; the method is pretty much the same as shown below.

m := make(map[string]int)

// Insert: Key "Alice" does not exist, so it is created.
m["Alice"] = 25 

// Update: Key "Alice" already exists, so its value is overwritten.
m["Alice"] = 26

Deleting Elements
When deleting from a map, we use the Go built-in function delete(). It removes the key and everything associated with it. Below is its syntax:

m := map[string]int{"Alice": 25, "Bob": 30}

// Removes "Alice" from the map
delete(m, "Alice")

The delete function has a safety feature that makes it very safe to work with. In case of deletion of something that is not in the map, it simply does nothing.

Iterating Over Maps
Now that you know how to add and remove individual items, you’ll likely want to loop through the entire collection. In Go, we use the range keyword to iterate over a map.

m := map[string]int{“Alice”: 25, “Bob”: 30, “Charlie”: 35}

for key, value := range m {
fmt.Printf(“Key: %s, Value: %d\n”, key, value)
}

Something to keep in mind when it comes to maps is that they are “commitment-phobic” when it comes to order. Unlike arrays or slices, they do not have a specified order during iteration. If you run the code above three times, chances are that you might get three different sequences. If you need a consistent order, you’ll have to sort the keys manually in a separate slice first.

Maps as Reference Types
The most significant points to keep in mind are that maps are a type of reference. Passing a map to a function does not give a copy of the data, but the pointer to the underlying data structure.
This implies that when you make changes to a map within a function, the changes will be carried over to the original map.

func updateAge(m map[string]int) {
m[“Alice”] = 30 // This changes the original map!
}

Map Performance and Concurrency
Maps are incredibly fast, offering O(1) average time complexity for searches, additions, and deletions. Maps are extremely quick with an average time complexity of O(1) for searches, add, and delete. There is, however, a kind of safety limit that they have: Maps are not thread-safe.
If two different goroutines try to write to the same map at the same time, your program will crash with a fatal error: concurrent map writes

Feature 
Behavior in Golang Maps
Search Speed
Extremely fast (Constant time)
Iteration Order
Random/Unordered
Thread Safety
None (Requires sync.Mutex or sync.Map)
Zero Value
nil (A nil map can be read, but writing to it causes a panic)

Conclusion
Maps are the go-to tool in Go when you need a fast, associative data structure. By mastering the make function, the “comma ok” idiom, and understanding the nuances of iteration and reference types, you can handle complex data relationships with very little code.

Go templates

Frihk Ian — Wed, 11 Feb 2026 12:23:08 +0000

The first thing to handle is answering the question, "what are Go templates?" Go templates are a way to create dynamic content in Go by allowing the user to mix data with plain text or HTML files with data received from the Go code. This makes it possible to change the data in a template very easily, as it can be edited with ease. They are mainly used in web dev to create web pages that rely on user inputs or content from a database.
A template is just a file that has placeholders for data. In Go, placeholders are written using double curly braces {{ }}. These curly braces can hold a user’s data, and this can be shown by {{ .name }}. The dot refers to the data object you refer to from Go. When the template is running, Go replaces the {{ .name }} with the actual user name from the user's input or the database.
To use templates in Go, a data structure that can help you hold the data to show, usually a map or a struct, is required.

type PageData struct {
    Title   string
    Message string
}

Then you parse the template file in your Go code and execute it with your data. The template system will automatically replace all placeholders with the correct values. This keeps your HTML or text separate from your Go code, making your program cleaner and easier to maintain.
A good example of template file is as shown below

<!DOCTYPE html>
<html>
<head>
    <title>{{ .Title }}</title>
</head>
<body>
    <h1>{{ .Title }}</h1>
    <p>{{ .Message }}</p>

    {{ if .IsLogged }}
        <p>Welcome back, {{ .User }}! </p>
    {{ else }}
        <p>Please login to continue. </p>
    {{ end }}

    <h2>Your Tasks:</h2>
    <ul>
        {{ range .Tasks }}
            <li>{{ . }}</li>
        {{ else }}
            <li>No tasks available.</li>
        {{ end }}
    </ul>
</body>
</html>

Go templates also support basic logic. This helps to manipulate the values to be displayed. You can display certain things if a certain condition is met. You can also range over maps, structs, among others. For example, you can display a specific message to only logged-in users, you can list all the content of a check list from a shopping list among many others. You can also use functions like len to make the content more flexible.
Below is an example of Go code that displays its output to the HTML file above.

package main

import (
    "html/template"
    "net/http"
)

type PageData struct {
    Title    string
    Message  string
    IsLogged bool
    User     string
    Tasks    []string
}

func handler(w http.ResponseWriter, r *http.Request) {
    data := PageData{
        Title:    "Go Templates Advanced Example",
        Message:  "Using conditions and loops in templates",
        IsLogged: true,
        User:     "Ian",
        Tasks:    []string{"Learn Go templates", "Build a web app", "Practice Go daily"},
    }

    tmpl := template.Must(template.ParseFiles("index.html"))
    tmpl.Execute(w, data)
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

In summary, to generate a dynamic text or HTML in Go, the best option is the Go template. They help separate the design of your output from your code logic, allow you to reuse templates with different data, and make it easy to build web pages, reports, or any text-based content.