This code defines a utility package in Go that generates...

September 2, 2025 at 04:41 AM

package utils

import (
	"crypto/rand"
	"fmt"
	"math/big"
	"sync"
)

// character set
var alphaNumeric = []byte("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")

// Store used IDs
// (thread-safe for concurrent use)
var usedIDs = make(map[string]bool)
var mu sync.Mutex

// "cryptographically" "secure" random string of length n
func generateUID(n int) (string, error) {
	const maxAttempts = 10
	for attempt := 0; attempt < maxAttempts; attempt++ {
		b := make([]byte, n)
		for i := range b {
			idx, err := rand.Int(rand.Reader, big.NewInt(int64(len(alphaNumeric))))
			if err != nil {
				return "", fmt.Errorf("failed to generate random number: %w", err)
			}
			b[i] = alphaNumeric[idx.Int64()]
		}
		id := string(b)
		mu.Lock()
		if !usedIDs[id] {
			usedIDs[id] = true
			mu.Unlock()
			return id, nil
		}
		mu.Unlock()
	}
	return "", fmt.Errorf("failed to generate unique ID after %d attempts", maxAttempts)
}

This code defines a utility package in Go that generates unique, cryptographically "secure", alphanumeric random strings (unique identifiers). Here's a detailed explanation of what the code does:

1. Variables and Setup

alphaNumeric is a slice of bytes containing all possible characters for the generated random string (a-z, A-Z, 0-9).
usedIDs is a map that stores previously generated IDs to ensure uniqueness. The map's keys are the generated IDs, and the values are true.
mu is a sync.Mutex used to provide thread-safe access to the usedIDs map when IDs are being checked or added.

2. Function: `generateUID(n int) (string, error)`

This function generates a unique random alphanumeric string of length n. The process involves the following steps:

Maximum Attempts (maxAttempts = 10): The function tries up to 10 times to generate a unique ID in case of collisions.
Random Character Selection:
- It creates a byte array b of size n.
- For each position i in the array, it generates a random index into the alphaNumeric slice using crypto/rand (for cryptographically secure random number generation).
- The selected character from alphaNumeric is assigned to position i of the byte array.
String Conversion: Once the byte array is filled, it is converted to a string.
Uniqueness Check:
- The usedIDs map is checked inside a mutex-protected critical section (mu.Lock() and mu.Unlock()).
- If the generated ID is not found in the map (!usedIDs[id]), the ID is added to the map (marking it as used), the mutex is unlocked, and the function returns the ID.
- If the ID is already used, the function retries (up to maxAttempts times).
Error Handling:
- If after maxAttempts, a unique ID cannot be generated (highly unlikely unless n is very small and/or usedIDs is very large), the function returns an error indicating failure.

3. Concurrency Handling

The inclusion of a mutex (sync.Mutex) around the usedIDs map ensures that concurrent calls to generateUID from multiple goroutines do not cause race conditions. This ensures thread-safety when accessing and modifying the usedIDs map.

4. Overall Purpose

The overall purpose of this code is to generate thread-safe, cryptographically secure, unique random strings of a specified length n. It guarantees:

The strings are random and composed of alphanumeric characters.
No duplicate strings are returned as long as the application keeps running (thanks to the usedIDs map).

5. Limitations

The usedIDs map grows indefinitely with each new ID, leading to potential memory issues if many IDs are generated.
It depends on a finite number of attempts (maxAttempts) to resolve collisions, which could theoretically fail for very large values of usedIDs.

This function is suitable for scenarios where unique identifiers (e.g., session tokens, temporary access codes) need to be generated in a secure and concurrent environment.

Generate your own explanations

Download our vscode extension

Read other generated explanations