Regex to find if the partial input is valid JSON

Question

I have a scenario where I need to validate whether the partial input(see below) is valid JSON or not? I have referred this answer to identify whether the given string is a valid JSON or not.

Example input:

 { 
 "JSON": [{
      "foo":"bar",
      "details": {
           "name":"bar",
           "id":"bar",

What I have tried so far:

/ (?(DEFINE)
         (?<number>   -? (?= [1-9]|0(?!\d) ) \d+ (\.\d+)? ([eE] [+-]? \d+)? )
         (?<boolean>   true | false | null )
         (?<string>    " ([^"\n\r\t\\\\]* | \\\\ ["\\\\bfnrt\/] | \\\\ u [0-9a-f]{4} )* " )
         (?<array>     \[  (?:  (?&json)  (?: , (?&json)  )*  )?  \s* \]{0,1} )
         (?<pair>      \s* (?&string) \s* : (?&json)  )
         (?<object>    \{  (?:  (?&pair)  (?: , (?&pair)  )*  )?  \s* \}{0,1} )
         (?<json>   \s* (?: (?&number) | (?&boolean) | (?&string) | (?&array) | (?&object) ) \s* )
) \A (?&json)\,{0,1} \Z /six

I made the closing of the array and objects optional(allow zero or one time). But there are some cases where this will fail, for example when you open a object without closing another object(shown below) the regex will still find a match.

Invalid, but still matches:

 { 
 "JSON": [{
      "foo":"bar",
      "details": {
           "name":"bar",
           "id":"bar",{

How to validate the partial JSON input?

EDIT:

As mentioned by @ntahdh in the comments, this regex won't work using the java.util.regex. So now I need a regex which should work without recursion

Answer 1

This is not quite an answer to you question and would have been if the form of a comment if the number of characters allowed for that were adequate.

JSON is not a regular language and cannot therefore be recognized solely by a regular expression engine (if you are programming in Python, the regex package provides extensions that might make it possible to accomplish your task, but what I said is generally true).

If a parser generator is not available for your preferred language, you might consider creating a simple recursive descent parser. The regular expressions you have already defined will serve you well for creating the tokens that will be the input to that parser. Of course, you will expect that a parsing error will occur -- but it should occur on the input token being the end-of-file token. A parsing error that occurs before the end-of-file token has been scanned suggests you do not have a prefix of valid JSON. If you are working with a bottom-up, shift-reduce parser such as one generated with YACC, then this would be a shift error on something other than the end-of-file token.

Answer 2

why not let a parser like Gson do it for you, you basically deal with a stream and at a token level.

import java.io.IOException;
import java.io.StringReader;

import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;

public class Main 
{
    public static void main(String[] args) throws Exception 
    {

        String json = "{'id': 1001,'firstName': 'Lokesh','lastName': 'Gupta','email': null}";

        JsonReader jsonReader = new JsonReader(new StringReader(json));
        jsonReader.setLenient(true);

        try
        {
            while (jsonReader.hasNext()) 
            {
                JsonToken nextToken = jsonReader.peek();

                if (JsonToken.BEGIN_OBJECT.equals(nextToken)) {

                    jsonReader.beginObject();

                } else if (JsonToken.NAME.equals(nextToken)) {

                    String name = jsonReader.nextName();
                    System.out.println("Token KEY >>>> " + name);

                } else if (JsonToken.STRING.equals(nextToken)) {

                    String value = jsonReader.nextString();
                    System.out.println("Token Value >>>> " + value);

                } else if (JsonToken.NUMBER.equals(nextToken)) {

                    long value = jsonReader.nextLong();
                    System.out.println("Token Value >>>> " + value);

                } else if (JsonToken.NULL.equals(nextToken)) {

                    jsonReader.nextNull();
                    System.out.println("Token Value >>>> null");

                } else if (JsonToken.END_OBJECT.equals(nextToken)) {

                    jsonReader.endObject();

                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            jsonReader.close();
        }
    }
}

source: https://howtodoinjava.com/gson/jsonreader-streaming-json-parser/

Answer 3

I know that using regex to validate some strings with nested structures is not easy, if not unfeasible at all. You will probably have more chance using an existing JSON parser.

Use a stack to keep track of still opened objects and arrays. Add required closing curly and square brackets. Ask to the JSON parser if your new string is a valid JSON.

You will probably have to do some work to handle commas and quotes too, but you get the idea.

With a code sample:

import com.google.gson.JsonParser;
import com.google.gson.JsonSyntaxException;

import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        String valid = "{\n" +
                       "\"JSON\": [{\n" +
                       "    \"foo\":\"bar\",\n" +
                       "    \"details\": {\n" +
                       "         \"name\":\"bar\",\n" +
                       "         \"id\":\"bar\"";
        System.out.println("Is valid?:\n" + valid + "\n" + validate(valid));

        String invalid = "{ \n" +
                         " \"JSON\": [{\n" +
                         "      \"foo\":\"bar\",\n" +
                         "      \"details\": {\n" +
                         "           \"name\":\"bar\",\n" +
                         "           \"id\":\"bar\",{";
        System.out.println("Is valid?:\n" + invalid + "\n" + validate(invalid));
    }

    public static boolean validate(String input) {
        Stack<String> closings = new Stack<>();

        for (char ch: input.toCharArray()) {
            switch(ch) {
                case '{':
                    closings.push("}");
                    break;
                case '[':
                    closings.push("]");
                    break;
                case '}':
                case ']':
                    closings.pop();
            }
        }

        StringBuilder closingBuilder = new StringBuilder();
        while (! closings.empty()) {
            closingBuilder.append(closings.pop());
        }
        String fullInput = input + closingBuilder.toString();
        JsonParser parser = new JsonParser();
        try{
            parser.parse(fullInput);
        }
        catch(JsonSyntaxException jse){
            return false;
        }
        return true;
    }
}

Which results in:

Is valid?:
{
"JSON": [{
    "foo":"bar",
    "details": {
         "name":"bar",
         "id":"bar"
true
Is valid?:
{ 
 "JSON": [{
      "foo":"bar",
      "details": {
           "name":"bar",
           "id":"bar",{
false

Note that adding a comma after the "bar" line in the valid example make it invalid (because "bar",}]}} is an invalid JSON).