Отправка/анализ нескольких объектов JSON

У меня есть сервер Sinatra, который потоковым образом возвращает несколько объектов JSON из базы данных. Объекты будут выглядеть так:

{"a": 1, "b": 2, "c": 3}
{"a": 4, "b": 5, "c": 6}
...

но это недействительно JSON. Я могу добавить взлома в обработку событий Sinatra (вручную вставляя отсутствующие разделители массива), чтобы сделать ответ похожим:

[
{"a": 1, "b": 2, "c": 3}
, {"a": 4, "b": 5, "c": 6}
]

который теперь действителен JSON, но этот метод неэлегантен. Есть ли способ сделать это на стороне клиента? В принципе, я хочу, чтобы функция JavaScript читала строку и потребляла действительный объект JSON, а затем возвращала мне объект JSON и оставшуюся часть строки, итеративно вызываясь до тех пор, пока не будет уничтожена вся строка.

ОТВЕТЫ

Ответ 1

Нативная функция JSON.parse() ожидает, что вся строка будет действительной JSON. Я не знаю синтаксического анализатора, который потребляет только первый действительный объект, как вам хотелось бы. И люди должны действительно создавать действительный JSON в любом случае.

Если вы знаете, что есть один объект на строку, вы можете просто разбить строку за строкой с помощью функции split() и разобрать каждую строку отдельно.

var str = '{"a": 1, "b": 2, "c": 3}\n'+
          '{"a": 4, "b": 5, "c": 6}';

var strLines = str.split("\n");


for (var i in strLines) {
  var obj = JSON.parse(strLines[i]);
  console.log(obj.a);
}

Вы также можете использовать немного строковых манипуляций, чтобы преобразовать каждую строку в элемент массива и проанализировать все это.

str = "["+str.replace(/\n/g, ",")+"]";
JSON.parse(str);

Ответ 2

Если строки JSON являются одной строкой, вы можете сделать что-то вроде этого:

var splitPoint = remainingData.indexOf("\n");
var currentJSONStr = splitPoint > -1 ? remainingData.substr(0, splitPoint) : remainingData;
remainingData =  splitPoint > -1 ? remainingData.substr(splitPoint+1) : '';
var dataObj = youJSONDecodeFuncOrEval(currentJSONStr);

Если нет, просто игнорируйте мой ответ.

Надеюсь, это поможет вам,
Alin

Примечание. Я попытался выполнить требование

В принципе, я хочу, чтобы Функция JavaScript читает строку и потребляют действительный объект JSON, а затем верните мне объект JSON и остаток строки, итеративно вызывается до полной строки потребляется.

Вот почему я не использовал .split("\n").

Ответ 3

o.string - это json Object.

добавить некоторую строку типа "новый" в массив объектов или несколько объектов json.

например:

json object----

{"id":2,"method":"listWirings","params":{"language":"anonymousLanguage","name":"mytest","working":"{\"modules\":[{\"config\":{\"position\":[186,59],\"xtype\":\"WireIt.ImageContainer\"},\"name\":\"Start\",\"value\":{}},{\"config\":{\"position\":[188,265],\"xtype\":\"WireIt.ImageContainer\"},\"name\":\"Stop\",\"value\":{}}],\"properties\":{\"description\":\"gfd\",\"name\":\"gf\"},\"wires\":[{\"src\":{\"moduleId\":0,\"terminal\":\"_OUTPUT\"},\"tgt\":{\"moduleId\":1,\"terminal\":\"StpIn\"}}]}"},"version":"json-rpc-2.0"}new

  var str = o.toString();
                var s = str.split("new");
                for (var i = 0; i < s.length-1; i++)
                {
                    var r = YAHOO.lang.JSON.parse(s[i]);
                }

надеемся, что это приведет к анализу нескольких объектов json.

Ответ 4

Я бы сделал это:

var str = '{"a": 1, "b": 2, "c": 3}{"a": 4, "b": 5, "c": 6}';

var res = JSON.parse('[' + str.replace(/}{/g, '},{') + ']');

Ответ 5

используя рекурсию немного (но относительно то же, что и @Alin, и как @Alin, предполагая, что символы новой строки являются разделителями "\n".

Конечно, если ваша плохая кодированная строка JSON содержит новые строки, где не ожидалось, что это не сработает. Лично я исправлял источник, а не постоянно настраивал бы плохие исходные данные.

var jsonObject = [];
function parseBadJSON(str){
    var parseStr = "", remainder = "";
    if(str.indexOf("\n") != -1){
        parseStr = str.substr(0,str.indexOf("\n"));
        remainder = str.substr(str.indexOf("\n") + 1);
        jsonObject.push($.parseJSON(parseStr));
        if(remainder !== ""){
            parseBadJSON(remainder);
        }
    } else if(str != ""){
        jsonObject.push($.parseJSON(str));
    }
}

//Пример

var badJSON = '{"a":1,"b":2,"c":3}\n{"a":4,"b":5,"c":6}';
parseBadJSON(badJSON);
console.log(jsonObject);

Ответ 6

Это может быть не самое эффективное, но должно выполняться.

var s = '{"a": 1, "b": 2, "c": 3}{"a": 4, "b": 5, "c": 6}';
var sTemp = "";
var aObjs = [];
for(var i=0; i<s.length; ++i)
{
    sTemp += s[i];
    if (s[i] == "}")
    {
        aObjs.push(JSON.parse(sTemp));
        sTemp = "";
    }
}

Если вы знаете, что между объектами есть новый символ линии, он становится намного проще.

var sBad = '{"a": 1, "b": 2, "c": 3}\n{"a": 4, "b": 5, "c": 6}';
var sGood = "[" + sBad.replace(/\n/g, ",") + "]";
var aObjs = JSON.parse(sGood);

Ответ 7

Я написал java-конвертер (используя библиотеку jackson), который превращает несколько объектов JSON в файл в соответствующий массив JSON:

import java.io.File;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.MappingJsonFactory;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import com.fasterxml.jackson.databind.node.ObjectNode;

public class ParseJson {
    ObjectMapper mapper = new ObjectMapper();

  public static void main(String[] args) throws Exception {
      File file = new File(args[0]);
      JsonNode jn = new Parser().parse(file);

      System.out.println(jn.toString());
  }

  private enum ParserState {
      start,
      object,
      array,
      field,
      done
  };

  private static class Parser {   

      public Parser() {
      }

      public JsonNode parse(File file) throws Exception {
          JsonNodeFactory factory = JsonNodeFactory.instance;
          JsonFactory mappingFactory = new MappingJsonFactory();          
          @SuppressWarnings("deprecation")
        JsonParser jp = mappingFactory.createJsonParser(file);

          int n = 0;
          JsonNode result = null;
          JsonNode jn;

          while((jn = parseNode(jp, false)) != null) {
              if(n == 0) {
                  result = jn;
              } else if(n == 1) {
                  ArrayNode an = factory.arrayNode();
                  an.add(result);
                  an.add(jn);
                  result = an;
              } else if(n > 1) {
                  ArrayNode an = (ArrayNode)result;
                  an.add(jn);
              } else {
                  throw new Exception("Unexpected parser state");
              }
              n++;
          }

          return result;
      }

      private JsonNode parseNode(JsonParser jp, boolean current) throws Exception {
          JsonNodeFactory factory = JsonNodeFactory.instance;

          ParserState state = ParserState.start;
          JsonNode result = null;
          String fieldName = null;

          JsonToken token = current ? jp.getCurrentToken() : jp.nextToken();

          for(; token != null; token = jp.nextToken()) {

              // System.out.println("Token: "+token+": "+jp.getValueAsString());

              switch(token) {
                /**
                 * NOT_AVAILABLE can be returned if {@link JsonParser}
                 * implementation can not currently return the requested
                 * token (usually next one), or even if any will be
                 * available, but that may be able to determine this in
                 * future. This is the case with non-blocking parsers --
                 * they can not block to wait for more data to parse and
                 * must return something.
                 */
              case NOT_AVAILABLE: {
                  break;
              }

                /**
                 * START_OBJECT is returned when encountering '{'
                 * which signals starting of an Object value.
                 */
              case START_OBJECT: {
                    switch(state) {
                        case start: {
                            assert result == null;
                            assert fieldName == null;

                            result = factory.objectNode();
                            state = ParserState.object;
                            break;
                        }
                        case field: {
                            assert result != null;
                            assert fieldName != null;

                            ObjectNode on = (ObjectNode)result;
                            JsonNode jn = parseNode(jp, true);
                            on.set(fieldName, jn);
                            fieldName = null;
                            state = ParserState.object;
                            break;
                        }
                        case array: {
                            assert result != null;
                            assert fieldName == null;

                            ArrayNode an = (ArrayNode)result;
                            JsonNode jn = parseNode(jp, true);
                            an.add(jn);
                            break;
                        }
                        default: {
                            throw new Exception("Unexpected state: "+state+", for token: "+token);
                        }
                    }

                  break;                  
              }

                /**
                 * END_OBJECT is returned when encountering '}'
                 * which signals ending of an Object value
                 */
              case END_OBJECT: {
                    switch(state) {
                        case object: {
                            assert result != null;
                            assert fieldName == null;

                            state = ParserState.done;
                            break;
                        }
                        default: {
                            throw new Exception("Unexpected state: "+state+", for token: "+token);
                        }
                    }

                  break;                  
              }

                /**
                 * START_ARRAY is returned when encountering '['
                 * which signals starting of an Array value
                 */
              case START_ARRAY: {
                    switch(state) {
                        case start: {
                            assert result == null;
                            assert fieldName == null;

                            result = factory.arrayNode();
                            state = ParserState.array;
                            break;
                        }
                        case field: {
                            assert result != null;
                            assert fieldName != null;

                            ObjectNode on = (ObjectNode)result;
                            JsonNode jn = parseNode(jp, true);
                            on.set(fieldName, jn);
                            fieldName = null;
                            state = ParserState.object;
                            break;
                        }
                        case array: {
                            assert result != null;
                            assert fieldName == null;

                            ArrayNode an = (ArrayNode)result;
                            JsonNode jn = parseNode(jp, true);
                            an.add(jn);
                            break;
                        }
                        default: {
                            throw new Exception("Unexpected state: "+state+", for token: "+token);
                        }
                    }

                  break;                  
              }

                /**
                 * END_ARRAY is returned when encountering ']'
                 * which signals ending of an Array value
                 */
              case END_ARRAY: {
                    switch(state) {
                        case array: {
                            assert result != null;
                            assert fieldName == null;

                            state = ParserState.done;
                            break;
                        }
                        default: {
                            throw new Exception("Unexpected state: "+state+", for token: "+token);
                        }
                    }

                  break;                  
              }

                /**
                 * FIELD_NAME is returned when a String token is encountered
                 * as a field name (same lexical value, different function)
                 */
              case FIELD_NAME: {
                    fieldName = jp.getValueAsString();
                    switch(state) {
                        case object: {
                            assert result != null;
                            assert fieldName == null;

                            state = ParserState.field;
                            break;
                        }
                        default: {
                            throw new Exception("Unexpected state: "+state+", for token: "+token);
                        }
                    }

                    break;
              }

                /**
                 * Placeholder token returned when the input source has a concept
                 * of embedded Object that are not accessible as usual structure
                 * (of starting with {@link #START_OBJECT}, having values, ending with
                 * {@link #END_OBJECT}), but as "raw" objects.
                 *<p>
                 * Note: this token is never returned by regular JSON readers, but
                 * only by readers that expose other kinds of source (like
                 * <code>JsonNode</code>-based JSON trees, Maps, Lists and such).
                 */
              case VALUE_EMBEDDED_OBJECT: {
                  throw new Exception("Token not supported: "+token);
              }

                /**
                 * VALUE_STRING is returned when a String token is encountered
                 * in value context (array element, field value, or root-level
                 * stand-alone value)
                 */
              case VALUE_STRING: {
                    switch(state) {
                        case start: {
                            assert result == null;
                            assert fieldName == null;

                            result = factory.textNode(jp.getValueAsString());
                            state = ParserState.done;
                            break;
                        }
                        case field: {
                            assert result != null;
                            assert fieldName != null;

                            ObjectNode on = (ObjectNode)result;
                            JsonNode jn = factory.textNode(jp.getValueAsString());
                            on.set(fieldName, jn);
                            fieldName = null;
                            state = ParserState.object;
                            break;
                        }
                        case array: {
                            assert result != null;
                            assert fieldName == null;

                            ArrayNode an = (ArrayNode)result;
                            JsonNode jn = factory.textNode(jp.getValueAsString());
                            an.add(jn);
                            break;
                        }
                        default: {
                            throw new Exception("Unexpected state: "+state+", for token: "+token);
                        }
                    }

                    break;
              }

                /**
                 * VALUE_NUMBER_INT is returned when an integer numeric token is
                 * encountered in value context: that is, a number that does
                 * not have floating point or exponent marker in it (consists
                 * only of an optional sign, followed by one or more digits)
                 */
              case VALUE_NUMBER_INT: {
                    switch(state) {
                        case start: {
                            assert result == null;
                            assert fieldName == null;

                            result = factory.numberNode(jp.getLongValue());
                            state = ParserState.done;
                            break;
                        }
                        case field: {
                            assert result != null;
                            assert fieldName != null;

                            ObjectNode on = (ObjectNode)result;
                            JsonNode jn = factory.numberNode(jp.getLongValue());
                            on.set(fieldName, jn);
                            fieldName = null;
                            state = ParserState.object;
                            break;
                        }
                        case array: {
                            assert result != null;
                            assert fieldName == null;

                            ArrayNode an = (ArrayNode)result;
                            JsonNode jn = factory.numberNode(jp.getLongValue());
                            an.add(jn);
                            break;
                        }
                        default: {
                            throw new Exception("Unexpected state: "+state+", for token: "+token);
                        }
                    }

                    break;
              }

                /**
                 * VALUE_NUMBER_INT is returned when a numeric token other
                 * that is not an integer is encountered: that is, a number that does
                 * have floating point or exponent marker in it, in addition
                 * to one or more digits.
                 */
              case VALUE_NUMBER_FLOAT: {
                    switch(state) {
                        case start: {
                            assert result == null;
                            assert fieldName == null;

                            result = factory.numberNode(jp.getDoubleValue());
                            state = ParserState.done;
                            break;
                        }
                        case field: {
                            assert result != null;
                            assert fieldName != null;

                            ObjectNode on = (ObjectNode)result;
                            JsonNode jn = factory.numberNode(jp.getDoubleValue());
                            on.set(fieldName, jn);
                            fieldName = null;
                            state = ParserState.object;
                            break;
                        }
                        case array: {
                            assert result != null;
                            assert fieldName == null;

                            ArrayNode an = (ArrayNode)result;
                            JsonNode jn = factory.numberNode(jp.getDoubleValue());
                            an.add(jn);
                            break;
                        }
                        default: {
                            throw new Exception("Unexpected state: "+state+", for token: "+token);
                        }
                    }

                    break;
              }

                /**
                 * VALUE_TRUE is returned when encountering literal "true" in
                 * value context
                 */
              case VALUE_TRUE: {
                    switch(state) {
                        case start: {
                            assert result == null;
                            assert fieldName == null;

                            result = factory.booleanNode(true);
                            state = ParserState.done;
                            break;
                        }
                        case field: {
                            assert result != null;
                            assert fieldName != null;

                            ObjectNode on = (ObjectNode)result;
                            JsonNode jn = factory.booleanNode(true);
                            on.set(fieldName, jn);
                            fieldName = null;
                            state = ParserState.object;
                            break;
                        }
                        case array: {
                            assert result != null;
                            assert fieldName == null;

                            ArrayNode an = (ArrayNode)result;
                            JsonNode jn = factory.booleanNode(true);
                            an.add(jn);
                            break;
                        }
                        default: {
                            throw new Exception("Unexpected state: "+state+", for token: "+token);
                        }
                    }

                    break;
              }

                /**
                 * VALUE_FALSE is returned when encountering literal "false" in
                 * value context
                 */
              case VALUE_FALSE: {
                    switch(state) {
                        case start: {
                            assert result == null;
                            assert fieldName == null;

                            result = factory.booleanNode(false);
                            state = ParserState.done;
                            break;
                        }
                        case field: {
                            assert result != null;
                            assert fieldName != null;

                            ObjectNode on = (ObjectNode)result;
                            JsonNode jn = factory.booleanNode(false);
                            on.set(fieldName, jn);
                            fieldName = null;
                            state = ParserState.object;
                            break;
                        }
                        case array: {
                            assert result != null;
                            assert fieldName == null;

                            ArrayNode an = (ArrayNode)result;
                            JsonNode jn = factory.booleanNode(false);
                            an.add(jn);
                            break;
                        }
                        default: {
                            throw new Exception("Unexpected state: "+state+", for token: "+token);
                        }
                    }

                    break;
              }

                /**
                 * VALUE_NULL is returned when encountering literal "null" in
                 * value context
                 */
              case VALUE_NULL: {
                    switch(state) {
                        case start: {
                            assert result == null;
                            assert fieldName == null;

                            result = factory.nullNode();
                            state = ParserState.done;
                            break;
                        }
                        case field: {
                            assert result != null;
                            assert fieldName != null;

                            ObjectNode on = (ObjectNode)result;
                            JsonNode jn = factory.nullNode();
                            on.set(fieldName, jn);
                            fieldName = null;
                            state = ParserState.object;
                            break;
                        }
                        case array: {
                            assert result != null;
                            assert fieldName == null;

                            ArrayNode an = (ArrayNode)result;
                            JsonNode jn = factory.nullNode();
                            an.add(jn);
                            break;
                        }
                        default: {
                            throw new Exception("Unexpected state: "+state+", for token: "+token);
                        }
                    }

                    break;
              }

              default: {
                  throw new Exception("Token not supported: "+token);
              }

              }

              if(state == ParserState.done) {
                  break;
              }
          }           

          return result;
      }
  }
}