Archive
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 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.
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 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.
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 var ptr *int The zero value of a pointer is nil. Use & to take an address and * to dereference it:
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.
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 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.
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 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.
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 project/ ├── main.go └── utils/ └── validation.go 1. Set Up Gin Create main.go:
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 project/ ├── main.go └── utils/ └── validation.go 1. Create the Gin Application Create main.go with a /register endpoint: