Bytes #

package main

import (
    "bytes"
    "fmt"
)

func main() {
    data := []byte("Hello, World! Hello, Go!")

    // Contains — does it contain a sub-slice?
    fmt.Println(bytes.Contains(data, []byte("World")))  // true
    fmt.Println(bytes.Contains(data, []byte("Python"))) // false

    // ContainsAny — contains any byte from the string?
    fmt.Println(bytes.ContainsAny(data, "aeiou")) // true — there are vowels
    fmt.Println(bytes.ContainsAny(data, "xyz"))   // false

    // ContainsRune — contains a specific rune?
    fmt.Println(bytes.ContainsRune(data, '!')) // true

    // Count — count the occurrences
    fmt.Println(bytes.Count(data, []byte("Hello"))) // 2
    fmt.Println(bytes.Count(data, []byte("")))      // 23 (len+1)

    // Index — the position of the first occurrence (-1 if absent)
    fmt.Println(bytes.Index(data, []byte("World"))) // 7
    fmt.Println(bytes.Index(data, []byte("Java")))  // -1

    // LastIndex — the position of the last occurrence
    fmt.Println(bytes.LastIndex(data, []byte("Hello"))) // 14

    // IndexByte — search for one byte (faster than Index)
    fmt.Println(bytes.IndexByte(data, '!')) // 12

    // IndexRune — search for one rune (supports multibyte)
    fmt.Println(bytes.IndexRune(data, 'W')) // 7

    // IndexAny — search for any byte from the set
    fmt.Println(bytes.IndexAny(data, "aeiou")) // 1 — 'e' in "Hello"

    // HasPrefix and HasSuffix
    fmt.Println(bytes.HasPrefix(data, []byte("Hello"))) // true
    fmt.Println(bytes.HasSuffix(data, []byte("Go!")))  // true
}

data := []byte("  Hello, World!  ")

// Trim — remove characters from both ends
fmt.Println(string(bytes.TrimSpace(data)))              // "Hello, World!"
fmt.Println(string(bytes.Trim(data, " !")))             // "Hello, World"
fmt.Println(string(bytes.TrimLeft(data, " ")))          // "Hello, World!  "
fmt.Println(string(bytes.TrimRight(data, " ")))         // "  Hello, World!"
fmt.Println(string(bytes.TrimPrefix(data, []byte("  ")))) // "Hello, World!  "
fmt.Println(string(bytes.TrimSuffix(data, []byte("  ")))) // "  Hello, World!"

// TrimFunc — remove bytes satisfying a condition
clean := bytes.TrimFunc(data, func(r rune) bool {
    return r == ' ' || r == '!'
})
fmt.Println(string(clean)) // "Hello, World"

// Case conversion
s := []byte("hello world")
fmt.Println(string(bytes.ToUpper(s))) // "HELLO WORLD"
fmt.Println(string(bytes.ToLower([]byte("HELLO WORLD")))) // "hello world"
fmt.Println(string(bytes.ToTitle(s))) // "HELLO WORLD" (title = upper for ASCII)

// Title — capitalize the start of each word (deprecated in strings, but exists in bytes)
fmt.Println(string(bytes.Title(s))) // "Hello World"

// Replace and ReplaceAll
text := []byte("the cat eats fish, the cat is happy")
fmt.Println(string(bytes.Replace(text, []byte("cat"), []byte("dog"), 1)))
// "the dog eats fish, the cat is happy" — replace only the first

fmt.Println(string(bytes.ReplaceAll(text, []byte("cat"), []byte("dog"))))
// "the dog eats fish, the dog is happy" — replace all

// Map — per-rune transformation
result := bytes.Map(func(r rune) rune {
    if r >= 'a' && r <= 'z' {
        return r - 32 // lowercase to uppercase
    }
    return r
}, []byte("hello, world!"))
fmt.Println(string(result)) // "HELLO, WORLD!"

// Split — split with a separator
data := []byte("apple,mango,orange,banana")
parts := bytes.Split(data, []byte(","))
for _, p := range parts {
    fmt.Println(string(p))
}
// apple
// mango
// orange
// banana

// SplitN — at most N parts
parts2 := bytes.SplitN(data, []byte(","), 2)
fmt.Println(string(parts2[0])) // "apple"
fmt.Println(string(parts2[1])) // "mango,orange,banana"

// SplitAfter — the separator goes with the previous part
parts3 := bytes.SplitAfter(data, []byte(","))
// ["apple," "mango," "orange," "banana"]

// Fields — split by whitespace (like strings.Fields)
sentence := []byte("  hello   world   go  ")
words := bytes.Fields(sentence)
for _, w := range words {
    fmt.Printf("[%s]\n", w)
}
// [hello]
// [world]
// [go]

// FieldsFunc — split by a condition
csv := []byte("one,,two,,,three")
columns := bytes.FieldsFunc(csv, func(r rune) bool {
    return r == ','
})
// ["one" "two" "three"] — empty fields are skipped

// Join — join with a separator
fruits := [][]byte{[]byte("apple"), []byte("mango"), []byte("orange")}
result := bytes.Join(fruits, []byte(", "))
fmt.Println(string(result)) // "apple, mango, orange"

// Repeat — repeat a byte slice
fmt.Println(string(bytes.Repeat([]byte("ab"), 4))) // "abababab"
fmt.Println(string(bytes.Repeat([]byte("-"), 20)))  // "--------------------"

a := []byte("apple")
b := []byte("mango")
c := []byte("apple")

// Equal — are the contents the same?
fmt.Println(bytes.Equal(a, c)) // true
fmt.Println(bytes.Equal(a, b)) // false

// ANTI-PATTERN: compare with string()
// This allocates a string copy!
fmt.Println(string(a) == string(c)) // true but inefficient

// CORRECT: use bytes.Equal
fmt.Println(bytes.Equal(a, c)) // true with no allocation

// Compare — like strcmp: -1, 0, or 1
fmt.Println(bytes.Compare(a, b)) // -1 (apple < mango)
fmt.Println(bytes.Compare(b, a)) // 1  (mango > apple)
fmt.Println(bytes.Compare(a, c)) // 0  (equal)

// EqualFold — case-insensitive comparison
x := []byte("Hello")
y := []byte("hello")
fmt.Println(bytes.EqualFold(x, y)) // true

import (
    "bytes"
    "fmt"
)

// Basic: building a byte slice
var buf bytes.Buffer

buf.WriteString("Hello, ")
buf.WriteString("World")
buf.WriteByte('!')
buf.WriteRune('🌍')

fmt.Println(buf.String()) // "Hello, World!🌍"
fmt.Println(buf.Len())    // 17 (in bytes, not runes)

// Use fmt.Fprintf for formatting
var buf2 bytes.Buffer
for i := 1; i <= 5; i++ {
    fmt.Fprintf(&buf2, "item %d\n", i)
}
fmt.Print(buf2.String())
// item 1
// item 2
// item 3
// item 4
// item 5

// Reset and reuse
buf.Reset()
fmt.Println(buf.Len())    // 0
fmt.Println(buf.Cap())    // the capacity is still there, not reallocated

// Initialize with initial content
buf3 := bytes.NewBuffer([]byte("initial data"))
buf3.WriteString(" appended")
fmt.Println(buf3.String()) // "initial data appended"

// Reading from the buffer
buf4 := bytes.NewBuffer([]byte("first line\nsecond line\nthird line\n"))
line, err := buf4.ReadString('\n')
fmt.Print(line) // "first line\n"
fmt.Println(err) // nil

line, err = buf4.ReadString('\n')
fmt.Print(line) // "second line\n"

// strings.Builder — for building a string (can't be read as a Reader)
var sb strings.Builder
sb.WriteString("Hello, ")
sb.WriteString("World!")
result := sb.String() // get the result as a string

// bytes.Buffer — for building []byte or when you need io.Reader
var buf bytes.Buffer
buf.WriteString("protocol data")
buf.WriteByte(0x00) // can write any byte including null

// Send as an io.Reader to another function
json.NewDecoder(&buf).Decode(&target)
http.Post(url, "application/octet-stream", &buf)

// ANTI-PATTERN: use bytes.Buffer only for a final string
var buf2 bytes.Buffer
for i := 0; i < 100; i++ {
    buf2.WriteString("item") // Buffer works, but Builder is more efficient
}
_ = buf2.String()

// CORRECT: strings.Builder for pure string building
var sb2 strings.Builder
for i := 0; i < 100; i++ {
    sb2.WriteString("item")
}
_ = sb2.String()

data := []byte(`{"name":"Budi","age":30}`)

// Create a Reader from []byte
reader := bytes.NewReader(data)

// Decode JSON from the Reader (not directly from []byte)
var user struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}
json.NewDecoder(reader).Decode(&user)
fmt.Println(user.Name, user.Age) // Budi 30

// Seek — go back to a certain position
reader.Seek(0, 0) // back to the beginning
fmt.Println(reader.Len()) // 25 — back to the full length

// ReadAt — read from a certain position without moving the position
buf := make([]byte, 4)
reader.ReadAt(buf, 2)
fmt.Println(string(buf)) // "\"nam"

// Size
fmt.Println(reader.Size()) // 25 — the total size (doesn't change after Seek)

// Use as an io.Reader for HTTP uploads
data2 := []byte("this file's content")
resp, err := http.Post(
    "https://api.example.com/upload",
    "application/octet-stream",
    bytes.NewReader(data2),
)
_ = resp
_ = err

import (
    "bytes"
    "encoding/binary"
    "fmt"
)

// Parsing a simple protocol frame:
// [4 length bytes][1 type byte][N payload bytes]
func parseFrame(data []byte) (kind byte, payload []byte, err error) {
    if len(data) < 5 {
        return 0, nil, fmt.Errorf("frame too short: %d bytes", len(data))
    }

    reader := bytes.NewReader(data)

    // Read the payload length (4 big-endian bytes)
    var length uint32
    if err := binary.Read(reader, binary.BigEndian, &length); err != nil {
        return 0, nil, fmt.Errorf("read length: %w", err)
    }

    // Read the type (1 byte)
    typeByte, err := reader.ReadByte()
    if err != nil {
        return 0, nil, fmt.Errorf("read type: %w", err)
    }

    // Read the payload
    payload = make([]byte, length)
    if _, err := reader.Read(payload); err != nil {
        return 0, nil, fmt.Errorf("read payload: %w", err)
    }

    return typeByte, payload, nil
}

// Building a protocol frame
func makeFrame(kind byte, payload []byte) []byte {
    var buf bytes.Buffer

    // Write the payload length (4 big-endian bytes)
    binary.Write(&buf, binary.BigEndian, uint32(len(payload)))

    // Write the type
    buf.WriteByte(kind)

    // Write the payload
    buf.Write(payload)

    return buf.Bytes()
}

// Usage
frame := makeFrame(0x01, []byte("Hello from Go!"))
kind, payload, err := parseFrame(frame)
if err == nil {
    fmt.Printf("Type: 0x%02X, Payload: %s\n", kind, payload)
}

import (
    "bytes"
    "compress/gzip"
    "io"
    "net/http"
)

func fetchAndProcess(url string) ([]byte, error) {
    resp, err := http.Get(url)
    if err != nil {
        return nil, fmt.Errorf("GET %s: %w", url, err)
    }
    defer resp.Body.Close()

    // Read the whole body into a buffer
    var buf bytes.Buffer
    if _, err := io.Copy(&buf, resp.Body); err != nil {
        return nil, fmt.Errorf("read body: %w", err)
    }

    data := buf.Bytes()

    // Check whether it's gzip-encoded
    if bytes.HasPrefix(data, []byte{0x1f, 0x8b}) {
        // gzip magic bytes
        reader, err := gzip.NewReader(bytes.NewReader(data))
        if err != nil {
            return nil, fmt.Errorf("open gzip: %w", err)
        }
        defer reader.Close()

        var decompressed bytes.Buffer
        if _, err := io.Copy(&decompressed, reader); err != nil {
            return nil, fmt.Errorf("decompress: %w", err)
        }
        return decompressed.Bytes(), nil
    }

    return data, nil
}

import (
    "bytes"
    "html/template"
)

var tmplEmail = template.Must(template.New("email").Parse(`
To: {{.Name}}

Thank you for registering with our service.
Your verification code: {{.Code}}

This code is valid for {{.DurationMinutes}} minutes.
`))

type EmailData struct {
    Name            string
    Code            string
    DurationMinutes int
}

func renderEmail(data EmailData) ([]byte, error) {
    var buf bytes.Buffer
    if err := tmplEmail.Execute(&buf, data); err != nil {
        return nil, fmt.Errorf("render email: %w", err)
    }
    return buf.Bytes(), nil
}

// Usage
content, err := renderEmail(EmailData{
    Name:            "Budi",
    Code:            "123456",
    DurationMinutes: 10,
})
if err == nil {
    fmt.Println(string(content))
}

func makeCSV(headers []string, rows [][]string) []byte {
    var buf bytes.Buffer

    // Write the header
    for i, h := range headers {
        if i > 0 {
            buf.WriteByte(',')
        }
        buf.WriteString(escapeCSV(h))
    }
    buf.WriteByte('\n')

    // Write the data rows
    for _, row := range rows {
        for i, cell := range row {
            if i > 0 {
                buf.WriteByte(',')
            }
            buf.WriteString(escapeCSV(cell))
        }
        buf.WriteByte('\n')
    }

    return buf.Bytes()
}

func escapeCSV(s string) string {
    // Quote if it contains a comma, newline, or quote
    if bytes.ContainsAny([]byte(s), ",\"\n\r") {
        return `"` + strings.ReplaceAll(s, `"`, `""`) + `"`
    }
    return s
}

// Usage
csv := makeCSV(
    []string{"ID", "Name", "Email", "City"},
    [][]string{
        {"1", "Budi Santoso", "[email protected]", "Jakarta"},
        {"2", "Ani", "[email protected]", "Bandung, West Java"},
        {"3", "Charlie", `char"[email protected]`, "Surabaya"},
    },
)
os.WriteFile("output.csv", csv, 0644)

import "sync"

// A pool of bytes.Buffers to avoid repeated allocations
var bufPool = sync.Pool{
    New: func() any {
        return new(bytes.Buffer)
    },
}

func getBuffer() *bytes.Buffer {
    buf := bufPool.Get().(*bytes.Buffer)
    buf.Reset() // IMPORTANT: reset before use
    return buf
}

func returnBuffer(buf *bytes.Buffer) {
    // Don't return overly large buffers to the pool
    // to avoid holding too much memory
    if buf.Cap() <= 64*1024 { // 64 KB
        bufPool.Put(buf)
    }
}

func processRequest(data []byte) string {
    buf := getBuffer()
    defer returnBuffer(buf)

    // Use buf to build the response
    buf.WriteString(`{"status":"ok","data":`)
    buf.Write(data)
    buf.WriteByte('}')

    return buf.String()
}

// Process a large file line by line without loading everything into memory
func processLargeFile(path string) error {
    f, err := os.Open(path)
    if err != nil {
        return fmt.Errorf("open file: %w", err)
    }
    defer f.Close()

    var (
        buf      = make([]byte, 64*1024) // 64 KB buffer
        leftover []byte                  // leftover from the previous read
        lines    int
    )

    for {
        n, err := f.Read(buf)
        if n > 0 {
            // Combine the previous leftover with the new data
            chunk := append(leftover, buf[:n]...)
            leftover = nil

            // Process each complete line
            for {
                idx := bytes.IndexByte(chunk, '\n')
                if idx < 0 {
                    // No newline — save as leftover
                    leftover = chunk
                    break
                }
                lines++
                processLineData(chunk[:idx])
                chunk = chunk[idx+1:]
            }
        }

        if err == io.EOF {
            // Process the final leftover if it doesn't end with a newline
            if len(leftover) > 0 {
                lines++
                processLineData(leftover)
            }
            break
        }
        if err != nil {
            return fmt.Errorf("read file: %w", err)
        }
    }

    fmt.Printf("Processed %d lines\n", lines)
    return nil
}

// ANTI-PATTERN: unnecessary back-and-forth conversions
func processDataBad(data []byte) []byte {
    s := string(data)           // first copy: []byte → string
    s = strings.ToUpper(s)     // process
    s = strings.TrimSpace(s)   // process
    return []byte(s)           // second copy: string → []byte
}

// CORRECT: stay in []byte, use the bytes package
func processDataGood(data []byte) []byte {
    result := bytes.ToUpper(data)
    return bytes.TrimSpace(result)
}

// When conversion IS genuinely needed:
// 1. Map/switch cases with string literals
switch string(data[:4]) {
case "HTTP", "POST", "GET ":
    // process
}

// 2. When an external function only accepts a string
log.Println(string(data)) // log.Println needs a string

// 3. When storing into a string-typed struct field
user.Name = string(nameBytes)