How to check string is in json format

I want to create a function to receive an input string which can be string in json format or just a string. For example, something easy like following function.

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

For anyone else looking for a way to validate any JSON string regardless of schema, try the following:

func IsJSON(str string) bool {
	var js json.RawMessage
	return json.Unmarshal([]byte(str), &js) == nil
}

I was unclear if you needed to know about just a "quoted string" or if you needed to know about json, or the difference between both of them, so this shows you how to detect both scenarios so you can be very specific.

I posted the interactive code sample here as well: 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))
	}

}

Which will output this:

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

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

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

Standard encoding/json library contains json.Valid function starting from go 1.9 - see https://github.com/golang/go/issues/18086 . This function may be used for checking whether the provided string is a valid json:

if json.Valid(input) {
    // input contains valid json
}

But json.Valid may be quite slow comparing to third-party solutions such as fastjson.Validate, which is up to 5x faster than the standard json.Valid - see json validation section in benchmarks.

For example,

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`))
}

Output:

true
false

This might be an older post to the actual function in the standard library.

But you can just use the json.Valid() function in the "encoding/json" package.

   var tests = []string{
	`"Platypus"`,
	`Platypus`,
	`{"id":"1"}`,
	`{"id":"1}`,
}

for _, t := range tests {
	fmt.Printf("is valid: (%s) = %v\n", t, json.Valid([]byte(t)))
	
}

example https://play.golang.org/p/nfvOzQB919s

In searching for an answer to this question, I found https://github.com/asaskevich/govalidator, which was tied to this blog post which describes creating an input validator: https://husobee.github.io/golang/validation/2016/01/08/input-validation.html. Just in case someone is looking for a quick library on doing this, I thought it would be useful to put that tool in an easy-to-find place.

This package uses the same method for isJSON that William King suggests, as follows:

// 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
}

This package gave me some greater insight into JSON in go, so it seemed useful to put here.

The current accepted answer (as of July 2017) fails for JSON arrays and hasn't been updated: https://repl.it/J8H0/10

Try this:

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

Or William King's solution, which is better.

how about you use something like this:

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