Code.ge Blog

JSON (JavaScript Object Notation) – ნოტაცია დღესდღეობით ფართოდ გამოყენებადი და ძალიან მოხერხებული საშუალებაა ინფორმაციის გაცვლისათვის. გამომდინარე იქედან რომ იგი არის ჩვეულებრივი სტრიქონი, იგი არ არის დამოკიდებული არც ენაზე და არც პლატფორმაზე.

JSON თანაბარი წარმატებით გამოიყენება ისეთი მაღალი დონის ენებში როგორიც არის: Java, PHP, Ruby, C#, JavaScript და ა.შ. გარდა ამისა იგი არის ერთერთი შეუცვლელი ნაწილი თანამედროვე Ajax აპლიკაციებისა და ფართოდ გამოიყენება კლიენტსა და სერვერს შორის ინფორმაციის მიმოცვლისათვის.

პრობლემა

მიუხედავად იმისა რომ JSON – ს საფუძვლად უდევს JavaScript ობიექტი, ამ ენას არ გააჩნია არანაირი საშუალება იმისათვის რომ ობიექტი გარდაქმნას JSON სტრიქონად. ბუნებრივია ეს აუცილებელია რადგან პირდაპირ JavaScript ობიექტის გაგზავნა/მიღება http პროტოკოლის მეშვეობით შეუძლებელია. გაგზავნისათვის საჭიროა ამ ობიექტის სერიალიზაცია(ანუ სტრიქონულ ფორმატში გადაყვანა, ხოლო მიღების დროს JSON სტრიქონის, უკან JavaScript ობიექტში გადაყვანა.

JSON სტრიქონის გადაყვანა ობიექტში, ძალიან მარტივია. ამისათვის საკმარისია JavaScript – ის eval ფუნქციის გამოყენება და გამზადებული ობიექტი ხელთ გვაქვს. თუმცა ობიექტის ხელახალი სერიალიზაცია JSON – ში ასეთი მარტივი არ არის.

გამოსავალი

იმისათვის რომ მოვახდინოთ ობიექტის სერიალიზაცია შესაძლებელია გამოვიყენოთ ქვემოთ მოყვანილი გზებიდან ერთერთი.

მაგალითში გამოყენებული იქნება შემდეგი სახის ობიექტი:

var myObj = {
    id: 'some-unique-id',
    name: 'obj-name',
    values: [1, 2, true, false, null, 'some string'],
    nested: {
        name: 'nested obj name',
        value: {name: 'other nested obj'}
    }
}

• JSON სტრიქონის ხელოვნურად აწყობა

  ასეთ შემთხვევაში, როდესაც საქმე გვაქვს მარტივ ობიექტთან, მისი ხელოვნური გზით სერიალიზაცია დიდ პრობლემას არ წარმოადგენს… თუმცა ეს მაინც არასასიამოვნო პროცესია.

  მაგალითად ზემოთ ნაჩვენები ობიექტის JSON სტრიქონად გარდაქმნისათვის საჭიროა მსგავსი მანიპულაციები:

  1 2 3 4 5 6 7

  var json = []; json.push('{id: "' + myObj.id + '",'); json.push('name: "' + myObj.name + '",'); json.push('values: ['); for (var i = 0; i < myObj.values.length; i++) {    json.push(myObj.values[i] + ','); }

  და ასე შემდეგ… რა თქმა უნდა ეს კოდი მოყვანილია პირობით მაგალითად თუ რა არის საჭირო ასეთ გზით JSON სტრიქონის ასაწყობად, და იგი ნათლად ასახავს თუ რამდენად არაეფექტური, შრომატევადი და რაც ყველაზე მნიშვნელოვანია შეცდომებისათვის განწირულია ასეთი მიდგომა.

• JSON სერიალიზაცია სპეციალური უნივერსალური მეთოდის მეშვეობით
  განსხვავებით წინა მაგალითისგან, ეს გზა არის გამართლებული, რეკომენდირებული და ასეთი გზით შეცდომების დაშვების ალბათობა დადის მინიმუმზე. იმ შემთხვევაშიც კი თუ აღმოჩენილი იქნება სერიალიზაციის შეცდომა, მისი ძებნა მოგვიწევს მხოლოდ ერთ ადგილას, და მისი აღმოფხვრა აისახება მთლიან შედეგზე, რაც ნიშნავს იმას რომ დაშვებული შეცდომების ძებნა არ არის საჭირო ბევრ ადგილას რაც გარდაუვალი იქნებოდა ობიექტების სერიალიზაციის ზემოთ ნაჩვენები მიდგომის გამოყენების შემთხვევაში.

  ობიექტის სერიალიზაციის კოდი:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

  function serialize(o, l) {         var res = [], tmp = [], l = l || 1, key;         var repeat = function(str, count) {         var tmp = [];         for (var i = 0; i < count; i++) {             tmp.push(str);         }         return tmp.join('');     }         for (var k in o) {         key = o.constructor == Object ? k + ': ' : '';         if (o[k] != undefined) {             if (o[k].constructor == Object) {                 tmp.push(repeat("\t", l) + key + serialize(o[k], l+1));             } else if (o[k].constructor == Array) {                 tmp.push(repeat("\t", l) + key + serialize(o[k], l+1));             } else {                 if (o[k].constructor == String) {                     tmp.push(repeat("\t", l) + key + '"' + o[k] + '"');                 } else {                     tmp.push(repeat("\t", l) + key + o[k]);                 }             }         } else if (o[k] === null) {             tmp.push(repeat("\t", l) + key + 'null');         }     }         res.push((o.constructor == Object ? '{' : '[') + "\n");     res.push(tmp.join(",\n"));     res.push("\n" + repeat("\t", (l - 1)) + (o.constructor == Object ? '}' : ']'));             return res.join('');     }

  ამ ფუნქციის გამოყენება ძალიან მარტივია, და განსხვავებით წინა მაგალითისგან ობიექტის სერიალიზაციისათვის საკმარისია შემდეგი კოდი:

  1 2 3

  var json = serialize(myObj); //json ცვლადის მნიშნველობა არის სწორად ფორმირებული JSON სტრიქონი //რომლის გაგზავნაც შესაძლებელია სერვერზე.

  ნაჩვენები კოდი ძალიან მარტივია, იგი არის ჩვეულებრივი რეკურსიული ფუნქცია რომელიც იქცევა ობიექტის თვისებების მნიშვნელობების მიხედვით, საბოლოო ჯამში კი აბრუნებს სწორად ფორმირებულ JSON სტრიქონს. აღასანიშნავია ის რომ ამ მეთოდს შეგვიძლია გადავცეთ ნებისმიერი სირთულის ობიექტი, ხოლო შედეგად მივიღებთ JSON სტრიქონს. ასევე აღსანიშნავია რომ ეს მეთოდი სტრიქონის ფორმირებისათვის იყენებს ახალი ხაზის(\n) და ტაბულაციის(\t) სიმბოლოებს, რაც მნიშვნელოვანია მიღებული შედეგის კითხვადობის თვალსაზრისით.

რაც შეეხება დესერიალიზაციას JavaScript – ში, და სერიალიაზაცია/დესერიალიზაციას სერვერულ ენებში:

• JavaScript

  //eval ფუნქციის გამოყენებით
  var myObj = eval(jsonString);
  

  თუმცა JavaScript – ში გაუგებრობების თავიდან ასაცილებლად, json სტრიქონის დესერიალიზაციისას მართებულია მოვიქცეთ შემდეგნაირად:

  try {
      //სტრიქონი მოვაქციოთ ფრჩხილებში
      var myObj = eval('(' + jsonString + ')');
  } catch(e) {
      //სხვა, შესაბამისი მოქმედებები
  }
  

  ამ შემთხვევაში ორი თავდაცვითი მექანიზმი გამოვიყენეთ: 1) JSON სტრიქონი მოვაქციეთ ფრჩხილებში; 2) კოდი შევასრულეთ try/catch ბლოკის შიგნით, რადგან თუ eval ფუნქციას გადავცემთ არაკორექტულ სტრიქონს მისი ობიექტად გარდაქმნა ვერ მოხერხდება რაც გამოიწვევს შეცდომას, ხოლო try/catch ბლოკი ამ შემთხვევაში საუკეთესო გამოსავალია შესაძლო გაუმართავობის სწორად დასამუშავებლად;

• PHP

  //PHP5 - ს აქვს ორი შესაბამისი ფუნქცია
  //სერიალიზაცია
  $arr = array('key1'=>'value2', 'key2'=>'value2');
  $json = json_encode($arr);
  //დესერიალიზაცია
  $deserialized = json_decode($json);
  

სხვადასხვა ენებში არსებობს შესაბამისი ბიბლიოთეკები JSON მანიპულაციისათვის, და მათი გამოყენება ისეთივე მარტივია როგორც ზემოთ ნაჩვენები მაგალითები.

ტეგები: Ajax, JavaScript