Go

Interfaces are one of Go’s most important abstraction tools. An interface describes behavior as a set of method signatures. A concrete type satisfies an interface implicitly simply by implementing the required methods—there is no separate implements declaration. What Is an Interface? An interface is a set of methods. For example: Copy type Speaker interface { Speak() string } type Person struct { Name string } func (p Person) Speak() string { return "Hello, my name is " + p.Name } Because Person has the required Speak() string method, it satisfies Speaker:

Go has only one looping keyword: for. That can look unusual if you come from a language with separate for, while, and do-while constructs, but Go’s for is flexible enough to cover the common looping patterns. 1. Basic for Loop Copy for i := 0; i < 5; i++ { fmt.Println(i) } This is similar to a traditional loop in C, Java, or JavaScript: initialize a counter, continue while the condition is true, and run the post statement after each iteration.

Goroutines are one of Go’s defining features. They make concurrent work inexpensive to start, but creating an uncontrolled number of goroutines can still overwhelm memory, downstream services, file descriptors, or database connections. A common solution is a bounded worker pool: tasks are placed on a channel and a fixed number of goroutines consume them. Why Use a Queue? A controlled work queue helps you: limit the number of active workers; apply backpressure when work arrives faster than it can be processed; centralize task scheduling; shut down cleanly after queued work finishes. 1. A Basic Channel-Based Queue Copy type Task struct { ID int } func worker(id int, tasks <-chan Task) { for task := range tasks { fmt.Printf("Worker %d processing task %d\n", id, task.ID) time.Sleep(time.Second) } } A channel can hold pending tasks while several workers read from it.

A Go map stores key-value pairs and gives you fast lookup by key. It is similar to a dictionary or hash map in other languages and is one of Go’s most useful built-in data structures. Creating a Map Using make: Copy personAge := make(map[string]int) personAge["Alice"] = 30 personAge["Bob"] = 25 fmt.Println(personAge) Using a map literal:

Combining slices is common when data comes from several sources or processing stages. In Go, the standard approach is append, optionally with preallocated capacity when the final size is known. 1. Combine Slices with append Copy package main import "fmt" func main() { slice1 := []int{1, 2, 3} slice2 := []int{4, 5, 6} slice3 := []int{7, 8, 9} combined := append(slice1, slice2...) combined = append(combined, slice3...) fmt.Println(combined) } Output:

Compact JSON is efficient for transport, but long documents can be difficult to inspect when everything appears on one line. Go’s standard encoding/json package includes json.MarshalIndent for producing human-readable JSON with line breaks and indentation. Pretty-printed JSON is useful for debugging, generated configuration, logs intended for people, and command-line output. 1. Use json.MarshalIndent Copy package main import ( "encoding/json" "fmt" ) func main() { data := map[string]any{ "name": "Alice", "age": 30, "address": map[string]string{ "street": "123 Main St", "city": "Wonderland", }, "hobbies": []string{"reading", "hiking", "coding"}, } prettyJSON, err := json.MarshalIndent(data, "", " ") if err != nil { fmt.Println("Error:", err) return } fmt.Println(string(prettyJSON)) } MarshalIndent accepts three arguments:

Go deliberately does not support optional or default function parameters like some other languages. Function signatures are explicit, which keeps call sites and APIs predictable. When an API genuinely needs optional configuration, Go developers usually choose one of a few established patterns. 1. Variadic Parameters A variadic parameter (...) is useful when the optional part is simply zero or more values of the same type: Copy func greet(message string, names ...string) { for _, name := range names { fmt.Printf("%s, %s!\n", message, name) } } func main() { greet("Hello") greet("Hello", "Alice", "Bob", "Charlie") } message is required, while names may contain zero, one, or many values.

A struct groups related fields into a single Go type. Structs are the standard way to model domain entities, configuration, request data, records, and many other compound values. Define a Struct Copy type Person struct { Name string Age int Address string } p := Person{Name: "Alice", Age: 30, Address: "123 Main St"} fmt.Println(p.Name, p.Age, p.Address) Using field names in composite literals is usually clearer and more resilient than relying on field order.

Time handling looks simple until time zones, parsing, durations, and scheduling enter the picture. Go’s standard time package covers the common cases without requiring third-party libraries. Current Time Copy currentTime := time.Now() fmt.Println("Now:", currentTime) time.Now() returns the current local time according to the process environment.

Functions are first-class values in Go: they can be assigned to variables, passed as arguments, returned from other functions, and wrapped in closures. Combined with multiple return values and defer, this gives Go a small but flexible set of function patterns. 1. Basic Functions Copy func add(a, b int) int { return a + b } result := add(3, 4) fmt.Println(result) // 7 Functions declare parameter types and, when needed, a return type after the parameter list.

Applications that store tokens, private configuration, or other sensitive values often need encryption at rest. Go includes everything required to implement modern symmetric encryption in its standard library. This example uses AES-GCM, an authenticated encryption mode that protects both confidentiality and integrity. That makes it a better default for new applications than older unauthenticated modes such as CFB. AES-GCM in Brief Symmetric encryption uses the same secret key for encryption and decryption. AES accepts 16-, 24-, or 32-byte keys for AES-128, AES-192, or AES-256. GCM adds authentication, so modified ciphertext is rejected during decryption. A fresh nonce must be used for every encryption operation with the same key. Complete Go Example Copy package main import ( "crypto/aes" "crypto/cipher" "crypto/rand" "encoding/base64" "fmt" ) func generateRandomKey() ([]byte, error) { key := make([]byte, 32) // AES-256 if _, err := rand.Read(key); err != nil { return nil, err } return key, nil } func encrypt(plaintext, key []byte) ([]byte, error) { block, err := aes.NewCipher(key) if err != nil { return nil, err } gcm, err := cipher.NewGCM(block) if err != nil { return nil, err } nonce := make([]byte, gcm.NonceSize()) if _, err := rand.Read(nonce); err != nil { return nil, err } // Prefix the ciphertext with the nonce so decrypt can recover it. return gcm.Seal(nonce, nonce, plaintext, nil), nil } func decrypt(ciphertext, key []byte) ([]byte, error) { block, err := aes.NewCipher(key) if err != nil { return nil, err } gcm, err := cipher.NewGCM(block) if err != nil { return nil, err } nonceSize := gcm.NonceSize() if len(ciphertext) < nonceSize { return nil, fmt.Errorf("ciphertext too short") } nonce := ciphertext[:nonceSize] ciphertext = ciphertext[nonceSize:] return gcm.Open(nil, nonce, ciphertext, nil) } func main() { plaintext := []byte("Secret application data") key, err := generateRandomKey() if err != nil { panic(err) } ciphertext, err := encrypt(plaintext, key) if err != nil { panic(err) } fmt.Println("Ciphertext (base64):", base64.StdEncoding.EncodeToString(ciphertext)) decrypted, err := decrypt(ciphertext, key) if err != nil { panic(err) } fmt.Println("Decrypted text:", string(decrypted)) } How It Works generateRandomKey creates a cryptographically secure 32-byte key for AES-256. encrypt creates an AES cipher, wraps it with GCM, generates a random nonce, and encrypts the plaintext. The nonce is stored at the beginning of the returned byte slice. A nonce does not need to be secret, but it must not be reused with the same key. decrypt separates the nonce from the ciphertext and calls gcm.Open. If the ciphertext was modified, authentication fails and an error is returned. Key Management Matters The encryption code is only one part of a secure design. Do not hard-code real encryption keys in source control. In production, load keys from an appropriate secret-management system, protected environment, or key-management service.

When an application exchanges sensitive data, it is often important to verify both the integrity and authenticity of each message. If an attacker can modify a request in transit or replay an old valid request, the receiving service needs a reliable way to reject it. One common building block is HMAC (Hash-based Message Authentication Code). This article shows how to generate and verify an HMAC in Go with SHA-512, plus a nonce and timestamp to reduce replay risk.

A pointer stores the memory address of another value. In Go, pointers are useful when a function needs to modify a caller-owned value, when a type needs a meaningful nil state, or when pointer receiver semantics are appropriate. Declaring a Pointer Copy var ptr *int The zero value of a pointer is nil. Use & to take an address and * to dereference it:

Go makes concurrent work straightforward with goroutines. One practical example is searching for a word across many text values at the same time. Instead of checking each text sequentially, you can launch a goroutine for each item and wait for all searches to finish. Overview The program below will: Search for a word in a single text value with searchInText. Search multiple text values concurrently with searchWordInTexts. Print whether the word was found. Complete Example Copy package main import ( "fmt" "strings" "sync" ) // searchInText reports whether word occurs in text. func searchInText(text, word string) bool { if text == "" || word == "" { return false } // Make the search case-insensitive. text = strings.ToLower(text) word = strings.ToLower(word) return strings.Contains(text, word) } // searchWordInTexts searches multiple texts concurrently. func searchWordInTexts(texts []string, word string) bool { var wg sync.WaitGroup var mu sync.Mutex found := false for _, text := range texts { wg.Add(1) go func(t string) { defer wg.Done() if searchInText(t, word) { mu.Lock() found = true mu.Unlock() } }(text) } wg.Wait() return found } func main() { texts := []string{ "This is a long example text", "Another text for word searching", "This program uses goroutines for searching", } word := "program" if searchWordInTexts(texts, word) { fmt.Printf("Word '%s' was found in at least one text\n", word) } else { fmt.Printf("Word '%s' was not found\n", word) } } How It Works searchInText converts both the text and search term to lowercase, then uses strings.Contains for a case-insensitive match. searchWordInTexts uses sync.WaitGroup to wait for every goroutine and sync.Mutex to protect the shared found variable. main provides sample data, runs the concurrent search, and prints the result. A Practical Note For short in-memory strings, launching one goroutine per string may be slower than a simple loop because goroutines and synchronization have overhead. This pattern becomes more useful when each task is expensive or blocking, such as reading files, calling services, or processing large independent inputs.

Variables are one of the basic building blocks of Go programs. Understanding declaration syntax, scope, zero values, constants, and type inference helps keep code predictable and easy to maintain. Declare Variables with var Copy var name string var age int If you do not provide an initializer, Go assigns the type’s zero value. Here, name starts as "" and age starts as 0.

Input validation is an important part of any web application. It lets the server reject malformed or incomplete data before business logic runs. This tutorial builds a small API with Gin and uses go-playground/validator for declarative validation rules. Project Structure Copy project/ ├── main.go └── utils/ └── validation.go 1. Create the Gin Application Create main.go with a /register endpoint:

Input validation is one of the first defenses a web application has against malformed, incomplete, or unexpected data. Validation should run before business logic writes data to a database or triggers other side effects. This example uses Gin with go-playground/validator to validate a simple registration request. Project Structure Copy project/ ├── main.go └── utils/ └── validation.go 1. Set Up Gin Create main.go: