recorrer - ¿Puede un valor JSON contener una cadena multilínea?

serialize json javascript

Question

Estoy escribiendo un archivo JSON que sería leído por un programa Java. El fragmento es el siguiente ...

{
  "testCases" :
  {
    "case.1" :
    {
      "scenario" : "this the case 1.",
      "result" : "this is a very long line which is not easily readble.
                  so i would like to write it in multiple lines.
                  but, i do NOT require any new lines in the output.
                  I need to split the string value in this input file only.
                  such that I don''t require to slide the horizontal scroll again and again while verifying the correctness of the statements.
                  the prev line, I have shown, without splitting just to give a feel of my problem"
    }
  }
}

Answer 1

¡Mira la especificación ! La producción de charla de la gramática JSON puede tomar los siguientes valores:

• cualquier-Unicode-character-except- " -or- / -or-control-character
• /"
• //
• //
• /b
• /f
• /n
• /r
• /t
• /u cuatro-hex-dígitos

Las líneas nuevas son "caracteres de control", por lo tanto, no, es posible que no tenga una nueva línea literal dentro de la cadena. Sin embargo, puedes codificarlo usando la combinación de /n y /r que necesites.

La herramienta JSONLint confirma que su JSON no es válido.

Actualización: Y si quiere escribir nuevas líneas dentro de su sintaxis JSON sin incluir realmente nuevas líneas en los datos, entonces está doblemente sin suerte. Si bien JSON está pensado para ser humano hasta cierto punto, sigue siendo información y está tratando de aplicar un formato arbitrario a esa información. De eso no se trata en absoluto JSON.

Answer 2

Como pude entender, la pregunta no es cómo pasar una cadena con símbolos de control usando json sino cómo almacenar y restaurar json en un archivo donde se puede dividir una cadena con símbolos de control del editor.

Si desea almacenar cadenas de varias líneas en un archivo, entonces su archivo no almacenará el objeto json válido. Pero si utiliza los archivos json en su programa, puede almacenar los datos como lo desee y eliminar manualmente todas las líneas nuevas del archivo cada vez que lo cargue en su programa y luego pasarlo a json parser.

O bien, como alternativa, lo que sería mejor, puede tener sus archivos fuente de datos json donde puede editar una picadura como desee y luego eliminar todas las líneas nuevas con alguna utilidad para el archivo json válido que usará su programa.

Answer 3

Creo que depende de qué intérprete json estés usando ... en javascript simple podrías usar terminadores de línea

{
  "testCases" :
  {
    "case.1" :
    {
      "scenario" : "this the case 1.",
      "result" : "this is a very long line which is not easily readble. /
                  so i would like to write it in multiple lines. /
                  but, i do NOT require any new lines in the output."
    }
  }
}

Answer 4

Esto se implementa como escritor porque para el carácter individual puede haber múltiples caracteres de salida. No podría imaginar esto como lector. Bastante pesado para la tarea pero bastante extensible.

String multilineJson = "{/n" +
        "prop1 = /"value1/",/n" +
        "prop2 = /"multi line/n" +
        "value2/"/n" +
        "}/n";
String multilineJsonExpected = "{/n" +
        "prop1 = /"value1/",/n" +
        "prop2 = /"multi line//nvalue2/"/n" +
        "}/n";

StringWriter sw = new StringWriter();
JsonProcessor jsonProcessor = new JsonProcessor(sw);
jsonProcessor.write(multilineJson);

assertEquals(multilineJsonExpected, sw.toString());

Implementación

public class JsonProcessor extends FilterWriter {

    private char[] curr;
    private int currIdx;

    private boolean doubleQuoted;

    public JsonProcessor(Writer out) {
        super(out);
    }

    @Override
    public void write(String str) throws IOException {
        char[] arr = str.toCharArray();
        write(arr, 0, arr.length);
    }

    @Override
    synchronized public void write(char[] cbuf, int off, int len) throws IOException {
        curr = Arrays.copyOfRange(cbuf, off, len - off);
        for (currIdx = 0; currIdx < curr.length; currIdx++) {
            processChar();
        }
    }

    private void processChar() throws IOException {
        switch (currentChar()) {
            case ''"'':
                processDoubleQuotesSymbol();
                break;
            case ''/n'':
            case ''/r'':
                processLineBreakSymbol();
                break;
            default:
                write(currentChar());
                break;
        }
    }

    private void processDoubleQuotesSymbol() throws IOException {
        doubleQuoted = !doubleQuoted;
        write(''"'');
    }

    private void processLineBreakSymbol() throws IOException {
        if (doubleQuoted) {
            write(''//');
            write(''n'');
            if (lookAhead() == ''/n'' || lookAhead() == ''/r'') {
                currIdx++;
            }
        } else {
            write(currentChar());
        }
    }

    private char currentChar() {
        return curr[currIdx];
    }

    private char lookAhead() {
        if (currIdx >= curr.length) {
            return 0;
        }
        return curr[currIdx + 1];
    }
}

Answer 5

No es una solución muy buena, pero puedes probar la herramienta hjson . Link . Le permite escribir texto multi-alineado en el editor y luego lo convierte al formato JSON válido. Nota: agrega ''/ n'' caracteres para las nuevas líneas, pero puede simplemente eliminarlos en cualquier editor de texto con la función "Reemplazar todo ...".

PD: debe ser un comentario a la pregunta, pero no tiene suficiente repo, lo siento.

Answer 6

No estoy seguro de su requisito exacto, pero una posible solución para mejorar la ''legibilidad'' es almacenarlo como una matriz.

{
  "testCases" :
  {
    "case.1" :
    {
      "scenario" : "this the case 1.",
      "result" : ["this is a very long line which is not easily readble.",
                  "so i would like to write it in multiple lines.",
                  "but, i do NOT require any new lines in the output."]
    }
  }
}

}

La unión regresa nuevamente cuando sea requerido con

result.join(" ")