DEV Community: Frihk Ian

Structs in Go

Frihk Ian — Thu, 04 Jun 2026 07:24:29 +0000

Let's explore structs in Go. If you know Go's basic types like string, int, and bool, structs let you handle more complex data.
Say you're building a store app. You need a product's name, price, and in-stock status. Using separate variables quickly becomes messy.
Structs can simplify this. Picture structures are like a blueprint. It makes it possible to package all the related information in one neat and organized bundle.
Now let's dive into creating and using custom data types in Go.

Declaring Structs

Before using a struct, we first need to describe what it looks like. The result of defining a struct is not a piece of data, but the blueprint of data we want to store later on.
Let's take a look at the declaration of the Product struct:

package main

import "fmt"

// We use the 'type' keyword to define a new custom type.
// We name our type 'Product' and specify that it is a 'struct'.
type Product struct {
   Name    string  // Field for the product's name
   Price   float64 // Field for the price
   InStock bool    // Field to check if it's available
}

Creating Struct Instances

Using the struct we just created, let's create a product. Using the struct blueprint to create a piece of data is referred to as creating an instance.

package main

import "fmt"

type Product struct {
   Name    string
   Price   float64
   InStock bool
}

func main() {
   // Creating an instance of Product using a "struct literal."
   item1 := Product{
       Name:    "Wireless Mouse",
       Price:   25.99,
       InStock: true,
   }

   // Creating an instance but leaving fields blank
   item2 := Product{
       Name: "Mousepad",
   }

   fmt.Println(item1)
   fmt.Println(item2)
}

Expected Output:

{Wireless Mouse 25.99 true}
{Mousepad 0 false}

You might be thinking Why does item2 show 0 and false when we didn’t set them?
This is one of Go’s most important behaviours: zero values. In Go, when you declare a variable but don’t give it a value, Go doesn’t leave it empty or undefined (which causes bugs in many other languages). Instead, Go automatically fills it with the zero value for that type.
Since we gave item2 a name, Go automatically sets the price to 0 and in stock to false . This is one of the features in Go that make it exceptional.
Accessing and Modifying Fields
When you want to modify or read information from a struct, you use a dot notation. Consider the dot to be opening up a particular drawer of your filing cabinet to view a folder.

package main

import "fmt"

type Product struct {
   Name    string
   Price   float64
   InStock bool
}

func main() {
   item := Product{
       Name:    "Keyboard",
       Price:   45.00,
       InStock: true,
   }

   // Reading a field
   fmt.Println("Original Price:", item.Price)

   // Modifying a field
   item.Price = 39.99

   fmt.Println("Discounted Price:", item.Price)
}

Expected Output:

Original Price: 45
Discounted Price: 39.99

Anonymous Structs

Sometimes we want to bundle up some information for one-time use. In such a case, we don’t want to have to go through the trouble of formally defining a whole blueprint. They are particularly useful when holding configuration settings, grouping test inputs, or temporarily organising data for a single function. We use anonymous structs in this way:

package main

import "fmt"

func main() {
   // Declaring and initializing a struct at the exact same time
   config := struct {
       Port string
       Env  string
   }{
       Port: "8080",
       Env:  "Production",
   }

   fmt.Println("Running on port:", config.Port)
}

Expected Output:

Running on port: 8080

This is a little confusing, if you are new to Go, because you create the blueprint, then use it to create an instance. Let's look at the code snippet again.

  config := struct { <- this is the blueprint opening brace
       Port string
       Env  string
   }{   <- this is the closing brace for the blueprint, followed by an opening brace.
       Port: "8080",
       Env:  "Production",
   }   <- this is the closing

Think of this like defining a shape, then filling it. Keep in mind that this is a non-reusable type.

Nested (Embedded) Structs

Unlike other programming languages, Go has no “classes” or “inheritance”. Instead, Go employs a technique of packing smaller structs into larger structs, similar to Russian nesting dolls.

package main

import "fmt"

// The smaller struct
type Address struct {
   City    string
   Country string
}

// The larger struct
type User struct {
   Name    string
   Contact Address // Embedding the Address struct here
}

func main() {
   player := User{
       Name: "Alice",
       Contact: Address{
           City:    "Nairobi",
           Country: "Kenya",
       },
   }

   // Accessing the nested data
   fmt.Println(player.Name, "lives in", player.Contact.City)
}

Expected Output:

Alice lives in Nairobi.

Struct Comparison

A question might pop into your brain asking, “Are you able to compare two structs to determine whether they are equal or not?” Yes! Go supports the normal == operator, but only if all the fields within the struct are comparable.

package main

import "fmt"

type Product struct {
   Name  string
   Price float64
}

func main() {
   item1 := Product{Name: "Mug", Price: 12.50}
   item2 := Product{Name: "Mug", Price: 12.50}
   item3 := Product{Name: "Mug", Price: 15.00}

   fmt.Println("Are item1 and item2 identical?", item1 == item2)
   fmt.Println("Are item1 and item3 identical?", item1 == item3)
}

Expected Output:

Are item1 and item2 identical? true
Are item1 and item3 identical? false

Go looks at every single field. If everything matches perfectly, the structs are considered equal.

The Photocopy vs. The Original

This is the most essential concept for beginners in Go. Go’s default behavior is to send a struct by value into a function.
If you were to give a friend a copy of your notes, how would they look? If they add a mustache to the photocopied version, you are fine! This is the default behavior of Go. To change an original struct, the function has to be passed a pointer to it (that is, the original notebook).
Let’s observe both of them together:

package main

import "fmt"

type Product struct {
   Name  string
   Price float64
}

// Pass by Value (The Photocopy)
func failedDiscount(p Product) {
   p.Price = p.Price - 5.00
}

// Pass by Pointer (The Original)
func successfulDiscount(p *Product) {
   p.Price = p.Price - 5.00
}

func main() {
   item := Product{Name: "Book", Price: 20.00}

   failedDiscount(item) // Trying to discount the photocopy
   fmt.Println("After failed discount:", item.Price)

   successfulDiscount(&item) // Giving the function the original via '&'
   fmt.Println("After successful discount:", item.Price)
}

Expected Output:

After failed discount: 20
After successful discount: 15

Best Practices & Common Beginner Mistakes

In Go, names of fields that begin with a capital letter are “exported” and available to other packages (as opposed to names that start with a lowercase letter, which are “private”). If it begins with a lower-case letter (e.g., name), it belongs only to the package it is in. If in any doubt, make them capitalized so that you can use them freely.
Pointers for Modification: Keep in mind the photocopy rule. If your function will call to change or update a struct, then you must pass a pointer (*).

Summary & Your Mini-Challenge

You’ve made it! You’ve learned to structure unsorted variables into orderly, sensible structures. You know how to construct blueprints, make instances, navigate nested data, and update nested data correctly with pointers.

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
structs

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.