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

Prenez votre JSON et .stringify() it. Ensuite, utilisez la méthode .replace() et remplacez toutes les occurrences de \n par \\n .

MODIFIER:

Pour autant que je sache, il n'existe pas de bibliothèques JS bien connues pour échapper à tous les caractères spéciaux dans une chaîne. Mais, vous pouvez chaîner la méthode .replace() 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 plutôt méchant, n'est-ce pas? Entrez la beauté des fonctions, en ce sens qu'elles vous permettent de briser le code en morceaux et de garder le flux principal de votre script propre et sans 8 appels .replace() . Donc, mettons cette fonctionnalité dans une fonction appelée, escapeSpecialChars() . Allons-y et attachez-nous à la prototype chain de l'objet String , afin que nous puissions appeler escapeSpecialChars() directement sur les 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 l'utilisateur667073 suggéré, sauf le réorganisation du remplacement de la barre oblique inverse d'abord, et la fixation du 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'); }; 

Je crains de dire que la réponse donnée par Alex est plutôt incorrecte, pour dire doucement:

• Certains personnages que Alex essaie d'échapper ne doivent pas être échappés (comme & et ');
• \ B n'est pas du tout le caractère arrière, mais plutôt une correspondance aux mots
• Les caractères devant être échappés ne sont pas traité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.

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

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

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

D'abord, j'ai fait JSON.stringify mon objet json et JSON.parse le résultat.

Par exemple:

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

Et il résout mon problème et fait avec Javascript pur.

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

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

Il s'agit d'une ancienne publication. Mais il peut être utile pour ceux qui utilisent angular.fromJson et JSON.stringify. Escape () est obsolète. Utilisez-le à 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

C'est une question ancienne, mais la solution ne m'a pas bien fonctionné car elle n'a pas résolu tous les cas. J'ai finalement trouvé une réponse qui a fait le travail ici

Je publierai ma solution combinée des deux en utilisant la composante escape and encode 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); } 

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

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

Dans chaque cas où les programmeurs publient ce problème, des solutions inadéquates sont présentées (en remplaçant souvent \ n par \\ n du côté de l'envoi) et la question est supprimée. Leur insuffisance est révélée lors du passage de valeurs de chaînes qui incorporent 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 {"fichier": "C: \ Chris \ Roberts.php"} à Boucle pour toujours. L'une des façons de générer de telles valeurs est délibérément de tenter de transmettre les messages d'avertissement et d'erreur PHP du serveur au client, une idée raisonnable.

Par définition, Ajax utilise les connexions HTTP derrière les scènes. De telles connexions transmettent des données à l'aide de GET et POST, qui nécessitent l'encodage des données envoyées pour éviter une syntaxe incorrecte, y compris les caractères de contrôle.

Cela donne assez d'un indice pour construire ce qui semble être une solution (il faut plus de tests): utiliser rawurlencode sur le côté PHP (en cours d'envoi) pour coder les données, et disparaître sur le côté Javascript (recevoir) 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 appliquer uniquement à des valeurs dans JSON.

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

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 (sinon php recherche une fonction similaire pour votre langue de script)

Puis utilisez $ .parseJSON () dans votre javascript, fait!

J'ai utilisé la version jQuery.serialize () pour extraire la valeur d'une zone de texte à urlencode l'entrée. La partie pro est que vous n'avez pas à chercher à remplacer chaque char spécial par vous-même et je garde également les nouvelles lignes et j'échappe html. Pour que la sérialisation fonctionne, il semble que le champ de saisie doit avoir un attribut de nom et qu'il ajoute également le même attribut à la chaîne échappée qui doit être remplacée. Ne peut-être pas ce que vous cherchez, mais cela fonctionne pour moi.

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