Go on Nelson Figueroa https://nelson.cloud/categories/go/ Recent content in Go on Nelson Figueroa Nelson Figueroa https://nelson.cloud/opengraph-images/default.png https://nelson.cloud/opengraph-images/default.png en Sat, 28 Mar 2026 23:31:55 -0700 Adding Headers to HTTP Requests in Go https://nelson.cloud/adding-headers-to-http-requests-in-go/?ref=rss Fri, 30 Jan 2026 00:00:00 +0000 https://nelson.cloud/adding-headers-to-http-requests-in-go/?ref=rss Build requests with http.NewRequest() to add headers, then send them with http.Client{}Go has several ways of sending requests, including some convenient methods such as:

  • http.Get()
  • http.Head()
  • http.Post()
  • http.PostForm()

However, these don’t let you add headers to requests! If you need customization of the HTTP method or headers, you need to use http.NewRequest().

There are three parts to this:

  1. Create a request using http.NewRequest() where you specify the HTTP method and URL
  2. Add headers to the request with Header.Set()
  3. Send the request using http.Client{}

Here’s a full example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

package main

import (
	"log"
	"net/http"
)

func main() {
	// create the client that will send the request later
	client := &http.Client{}

	// create a request with NewRequest, specifying HTTP method and URL
	req, err := http.NewRequest("GET", "https://example.com/", nil)
	if err != nil {
		log.Fatal(err)
	}

	// add headers to the request
	req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0")
	req.Header.Set("Accept-Language", "en-US,en;q=0.9")
	req.Header.Set("Accept-Encoding", "gzip, deflate")
	req.Header.Set("Sec-GPC", "1")
	req.Header.Set("Connection", "keep-alive")

	// use the client to actually send the request
	resp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()
}

Note:

req.Header.Set() can be used to set a header but will overwrite any existing value for that header.

req.Header.Add() can be used to add a value to a header and will append to any existing value for that header.

For the purposes of this blog post we only need to worry about setting the header once, hence the usage of req.Header.Set().

Similar to my “Using time.Sleep() in Go” post, I wrote this up because the Go docs are too dense and I just needed one full example to understand it and get going.

References

]]> Using time.Sleep() in Go https://nelson.cloud/using-time.sleep-in-go/?ref=rss Thu, 29 Jan 2026 00:00:00 +0000 https://nelson.cloud/using-time.sleep-in-go/?ref=rss Examples of using time.Sleep() in Go because the official documentation is lacking.Basic Usage of time.Sleep()

You can use time.Sleep() to pause your program for a predetermined amount of time, similar to most programming languages.

First, you should know that the time package has useful constants that allow you to conveniently specify time in units.

1
2
3
4
5
6
7
8

const (
	Nanosecond  Duration = 1
	Microsecond          = 1000 * Nanosecond
	Millisecond          = 1000 * Microsecond
	Second               = 1000 * Millisecond
	Minute               = 60 * Second
	Hour                 = 60 * Minute
)

They’re accessed with the time.<Constant> notation. (e.g. time.Second)

You can use these constants with the time.Sleep() function. For example, if we want to pause execution for 1 second, we can write the following code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Println("one second will pass between this message...")
	time.Sleep(time.Second)
	fmt.Println("...and this message")
}

We can do some multiplication with time.Second to pause a program for 30 seconds:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Println("30 seconds will pass between this message...")
	time.Sleep(time.Second * 30)
	fmt.Println("...and this message")
}

You can do multiplication with all of the other constants mentioned as well.

Examples

Here are some more examples using the other constants.

Sleep for 500 milliseconds

1
2
3
4
5
6
7
8
9

package main

import (
	"time"
)

func main() {
	time.Sleep(time.Millisecond * 500)
}

Sleep for 10 seconds

1
2
3
4
5
6
7
8
9

package main

import (
	"time"
)

func main() {
	time.Sleep(time.Second * 10)
}

Sleep for 5 minutes

1
2
3
4
5
6
7
8
9

package main

import (
	"time"
)

func main() {
	time.Sleep(time.Minute * 5)
}

Sleep for 2 hours

Not really sure why you would use this, but just know it’s possible.

1
2
3
4
5
6
7
8
9

package main

import (
	"time"
)

func main() {
	time.Sleep(time.Hour * 2)
}

My main motivation for writing this is that I think the official documentation is way too dense and doesn’t show several examples of time.Sleep(). I just needed some examples to understand the syntax and move on with my day.

References

]]> Validate HTTP Status Codes in Go Using Built-in Constants https://nelson.cloud/validate-http-status-codes-in-go-using-built-in-constants/?ref=rss Sat, 24 May 2025 00:00:00 +0000 https://nelson.cloud/validate-http-status-codes-in-go-using-built-in-constants/?ref=rss Use Go net/http constants like StatusOK and StatusNotFound for more readable code.Constants to Use When Checking for HTTP Status Codes

Go has useful constants in the net/http package that can make your code more readable when checking for status codes in responses.

For example, instead of writing something like

1
2
3

if resp.StatusCode == 200 {
    // do something if the status code is 200
}

You can write

1
2
3

if resp.StatusCode == http.StatusOK {
    // do something if the status code is 200
}

Unfortunately the link doesn’t show any full, working examples. So here’s an example covering some of the more common http status codes that you can use and modify as needed.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

package main

import (
	"fmt"
	"log"
	"net/http"
)

func main() {
	resp, err := http.Get("https://example.com")
	if err != nil {
		log.Fatalf("error: %v", err)
	}

	defer resp.Body.Close()

	// Status code 200
	if resp.StatusCode == http.StatusOK {
		fmt.Println("ok!")
	}

	// Status code 301
	if resp.StatusCode == http.StatusMovedPermanently {
		fmt.Println("moved permanently")
	}

	// Status code 403
	if resp.StatusCode == http.StatusForbidden {
		fmt.Println("forbidden")
	}

	// Status code 404
	if resp.StatusCode == http.StatusNotFound {
		fmt.Println("not found")
	}

	// Status code 429
	if resp.StatusCode == http.StatusTooManyRequests {
		fmt.Println("too many requests")
	}

	// Status code 500
	if resp.StatusCode == http.StatusInternalServerError {
		fmt.Println("internal server error")
	}

	// Status code 502
	if resp.StatusCode == http.StatusBadGateway {
		fmt.Println("bad gateway")
	}
}

Turning HTTP Status Codes into Messages with http.StatusText()

There’s also a function http.StatusText() that allows you to pass in status codes and get a message for logging purposes or displaying to users. You can see all the responses in the source code here, it’s a bunch of case statements.

For example, let’s say we want to display a message if we don’t get a 200 status code. Instead of writing code to print out a different message depending on the status code value, we can use the http.StatusText() function:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

package main

import (
	"fmt"
	"log"
	"net/http"
)

func main() {
	resp, err := http.Get("https://example.com/404") // this URL returns a 404 status code
	if err != nil {
		log.Fatalf("error: %v", err)
	}

	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		// if it's not 200, print out a message depending on the status code
		fmt.Println(http.StatusText(resp.StatusCode)) // http.StatusText() is called here
	}
}

$ go run example.go

Not Found

Super convenient.

References

]]> Iterate Through Strings in Go with a for-range Loop https://nelson.cloud/iterate-through-strings-in-go-with-a-for-range-loop/?ref=rss Tue, 27 Aug 2024 00:00:00 +0000 https://nelson.cloud/iterate-through-strings-in-go-with-a-for-range-loop/?ref=rss You can use for-range loops to iterate through strings in Go without splitting because Go handles strings as byte slices.Today I learned you can use for...range loops in Go to iterate over a string. There is no need to split the string first like in other programming languages.

Here’s an example:

1
2
3
4
5
6
7
8
9

package main

import "fmt"

func main() {
	for i, v := range "testing" {
		fmt.Printf("index: %d, char: %c\n", i, v)
	}
}

This outputs:

index: 0, char: t
index: 1, char: e
index: 2, char: s
index: 3, char: t
index: 4, char: i
index: 5, char: n
index: 6, char: g

Without any formatting from fmt.Printf each character in the string is printed out in its Unicode form:

1
2
3
4
5
6
7
8
9

package main

import "fmt"

func main() {
	for _, v := range "testing" {
		fmt.Println(v)
	}
}

This outputs:

116
101
115
116
105
110
103

This is cleaner than looping through a string using a for loop without range:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

package main

import "fmt"

func main() {
	str := "testing"

	for i := 0; i < len(str); i++ {
		fmt.Printf("index: %d, char: %c\n", i, str[i])
	}
}

As a side note, strings in Go are basically slices of bytes. This is why we can iterate through them using range like we would a typical slice.

From https://go.dev/blog/strings:

Quote:

In Go, a string is in effect a read-only slice of bytes

References

]]> Insertion Order Iteration of Maps in Go https://nelson.cloud/insertion-order-iteration-of-maps-in-go/?ref=rss Tue, 23 Feb 2021 00:00:00 +0000 https://nelson.cloud/insertion-order-iteration-of-maps-in-go/?ref=rss Iterating through Go maps in insertion order.In Go, map contents are randomized. Go doesn’t care about insertion order. Elements in a map are always random when iterating through them.

To iterate through map contents in insertion order, we need to create a slice that keeps track of each key. Then we iterate through this slice and use its contents (which are the map keys) to access the map’s values in the order in which they were inserted:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

package main

import "fmt"

func main() {
	m := make(map[string]int)
	m["a"] = 0
	m["b"] = 1
	m["c"] = 2
	m["d"] = 3
	m["e"] = 4
	m["f"] = 5

	// store map keys in a slice
	keys := []string{"a", "b", "c", "d", "e", "f"}

	// iterate through "keys" slice to get map values in insert order
	// the underscore is there because we won't be using the first value, which is the index of the slice
	for _, key := range keys {
		fmt.Println("Key:", key, "\t", "Value:", m[key])
	}
}

$ go run example.go

Key: a 	 Value: 0
Key: b 	 Value: 1
Key: c 	 Value: 2
Key: d 	 Value: 3
Key: e 	 Value: 4
Key: f 	 Value: 5

Now each key and value is printed in insertion order.

Additional Notes

The following example shows how iterating through a map won’t print out values in order even if assignment was done in a certain order:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// example.go

package main

import "fmt"

func main() {
	m := make(map[string]int)

	m["a"] = 0
	m["b"] = 1
	m["c"] = 2
	m["d"] = 3
	m["e"] = 4
	m["f"] = 5

	// iterate through map and print each key, value
	for key, value := range m {
		fmt.Println("Key:", key, "\t", "Value:", value)
	}
}

And the output is:

$ go run example.go

Key: e 	 Value: 4
Key: f 	 Value: 5
Key: a 	 Value: 0
Key: b 	 Value: 1
Key: c 	 Value: 2
Key: d 	 Value: 3

Interestingly, printing a map with fmt.Println prints elements in key-sorted order and NOT by insertion order. Since Go 1.12, the fmt package sorts map keys for display purposes:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// example.go

package main

import "fmt"

func main() {
	m := make(map[string]int)

	m["c"] = 2
	m["a"] = 0
	m["f"] = 5
	m["b"] = 1
	m["e"] = 4
	m["d"] = 3

	// print map directly
	fmt.Println(m)
}

$ go run example.go

map[a:0 b:1 c:2 d:3 e:4 f:5]

The keys were inserted in a random order, but printing the map displays the key-value pairs sorted by key (alphabetically).

]]>