Strings in Go — Optimize¶

func joinComma(items []string) string {
    // Option 1: strings.Join (simplest)
    return strings.Join(items, ",")

    // Option 2: strings.Builder with Grow
    // var sb strings.Builder
    // total := len(items) - 1 // separators
    // for _, s := range items { total += len(s) }
    // sb.Grow(total)
    // for i, item := range items {
    //     if i > 0 { sb.WriteByte(',') }
    //     sb.WriteString(item)
    // }
    // return sb.String()
}

// Option 1: Accept the cost but avoid double work
// The current code is actually reasonable. ToLower is O(n) per string.
// Main optimization: avoid calling ToLower twice if you store lowercased keys

// Option 2: Use strings.EqualFold in a different approach (only if N is tiny)

// Option 3: For ASCII-only data, write a fast no-alloc toLower check
func isAlreadyLower(s string) bool {
    for i := 0; i < len(s); i++ {
        c := s[i]
        if c >= 'A' && c <= 'Z' {
            return false
        }
    }
    return true
}

func deduplicateCaseInsensitive(items []string) []string {
    seen := make(map[string]bool, len(items))
    result := make([]string, 0, len(items))
    for _, item := range items {
        var key string
        if isAlreadyLower(item) {
            key = item // no allocation needed
        } else {
            key = strings.ToLower(item)
        }
        if !seen[key] {
            seen[key] = true
            result = append(result, item)
        }
    }
    return result
}

var htmlReplacer = strings.NewReplacer(
    "&", "&",
    "<", "&lt;",
    ">", "&gt;",
    "\"", "&#34;",
    "'", "&#39;",
)

func escapeHTML(s string) string {
    return htmlReplacer.Replace(s)
}

func formatLogLine(level, message string) string {
    var sb strings.Builder
    sb.Grow(1 + len(level) + 2 + len(message))
    sb.WriteByte('[')
    sb.WriteString(level)
    sb.WriteString("] ")
    sb.WriteString(message)
    return sb.String()
}

func formatLogLine(level, message string) string {
    return "[" + level + "] " + message
}
// For 3 parts, the compiler may optimize to a single allocation

// The compiler already optimizes map[string(b)] lookups in Go 1.6+
// for the pattern: m[string(byteSlice)]

type Router struct {
    routes map[string]http.HandlerFunc
}

func (r *Router) lookup(pathBytes []byte) http.HandlerFunc {
    // This does NOT allocate — compiler optimization for map key lookup
    return r.routes[string(pathBytes)]
}

// For custom hot-path parsers where you control the []byte:
// Use unsafe zero-copy only if profiling confirms it is necessary
import "unsafe"

func lookupUnsafe(routes map[string]http.HandlerFunc, path []byte) http.HandlerFunc {
    // Zero-copy: safe only because map lookup does not retain the string
    return routes[unsafe.String(unsafe.SliceData(path), len(path))]
}

func (s *SessionStore) ParseCookie(cookieHeader string) string {
    i := strings.Index(cookieHeader, "session=")
    if i < 0 {
        return ""
    }
    i += len("session=")
    j := strings.Index(cookieHeader[i:], ";")

    var token string
    if j < 0 {
        token = cookieHeader[i:]
    } else {
        token = cookieHeader[i : i+j]
    }

    // strings.Clone creates an independent copy, releasing the 4KB backing array
    return strings.Clone(token)
}

type Logger struct {
    mu sync.Mutex
    sb strings.Builder
}

func (l *Logger) Format(fields map[string]string) string {
    l.mu.Lock()
    defer l.mu.Unlock()

    l.sb.Reset() // reset length, keep capacity
    first := true
    for k, v := range fields {
        if !first {
            l.sb.WriteByte(' ')
        }
        l.sb.WriteString(k)
        l.sb.WriteByte('=')
        l.sb.WriteString(v)
        first = false
    }
    return l.sb.String()
}

var builderPool = sync.Pool{
    New: func() interface{} { return new(strings.Builder) },
}

func Format(fields map[string]string) string {
    sb := builderPool.Get().(*strings.Builder)
    sb.Reset()
    defer builderPool.Put(sb)

    for k, v := range fields {
        sb.WriteString(k)
        sb.WriteByte('=')
        sb.WriteString(v)
        sb.WriteByte(' ')
    }
    return strings.TrimSpace(sb.String())
}

func splitCSV(line string) []string {
    var fields []string
    for {
        i := strings.IndexByte(line, ',') // single byte search — faster
        if i < 0 {
            fields = append(fields, line)
            break
        }
        fields = append(fields, line[:i])
        line = line[i+1:]
    }
    return fields
}

func processLines(data string) []string {
    lines := strings.Split(data, "\n")
    results := make([]string, 0, len(lines)) // pre-allocate with upper bound
    for _, line := range lines {
        trimmed := strings.TrimSpace(line)
        if trimmed != "" {
            results = append(results, trimmed)
        }
    }
    return results
}

count := 0
for _, line := range lines {
    if strings.TrimSpace(line) != "" { count++ }
}
results := make([]string, 0, count)

func buildQueryParams(params map[string]string) string {
    var sb strings.Builder
    first := true
    for k, v := range params {
        if !first {
            sb.WriteByte('&')
        }
        sb.WriteString(k)
        sb.WriteByte('=')
        sb.WriteString(v)
        first = false
    }
    return sb.String()
}

// Option 1: Guard with log level check
const debugEnabled = false // or from config

func processItem(item Item) {
    if debugEnabled {
        log.Printf("Processing item: id=%d, name=%s, tags=%v, meta=%+v",
            item.ID, item.Name, item.Tags, item.Meta)
    }
    // ... actual processing
}

// Option 2: Lazy stringer interface
type ItemDebug struct{ item Item }

func (d ItemDebug) String() string {
    return fmt.Sprintf("id=%d, name=%s, tags=%v", d.item.ID, d.item.Name, d.item.Tags)
}

func processItem(item Item) {
    // String() is only called if the log level is active
    logger.Debug("Processing item", "item", ItemDebug{item})
}

// Option 3: Use slog (Go 1.21+) with lazy evaluation
import "log/slog"

func processItem(item Item) {
    slog.Debug("Processing item",
        slog.Int("id", item.ID),
        slog.String("name", item.Name),
    )
    // slog skips string formatting entirely if Debug level is disabled
}