golang gère les commentaires json

Pendant le processus de développement de Golang, nous rencontrons souvent des situations où json doit être traité. Cependant, le traitement des commentaires en json est un problème très gênant. L'utilisation de commentaires dans les fichiers json peut aider les développeurs à mieux comprendre et maintenir le code, mais la bibliothèque json standard ne prend pas en charge les commentaires. Alors, comment résoudre ce problème ?

1. La bibliothèque standard golang ne peut pas gérer les commentaires json

La première chose que vous devez comprendre est que la bibliothèque standard golang json ne peut pas gérer les commentaires dans json, même si nous ajoutons des commentaires à json, il ne peut pas être analysé à l'aide de json. Fonction Unmarshal() . Nous devons donc trouver d’autres solutions pour résoudre ce problème.

2. Bibliothèques tierces

En effectuant une recherche, nous pouvons trouver des bibliothèques tierces, telles que : encorehu/json-annotate, jbarratt/jsonparser ou pebbe/util, etc. Elles peuvent toutes prendre en charge le traitement des annotations json, mais ils sont difficiles à utiliser. C'est plus gênant et vous devez l'encapsuler vous-même ou effectuer un développement secondaire.

3. Analyseur personnalisé

La troisième méthode consiste à utiliser un analyseur personnalisé. Vous pouvez écrire votre propre analyseur pour traiter les commentaires dans les fichiers json. Cette méthode est la plus flexible et peut être personnalisée en fonction des besoins réels.

Ce qui suit est un exemple de code pour utiliser l'analyseur personnalisé Golang pour analyser les fichiers json contenant des commentaires :

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. Règles de commentaire

Bien que l'analyseur personnalisé puisse gérer les commentaires, nous devons également stipuler certaines règles pour les commentaires afin de le rendre plus efficace. pratique. Écrivez et gérez facilement des fichiers JSON annotés. Voici une référence à quelques règles de commentaires :

1. Les commentaires sur une seule ligne commencent par "//" et se terminent à la fin de la ligne.

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

2. Les commentaires sur plusieurs lignes commencent par "/" et se terminent par "/".

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

3. Les annotations peuvent apparaître n'importe où qui ne sont pas des chaînes, des nombres et des valeurs booléennes.

4. Résumé

Il peut être difficile de traiter des fichiers json contenant des commentaires en golang, mais nous pouvons utiliser des bibliothèques tierces ou des analyseurs personnalisés pour résoudre ce problème. Les analyseurs personnalisés peuvent réaliser le traitement le plus flexible, mais nécessitent des coûts de développement supplémentaires. Les règles d'annotation doivent également être standardisées pour une meilleure application.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!