Wie kann ich mit Go-Yaml ganzzahlige Werte in Hex umwandeln?

Der PHP-Editor Banana zeigt Ihnen, wie Sie mit go-yaml ganzzahlige Werte in Hexadezimalzahlen umwandeln. go-yaml ist eine Go-Sprachbibliothek zur Verarbeitung von Daten im YAML-Format, die eine einfache und benutzerfreundliche API bietet. Um einen Ganzzahlwert in einen Hexadezimalwert umzuwandeln, können wir die Ganzzahl zunächst in einen Byte-Slice konvertieren und dann die Funktion fmt.Sprintf verwenden, um den Byte-Slice in eine hexadezimale Zeichenfolge zu formatieren. Schließlich können wir die go-yaml-Bibliothek verwenden, um den formatierten String in eine YAML-Datei zu schreiben. Diese Methode ist einfach und effizient und kann unsere Anforderungen erfüllen. Schauen wir uns als Nächstes die konkreten Umsetzungsschritte genauer an.

Frageninhalt

Ich habe eine Struktur mit einem ganzzahligen Feld, das für Menschen in einer hexadezimalen Darstellung von Bedeutung ist. Legen Sie dies beispielsweise auf das Feld „Vendor ID“ fest. Ich möchte diese Daten zur manuellen Bearbeitung in einer YAML-Datei speichern und sie dann aus der Datei laden. Soweit ich weiß, gibt es kein Problem mit der hexadezimalen Darstellung von Zahlen in YAML selbst, aber

) kodiert ganze Zahlen in Dezimalform, und ich habe keinen normalen Weg gefunden, sie dazu zu bringen, sie in Hexadezimalform zu speichern.

go-yaml （我使用 v3Nehmen wir den folgenden Code als Ausgangspunkt:

import (
    //...
    "gopkg.in/yaml.v3"
)

type DeviceInfo struct {
    VendorId uint32 `yaml:"vendorid"`
}

func main() {
    deviceInfo := DeviceInfo{VendorId: 0xdeadbeef}

    yml, err := yaml.Marshal(deviceInfo)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(string(yml))
}

Dieser Code generiert YAML mit Dezimalwerten:

vendorid: 3735928559

Als nächstes

Präfix):

type Uint32Hex uint32

func (U Uint32Hex) MarshalYAML() (interface{}, error) {
    return fmt.Sprintf("%x", U), nil
}

type DeviceInfo struct {
    VendorId Uint32Hex `yaml:"vendorid"`
}

func main() {
    // the same code
}

go-yaml 允许您为自己的类型创建自定义封送拆收器。我这样做了（我故意省略了 fmt.Sprintf() 格式字符串中的 0xDieser Code generiert Hexadezimalwerte ohne das Präfix

(vorerst logisch):

vendorid: deadbeef

0xAber wenn ich im benutzerdefinierten Marshaller das Präfix

hinzufüge:

func (U Uint32Hex) MarshalYAML() (interface{}, error) {
    return fmt.Sprintf("0x%x", U), nil
}

0xDer Wert wird korrekt generiert, ist aber keine Zahl, sondern eine Zeichenfolge:

vendorid: "0xdeadbeef"

Um diese Zeile in Zahlen zu entmarshalieren, musste ich auch einen benutzerdefinierten Unmarshaler schreiben. Diese Lösung gefällt mir nicht.

Abschließend habe ich noch folgende Fragen:

Gibt es eine einfache Möglichkeit, Hexadezimalzahlen mit
1. zu generieren, die ich nicht gefunden habe?

   go-yaml

Ist es möglich, einen benutzerdefinierten Encoder basierend auf
2. als Erweiterung eines Pakets zu erstellen, ohne das Paket selbst zu ändern? Für mich ist es bequemer, das Format-Tag in der Strukturbeschreibung zu übergeben, beispielsweise so:

   type DeviceInfo struct {
       VendorId uint32 `yaml:"vendorid,hex"`
   }
   

   go-yaml

Wenn dies Änderungen am Paketcode erfordert, wie geht Go in dieser Situation vor? Einfach die Paketdatei in mein Projekt kopieren, nach Bedarf ändern und lokal importieren?

Workaround

Das Problem hierbei ist, dass das Zitieren von Zeichenfolgen in Yaml optional ist, aber

dasselbe interne Schema wie der JSON-Encoder verwendet. Dies bedeutet, dass zuerst das benutzerdefinierte Marshalling durchgeführt wird und dann die Zitierlogik völlig unabhängig angewendet wird. Auf deadbeef wird nicht verwiesen, aber der Grund, warum auf 0xdeadbeef verwiesen wird, liegt darin, dass Letzteres

eine Zahl go-yaml 使用与 JSON 编码器相同的内部架构。这意味着首先处理自定义封送处理，然后完全独立地应用引用逻辑。 deadbeef 没有被引用，但 0xdeadbeef 被引用的原因是因为后者是一个数字。它被引用，这样当它知道它应该是一个字符串时，它就不会意外地被解组为数字，因为您的自定义封送拆收器返回了一个字符串。由于 deadbeef ist. Es wird in Anführungszeichen gesetzt, damit es nicht versehentlich in eine Zahl umgewandelt wird, da Ihr benutzerdefinierter Marshaller eine Zeichenfolge zurückgibt, obwohl er weiß, dass es sich um eine Zeichenfolge handeln soll. Da deadbeef nicht als gültige Zahl gelesen werden kann, sind keine Anführungszeichen erforderlich. Du kannst zwei Dinge tun:

1. Benutzerdefiniertes Marshalling/Unmarshalling aus Strings:

func (U *Uint32Hex) UnmarshalYAML(value *yaml.Node) error {
    parsed, err := strconv.ParseUint(value.Value, 0, 32)
    *U = Uint32Hex(parsed)
    return err
}

Fork go-yaml 并修改它。如果您这样做，则不应更改源文件中的导入。相反，您应该将 replace 指令添加到 go.mod und modifizieren Sie es. Wenn Sie dies tun, sollten die Importe in der Quelldatei nicht geändert werden. Stattdessen sollten Sie die replace-Direktive wie folgt zu go.mod hinzufügen:

require gopkg.in/yaml.v3 v3.0.1

replace gopkg.in/yaml.v3 v3.0.1 => ../yaml.v3 // Your local path to the fork

Ich bevorzuge Lösung 1, weil Sie damit die Werte nach Belieben serialisieren können, ohne vom von anderen generierten Yaml abzuweichen, und Sie keinen Zweig pflegen müssen.

Das obige ist der detaillierte Inhalt vonWie kann ich mit Go-Yaml ganzzahlige Werte in Hex umwandeln?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!