Un moyen facile de vérifier la chaîne est au format json en golang?

Je veux créer une fonction pour recevoir une entrée de chaîne de caractères qui peut être à chaîne au format json ou tout simplement une chaîne de caractères. Par exemple, quelque chose de facile comme suit la fonction.

func checkJson(input string){
   if ... input is in json ... {
      fmt.Println("it's json!")
   } else {
      fmt.Println("it's normal string!")
   }
}

source d'informationauteur A-letubby

go json

Je ne sait pas si vous avez besoin de savoir sur juste une "chaîne" ou si vous avez besoin de savoir sur json, ou la différence entre les deux d'entre eux, si cela vous montre comment détecter à la fois les scénarios de sorte que vous pouvez être très précis.

J'ai posté interactive exemple de code ici: http://play.golang.org/p/VmT0BVBJZ7

package main

import (
    "encoding/json"
    "fmt"
)

func isJSONString(s string) bool {
    var js string
    return json.Unmarshal([]byte(s), &js) == nil

}

func isJSON(s string) bool {
    var js map[string]interface{}
    return json.Unmarshal([]byte(s), &js) == nil

}

func main() {
    var tests = []string{
        `"Platypus"`,
        `Platypus`,
        `{"id":"1"}`,
    }

    for _, t := range tests {
        fmt.Printf("isJSONString(%s) = %v\n", t, isJSONString(t))
        fmt.Printf("isJSON(%s) = %v\n\n", t, isJSON(t))
    }

}

Qui sera de sortie ce:

isJSONString("Platypus") = true
isJSON("Platypus") = false

isJSONString(Platypus) = false
isJSON(Platypus) = false

isJSONString({"id":"1"}) = false
isJSON({"id":"1"}) = true

27

Pour quelqu'un d'autre à la recherche d'un moyen de valider la chaîne JSON quel que soit le schéma, essayez les solutions suivantes:
```
func IsJSON(str string) bool {
    var js json.RawMessage
    return json.Unmarshal([]byte(str), &js) == nil
}
```

Par exemple,

package main

import (
    "encoding/json"
    "fmt"
)

func isJSONString(s string) bool {
    var js string
    err := json.Unmarshal([]byte(s), &js)
    return err == nil
}

func main() {
    fmt.Println(isJSONString(`"Platypus"`))
    fmt.Println(isJSONString(`Platypus`))
}

De sortie:

true
false

1

L'actuel accepté de répondre (juillet 2017) échoue pour JSON tableaux et n'a pas été mis à jour à: https://repl.it/J8H0/10

Essayez ceci:
```
func isJSON(s string) bool {
  var js interface{}
  return json.Unmarshal([]byte(s), &js) == nil
}
```
Ou William King de la solution, ce qui est mieux.
1

Standard encoding/json bibliothèque contient json.Valide fonction à partir de aller de 1,9 voir https://github.com/golang/go/issues/18086 . Cette fonction peut être utilisée pour vérifier si la condition de chaîne est un json valide:
```
if json.Valid(input) {
    //input contains valid json
}
```
Mais json.Valid peut être assez lente comparant à des solutions tierces telles que fastjson.Validerqui est jusqu'à 5 fois plus rapide que la norme json.Valid - voir json validation section dans repères.

que diriez-vous d'utiliser quelque chose comme ceci:

if err := json.Unmarshal(input, temp_object); err != nil {
    fmt.Println("it's normal string!")
} else {
    fmt.Println("it's json!")
}

0

Dans la recherche d'une réponse à cette question, j'ai trouvé https://github.com/asaskevich/govalidatorqui était attachée à ce blog qui décrit la création d'un programme de validation d'entrée: https://husobee.github.io/golang/validation/2016/01/08/input-validation.html. Juste au cas où quelqu'un est à la recherche d'une bibliothèque rapide de le faire, j'ai pensé qu'il serait utile de mettre cet outil à un facile à trouver l'endroit.

Ce package utilise la même méthode pour isJSON que William King suggère, comme suit:
```
//IsJSON check if the string is valid JSON (note: uses json.Unmarshal).
func IsJSON(str string) bool {
    var js json.RawMessage
    return json.Unmarshal([]byte(str), &js) == nil
}
```
Ce paquet m'a donné un peu plus de perspicacité dans JSON en aller, il m'a donc semblé utile de mettre ici.

Vous devez vous connecter pour publier un commentaire.