Bezpiecznie zamienia ciąg JSON w obiekt

Biorąc pod uwagę ciąg danych JSON, jak mogę bezpiecznie przekształcić ten ciąg w obiekt JavaScript?

Oczywiście mogę to zrobić niepewnie za pomocą czegoś takiego:

var obj = eval("(" + json + ')');

ale to sprawia, że ​​jestem podatny na ciąg JSON zawierający inny kod, którego ewolucję wydaje się bardzo niebezpieczna.

JSON.parse(jsonString) jest czystym podejściem JavaScript, o ile możesz zagwarantować dość nowoczesną przeglądarkę.

Metoda jQuery jest teraz przestarzała. Zamiast tego użyj tej metody:

let jsonObject = JSON.parse(jsonString);

Oryginalna odpowiedź przy użyciu przestarzałej funkcji jQuery :

Jeśli używasz jQuery, po prostu użyj:

jQuery.parseJSON( jsonString );

Właśnie tego szukasz (zobacz dokumentację jQuery ).

Ta odpowiedź dotyczy IE <7, w przypadku współczesnych przeglądarek sprawdź odpowiedź Jonathana powyżej.

Ta odpowiedź jest nieaktualna, a odpowiedź Jonathana powyżej ( JSON.parse(jsonString)) jest teraz najlepszą odpowiedzią .

JSON.org ma parsery JSON dla wielu języków, w tym czterech różnych dla JavaScript. Wierzę, że większość ludzi uważa json2.js za implementację goto.

Skorzystaj z prostego przykładu kodu w „ JSON.parse () ”:

var jsontext = '{"firstname":"Jesper","surname":"Aaberg","phone":["555-0100","555-0120"]}';
var contact = JSON.parse(jsontext);

i odwrócenie:

var str = JSON.stringify(arr);

Nie jestem pewien, czy można to zrobić inaczej, ale oto jak to zrobić w Prototypie (samouczek JSON) .

new Ajax.Request('/some_url', {
  method:'get',
  requestHeaders: {Accept: 'application/json'},
  onSuccess: function(transport){
    var json = transport.responseText.evalJSON(true);
  }
});

Wywołanie evalJSON()z wartością true, ponieważ argument dezynfekuje przychodzący ciąg.

To wydaje się być problemem:

Dane wejściowe, które są odbierane przez Ajax websocket itp., I będą w formacie String, ale musisz wiedzieć, czy tak JSON.parsable. Najważniejsze jest to, że jeśli zawsze go uruchomisz JSON.parse, program MOŻE kontynuować „z powodzeniem”, ale nadal zobaczysz błąd zgłaszany do konsoli z przerażeniem "Error: unexpected token 'x'".

var data;

try {
  data = JSON.parse(jqxhr.responseText);
} catch (_error) {}

data || (data = {
  message: 'Server error, please retry'
});

Jeśli używasz jQuery , możesz także użyć:

$.getJSON(url, function(data) { });

Następnie możesz robić takie rzeczy jak

data.key1.something
data.key1.something_else

itp.

$.ajax({
  url: url,
  dataType: 'json',
  data: data,
  success: callback
});

Oddzwanianie jest przekazywane zwracane dane, które będą obiektem JavaScript lub tablicą zdefiniowaną przez strukturę JSON i analizowane przy użyciu $.parseJSON()metody.

Dla zabawy, oto sposób korzystania z funkcji:

 jsonObject = (new Function('return ' + jsonFormatData))()

Korzystanie JSON.parsejest prawdopodobnie najlepszym sposobem.

Oto przykład demo na żywo .

var jsonRes = '{ "students" : [' +
          '{ "firstName":"Michel" , "lastName":"John" ,"age":18},' +
          '{ "firstName":"Richard" , "lastName":"Joe","age":20 },' +
          '{ "firstName":"James" , "lastName":"Henry","age":15 } ]}';
var studentObject = JSON.parse(jsonRes);

Najłatwiejszy sposób przy użyciu parse()metody:

var response = '{"result":true,"count":1}';
var JsonObject= JSON.parse(response);

Następnie możesz uzyskać wartości elementów JSON, na przykład:

var myResponseResult = JsonObject.result;
var myResponseCount = JsonObject.count;

Korzystanie z jQuery zgodnie z opisem w jQuery.parseJSON()dokumentacji:

JSON.parse(jsonString);

Spróbuj użyć metody z tym obiektem Data. ex: Data='{result:true,count:1}'

try {
  eval('var obj=' + Data);
  console.log(obj.count);
}
catch(e) {
  console.log(e.message);
}

Ta metoda naprawdę pomaga w Nodejs, gdy pracujesz z programowaniem portu szeregowego

Znalazłem „lepszy” sposób:

W CoffeeScript:

try data = JSON.parse(jqxhr.responseText)
data ||= { message: 'Server error, please retry' }

W JavaScript:

var data;

try {
  data = JSON.parse(jqxhr.responseText);
} catch (_error) {}

data || (data = {
  message: 'Server error, please retry'
});

Parsowanie JSON jest zawsze bólem. Jeśli dane wejściowe nie są zgodne z oczekiwaniami, generuje błąd i psuje to, co robisz.

Możesz użyć poniższej małej funkcji, aby bezpiecznie przeanalizować dane wejściowe. Zawsze obraca obiekt, nawet jeśli dane wejściowe są niepoprawne lub są już obiektami, które są lepsze w większości przypadków:

JSON.safeParse = function (input, def) {
  // Convert null to empty object
  if (!input) {
    return def || {};
  } else if (Object.prototype.toString.call(input) === '[object Object]') {
    return input;
  }
  try {
    return JSON.parse(input);
  } catch (e) {
    return def || {};
  }
};

JSON.parse(jsonString);

json.parse zmieni się w obiekt.

Jeśli mamy taki ciąg:

"{\"status\":1,\"token\":\"65b4352b2dfc4957a09add0ce5714059\"}"

możemy po prostu użyć JSON.parsedwukrotnie, aby przekonwertować ten ciąg na obiekt JSON:

var sampleString = "{\"status\":1,\"token\":\"65b4352b2dfc4957a09add0ce5714059\"}"
var jsonString= JSON.parse(sampleString)
var jsonObject= JSON.parse(jsonString)

Możemy wyodrębnić wartości z obiektu JSON, używając:

// instead of last JSON.parse:
var { status, token } = JSON.parse(jsonString);

Wynik będzie:

status = 1 and token = 65b4352b2dfc4957a09add0ce5714059

JSON.parse() konwertuje dowolny ciąg JSON przekazany do funkcji na obiekt JSON.

Aby to lepiej zrozumieć, naciśnij, F12aby otworzyć „Inspect Element” w przeglądarce i przejdź do konsoli, aby napisać następujące polecenia:

var response = '{"result":true,"count":1}'; //sample json object(string form)
JSON.parse(response); //converts passed string to JSON Object.

Teraz uruchom polecenie:

console.log(JSON.parse(response));

Otrzymasz wynik jako obiekt {result: true, count: 1}.

Aby użyć tego obiektu, możesz przypisać go do zmiennej, może obj:

var obj = JSON.parse(response);

Za pomocą operatora obji (kropka .) można uzyskać dostęp do właściwości obiektu JSON.

Spróbuj uruchomić polecenie:

console.log(obj.result);

Oficjalna dokumentacja :

JSON.parse()Metoda analizuje ciąg JSON, konstruowanie wartości JavaScript lub obiekt opisany przez ciąg. reviverMożna zapewnić opcjonalną funkcję do przeprowadzenia transformacji obiektu wynikowego przed jego zwróceniem.

Składnia:

JSON.parse(text[, reviver])

Parametry:

text : Ciąg do analizy jako JSON. Zobacz obiekt JSON, aby uzyskać opis składni JSON.

reviver (optional) : Jeśli funkcja, określa, w jaki sposób wartość pierwotnie wygenerowana przez parsowanie jest przekształcana przed zwróceniem.

Zwracana wartość

Obiekt odpowiadający podanemu tekstowi JSON.

Wyjątki

Zgłasza wyjątek SyntaxError, jeśli analizowany ciąg nie jest prawidłowym kodem JSON.

Konwersja obiektu na JSON, a następnie jego parsowanie działa dla mnie jak:

JSON.parse(JSON.stringify(object))

Analizując ciąg JSON JSON.parse(), dane stają się obiektem JavaScript:

JSON.parse(jsonString)

Tutaj JSON reprezentuje przetwarzanie zestawu danych JSON.

Wyobraź sobie, że otrzymaliśmy ten tekst z serwera internetowego:

'{ "name":"John", "age":30, "city":"New York"}'

Aby przeanalizować w obiekcie JSON:

var obj = JSON.parse('{ "name":"John", "age":30, "city":"New York"}'); 

Oto objodpowiedni obiekt JSON, który wygląda:

{ "name":"John", "age":30, "city":"New York"}

Aby pobrać wartość, użyj .operatora:

obj.name // John
obj.age //30

Konwertuj obiekt JavaScript na ciąg znaków za pomocą JSON.stringify().

Wystarczy przeanalizować okładkę dla różnych typów danych wejściowych

Analizuj dane za pomocą JSON.parse (), a dane stają się obiektem JavaScript.

var obj = JSON.parse('{ "name":"John", "age":30, "city":"New York"}');

Podczas korzystania z JSON.parse () na JSON pochodzącym z tablicy metoda zwróci tablicę JavaScript zamiast obiektu JavaScript.

var myArr = JSON.parse(this.responseText);
console.log(myArr[0]);

Obiekty daty nie są dozwolone w JSON. Bo Daty robią coś takiego

var text = '{ "name":"John", "birth":"1986-12-14", "city":"New York"}';
var obj = JSON.parse(text);
obj.birth = new Date(obj.birth);

Funkcje nie są dozwolone w JSON. Jeśli potrzebujesz dołączyć funkcję, napisz ją jako ciąg.

var text = '{ "name":"John", "age":"function () {return 30;}", "city":"New York"}';
var obj = JSON.parse(text);
obj.age = eval("(" + obj.age + ")");

Starsze pytanie, wiem, jednak nikt nie zauważa tego rozwiązania za pomocą new Function()anonimowej funkcji zwracającej dane.

Tylko przykład:

 var oData = 'test1:"This is my object",test2:"This is my object"';

 if( typeof oData !== 'object' )
  try {
   oData = (new Function('return {'+oData+'};'))();
  }
  catch(e) { oData=false; }

 if( typeof oData !== 'object' )
  { alert( 'Error in code' ); }
 else {
        alert( oData.test1 );
        alert( oData.test2 );
      }

Jest to trochę bardziej bezpieczne, ponieważ wykonuje się wewnątrz funkcji i nie kompiluje bezpośrednio w kodzie. Jeśli więc wewnątrz znajduje się deklaracja funkcji, nie będzie ona powiązana z domyślnym obiektem okna.

Używam tego do łatwego i szybkiego „kompilowania” ustawień konfiguracji elementów DOM (na przykład atrybutu danych).

Podsumowanie:

JavaScript (zarówno przeglądarka, jak i NodeJS) mają wbudowany JSONobiekt. Na tym obiekcie są 2 wygodne metody radzenia sobie JSON. Są to:

1. JSON.parse() Bierze JSONjako argument, zwraca obiekt JS
2. JSON.stringify() Pobiera obiekt JS jako argument zwracający JSONobiekt

Inne aplikacje:

Poza tym bardzo wygodnie sobie z JSONnimi radzą można je wykorzystać na inne sposoby. Połączenie obu JSONmetod pozwala nam bardzo łatwo tworzyć głębokie klony tablic lub obiektów. Na przykład:

let arr1 = [1, 2, [3 ,4]];
let newArr = arr1.slice();

arr1[2][0] = 'changed'; 
console.log(newArr); // not a deep clone

let arr2 = [1, 2, [3 ,4]];
let newArrDeepclone = JSON.parse(JSON.stringify(arr2));

arr2[2][0] = 'changed'; 
console.log(newArrDeepclone); // A deep clone, values unchanged

Możesz także użyć reviverfunkcji do filtrowania.

var data = JSON.parse(jsonString, function reviver(key, value) {
   //your code here to filter
});

Aby uzyskać więcej informacji przeczytaj JSON.parse.

JSON.parse to właściwy sposób na konwersję łańcucha na obiekt, ale jeśli analizowany ciąg nie jest obiektem lub łańcuch nie jest poprawny, wygeneruje błąd, który spowoduje przerwanie reszty kodu, więc jest idealny do zawijania funkcji JSON.parse w try-catch like

try{
   let obj = JSON.parse(string);
}catch(err){
   console.log(err);
}

Spróbuj tego. Ten jest napisany na maszynie.

         export function safeJsonParse(str: string) {
               try {
                 return JSON.parse(str);
                   } catch (e) {
                 return str;
                 }
           }

/**
 * Safely turning a JSON string into an object
 *
 * @param {String} str - JSON String
 * @returns deserialized object, false if error
 */
export function jsonParse(str) {
  let data = null;
  try {
    data = JSON.parse(str);
  } catch (err) {
    return false;
  }
  return data;
}