Wie kann ich Go-Strukturen bei minimaler Dateigröße effizient auf die Festplatte serialisieren?

Effiziente Go-Serialisierung von Strukturen auf die Festplatte: Erzielen einer minimalen Aufblähung

Trotz der aufgeblähten Ausgabe, die durch die Gob-Serialisierung erzeugt wird, zeigt eine tiefergehende Analyse Folgendes Einträge desselben Typs verursachen nur einen Overhead von 12 Byte. Dieser Overhead stellt die Mindestgröße dar, die zum Codieren von zwei Zeichenfolgen mit einer Länge von 4 Byte (einschließlich Längenpräfixen) erforderlich ist.

Um die Gesamtdateigröße zu reduzieren, sollten Sie die folgenden Strategien in Betracht ziehen:

• Verwenden Sie mehrere Encoder-Instanzen: Durch die Amortisierung der Kompilierungskosten des benutzerdefinierten Codecs über mehrere Encoder hinweg kann der Overhead für den ersten Encoder erheblich reduziert werden Eintrag.
• Komprimieren Sie die Ausgabe: Durch die Verwendung von Komprimierungsbibliotheken wie compress/flate oder bzip2 kann die Dateigröße weiter reduziert werden, wobei bzip2 im bereitgestellten Test die höchste Effizienz erzielt (2,04 Byte/Eintrag). .

Code-Demonstration:

Der folgende Go-Code demonstriert die verschiedene Ansätze besprochen:

package main

import (
    "bytes"
    "compress/bzip2"
    "compress/flate"
    "compress/gzip"
    "compress/zlib"
    "encoding/gob"
    "fmt"
    "io"
)

type Entry struct {
    Key string
    Val string
}

func main() {
    // Create test data
    entries := make([]Entry, 1000)
    for i := 0; i < 1000; i++ {
        entries[i].Key = fmt.Sprintf("k%03d", i)
        entries[i].Val = fmt.Sprintf("v%03d", i)
    }

    // Test different encoding/compression techniques
    for _, name := range []string{"Naked", "flate", "zlib", "gzip", "bzip2"} {
        buf := &bytes.Buffer{}

        var out io.Writer
        switch name {
        case "Naked":
            out = buf
        case "flate":
            out, _ = flate.NewWriter(buf, flate.DefaultCompression)
        case "zlib":
            out, _ = zlib.NewWriterLevel(buf, zlib.DefaultCompression)
        case "gzip":
            out = gzip.NewWriter(buf)
        case "bzip2":
            out, _ = bzip2.NewWriter(buf, nil)
        }

        enc := gob.NewEncoder(out)
        for _, e := range entries {
            enc.Encode(e)
        }

        if c, ok := out.(io.Closer); ok {
            c.Close()
        }
        fmt.Printf("[%5s] Length: %5d, average: %5.2f / Entry\n",
            name, buf.Len(), float64(buf.Len())/1000)
    }
}

Ausgabe:

[Naked] Length: 16053, average: 16.05 / Entry
[flate] Length:  3988, average:  3.99 / Entry
[ zlib] Length:  3994, average:  3.99 / Entry
[ gzip] Length:  4006, average:  4.01 / Entry
[bzip2] Length:  1977, average:  1.98 / Entry

Wie aus der Ausgabe hervorgeht, reduziert der Einsatz von Komprimierungstechniken die Dateigröße erheblich, wobei bzip2 eine beeindruckende Leistung erzielt 1,98 Bytes/Eintrag.

Das obige ist der detaillierte Inhalt vonWie kann ich Go-Strukturen bei minimaler Dateigröße effizient auf die Festplatte serialisieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!