რა არის ჯსონი. JSON ფორმატი: რა არის ეს, როგორ უნდა შექმნათ და გახსნათ ფაილი

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

მიღებულია JSON– ის ასოცირება curly braces– თან და ეს უკანასკნელი საკმაოდ გამართლებულია, ვინაიდან JSON format \u003d Object Notation JavaScript. ბოლო განსაკუთრებით დინამიური წლების განმავლობაში ბევრი რამ შეიცვალა. რაც სპეციფიკური მიზნით შეიქმნა, ხშირად მოუტანს მოულოდნელ შედეგებს ან ხსნის ახალ ჰორიზონტებს.

მონაცემთა გაცვლა: ბრაუზერი - სერვერი

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

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

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

კირილიცას გამოყენება ცვლადი დასახელებისას ძალიან მოულოდნელი მოვლენაა (სისულელეა), მაგრამ ის მუშაობს Chrome, Firefox და Internet Explorer 11-ის უახლეს ვერსიებშიც კი.

კირილიცა და JSON

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

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

მნიშვნელობა არ აქვს სინტაქსური ინოვაცია რა სახის საფუძველს ემყარებოდა - JSON, მნიშვნელოვანია, რომ მან მისცა იურიდიული უფლება და რეალური შესაძლებლობა დაეწერა კორესპონდენცია: "ნებისმიერი სახელი \u003d ნებისმიერი მნიშვნელობა".

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

PHP და JSON

მონაცემების JSON ფორმატში მიღების გზით, სერვერი (კერძოდ PHP– ის საშუალებით) უზრუნველყოფს მისი დამუშავების, როგორც შედეგის, და შედეგის დაბრუნების ბრაუზერს მსგავსი ფორმატით უზრუნველყოფის შესაძლებლობას. PHP ორიგინალური მასივი:

• $ cJSON \u003d მასივი ("a" \u003d\u003e "alfa", "b" \u003d\u003e "beta", "g" \u003d\u003e "გამა").

გადადით JSON ფორმატში ბრაუზერში გადასასვლელად:

• $ cJS \u003d json_encode ($ cJSON).

შედეგი:

• ("ა": "ალფა", "ბ": "ბეტა", "გ": "გამა").

დასაშვებია ფოტოზე ნაჩვენები ბუდე.

აქ წარმოქმნილ მასივს დაემატა ახალი ელემენტი "თავისთავად" ავტომატური ინდექსით "0", შემდეგ კი ისევ მითითებული ინდექსით "z".

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

ბუდეების დონე

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

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

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

JSON ფაილები

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

საწარმოს პერსონალი და JSON ფორმატი: მაგალითი

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

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

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

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

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

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

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

XML და JSON

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

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

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

პრაქტიკაში იყო შემთხვევები, როდესაც BASIC- ში იწერებოდა პროგრამებს, რომლებშიც არ იყო გამოყენებული JSON, მაგრამ მშვენივრად ინახავდა "name \u003d value" წყვილებს და სწორ დროს აყენებდი სწორი ალგორითმების განკარგულებაში.

სპეციალური სიმბოლოები ("", "~", "|", ...) და მონაცემთა ფორმატები

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

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

JSON– ის გამოყენება Android– ში

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

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

ასოციაციური მასივები

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

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

ეს გარემოება განსაკუთრებით გამოხატულია PHP– ში, მაგრამ თქვენ შეგიძლიათ შეეგუოთ მას, როგორც სხვათა შორის, ცვლადის სახელის "$" სიმბოლოთი და ობიექტის შიგნით "$ this-\u003e". პროგრამირება JavaScript და PHP ერთდროულად, თავიდან ნამდვილად გაინტერესებთ რამდენად განსხვავებულია ყველაფერი, მაგრამ შემდეგ ყველაფერი ხდება ისე ნაცნობი და ბუნებრივი ...

ასოციაციური მასივი -\u003e JSON

ამ მაგალითში * .docx დოკუმენტი იქმნება PHPOffice / PHPWord ბიბლიოთეკის გამოყენებით და aProperties მასივი შეიცავს ამ დოკუმენტის თვისებებს (ავტორი, კომპანია, სათაური, კატეგორია, შექმნის თარიღი ...).

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

• ორიენტაცია (ლანდშაფტი ან ნორმალური);
• ვერტიკალური და ჰორიზონტალური ზომები;
• ჩაღრმავებები (მინდვრები მარცხნივ, ზემოდან, ქვედადან, მარჯვნივ);
• სათაურები და ქვედა კოლონტიტულები.

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

დინამიკური ცვლადები

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

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

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

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– ის გამოყენებით, რაც საშუალებას აძლევს ბრაუზერს და სერვერს დაუკავშირდნენ გვერდის გადატვირთვის გარეშე.

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

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

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

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

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

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

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

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

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

("orderID": 12345, "shopperName": "ვანია ივანოვი", "shopperEmail": " [ელ.ფოსტით დაცულია]"," შინაარსები ": [(" პროდუქტის ID ": 34," პროდუქტის სახელი ":" სუპერ პროდუქტი "," რაოდენობა ": 1), (" პროდუქტის ID ": 56," პროდუქტის სახელი ":" მშვენიერი პროდუქტი "," რაოდენობა ": 3)], "orderCompleted": მართალია)

დეტალურად განვიხილოთ ხაზი:

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

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

JSON და XML შედარება

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

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

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

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 ობიექტს ან მასივს, რომელიც შეიცავს მონაცემებს. Მაგალითად:

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

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

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

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

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

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

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

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

12345, "shopperName" \u003d\u003e "ვანია ივანოვი", "shopperEmail" \u003d\u003e " [ელ.ფოსტით დაცულია]"," შინაარსის "\u003d\u003e მასივი (მასივი (" პროდუქტის ID "\u003d\u003e 34," პროდუქტის სახელი "\u003d\u003e" სუპერ პროდუქტი "," რაოდენობა "\u003d\u003e 1), მასივი (" პროდუქტის ID "\u003d\u003e 56," პროდუქტის სახელი "\u003d\u003e "საოცარი პროდუქტი", "რაოდენობა" \u003d\u003e 3)), "orderCompleted" \u003d\u003e მართალი); echo json_encode ($ კალათა);?\u003e

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

("orderID": 12345, "shopperName": "ვანია ივანოვი", "shopperEmail": " [ელ.ფოსტით დაცულია]"," შინაარსები ": [(" პროდუქტის ID ": 34," პროდუქტის სახელი ":" სუპერ პროდუქტი "," რაოდენობა ": 1), (" პროდუქტის ID ": 56," პროდუქტის სახელი ":" მშვენიერი პროდუქტი "," რაოდენობა ": 3)], "orderCompleted": მართალია)

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

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

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

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

shopperEmail. "
"; echo $ cart-\u003e content-\u003e ProductName."
"; ?>

რაც შეეხება JavaScript- ს, ამ კოდში შევა:

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

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

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

$ cart \u003d json_decode ($ jsonString, მართალია); echo $ cart ["shopperEmail"]. "
"; echo $ cart [" content "] [" ProductName "]."
";

ეს კოდი იგივე შედეგს მისცემს:

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

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

დასკვნა

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

ჯსონი (JavaScript Object Notation) არის მონაცემთა სტრუქტურირებული წარმოდგენის ფორმატი, რომელიც გამოიყენება ინტერნეტის საშუალებით მონაცემთა გადასაცემად.

სინამდვილეში, JSON ფორმატი არის ჩვეულებრივი სტრიქონი.

JSON სინტაქსი

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

JSON მონაცემთა ტიპები

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

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

კომპლექსური ტიპები მოიცავს:

• ობიექტი - ობიექტები
• მასივი - მასივები

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

მარტივი ღირებულებები

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

5 2.3 "გამარჯობა!" ნამდვილი ნული

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

ობიექტები

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

("სახელი": "გომერი", "ასაკი": 40, "სამუშაო": ("ადგილი": "ბირთვული სადგური", "ადგილმდებარეობა": "სპრინგფილდი"))

მასივები

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

[("სახელი": "გომერი", "ასაკი": 40, "სამუშაო": ("ადგილი": "ბირთვული ქარხანა", "ადგილმდებარეობა": "სპრინგფილდი"), "ბავშვები": ["ბარტი", "ლიზა" "," მეგი "]), (" სახელი ":" მარჯი "," ასაკი ": 37," სამუშაო ": (" ადგილი ":" სახლი "," ადგილმდებარეობა ":" სპრინგფილდი ")," ბავშვები ": [ "ბარტი", "ლიზა", "მეგი"]]]]

რა არის 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 ტექნოლოგიისთვის. ეს ძალიან მოსახერხებელია, როდესაც მრავალ ცვლადს ან მონაცემთა მთელ მასივს გადასცემთ.

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

1. მომხმარებელი დააჭერს მინიატურების სურათები
2. JavaScript ამუშავებს ამ ღონისძიებას და აგზავნის ajax მოთხოვნას PHP სკრიპტზე, სურათის ID– ს გადაცემით.
3. სერვერზე, php იღებს სურათის აღწერას, სურათის სახელს, მისამართს დიდ სურათზე და სხვა ინფორმაციას მონაცემთა ბაზაში. მას შემდეგ, რაც იგი მიიღებს, იგი გარდაქმნის მას JSON ფორმატში და აგზავნის მას მომხმარებლის გვერდზე.
4. JavaScript იღებს JSON პასუხს, ამუშავებს მონაცემებს, წარმოქმნის html კოდს და აჩვენებს გაფართოებულ სურათს აღწერით და სხვა ინფორმაციით.

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

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

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

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

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

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

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

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

("orderID": 12345, "shopperName": "ჯონ სმიტი", "shopperEmail": " [ელ.ფოსტით დაცულია]"," შინაარსები ": [(" პროდუქტის ID ": 34," პროდუქტის სახელი ":" SuperWidget "," რაოდენობა ": 1), (" ProductID ": 56," ProductName ":" WonderWidget "," რაოდენობა ": 3) ], "orderCompleted": მართალი)

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

1. დასაწყისში და ბოლოს, ჩვენ ვიყენებთ curly მშვილდი (s), რომელიც ცხადყოფს, რომ ეს არის ობიექტი.
2. ობიექტის შიგნით, ჩვენ გვაქვს რამდენიმე სახელი / მნიშვნელობა წყვილი:
3. "orderID": 12345 - ველი, სახელად orderId და მნიშვნელობა 12345
4. "shopperName": "ჯონ სმიტი" ველი, სახელად shopper სახელი და მნიშვნელობა ჯონ სმიტ
5. " shopperEmail ":"[ელ.ფოსტით დაცულია] მაგალითი.com " - წინა ველის მსგავსად, აქ ინახება მომხმარებლის ელ.ფოსტა.
6. "შინაარსი": [...] - ველი, სახელად შინაარსი, რომლის მნიშვნელობა არის მასივი.
7. "orderCompleted": მართალია - ველი, სახელად ბრძანება დასრულებულია, რომლის მნიშვნელობა მართალია
8. შინაარსის მასივის შიგნით, ჩვენ გვაქვს ორი ობიექტი, რომლებიც აჩვენებს კალათის შინაარსს. თითოეული პროდუქტის ობიექტს აქვს სამი თვისება: პროდუქტის ID, პროდუქტის სახელი, რაოდენობა.

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

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

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

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

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

როგორც ხედავთ, იგი რამდენჯერმე გრძელია ვიდრე 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": "ჯონ სმიტი", "shopperEmail": " [ელ.ფოსტით დაცულია]"," შინაარსები ": [(" პროდუქტის ID ": 34," პროდუქტის სახელი ":" SuperWidget "," რაოდენობა ": 1), (" ProductID ": 56," ProductName ":" WonderWidget "," რაოდენობა ": 3) ], "orderCompleted": მართალი)

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

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

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

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

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

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

JSON ფორმატის შექმნა და კითხვა PHP– ით

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

JSON სტრიქონის გენერირება PHP ცვლადიდან

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

12345, "shopperName" \u003d\u003e "ჯონ სმიტი", "shopperEmail" \u003d\u003e " [ელ.ფოსტით დაცულია]"," შინაარსები "\u003d\u003e მასივი (მასივი (" ProductID "\u003d\u003e 34," ProductName "\u003d\u003e" SuperWidget "," რაოდენობა "\u003d\u003e 1), მასივი (" ProductID "\u003d\u003e 56," ProductName "\u003d\u003e") WonderWidget "," რაოდენობა "\u003d\u003e 3))," orderCompleted "\u003d\u003e მართალი); echo json_encode ($ კალათა);?\u003e

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

("orderID": 12345, "shopperName": "ჯონ სმიტი", "shopperEmail": " [ელ.ფოსტით დაცულია]"," შინაარსები ": [(" პროდუქტის ID ": 34," პროდუქტის სახელი ":" SuperWidget "," რაოდენობა ": 1), (" ProductID ": 56," ProductName ":" WonderWidget "," რაოდენობა ": 3) ], "orderCompleted": მართალი)

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

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

PHP ცვლადის შექმნა JSON სიმებიდან

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

shopperEmail. "
"; echo $ cart-\u003e content-\u003e ProductName."
"; ?>

როგორც JavaScript– ში, ამ კოდში გამოვა შემდეგი:

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

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

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

$ cart \u003d json_decode ($ jsonString, მართალია); echo $ cart ["shopperEmail"]. "
"; echo $ cart [" content "] [" ProductName "]."
";

ეს გამოდის იგივე შედეგი:

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

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

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

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

განცხადება

JSON ვებსაიტის ფაილის ფორმატი

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

JSON ფაილების ტექნიკური დეტალები

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

დამატებითი ინფორმაცია JSON ფორმატის შესახებ

Ფაილის გაფართოება	.ჯონს
ფაილის კატეგორია
მაგალითი ფაილი	(0.57 KiB)
დაკავშირებული პროგრამები	Microsoft Notepad Microsoft WordPad ჩასაწერი ++ Mozilla Firefox