¿Cómo escapar de una cadena JSON que contiene caracteres de nueva línea usando JavaScript?

Tengo que formar una cadena JSON en la que un valor tenga un nuevo carácter de línea. Esto tiene que ser escapado y luego publicado usando la llamada AJAX. ¿Alguien puede sugerir una forma de escapar de la cadena con JavaScript? No estoy usando jQuery.

Toma tu JSON y .stringify()eso. Luego use el .replace()método y reemplace todas las apariciones de \ncon \\n.

EDITAR:

Hasta donde yo sé, no hay bibliotecas JS conocidas para escapar de todos los caracteres especiales en una cadena. Pero, podría encadenar el .replace()método y reemplazar todos los caracteres especiales como este:

var myJSONString = JSON.stringify(myJSON);
var myEscapedJSONString = myJSONString.replace(/\\n/g, "\\n")
                                      .replace(/\\'/g, "\\'")
                                      .replace(/\\"/g, '\\"')
                                      .replace(/\\&/g, "\\&")
                                      .replace(/\\r/g, "\\r")
                                      .replace(/\\t/g, "\\t")
                                      .replace(/\\b/g, "\\b")
                                      .replace(/\\f/g, "\\f");
// myEscapedJSONString is now ready to be POST'ed to the server. 

Pero eso es bastante desagradable, ¿no? Ingrese la belleza de las funciones, ya que le permiten dividir el código en pedazos y mantener el flujo principal de su script limpio y libre de 8 .replace()llamadas encadenadas . Pongamos esa funcionalidad en una función llamada escapeSpecialChars(),. Vamos a seguir adelante y adjuntarlo a la prototype chaindel Stringobjeto, por lo que podemos llamar escapeSpecialChars()directamente sobre los objetos de cadena.

Al igual que:

String.prototype.escapeSpecialChars = function() {
    return this.replace(/\\n/g, "\\n")
               .replace(/\\'/g, "\\'")
               .replace(/\\"/g, '\\"')
               .replace(/\\&/g, "\\&")
               .replace(/\\r/g, "\\r")
               .replace(/\\t/g, "\\t")
               .replace(/\\b/g, "\\b")
               .replace(/\\f/g, "\\f");
};

Una vez que hemos definido esa función, el cuerpo principal de nuestro código es tan simple como esto:

var myJSONString = JSON.stringify(myJSON);
var myEscapedJSONString = myJSONString.escapeSpecialChars();
// myEscapedJSONString is now ready to be POST'ed to the server

Según el usuario 667073 sugerido, excepto reordenar el reemplazo de la barra diagonal inversa primero y arreglar el reemplazo de la cotización

escape = function (str) {
  return str
    .replace(/[\\]/g, '\\\\')
    .replace(/[\"]/g, '\\\"')
    .replace(/[\/]/g, '\\/')
    .replace(/[\b]/g, '\\b')
    .replace(/[\f]/g, '\\f')
    .replace(/[\n]/g, '\\n')
    .replace(/[\r]/g, '\\r')
    .replace(/[\t]/g, '\\t');
};

Al igual que usted, he estado buscando varios comentarios y publicaciones para reemplazar los caracteres de escape especiales en mi JSON que contiene objetos HTML dentro de eso.

Mi objetivo es eliminar los caracteres especiales en el objeto JSON y también renderizar el html que está dentro del objeto json.

Esto es lo que hice y espero que sea muy fácil de usar.

Primero hice JSON.stringify mi objeto json y JSON.parse el resultado.

Por ejemplo:

JSON.parse(JSON.stringify(jsonObject));

Y resuelve mi problema y termina usando Pure Javascript.

Me temo decir que la respuesta dada por Alex es bastante incorrecta, por decirlo suavemente:

• No es necesario que algunos personajes que Alex intenta escapar (como & y ');
• \ b no es en absoluto el carácter de retroceso sino más bien una coincidencia de límite de palabra
• Los caracteres necesarios para escapar no se manejan.

Esta función

escape = function (str) {
    // TODO: escape %x75 4HEXDIG ?? chars
    return str
      .replace(/[\"]/g, '\\"')
      .replace(/[\\]/g, '\\\\')
      .replace(/[\/]/g, '\\/')
      .replace(/[\b]/g, '\\b')
      .replace(/[\f]/g, '\\f')
      .replace(/[\n]/g, '\\n')
      .replace(/[\r]/g, '\\r')
      .replace(/[\t]/g, '\\t')
    ; };

Parece ser una mejor aproximación.

Una pequeña actualización para comillas simples

function escape (key, val) {
    if (typeof(val)!="string") return val;
    return val      
        .replace(/[\\]/g, '\\\\')
        .replace(/[\/]/g, '\\/')
        .replace(/[\b]/g, '\\b')
        .replace(/[\f]/g, '\\f')
        .replace(/[\n]/g, '\\n')
        .replace(/[\r]/g, '\\r')
        .replace(/[\t]/g, '\\t')
        .replace(/[\"]/g, '\\"')
        .replace(/\\'/g, "\\'"); 
}

var myJSONString = JSON.stringify(myJSON,escape);

Esta es una publicación vieja. pero aún puede ser útil para aquellos que usan angular.fromJson y JSON.stringify. escape () está en desuso. use esto en su lugar,

var uri_enc = encodeURIComponent(uri); //before you post the contents
var uri_dec = decodeURIComponent(uri_enc); //before you display/use the contents.

ref http://www.w3schools.com/jsref/jsref_decodeuricomponent.asp

También hay un segundo parámetro en JSON.stringify. Entonces, la solución más elegante sería:

function escape (key, val) {
    if (typeof(val)!="string") return val;
    return val
      .replace(/[\"]/g, '\\"')
      .replace(/[\\]/g, '\\\\')
      .replace(/[\/]/g, '\\/')
      .replace(/[\b]/g, '\\b')
      .replace(/[\f]/g, '\\f')
      .replace(/[\n]/g, '\\n')
      .replace(/[\r]/g, '\\r')
      .replace(/[\t]/g, '\\t')
    ; 
}

var myJSONString = JSON.stringify(myJSON,escape);

Esta es una vieja pregunta, pero la solución no funcionó bien para mí, ya que no resolvió todos los casos. Finalmente encontré una respuesta que hizo el trabajo aquí

Publicaré mi solución combinada de ambos usando escape y codificar componente uri:

// implement JSON stringify serialization
JSON.stringify = JSON.stringify || function (obj) {
    var t = typeof (obj);
    if (t != "object" || obj === null) {
        // simple data type
        if (t == "string") obj = '"'+obj+'"';
        return String(obj);
    }
    else {
        // recurse array or object
        var n, v, json = [], arr = (obj && obj.constructor == Array);
        for (n in obj) {
            v = obj[n]; t = typeof(v);
            if (t == "string") v = '"'+v+'"';
            else if (t == "object" && v !== null) v = JSON.stringify(v);
            json.push((arr ? "" : '"' + n + '":') + String(v));
        }
        var rawString = (arr ? "[" : "{") + String(json) + (arr ? "]" : "}");
       return rawString;
    }
};
function escape (key, val) {
    if (typeof(val)!="string") return val;

    var replaced = encodeURIComponent(val);
    return replaced;
}

JSON.stringifyEscaped = function(obj){
    return JSON.stringify(obj,escape);
}

Es mejor usar JSON.parse(yourUnescapedJson);

Use json_encode () si su idioma de scripting del lado del servidor es PHP, json_encode()escapa de la nueva línea y otros tokens inesperados por usted (si no usa PHP, busque una función similar para su lenguaje de scripting)

a continuación, utilizar $.parseJSON()en su JavaScript, hecho!

Tuve la misma situación en una de mis llamadas de Ajax, donde JSONestaba arrojando un error debido a la nueva línea en el campo Textarea. La solución dada aquí no funcionó para mí. Así que usé la .escapefunción de Javascript y funcionó bien. Luego, para recuperar el valor JSON, simplemente escapé usando .unescape.

I utilizado el construido en jQuery.serialize () para extraer el valor de un área de texto a urlencode la entrada. La parte profesional es que no tiene que buscar reemplazar cada carácter especial por su cuenta y también mantengo las nuevas líneas y escapa html. Para que la serialización funcione, parece que el campo de entrada debe tener un atributo de nombre y también agrega el mismo atributo a la cadena escapada que debe reemplazarse. Puede que no sea lo que estás buscando, pero funciona para mí.

var myinputfield = jQuery("#myinputfield"); 
var text = myinputfield.serialize();
text = text.replace(myinputfield.attr('name') + '=','');

Cuando se utiliza cualquier forma de Ajax, la documentación detallada para el formato de las respuestas recibidas del servidor CGI parece faltar en la Web. Algunas entradas aquí señalan que las nuevas líneas en el texto devuelto o en los datos json deben escaparse para evitar bucles infinitos (bloqueos) en la conversión JSON (posiblemente creada al lanzar una excepción no detectada), ya sea que se realice automáticamente mediante jQuery o manualmente usando el sistema Javascript o el análisis JSON de la biblioteca llamadas.

En cada caso donde los programadores publican este problema, se presentan soluciones inadecuadas (la mayoría de las veces reemplazando \ n por \\ n en el lado de envío) y el asunto se descarta. Su insuficiencia se revela al pasar valores de cadena que incrustan accidentalmente secuencias de escape de control, como nombres de ruta de Windows. Un ejemplo es "C: \ Chris \ Roberts.php", que contiene los caracteres de control ^ c y ^ r, que pueden provocar la conversión JSON de la cadena {"archivo": "C: \ Chris \ Roberts.php"} a bucle para siempre. Una forma de generar tales valores es deliberadamente intentar pasar mensajes de advertencia y error de PHP del servidor al cliente, una idea razonable.

Por definición, Ajax usa conexiones HTTP detrás de escena. Dichas conexiones pasan datos utilizando GET y POST, los cuales requieren codificar los datos enviados para evitar una sintaxis incorrecta, incluidos los caracteres de control.

Esto da una pista suficiente para construir lo que parece ser una solución (necesita más pruebas): usar el código rawurlen en el lado PHP (envío) para codificar los datos y no escapar en el lado Javascript (recepción) para decodificar los datos. En algunos casos, los aplicará a cadenas de texto completas, en otros casos los aplicará solo a valores dentro de JSON.

Si esta idea resulta ser correcta, se pueden construir ejemplos simples para ayudar a los programadores en todos los niveles a resolver este problema de una vez por todas.

Parece que esta es una publicación antigua realmente :-) Pero chicos, la mejor solución que tengo para esto, para ser 100% que funciona sin código complicado, es usar ambas funciones de codificación / decodificación a base64. Estos son atob () y btoa (). Con mucho, la forma más fácil y mejor, no hay que preocuparse si se perdió algún personaje para escapar.

Jorge

Si sus Google continúan aterrizando aquí y su api arroja errores a menos "{\"foo\": true}"que se escapen sus comillas dobles JSON ( ), todo lo que necesita hacer es stringificar dos veces, por ejemploJSON.stringify(JSON.stringify(bar))

Use encodeURIComponent () para codificar la cadena.

P.ej. var myEscapedJSONString = encodeURIComponent (JSON.stringify (myJSON));

No necesita decodificarlo, ya que el servidor web automáticamente hace lo mismo.

Nunca use expresiones regulares (quiero decir, nunca como nunca). La mejor y más efectiva forma:

String.prototype.escapeJSON = function() {
    var result = "";
    for (var i = 0; i < this.length; i++)
    {
        var ch = this[i];
        switch (ch)
        {
            case "\\": ch = "\\\\"; break;
            case "\'": ch = "\\'"; break;
            case "\"": ch = '\\"'; break;
            case "\&": ch = "\\&"; break;
            case "\t": ch = "\\t"; break;
            case "\n": ch = "\\n"; break;
            case "\r": ch = "\\r"; break;
            case "\b": ch = "\\b"; break;
            case "\f": ch = "\\f"; break;
            case "\v": ch = "\\v"; break;
            default: break;
        }

        result += ch;
    }

    return result;
};