JSON නූලක් වස්තුවක් බවට ආරක්ෂිතව හරවන්න

JSON දත්ත මාලාවක් ලබා දී ඇති විට, එම නූල ජාවාස්ක්‍රිප්ට් වස්තුවක් බවට ආරක්ෂිතව හරවා ගන්නේ කෙසේද?

නිසැකවම මට මෙය අනාරක්ෂිත ලෙස මෙවැනි දෙයක් සමඟ කළ හැකිය:

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

නමුත් එය වෙනත් කේත අඩංගු JSON නූලට මා ගොදුරු වේ, එය හුදෙක් එවාල් කිරීම ඉතා භයානක බව පෙනේ.

JSON.parse(jsonString) ඔබට සාධාරණ නවීන බ්‍රව්සරයක් සහතික කළ හැකි තාක් දුරට පිරිසිදු ජාවාස්ක්‍රිප්ට් ප්‍රවේශයකි.

JQuery ක්‍රමය දැන් අතහැර දමා ඇත. ඒ වෙනුවට මෙම ක්‍රමය භාවිතා කරන්න:

let jsonObject = JSON.parse(jsonString);

අතහැර දැමූ jQuery ක්‍රියාකාරීත්වය භාවිතා කරන මුල් පිළිතුර :

ඔබ jQuery භාවිතා කරන්නේ නම් භාවිතා කරන්න:

jQuery.parseJSON( jsonString );

එය ඔබ සොයන දේමයි (jQuery ප්‍රලේඛනය බලන්න ).

මෙම පිළිතුර IE <7 සඳහා වේ, නවීන බ්‍රව්සර් සඳහා ඉහත ජොනතන්ගේ පිළිතුර පරීක්ෂා කරන්න.

මෙම පිළිතුර යල් පැන ගිය එකක් වන අතර ඉහත ( JSON.parse(jsonString)) ට ඉහළින් ඇති ජොනතන්ගේ පිළිතුර දැන් හොඳම පිළිතුරයි .

JSON.org හි ජාවාස්ක්‍රිප්ට් සඳහා විවිධ භාෂා හතරක් ඇතුළුව බොහෝ භාෂා සඳහා JSON පාර්සර් ඇත. බොහෝ අය json2.js ඔවුන්ගේ ගොටෝ ක්‍රියාත්මක කිරීම ගැන සලකා බලනු ඇතැයි මම විශ්වාස කරමි .

" JSON.parse () " හි සරල කේත උදාහරණය භාවිතා කරන්න :

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

එය ආපසු හැරවීම:

var str = JSON.stringify(arr);

එය කිරීමට වෙනත් ක්‍රම ගැන මට විශ්වාස නැත, නමුත් ඔබ එය මූලාකෘති (JSON නිබන්ධනය) තුළ කරන්නේ කෙසේද යන්න මෙන්න .

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

evalJSON()තර්කය ලෙස සත්‍ය ලෙස ඇමතීම පැමිණෙන නූල සනීපාරක්ෂාව කරයි.

මෙය ගැටළුව බව පෙනේ:

අජැක්ස් වෙබ්සොකට් යනාදිය හරහා ලැබෙන ආදානයක්, එය සංගීත ආකෘතියෙන් වනු ඇත, නමුත් එය එසේ දැයි ඔබ දැනගත යුතුය JSON.parsable. ස්පර්ශය නම්, ඔබ එය සැමවිටම ක්‍රියාත්මක කරන්නේ නම් JSON.parse, වැඩසටහන “සාර්ථකව” දිගටම කරගෙන යනු ඇත, නමුත් භීතියෙන් යුතුව කොන්සෝලය තුළ විසිරී ඇති දෝෂයක් ඔබට තවමත් පෙනෙනු ඇත "Error: unexpected token 'x'".

var data;

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

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

ඔබ jQuery භාවිතා කරන්නේ නම් , ඔබට ද මෙය භාවිතා කළ හැකිය:

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

එවිට ඔබට වැනි දේ කළ හැකිය

data.key1.something
data.key1.something_else

ආදිය.

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

ඇමතුම ආපසු ලබා දුන් දත්ත සම්මත කර ඇති අතර එය JSON ව්‍යුහය මගින් අර්ථ දක්වා ඇති පරිදි ජාවාස්ක්‍රිප්ට් වස්තුවක් හෝ අරාවක් වනු ඇත $.parseJSON().

විනෝදය සඳහා, ශ්‍රිතයක් භාවිතා කරන ක්‍රමයක් මෙන්න:

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

භාවිතා JSON.parseකිරීම හොඳම ක්‍රමයයි.

මෙන්න සජීවී නිරූපණයක් සඳහා උදාහරණයක් .

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

ක්‍රමය භාවිතා කිරීමට පහසුම parse()ක්‍රමය:

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

එවිට ඔබට JSON මූලද්‍රව්‍යවල අගයන් ලබා ගත හැකිය, උදාහරණයක් ලෙස:

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

ප්‍රලේඛනයේ විස්තර කර ඇති පරිදි jQuery භාවිතා jQuery.parseJSON()කිරීම:

JSON.parse(jsonString);

මෙම දත්ත වස්තුව සමඟ ක්‍රමය භාවිතා කිරීමට උත්සාහ කරන්න. උදා: Data='{result:true,count:1}'

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

ඔබ අනුක්‍රමික වරාය ක්‍රමලේඛනය සමඟ වැඩ කරන විට මෙම ක්‍රමය ඇත්ත වශයෙන්ම Nodejs සඳහා උපකාරී වේ

මම "වඩා හොඳ" ක්‍රමයක් සොයා ගතිමි:

කෝපි ස්ක්‍රිප්ට් හි:

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

ජාවාස්ක්‍රිප්ට් හි:

var data;

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

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

JSON විග්‍රහ කිරීම සැමවිටම වේදනාවකි. ආදානය අපේක්ෂා කළ පරිදි නොවේ නම් එය දෝෂයක් විසි කර ඔබ කරන දේ බිඳ වැටේ.

ඔබේ ආදානය ආරක්ෂිතව විග්‍රහ කිරීමට ඔබට පහත සඳහන් කුඩා ශ්‍රිතය භාවිතා කළ හැකිය. ආදානය වලංගු නොවුවද හෝ දැනටමත් බොහෝ අවස්ථාවන්ට වඩා හොඳ වස්තුවක් වුවද එය සැමවිටම වස්තුවක් බවට පත් කරයි:

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 වස්තුව බවට වෙනස් වේ.

අපට මේ වගේ නූලක් තිබේ නම්:

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

JSON.parseමෙම දාමය JSON වස්තුවක් බවට පරිවර්තනය කිරීම සඳහා අපට දෙවරක් භාවිතා කළ හැකිය :

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

තවද අපට JSON වස්තුවෙන් අගයන් උකහා ගත හැකිය:

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

ප්රති result ලය වනු ඇත්තේ:

status = 1 and token = 65b4352b2dfc4957a09add0ce5714059

JSON.parse() ශ්‍රිතයට සම්ප්‍රේෂණය වන ඕනෑම JSON නූලක් JSON වස්තුවක් බවට පරිවර්තනය කරයි.

එය වඩා හොඳින් අවබෝධ කර ගැනීම සඳහා, F12ඔබගේ බ්‍රව්සරයේ "මූලද්රව්යය පරීක්ෂා කිරීම" විවෘත කිරීමට ඔබා පහත සඳහන් විධානයන් ලිවීමට කොන්සෝලය වෙත යන්න:

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

දැන් විධානය ක්‍රියාත්මක කරන්න:

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

ඔබට වස්තුවක් ලෙස ප්‍රතිදානය ලැබෙනු ඇත {result: true, count: 1}.

එම වස්තුව භාවිතා කිරීම සඳහා, ඔබට එය විචල්‍යයට පැවරිය හැකිය, සමහර විට obj:

var obj = JSON.parse(response);

objතිත් ( .) ක්‍රියාකරු භාවිතා කිරීමෙන් ඔබට JSON වස්තුවෙහි ගුණාංග වෙත පිවිසිය හැකිය.

විධානය ක්‍රියාත්මක කිරීමට උත්සාහ කරන්න:

console.log(obj.result);

නිල ලියකියවිලි :

මෙම JSON.parse()ක්‍රමය JSON නූලක් විග්‍රහ කර, ජාවාස්ක්‍රිප්ට් අගය හෝ වස්තුව විසින් විස්තර කරන ලද වස්තුවක් සාදයි. reviverප්‍රති object ලයක් ලෙස ඇති වස්තුව නැවත ලබා දීමට පෙර එහි පරිවර්තනයක් සිදු කිරීම සඳහා විකල්ප ශ්‍රිතයක් සැපයිය හැකිය.

වාක්‍ය ඛණ්ඩය:

JSON.parse(text[, reviver])

පරාමිතීන්:

text : JSON ලෙස විග්‍රහ කිරීමට ඇති නූල. JSON සින්ටැක්ස් පිළිබඳ විස්තරයක් සඳහා JSON වස්තුව බලන්න.

reviver (optional) : ශ්‍රිතයක් නම්, නැවත ලබා දීමට පෙර, විග්‍රහ කිරීමෙන් මුලින් නිපදවන අගය පරිවර්තනය වන්නේ කෙසේදැයි මෙය නියම කරයි.

ප්‍රතිලාභ අගය

දී ඇති JSON පෙළට අනුරූප වස්තුව.

ව්යතිරේක

විග්‍රහ කිරීම සඳහා වන නූල වලංගු නොවේ නම් සින්ටැක්ස් දෝෂ ව්‍යතිරේකයක් විසි කරයි JSON.

වස්තුව JSON බවට පරිවර්තනය කිරීම, පසුව එය විග්‍රහ කිරීම මට වැඩ කරයි, වැනි:

JSON.parse(JSON.stringify(object))

JSON නූල සමඟ විග්‍රහ කරන්න JSON.parse(), දත්ත ජාවාස්ක්‍රිප්ට් වස්තුවක් බවට පත්වේ:

JSON.parse(jsonString)

මෙන්න, JSON දත්ත සමුදාය සැකසීමට JSON නියෝජනය කරයි.

වෙබ් සේවාදායකයකින් අපට මෙම පා received ය ලැබී ඇතැයි සිතන්න:

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

JSON වස්තුවකට විග්‍රහ කිරීමට:

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

පහත objදැක්වෙන අදාළ JSON වස්තුව මෙන්න :

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

වටිනාකමක් ලබා ගැනීමට .ක්‍රියාකරු භාවිතා කරන්න :

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

ජාවාස්ක්‍රිප්ට් වස්තුවක් සමඟ නූලක් බවට පරිවර්තනය කරන්න JSON.stringify().

විවිධ ආදාන වර්ග සඳහා ආවරණ විග්‍රහයට

JSON.parse () සමඟ දත්ත විග්‍රහ කරන්න, එවිට දත්ත ජාවාස්ක්‍රිප්ට් වස්තුවක් බවට පත්වේ.

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

අරාවකින් ලබාගත් JSON මත JSON.parse () භාවිතා කරන විට, මෙම ක්‍රමය ජාවාස්ක්‍රිප්ට් වස්තුවක් වෙනුවට ජාවාස්ක්‍රිප්ට් අරාවක් ලබා දෙනු ඇත.

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

JSON හි දිනය වස්තු සඳහා අවසර නැත. දිනයන් සඳහා මේ වගේ දෙයක් කරන්න

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

JSON හි කාර්යයන් සඳහා අවසර නැත. ඔබට ශ්‍රිතයක් ඇතුළත් කිරීමට අවශ්‍ය නම් එය නූලක් ලෙස ලියන්න.

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

පැරණි ප්‍රශ්නය, මම දනිමි, කෙසේ වෙතත් new Function()දත්ත නැවත ලබා දෙන නිර්නාමික ශ්‍රිතයක් භාවිතා කිරීමෙන් කිසිවෙකු මෙම විසඳුම නොදකිති.

උදාහරණයක් පමණි:

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

මෙය තව ටිකක් ආරක්ෂිත වන්නේ එය ශ්‍රිතයක් තුළ ක්‍රියාත්මක වන නිසා සහ ඔබේ කේතය කෙලින්ම සම්පාදනය නොකරන බැවිනි. එබැවින් එය තුළ ශ්‍රිත ප්‍රකාශයක් තිබේ නම් එය පෙරනිමි කවුළු වස්තුවට බැඳී නොමැත.

මම මෙය භාවිතා කරන්නේ DOM මූලද්‍රව්‍යවල වින්‍යාස සැකසුම් 'සම්පාදනය කිරීමට' (උදාහරණයක් ලෙස දත්ත ආරෝපණය) සරල හා වේගවත් ය.

සාරාංශය:

ජාවාස්ක්‍රිප්ට් (බ්‍රව්සරය සහ නෝඩ්ජේඑස් යන දෙකම) තුළ සාදන ලද JSONවස්තුවක් ඇත. මෙම වස්තුව සමඟ කටයුතු කිරීමට පහසු ක්‍රම 2 ක් ඇත JSON. ඒවා පහත දැක්වේ:

1. JSON.parse() ගනී JSONතර්කය, ප්රතිලාභ JS වස්තුව ලෙස
2. JSON.stringify() JS වස්තුව තර්කය ආපසු ලබා දෙන JSONවස්තුව ලෙස ගනී

වෙනත් යෙදුම්:

JSONඔවුන් සමඟ ඉතා පහසුවෙන් ගනුදෙනු කිරීම හැරුණු විට වෙනත් ක්‍රම සඳහාද භාවිතා කළ හැකිය. JSONක්‍රම දෙකේම සංයෝජනය මඟින් අරා හෝ වස්තූන්ගේ ගැඹුරු ක්ලෝන සෑදීම ඉතා පහසු කරයි. උදාහරණයක් වශයෙන්:

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

ඔබට reviverපෙරණය සඳහා ශ්‍රිතය භාවිතා කළ හැකිය .

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

වැඩි විස්තර සඳහා කියවන්න JSON.parse.

JSON.parse යනු නූලක් වස්තුවක් බවට පරිවර්තනය කිරීමේ නිවැරදි ක්‍රමය වන නමුත් විග්‍රහ කරන ලද නූල වස්තුවක් නොවේ නම් හෝ නූල නිවැරදි නොවේ නම් එය දෝෂයක් විසි කරන අතර එමඟින් ඉතිරි කේතය කැඩීමට හේතු වේ. උත්සාහ කිරීම වැනි JSON.parse ශ්‍රිතය එතීමට වඩාත් සුදුසුය

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

මෙය උත්සාහ කරන්න. මෙය ලියා ඇත්තේ යතුරු ලියනයෙනි.

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