Comment échapper à une chaîne JSON contenant des caractères de nouvelle ligne à l'aide de JavaScript?

Je dois former une chaîne JSON dans laquelle une valeur a un nouveau caractère de ligne. Cela doit être échappé puis publié à l'aide de l'appel AJAX. Quelqu'un peut-il suggérer un moyen d'échapper à la chaîne avec JavaScript. Je n'utilise pas jQuery.

Prenez votre JSON et .stringify()ça. Utilisez ensuite la .replace()méthode et remplacez toutes les occurrences de \npar \\n.

ÉDITER:

Pour autant que je sache, il n'existe pas de bibliothèques JS bien connues pour échapper à tous les caractères spéciaux d'une chaîne. Mais vous pouvez chaîner la .replace()méthode et remplacer tous les caractères spéciaux comme ceci:

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. 

Mais c'est assez méchant, n'est-ce pas? Entrez la beauté des fonctions, en ce qu'elles vous permettent de diviser le code en morceaux et de garder le flux principal de votre script propre et exempt de 8 .replace()appels en chaîne . Mettons donc cette fonctionnalité dans une fonction appelée escapeSpecialChars(),. Allons allez - y et le joindre à la prototype chainde l' Stringobjet, afin que nous puissions appeler escapeSpecialChars()directement sur des objets String.

Ainsi:

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");
};

Une fois que nous avons défini cette fonction, le corps principal de notre code est aussi simple que ceci:

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

Selon user667073 suggéré, sauf réorganiser d'abord le remplacement de la barre oblique inverse et réparer le remplacement du devis

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');
};

Comme vous, j'ai examiné plusieurs commentaires et posté pour remplacer les caractères d'échappement spéciaux dans mon JSON qui contient un objet html à l'intérieur.

Mon objectif est de supprimer les caractères spéciaux dans l'objet JSON et également de rendre le html qui se trouve à l'intérieur de l'objet json.

Voici ce que j'ai fait et j'espère que c'est très simple à utiliser.

J'ai d'abord fait JSON.stringify mon objet json et JSON.parse le résultat.

Par exemple:

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

Et cela résout mon problème et fait en utilisant Pure Javascript.

J'ai peur de dire que la réponse d'Alex est plutôt incorrecte, pour le dire légèrement:

• Certains personnages qu'Alex tente de s'échapper ne sont pas du tout obligés d'être échappés (comme & et ');
• \ b n'est pas du tout le caractère de retour arrière mais plutôt une correspondance de limite de mot
• Les caractères devant être échappés ne sont pas gérés.

Cette fonction

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')
    ; };

semble être une meilleure approximation.

Une petite mise à jour pour les guillemets 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);

ceci est un ancien message. mais cela peut toujours être utile pour ceux qui utilisent angular.fromJson et JSON.stringify. escape () est obsolète. utilisez plutôt ceci,

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

réf http://www.w3schools.com/jsref/jsref_decodeuricomponent.asp

Il existe également un deuxième paramètre sur JSON.stringify. Donc, une solution plus élégante serait:

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);

C'est une vieille question mais la solution ne fonctionnait pas bien pour moi car elle ne résolvait pas tous les cas. J'ai enfin trouvé une réponse qui a fait le travail ici

Je publierai ma solution combinée à la fois en utilisant escape et encoder le composant 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);
}

Il vaut mieux utiliser JSON.parse(yourUnescapedJson);

Utilisez json_encode () si votre langage de script côté serveur est PHP, json_encode()échappe la nouvelle ligne et d'autres jetons inattendus pour vous (si vous n'utilisez pas PHP, recherchez une fonction similaire pour votre langage de script)

puis utilisez $.parseJSON()dans votre JavaScript, c'est fait!

J'ai eu la même situation dans l'un de mes appels Ajax, où JSONune erreur était générée en raison de la nouvelle ligne dans le champ Textarea. La solution donnée ici n'a pas fonctionné pour moi. J'ai donc utilisé la .escapefonction de Javascript et cela a bien fonctionné. Ensuite, pour récupérer la valeur de JSON, je viens de ne pas utiliser .unescape.

J'ai utilisé le jQuery.serialize () intégré pour extraire la valeur d'une zone de texte pour encoder l'URL de l'entrée. La partie pro est que vous n'avez pas à rechercher de remplacer chaque caractère spécial par vous-même et je garde également les nouvelles lignes et les échappements html. Pour que la sérialisation fonctionne, il semble que le champ d'entrée doit avoir un attribut de nom et il ajoute également le même attribut à la chaîne échappée qui doit être remplacée. Ce n'est peut-être pas ce que vous recherchez, mais cela fonctionne pour moi.

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

Lors de l'utilisation de toute forme d'Ajax, une documentation détaillée sur le format des réponses reçues du serveur CGI semble manquer sur le Web. Certaines entrées ici soulignent que les retours à la ligne dans le texte retourné ou les données json doivent être échappés pour éviter les boucles infinies (se bloque) dans la conversion JSON (éventuellement créé en lançant une exception non interceptée), que ce soit fait automatiquement par jQuery ou manuellement à l'aide du système Javascript ou de la bibliothèque d'analyse JSON appels.

Dans chaque cas où les programmeurs publient ce problème, des solutions inadéquates sont présentées (le plus souvent en remplaçant \ n par \\ n côté envoi) et le problème est abandonné. Leur inadéquation est révélée lors de la transmission de valeurs de chaîne qui intègrent accidentellement des séquences d'échappement de contrôle, telles que les chemins d'accès Windows. Un exemple est "C: \ Chris \ Roberts.php", qui contient les caractères de contrôle ^ c et ^ r, ce qui peut provoquer la conversion JSON de la chaîne {"file": "C: \ Chris \ Roberts.php"} en boucle pour toujours. Une façon de générer de telles valeurs est de tenter délibérément de transmettre des messages d'avertissement et d'erreur PHP du serveur au client, une idée raisonnable.

Par définition, Ajax utilise des connexions HTTP dans les coulisses. Ces connexions transmettent des données à l'aide de GET et POST, qui nécessitent tous deux le codage des données envoyées pour éviter une syntaxe incorrecte, y compris des caractères de contrôle.

Cela donne suffisamment d'indices pour construire ce qui semble être une solution (il faut plus de tests): utiliser rawurlencode du côté PHP (envoi) pour encoder les données, et unscape du côté Javascript (réception) pour décoder les données. Dans certains cas, vous les appliquerez à des chaînes de texte entières, dans d'autres cas, vous les appliquerez uniquement aux valeurs dans JSON.

Si cette idée s'avère correcte, des exemples simples peuvent être construits pour aider les programmeurs à tous les niveaux à résoudre ce problème une fois pour toutes.

On dirait que c'est vraiment un article ancien :-) Mais les gars, la meilleure solution de contournement que j'ai pour cela, être à 100% que cela fonctionne sans code compliqué, est d'utiliser les deux fonctions d'encodage / décodage en base64. Ce sont atob () et btoa (). De loin le moyen le plus simple et le meilleur, pas besoin de s'inquiéter si vous avez manqué des caractères à échapper.

George

Si vos Googles continuent de vous atterrir ici et que votre API génère des erreurs à moins que vos guillemets JSON ne soient échappés ( "{\"foo\": true}"), tout ce que vous avez à faire est de stringify deux fois, par exempleJSON.stringify(JSON.stringify(bar))

Utilisez encodeURIComponent () pour encoder la chaîne.

Par exemple. var myEscapedJSONString = encodeURIComponent (JSON.stringify (myJSON));

Vous n'avez pas besoin de le décoder car le serveur Web fait automatiquement de même.

N'utilisez jamais d'expressions régulières (je veux dire comme jamais du tout). Le meilleur moyen efficace:

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;
};