6 Essential Go Tricks to Boost Your Backend Development

01. Loop Labels for Prime Numbers

Go's for loops can use labeled continue to break out of nested loops without auxiliary flags. Example prints primes below 10.

package main

import "fmt"

func main() { printPrime(10) }

func printPrime(maxNum int) {
next:
    for outer := 2; outer < maxNum; outer++ {
        for inner := 2; inner < outer; inner++ {
            if outer%inner == 0 {
                continue next
            }
        }
        fmt.Printf("%d
", outer)
    }
    fmt.Println("Completed")
}

Equivalent C implementation requires a flag variable.

#include <stdio.h>

void printPrime(int maxNum) {
    int outer, inner;
    int flag;
    for (outer = 2; outer < maxNum; outer++) {
        flag = 1;
        for (inner = 2; inner < outer; inner++) {
            if (outer % inner == 0) {
                flag = 0;
                break;
            }
        }
        if (flag == 1) {
            printf("%d
", outer);
        }
    }
    printf("Completed
");
}

int main() { printPrime(10); return 0; }

02. IP Address String ↔ Integer Conversion

Utility functions to convert IPv4 string to a 64‑bit integer and back, using net.ParseIP and math/big.

package main

import (
    "fmt"
    "math/big"
    "net"
)

func InetNtoA(ip int64) string {
    return fmt.Sprintf("%d.%d.%d.%d",
        byte(ip>>24), byte(ip>>16), byte(ip>>8), byte(ip))
}

func InetAtoN(ip string) int64 {
    ret := big.NewInt(0)
    ret.SetBytes(net.ParseIP(ip).To4())
    return ret.Int64()
}

func main() {
    ip := "192.168.78.123"
    ipInt := InetAtoN(ip)
    fmt.Printf("convert string ip [%s] to int: %d
", ip, ipInt)
    fmt.Printf("convert int ip [%d] to string: %s
", ipInt, InetNtoA(ipInt))
}

Check that net.ParseIP(ip).To4() is not nil before using.

03. Octal UTF‑8 to Chinese

Convert octal‑escaped UTF‑8 sequences (e.g., \346\200\241) back to readable characters using a regular‑expression based function.

package main

import (
    "fmt"
    "regexp"
    "strconv"
)

func convertOctonaryUtf8(in string) string {
    s := []byte(in)
    reg := regexp.MustCompile(`\\[0-7]{3}`)
    out := reg.ReplaceAllFunc(s, func(b []byte) []byte {
        i, _ := strconv.ParseInt(string(b[1:]), 8, 0)
        return []byte{byte(i)}
    })
    return string(out)
}

func main() {
    s1 := "\346\200\241" // literal
    s2 := `\346\200\241` // raw string
    fmt.Println("s1 =", s1)
    fmt.Println("s2 =", s2)
    s3 := convertOctonaryUtf8(s2)
    fmt.Println("s3 =", s3)
}

04. Simplified HTTP Requests with httputil

A lightweight library abstracts common HTTP client steps (URL construction, body handling, timeout, error checking, response parsing). It supports GET, POST, PUT, PATCH, DELETE and payload types string, []byte, map, struct. Default timeout 30 s and JSON content type.

package main

import (
    "context"
    "log"

    hu "github.com/chinaran/httputil"
)

func main() {
    // GET example
    urlGet := "https://httpbin.org/get?hello=world"
    var respGetM map[string]interface{}
    if err := hu.Get(context.TODO(), urlGet, &respGetM, hu.WithLogTimeCost()); err != nil {
        log.Printf("Get %s err: %s", urlGet, err)
        return
    }
    log.Printf("Get %s map response: %+v", urlGet, respGetM)

    // POST example
    urlPost := "https://httpbin.org/post"
    req := map[string]string{"hello": "world"}
    var respPost struct{ Data string `json:"data"` }
    if err := hu.Post(context.TODO(), urlPost, &req, &respPost, hu.WithLogTimeCost()); err != nil {
        log.Printf("Post %s err: %s", urlPost, err)
        return
    }
    log.Printf("Post %s struct response: %+v", urlPost, respPost)
}

05. Quick Variable Inspection with debuglog

Utility functions for logging values without explicit formatting: Val, SpewVal (deep inspection via spew), ToJson, and ToJsonPretty.

package main

import "github.com/chinaran/debuglog"

type TestJson struct {
    Id   int64
    Name string
}

func main() {
    intVal := 123
    debuglog.Val(intVal)
    debuglog.Val(intVal, "prefix1")
    debuglog.Val(intVal, "prefix1", "prefix2")

    testJson := TestJson{Id: 987, Name: "alan"}
    debuglog.SpewVal(testJson, "testJson Spew")
    debuglog.ToJson(testJson, "testJson")
    debuglog.ToJsonPretty(testJson, "testJson Pretty")
}

06. go-httpbin – A Go‑Based HTTP Testing Service

A minimal reimplementation of httpbin using only the Go standard library. It adds response‑delay arguments, pretty‑printed JSON, environment query parameters, and an “anything” endpoint. Run with Docker:

docker run -p 8080:80 ghcr.io/chinaran/go-httpbin:1.2-alpine3.13

Example request:

curl http://go-httpbin/get
{
    "envs": {"HOSTNAME": "go-httpbin-6f55bbcfcd-skrxl"},
    "args": {},
    "headers": {...},
    "origin": "127.0.0.1:46756",
    "url": "http://go-httpbin/get"
}