Jak uciec przed ciągiem JSON zawierającym znaki nowej linii za pomocą JavaScript?

Muszę utworzyć ciąg JSON, w którym wartość ma znak nowego wiersza. To musi zostać usunięte, a następnie wysłane za pomocą połączenia AJAX. Czy ktoś może zasugerować sposób na uniknięcie ciągu za pomocą JavaScript. Nie używam jQuery.

Weź swój JSON i .stringify()to. Następnie za pomocą .replace()metody i zastąpić wszystkie wystąpienia \nz \\n.

EDYTOWAĆ:

O ile mi wiadomo, nie ma dobrze znanych bibliotek JS do unikania wszystkich znaków specjalnych w ciągu. Ale możesz połączyć .replace()metodę i zastąpić wszystkie znaki specjalne w następujący sposób:

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. 

Ale to dość paskudne, prawda? Wprowadź piękno funkcji, ponieważ pozwalają one na rozbicie kodu na części i utrzymanie głównego przepływu skryptu w czystości i bez 8 połączonych .replace()wywołań. Więc postawmy tę funkcjonalność do funkcji o nazwie, escapeSpecialChars(). Idziemy do przodu i dołączyć go do prototype chaintego Stringobiektu, więc możemy wywołać escapeSpecialChars()bezpośrednio na obiektach String.

Tak jak to:

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

Po zdefiniowaniu tej funkcji główna część naszego kodu jest tak prosta:

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

Zgodnie z sugestią użytkownika667073, z wyjątkiem zmiany kolejności zamiany ukośnika odwrotnego w pierwszej kolejności i naprawienia zamiany oferty

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

Podobnie jak ty, przeglądałem kilka komentarzy i postów, aby zamienić specjalne znaki ucieczki w moim JSON, który zawiera w sobie obiekt HTML.

Moim celem jest usunięcie znaków specjalnych z obiektu JSON, a także renderowanie html, który znajduje się wewnątrz obiektu json.

Oto, co zrobiłem i mam nadzieję, że jest to bardzo proste w użyciu.

Najpierw zrobiłem JSON.stringify mój obiekt json i JSON.parse wynik.

Na przykład:

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

I rozwiązuje mój problem i zostało zrobione przy użyciu czystego JavaScript.

Obawiam się powiedzieć, że odpowiedź udzielona przez Alexa jest raczej błędna, delikatnie mówiąc:

• Niektóre postacie, które Alex próbuje uciec, nie muszą w ogóle uciekać (np. & I ');
• \ b wcale nie jest znakiem cofania, ale raczej dopasowaniem granicy słowa
• Znaki wymagane do ucieczki nie są obsługiwane.

Ta funkcja

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

wydaje się być lepszym przybliżeniem.

Mała aktualizacja dla pojedynczych cudzysłowów

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

to jest stary post. ale nadal może być pomocne dla osób używających angular.fromJson i JSON.stringify. escape () jest przestarzały. użyj tego zamiast tego,

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

Istnieje również drugi parametr w JSON.stringify. Tak więc bardziej eleganckim rozwiązaniem byłoby:

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

To stare pytanie, ale rozwiązanie nie działało dobrze, ponieważ nie rozwiązało wszystkich przypadków. W końcu znalazłem odpowiedź, że spełnił swoje zadanie tutaj

Opublikuję moje połączone rozwiązanie wykorzystujące zarówno ucieczkę, jak i kodowanie komponentu 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);
}

Lepiej go używać JSON.parse(yourUnescapedJson);

Użyj json_encode (), jeśli język skryptów po stronie serwera to PHP, json_encode()ucieka znak nowej linii i inne nieoczekiwane tokeny (jeśli nie używasz PHP, poszukaj podobnej funkcji dla swojego języka skryptowego)

następnie użyj $.parseJSON()w swoim JavaScript, gotowe!

Mam taką samą sytuację w jednym z moich wywołań Ajax, gdzie JSONwyrzucałem błąd z powodu nowej linii w polu Textarea. Podane tutaj rozwiązanie nie zadziałało. Więc użyłem .escapefunkcji Javascript i działało dobrze. Następnie, aby pobrać wartość JSON, po prostu cofnąłem zmianę za pomocą .unescape.

Użyłem wbudowanej funkcji jQuery.serialize (), aby wyodrębnić wartość z obszaru tekstowego, aby urlencode wprowadzić dane wejściowe. Zaletą jest to, że nie musisz samodzielnie wyszukiwać i zastępować wszystkich znaków specjalnych, a ja również zachowuję znaki nowej linii i znaki ucieczki w html. Aby serializacja działała, wydaje się, że pole wejściowe musi mieć atrybut nazwy, a także dodaje ten sam atrybut do ciągu znaków ucieczki, który należy zastąpić. Może nie być tym, czego szukasz, ale dla mnie działa.

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

Podczas korzystania z dowolnej formy Ajax w sieci WWW brakuje szczegółowej dokumentacji formatu odpowiedzi otrzymywanych z serwera CGI. Niektóre wpisy wskazują, że znaki nowej linii w zwracanym tekście lub danych json muszą zostać zmienione, aby zapobiec nieskończonym pętlom (zawieszeniom) w konwersji JSON (prawdopodobnie utworzonej przez wyrzucenie niepochwyconego wyjątku), niezależnie od tego, czy jest to wykonywane automatycznie przez jQuery, czy ręcznie przy użyciu systemu JavaScript lub analizy JSON biblioteki wezwania.

W każdym przypadku, gdy programiści publikują ten problem, przedstawiane są nieadekwatne rozwiązania (najczęściej zastępując \ n przez \\ n po stronie wysyłającej) i sprawa zostaje odrzucona. Ich nieadekwatność ujawnia się podczas przekazywania wartości ciągów, które przypadkowo osadzają sekwencje sterujące, takie jak nazwy ścieżek systemu Windows. Przykładem jest „C: \ Chris \ Roberts.php”, który zawiera znaki sterujące ^ c i ^ r, co może spowodować konwersję ciągu JSON ciągu {"file": "C: \ Chris \ Roberts.php"} na pętla na zawsze. Jednym ze sposobów generowania takich wartości jest celowa próba przekazywania ostrzeżeń PHP i komunikatów o błędach z serwera do klienta, co jest rozsądnym pomysłem.

Z definicji Ajax używa połączeń HTTP za kulisami. Takie połączenia przekazują dane za pomocą GET i POST, które wymagają kodowania wysyłanych danych, aby uniknąć nieprawidłowej składni, w tym znaków sterujących.

Daje to wystarczającą wskazówkę, aby skonstruować coś, co wydaje się być rozwiązaniem (wymaga więcej testów): użyć kodu rawurlen po stronie PHP (wysyłającej) do kodowania danych i unescape po stronie JavaScript (odbierającej) do dekodowania danych. W niektórych przypadkach zastosujesz je do całych ciągów tekstowych, w innych zastosujesz je tylko do wartości wewnątrz JSON.

Jeśli ten pomysł okaże się słuszny, można skonstruować proste przykłady, które pomogą programistom na wszystkich poziomach raz na zawsze rozwiązać ten problem.

Wygląda na to, że to naprawdę starożytny post :-) Ale najlepsze obejście, jakie mam, aby to było w 100% działało bez skomplikowanego kodu, jest użycie obu funkcji kodowania / dekodowania do base64. Są to atob () i btoa (). Zdecydowanie najłatwiejszy i najlepszy sposób, nie musisz się martwić, jeśli przegapiłeś jakiekolwiek postacie, którym chcesz uciec.

Jerzy

Jeśli Twoje Google wciąż Cię tu lądują, a Twój interfejs API generuje błędy, chyba że podwójne cudzysłowy JSON są "{\"foo\": true}"oznaczone znakami ucieczki ( ), wszystko, co musisz zrobić, to dwukrotnie wpisać ciąg znaków, np.JSON.stringify(JSON.stringify(bar))

Użyj metody encodeURIComponent (), aby zakodować ciąg.

Na przykład. var myEscapedJSONString = encodeURIComponent (JSON.stringify (myJSON));

Nie musisz go dekodować, ponieważ serwer WWW robi to samo.

Nigdy nie używaj wyrażeń regularnych (mam na myśli jak nigdy). Najlepszy i skuteczny sposób:

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