Comment échapper à une chaîne JSON contenant des caractères newline en utilisant JavaScript?

selon user667073 suggéré, sauf réordonner le remplacement antislash d'abord, et la fixation du remplacement de 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 cherché dans plusieurs commentaires et post pour remplacer des caractères d'échappement spéciaux dans mon JSON qui contient l'objet html à l'intérieur de cela.

mon objet est de supprimer les caractères spéciaux dans l'objet JSON et aussi de rendre le html qui est à l'intérieur de l'objet json.

voici ce que j'ai fait et j'espère qu'il est très simple à utiliser.

D'abord JSON.stringifiez mon objet json et JSON.analyser le résultat.

pour eg:

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

et il résout mon problème et fait en utilisant pur Javascript.

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

• certains personnages Qu'Alex essaie d'échapper ne sont pas tenus d'être échappés du tout (comme & et');
• \b n'est pas du tout le caractère backspace mais plutôt une correspondance de limite de mots
Les caractères
• nécessaires pour être échappés ne sont pas manipulé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);

c'est un vieux post. mais il peut encore être utile pour ceux qui utilisent angulaire.de JSON, et JSON.stringify. escape () est dépréciée. utilisez ceci à la place,

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

il y a aussi le second paramètre sur JSON.stringify. Ainsi, la solution la 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 n'a pas bien fonctionné pour moi car elle n'a pas résolu tous les cas. J'ai finalement trouvé une réponse qui a fait le travail ici

je posterai ma solution combinée des deux en utilisant escape et le composant uri d'encode:

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

j'ai eu la même situation dans un de mes appels Ajax, où JSON lançait une erreur due à la nouvelle ligne dans le champ Textarea. La solution donnée ici n'a pas fonctionné pour moi. J'ai donc utilisé la fonction .escape de Javascript et ça a bien marché. Ensuite, pour récupérer la valeur de JSON , je viens de sortir en utilisant .unescape .

Lorsqu'on utilise N'importe quelle forme D'Ajax, la documentation détaillée pour le format des réponses reçues du serveur CGI semble faire défaut sur le Web. Certaines entrées ici soulignent que les nouvelles lignes dans le texte retourné ou les données json doivent être échappées pour empêcher les boucles infinies (hangs) dans la conversion JSON (peut-être créé en lançant une exception uncaught), que ce soit fait automatiquement par jQuery ou manuellement en utilisant le système Javascript ou la bibliothèque JSON parsing appels.

dans chaque cas lorsque les programmeurs affichent ce problème, des solutions inadéquates sont présentées (remplaçant le plus souvent \n par \\N du côté émetteur) et la question est abandonnée. Leur inadéquation est révélée en passant des valeurs de chaîne qui incorporent accidentellement des séquences d'échappement de contrôle, comme Windows pathnames. Un exemple est "C:\Chris\Roberts.php", qui contient les caractères de contrôle ^c et ^R, qui peuvent causer la conversion JSON de la chaîne {"file":"C:\Chris\Roberts.php"} boucle pour toujours. Une façon de générer une telle valeurs est délibérément pour tenter de passer des messages D'avertissement et d'erreur de PHP du serveur au client, une idée raisonnable.

par définition, Ajax utilise des connexions HTTP en coulisse. De telles connexions transmettent des données à L'aide de GET et POST, qui nécessitent tous deux l'encodage des données envoyées pour éviter une syntaxe incorrecte, y compris les caractères de contrôle.

cela donne assez d'indication pour construire ce qui semble être une solution( il a besoin de plus de tests): PHP (sending) side pour encoder les données, et unescape sur Javascript (receiving) side 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 seulement à des valeurs à l'intérieur de 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.

utiliser json_encode() si vos scripts côté serveur lang est php, json_encode () échappe à la nouvelle ligne et autres tokens inattendus pour vous (si ce n'est pas php chercher une fonction similaire pour votre lan de script)

alors utilisez $.parseJSON() dans votre code javascript, en fait!

j'ai utilisé le construit dans jQuery.serialize () extraire la valeur d'un textarea pour urlencode l'entrée. La partie pro est que vous n'avez pas à chercher remplacer tous les caractères spéciaux sur votre propre et je garde également les nouvelles lignes et échappe html. Pour que serialize fonctionne, il semble que le champ input doive avoir un attribut name et ajoute aussi le même attribut à la chaîne échappée qui doit être remplacée. Peut - être pas ce que vous cherchez mais ça marche pour je.

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

ressemble à ceci est un post Antique vraiment :-) mais les gars, le meilleur contournement que j'ai pour cela, pour être à 100% qu'il fonctionne sans code compliqué, est d'utiliser les deux fonctions d'encodage/décodage pour base64. Ce sont atob() et btoa(). De loin la manière la plus simple et la meilleure, Pas besoin de s'inquiéter si vous avez manqué des personnages à échapper.

George