Golang verarbeitet JSON-Kommentare

Während des Golang-Entwicklungsprozesses stoßen wir häufig auf Situationen, in denen JSON verarbeitet werden muss. Die Verarbeitung von Kommentaren in JSON ist jedoch ein sehr problematisches Problem. Die Verwendung von Kommentaren in JSON-Dateien kann Entwicklern helfen, den Code besser zu verstehen und zu verwalten, die Standard-JSON-Bibliothek unterstützt jedoch keine Kommentare. Wie kann man dieses Problem lösen?

1. Die Golang-Standardbibliothek kann keine JSON-Kommentare verarbeiten. Das erste, was Sie verstehen müssen, ist, dass die Standard-Golang-JSON-Bibliothek keine Kommentare in JSON verarbeiten kann. Selbst wenn wir Kommentare zu JSON hinzufügen, können diese nicht mit JSON analysiert werden. Unmarshal()-Funktion. Daher müssen wir andere Lösungen finden, um dieses Problem zu lösen.

2. Bibliotheken von Drittanbietern

Durch die Suche können wir einige Bibliotheken von Drittanbietern finden, wie zum Beispiel: encorehu/json-annotate, jbarratt/jsonparser oder pebbe/util usw. Sie können alle die Verarbeitung von JSON-Annotationen unterstützen, aber Sie sind schwierig zu verwenden. Es ist mühsamer und Sie müssen es selbst kapseln oder eine Sekundärentwicklung durchführen.

3. Benutzerdefinierter Parser

Die dritte Methode besteht darin, einen benutzerdefinierten Parser zu verwenden. Sie können Ihren eigenen Parser schreiben, um Kommentare in JSON-Dateien zu verarbeiten. Diese Methode ist die flexibelste und kann an die tatsächlichen Bedürfnisse angepasst werden.

Das Folgende ist ein Beispielcode für die Verwendung des benutzerdefinierten Golang-Parsers zum Parsen von JSON-Dateien, die Kommentare enthalten:

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
    "unicode"
)

type JsonScanner struct {
    r *bufio.Reader
}

func NewJsonScanner(r io.Reader) *JsonScanner {
    return &JsonScanner{
        r: bufio.NewReader(r),
    }
}

func (s *JsonScanner) read() (rune, error) {
    char, _, err := s.r.ReadRune()
    return char, err
}

func (s *JsonScanner) unread() error {
    return s.r.UnreadRune()
}

func (s *JsonScanner) Scan() (string, error) {
    var c rune
    var err error
    var token []rune
    var inComment bool

    for {
        c, err = s.read()
        if err != nil {
            break
        }

        if !inComment {
            if unicode.IsSpace(c) || c == ',' || c == ':' || c == '{' || c == '}' || c == '[' || c == ']' || c == '"' {
                if err = s.unread(); err != nil {
                    break
                }
                break
            }
        }

        token = append(token, c)

        if c == '/' {
            nextChar, err := s.read()
            if err == nil && nextChar == '/' {
                inComment = true
            } else {
                err = s.unread()
                break
            }
        } else if c == '
' {
            inComment = false
        }
    }

    if inComment {
        return "", fmt.Errorf("comment not closed")
    }

    return string(token), err
}

func parseJson(r io.Reader) error {
    scanner := NewJsonScanner(r)

    for {
        token, err := scanner.Scan()
        if err == io.EOF {
            break
        } else if err != nil {
            return err
        }

        fmt.Println(token)
    }

    return nil
}

func main() {
    f, _ := os.Open("test.json")
    defer f.Close()

    if err := parseJson(f); err != nil {
        fmt.Printf("parseJson error: %v
", err)
    }
}

4 Kommentarregeln

Obwohl der benutzerdefinierte Parser Kommentare verarbeiten kann, müssen wir auch einige Regeln für Kommentare festlegen, um ihn besser zu machen Bequemes Schreiben und Verwalten von JSON-Dateien mit Kommentaren. Hier ist ein Verweis auf einige Kommentarregeln:

Einzeilige Kommentare beginnen mit „//“ und enden am Ende der Zeile.

1. {
   "name": "test", // 名称
   "age": 22 // 年龄
   }

Mehrzeilige Kommentare beginnen mit „/
2. “ und enden mit „

   /“.

   {
   "name": "test", /* 名称 */
   "age": 22 /* 年龄 */
   }

   Anmerkungen können überall dort erscheinen, wo es sich nicht um Zeichenfolgen, Zahlen und boolesche Werte handelt.
3. 4. Zusammenfassung

   Es kann mühsam sein, JSON-Dateien mit Kommentaren in Golang zu verarbeiten, aber wir können Bibliotheken von Drittanbietern oder benutzerdefinierte Parser verwenden, um dieses Problem zu lösen. Benutzerdefinierte Parser können die flexibelste Verarbeitung erreichen, erfordern jedoch zusätzliche Entwicklungskosten. Auch Anmerkungsregeln müssen für eine bessere Anwendung standardisiert werden.

   Das obige ist der detaillierte Inhalt vonGolang verarbeitet JSON-Kommentare. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!