Come gestisco le newline in JSON?

Ho generato alcuni JSON e sto cercando di inserirlo in un oggetto in JavaScript. Continuo a ricevere errori. Ecco cosa ho:

var data = '{"count" : 1, "stack" : "sometext\n\n"}';
var dataObj = eval('('+data+')');

Questo mi dà un errore:

unterminated string literal

Con JSON.parse(data), vedo messaggi di errore simili: " Unexpected token ↵" in Chrome e " unterminated string literal" in Firefox e IE.

Quando tolgo il \ndopo sometextl'errore scompare in entrambi i casi. Non riesco a capire il motivo per cui il \nmake evaland JSON.parsefail.

Immagino che questo sia quello che vuoi:

var data = '{"count" : 1, "stack" : "sometext\\n\\n"}';

(È necessario sfuggire al "\" nella stringa (trasformandolo in un doppio - "\"), altrimenti diventerà una nuova riga nell'origine JSON, non i dati JSON.)

Avrete bisogno di avere una funzione che sostituisce \na \\nnel caso in cui datanon è un letterale stringa.

function jsonEscape(str)  {
    return str.replace(/\n/g, "\\\\n").replace(/\r/g, "\\\\r").replace(/\t/g, "\\\\t");
}

var data = '{"count" : 1, "stack" : "sometext\n\n"}';
var dataObj = JSON.parse(jsonEscape(data));

Il risultato dataObjsarà

Object {count: 1, stack: "sometext\n\n"}

Secondo le specifiche, http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf :

Una stringa è una sequenza di punti di codice Unicode racchiusi tra virgolette ( U+0022). Tutti i caratteri possono essere inseriti tra virgolette ad eccezione dei caratteri che devono essere sfuggiti: virgolette ( U+0022), reverse solidus ( U+005C) e i caratteri di controllo U+0000perU+001F . Esistono rappresentazioni di sequenze di escape a due caratteri di alcuni personaggi.

Quindi non puoi passare 0x0Ao 0x0Ccodici direttamente. È vietato! La specifica suggerisce di utilizzare sequenze di escape per alcuni codici ben definiti da U+0000a U+001F:

• \frappresenta il carattere di feed del modulo ( U+000C).
• \nrappresenta il carattere di avanzamento riga ( U+000A).

Poiché la maggior parte dei linguaggi di programmazione utilizza \per il preventivo, è necessario evitare la sintassi di escape (double-escape - una volta per linguaggio / piattaforma, una volta per JSON stesso):

jsonStr = "{ \"name\": \"Multi\\nline.\" }";

Potresti semplicemente sfuggire alla tua stringa sul server durante la scrittura del valore del campo JSON e annullarla durante il recupero del valore nel browser client, ad esempio.

L'implementazione JavaScript di tutti i principali browser ha il comando unescape.

Esempio:

Sul server:

response.write "{""field1"":""" & escape(RS_Temp("textField")) & """}"

Nel browser:

document.getElementById("text1").value = unescape(jsonObject.field1)

Potresti voler esaminare questa funzione C # per sfuggire alla stringa:

http://www.aspcode.net/C-encode-a-string-for-JSON-JavaScript.aspx

public static string Enquote(string s)  
{ 
    if (s == null || s.Length == 0)  
    { 
        return "\"\""; 
    } 
    char         c; 
    int          i; 
    int          len = s.Length; 
    StringBuilder sb = new StringBuilder(len + 4); 
    string       t; 

    sb.Append('"'); 
    for (i = 0; i < len; i += 1)  
    { 
        c = s[i]; 
        if ((c == '\\') || (c == '"') || (c == '>')) 
        { 
            sb.Append('\\'); 
            sb.Append(c); 
        } 
        else if (c == '\b') 
            sb.Append("\\b"); 
        else if (c == '\t') 
            sb.Append("\\t"); 
        else if (c == '\n') 
            sb.Append("\\n"); 
        else if (c == '\f') 
            sb.Append("\\f"); 
        else if (c == '\r') 
            sb.Append("\\r"); 
        else 
        { 
            if (c < ' ')  
            { 
                //t = "000" + Integer.toHexString(c); 
                string t = new string(c,1); 
                t = "000" + int.Parse(tmp,System.Globalization.NumberStyles.HexNumber); 
                sb.Append("\\u" + t.Substring(t.Length - 4)); 
            }  
            else  
            { 
                sb.Append(c); 
            } 
        } 
    } 
    sb.Append('"'); 
    return sb.ToString(); 
} 

Ho usato questa funzione per eliminare la nuova riga o altri caratteri nei dati per analizzare i dati JSON:

function normalize_str($str) {

    $invalid = array(
        'Š'=>'S', 'š'=>'s',  'Đ'=>'Dj', 'đ'=>'dj', 'Ž'=>'Z', 'ž'=>'z',
        'Č'=>'C', 'č'=>'c',  'Ć'=>'C',  'ć'=>'c',  'À'=>'A', 'Á'=>'A', 'Â'=>'A', 'Ã'=>'A',
        'Ä'=>'A', 'Å'=>'A',  'Æ'=>'A',  'Ç'=>'C',  'È'=>'E', 'É'=>'E', 'Ê'=>'E', 'Ë'=>'E',
        'Ì'=>'I', 'Í'=>'I',  'Î'=>'I',  'Ï'=>'I',  'Ñ'=>'N', 'Ò'=>'O', 'Ó'=>'O', 'Ô'=>'O',
        'Õ'=>'O', 'Ö'=>'O',  'Ø'=>'O',  'Ù'=>'U',  'Ú'=>'U', 'Û'=>'U', 'Ü'=>'U', 'Ý'=>'Y',
        'Þ'=>'B', 'ß'=>'Ss', 'à'=>'a',  'á'=>'a',  'â'=>'a', 'ã'=>'a', 'ä'=>'a', 'å'=>'a',
        'æ'=>'a', 'ç'=>'c',  'è'=>'e',  'é'=>'e',  'ê'=>'e', 'ë'=>'e', 'ì'=>'i', 'í'=>'i',
        'î'=>'i', 'ï'=>'i',  'ð'=>'o',  'ñ'=>'n',  'ò'=>'o', 'ó'=>'o', 'ô'=>'o', 'õ'=>'o',
        'ö'=>'o', 'ø'=>'o',  'ù'=>'u',  'ú'=>'u',  'û'=>'u', 'ý'=>'y', 'ý'=>'y', 'þ'=>'b',
        'ÿ'=>'y', 'Ŕ'=>'R',  'ŕ'=>'r',
        "`" => "'", "´" => "'",  '"' => ',',  '`' => "'",
        '´' => "'", '"' => '\"', '"' => "\"", '´' => "'",
        "’" => "'",
        "{" => "",
        "~" => "",  "–" => "-",  "'" => "'",  "     " => " ");

    $str = str_replace(array_keys($invalid), array_values($invalid), $str);

    $remove = array("\n", "\r\n", "\r");
    $str = str_replace($remove, "\\n", trim($str));

    //$str = htmlentities($str, ENT_QUOTES);

    return htmlspecialchars($str);
}

echo normalize_str($lst['address']);

JSON.stringify

JSON.stringify(`{ 
  a:"a"
}`)

converte la stringa sopra in

"{ \n      a:\"a\"\n    }"

come menzionato qui

json stringify

Questa funzione aggiunge virgolette all'inizio e alla fine della stringa di input e sfugge ai caratteri JSON speciali. In particolare, una nuova riga viene sostituita dal carattere \ n, una scheda viene sostituita dal carattere \ t, una barra rovesciata viene sostituita da due barre rovesciate \ e una barra rovesciata viene posizionata prima di ogni virgoletta.

Ho riscontrato questo problema durante la creazione di una classe in PHP 4 per emulare json_encode (disponibile in PHP 5). Ecco cosa mi è venuto in mente:

class jsonResponse {
    var $response;

    function jsonResponse() {
        $this->response = array('isOK'=>'KO', 'msg'=>'Undefined');
    }

    function set($isOK, $msg) {
        $this->response['isOK'] = ($isOK) ? 'OK' : 'KO';
        $this->response['msg'] = htmlentities($msg);
    }

    function setData($data=null) {
        if(!is_null($data))
            $this->response['data'] = $data;
        elseif(isset($this->response['data']))
            unset($this->response['data']);
    }

    function send() {
        header('Content-type: application/json');
        echo '{"isOK":"' . $this->response['isOK'] . '","msg":' . $this->parseString($this->response['msg']);
        if(isset($this->response['data']))
            echo ',"data":' . $this->parseData($this->response['data']);
        echo '}';
    }

    function parseData($data) {
        if(is_array($data)) {
            $parsed = array();
            foreach ($data as $key=>$value)
                array_push($parsed, $this->parseString($key) . ':' . $this->parseData($value));
            return '{' . implode(',', $parsed) . '}';
        }
        else
            return $this->parseString($data);
    }

    function parseString($string) {
            $string = str_replace("\\", "\\\\", $string);
            $string = str_replace('/', "\\/", $string);
            $string = str_replace('"', "\\".'"', $string);
            $string = str_replace("\b", "\\b", $string);
            $string = str_replace("\t", "\\t", $string);
            $string = str_replace("\n", "\\n", $string);
            $string = str_replace("\f", "\\f", $string);
            $string = str_replace("\r", "\\r", $string);
            $string = str_replace("\u", "\\u", $string);
            return '"'.$string.'"';
    }
}

Ho seguito le regole menzionate qui . Ho usato solo ciò di cui avevo bisogno, ma immagino che tu possa adattarlo alle tue esigenze nella lingua che stai usando. Il problema nel mio caso non riguardava le newline come pensavo inizialmente, ma il fatto di non essere evaso. Spero che questo prevenga qualcun altro dal piccolo mal di testa che ho avuto per capire cosa ho fatto di sbagliato.

Come ho capito domanda, non si tratta di analisi JSON, perché è possibile copiare e incollare il tuo JSON nel codice direttamente - quindi se questo è il caso, allora basta copiare il JSON direttamente a dataObjvariabile senza avvolgendolo con apici (suggerimento: eval==evil)

var dataObj = {"count" : 1, "stack" : "sometext\n\n"};

console.log(dataObj);