JSON-format: exempel och beskrivning. JSON-format: dataskapande, använd med PHP och JS Json förkortningsavkodning
), och mellan servrarna själva (HTTP-programvarugränssnitt). JSON-formatet är också väl lämpat för att lagra komplexa dynamiska strukturer i relationsdatabaser eller filcacher.
Eftersom JSON är en delmängd av JavaScript-syntax, kan den snabbt deserialiseras med den inbyggda eval()-funktionen. Dessutom är det möjligt att infoga fullt fungerande JavaScript-funktioner. I PHP, från och med version 5.2.0, ingår JSON-stöd i kärnan i form av funktionerna json_decode() och json_encode(), som själva konverterar JSON-datatyper till motsvarande PHP-typer och vice versa.
SyntaxJSON är byggd på två strukturer:
- En uppsättning nyckel/värdepar. På olika språk implementeras detta som ett objekt, post , struktur , ordbok , hashtabell , nyckellista eller associativ array . Nyckeln kan bara vara en sträng, värdet kan bara vara vilken form som helst.
- En numrerad uppsättning värden. På många språk är detta implementerat som array, vektor, lista eller sekvens.
Dessa är universella datastrukturer. I teorin stöder alla moderna programmeringsspråk dem i en eller annan form. Eftersom JSON används för att utbyta data mellan olika programmeringsspråk är det vettigt att bygga det på dessa strukturer.
Följande formulär används i JSON:
- Ett objekt är en oordnad uppsättning namn/värdepar omslutna av krulliga klammerparenteser ( ). Det finns en symbol mellan namnet och värdet ": " , och namn/värdepar separeras med kommatecken.
- En array (endimensionell) är en uppsättning värden som har serienummer (index). Arrayen omges av hakparenteser. Värden separeras med kommatecken.
- Värdet kan vara linje inom dubbla citattecken, siffra, värde Sann eller falsk, objekt, array, eller värde null. Dessa strukturer kan vara kapslade i varandra.
- En sträng är en ordnad uppsättning av noll eller fler Unicode-tecken, omgiven av dubbla citattecken, med escape-sekvenser med omvänt snedstreck. Tecknen representeras som en enkel sträng.
- Namnet är en sträng.
Linje mycket lik en sträng i språken och Java. siffra också mycket likt ett C- eller Java-nummer, förutom att endast decimalformat används. Mellanslag kan infogas mellan vilka två tecken som helst.
Följande exempel visar en JSON-representation av ett objekt som beskriver en person. Objektet har sträng för- och efternamnsfält, ett objekt som beskriver adressen och en array som innehåller en lista med telefonnummer.
( "firstName" : "Ivan" , "efternamn" : "Ivanov" , "address" : ( "streetAddress" : "Moskovskoe sh., 101, lägenhet 101" , "stad" : "Leningrad" , "postalCode" : 101101 ), "telefonnummer" : [ "812 123-1234", "916 123-4567" ] )
I XML skulle en sådan struktur se ut ungefär så här:
Ivan Ivanov Moskovskoe sh., 101, lägenhet 101 Leningrad 101101 812 123-1234 916 123-4567
812 123-1234 916 123-4567
Jämförelse med YAMLBåde funktionellt och syntaktisk är JSON en delmängd av YAML-språket. Specifikt säger YAML 1.2-specifikationen att "alla JSON-filer är en giltig YAML-fil." Den vanligaste YAML-parsern kan också bearbeta JSON. YAML-specifikationen före version 1.2 täckte inte helt JSON, främst på grund av bristen på inbyggt stöd för UTF-32 i YAML, samt kravet på ett mellanslag efter kommaavgränsaren. Dessutom inkluderade JSON-specifikationen /* */ stilkommentarer.
Den viktigaste skillnaden i YAML är uppsättningen syntaxtillägg som inte har några analoger i JSON:
Relationell: YAML stöder relationsdata: i ett YAML-dokument kan du referera till ett ankare som inträffade tidigare i en fil/ström. Rekursiva strukturer kan uttryckas på detta sätt. Utökningsbar: YAML stöder utökningsbara datatyper bortom primitiva (d.v.s. strängar, tal, booleaner). Block: I YAML är indragen blocksyntax tillgänglig; den låter dig beskriva strukturerad data utan att använda onödiga symboler (alla typer av parenteser, citattecken, etc.).
JSON-schemaJSON Schema är ett av språken för att beskriva strukturen i ett JSON-dokument. Använder JSON-syntax. Baserat på begreppen XML Schema, RelaxNG, Kwalify. JSON Schema är ett självbeskrivande språk: när det används kan samma serialiserings-/deserialiseringsverktyg användas för att bearbeta data och beskriva dess giltighet.
Använder JSON i AjaxFöljande exempel på Javascript-kod visar hur en webbläsare kan använda XMLHttpRequest för att begära ett JSON-formaterat objekt från servern (serversidan av programmet är utelämnad; den måste innehålla koden som skickar data som en JSON-sträng som svar på förfrågningar av url).
Var the_object; var http_request = new XMLHttpRequest() ; http_request.open("GET", url, true); http_request.send(null); http_request.onreadystatechange = function () ( if ( http_request.readyState == 4 ) ( if ( http_request.status == 200 ) ( the_object = JSON.parse ( http_request.responseText ) ; ) else ( alert( "Det var ett problem med URL:en." ) ; ) http_request = null ; ) ) ;
Observera att detta exempel på att använda XMLHttpRequest inte är universellt för alla webbläsare (för webbläsare baserade på Internet Explorer, Opera, Safari och Mozilla bör det finnas vissa skillnader i koden). Användningen av XMLHttpRequest är begränsad på grund av samma ursprungspolicy: URL:en för svaret på begäran måste vara i samma DNS-domän som servern där sidan som begär svaret finns. Ett alternativ är JSONP-metoden, som innebär att man använder ett kodat funktionsanrop som skickas mellan klienten och servern så att klienten kan ladda JSON-kodad data från tredjepartsdomäner och meddela anroparen om slutförandet, även om detta medför vissa säkerhetsrisker och ytterligare serverkrav.
Alternativt kan sidkoden använda element för att asynkront begära JSON-data, eller helt enkelt . Dessa tillvägagångssätt var vanliga innan det utbredda stödet för XMLHttpRequest.
Du kan också använda samma ursprungspolicy för att överföra JSON-data med dynamiska taggar, men detta resulterar i sårbar kod. Som ett säkrare alternativ har det föreslagits att använda JSONRequest.
SäkerhetsfrågorÄven om JSON är utformad för att överföra data i en serialiserad form, följer dess syntax JavaScript-syntaxen och detta skapar ett antal säkerhetsproblem. Ofta, för att behandla data som tas emot från en extern källa i JSON-format, appliceras funktionen eval() på den utan någon preliminär validering.
JavaScript eval()Eftersom JSON verkar vara en syntaktisk korrekt del av JavaScript-kod, är det enklaste sättet att analysera JSON-data i ett JavaScript-program att använda den inbyggda JavaScript eval()-funktionen, som är utformad för att exekvera JavaScript-uttryck. Med detta tillvägagångssätt finns det inget behov av att använda ytterligare parsers.
Tekniken eval() gör systemet sårbart om källan till JSON-data som används inte är betrodd ( engelsk). Sådan data kan vara skadlig JavaScript-kod för Code Injection-attacker ( engelsk). Genom att använda denna sårbarhet är det möjligt att stjäla data och förfalska autentisering. Sårbarheten kan dock elimineras genom att använda ytterligare datavalideringsverktyg. Till exempel, innan du kör eval(), kan data som tas emot från en extern källa valideras med hjälp av reguljära uttryck. RFC:n som definierar JSON föreslår att du använder följande kod för att kontrollera om den överensstämmer med JSON-formatet
Var my_JSON_object = ! (/[^,:()\[\]0-9.\-+Eaeflnr-u \n\r\t]/ .test ( text.replace (/"(\\.|[^"\\] )*"/g , "" ) ) ) && eval("(" + text + ")" );
Som ett säkrare alternativ till eval() har en ny funktion, parseJSON(), föreslagits som endast kan bearbeta JSON-data. Den introducerades i version 4 av ECMAScript-standarden och beskrivs i artikeln "JSON: A Low-Fat Alternative to XML". Det är för närvarande tillgängligt som ett JavaScript-bibliotek och kommer att ingå i den femte upplagan av ECMAScript.
Inbäddad JSONSenaste versioner av webbläsare har inbyggt stöd för JSON och kan bearbeta det utan att anropa eval()-funktionen, vilket leder till det beskrivna problemet. JSON-behandling är vanligtvis snabbare i det här fallet. Så i juni 2009 hade följande webbläsare inbyggt JSON-stöd:
Minst fem populära JavaScript-bibliotek använder inline JSON när det är tillgängligt:
Förfalskning av begäranden över flera domänerDålig användning av JSON gör webbplatser sårbara för förfalskning av förfrågningar mellan webbplatser (CSRF eller XSRF). Eftersom taggen tillåter användning av en källa som inte tillhör samma domän som resursen som använder den, tillåter den att kod exekveras under sken av JSON-data i sammanhanget av en godtycklig sida, vilket gör det möjligt att kompromissa med lösenord eller annan känslig information om användare som är auktoriserade till en annan webbplats.
Detta verkar bara vara ett problem om JSON-data innehåller känslig information som kan äventyras av en tredje part och om servern förlitar sig på en policy med ett enda ursprung ( engelsk), blockerar åtkomst till data när en extern begäran upptäcks. Detta är inte ett problem om servern bestämmer giltigheten av begäran och tillhandahåller data endast om den är korrekt. HTTP-cookies kan inte användas för att fastställa detta. Den exklusiva användningen av HTTP-cookies används av förfalskning av begäranden över flera webbplatser.
JSONP & JSONPPJSONP (JSON Padding) eller "JSON with padding" är en förlängning av JSON när namnet på en callback-funktion anges som ett inmatningsargument.
Tekniken bygger på att webbläsarens säkerhetspolicy tillåter användning av taggen för att komma åt andra servrar än den server från vilken sidan laddades.
Utan att använda JSONP-teknik (det vill säga att bara använda JSON-datakodning) kan servern bara returnera data. Till exempel så här:
("papper": "A4", "antal": 5)
Detta är dock endast data och kan inte påverka webbläsaren.
Med JSONP-tekniken skickas namnet på återuppringningsfunktionen till tredjepartsservern i samtalslinjen (GET):
Här innehåller jsonp-parametern namnet på callback-funktionen parseResponse.
Nu kan den utländska servern example.com returnera följande kod:
ParseResponse(( "paper" : "A4" , "count" : 5 ) )
Koden anropar nu den första domänens javascript-funktion.
Idén föreslogs ursprungligen på MacPython-bloggen 2005 och används för närvarande av många Web 2.0-applikationer som Dojo Toolkit Applications, Google Toolkit Applications och zanox Web Services. Ytterligare tillägg till detta protokoll har föreslagits för att inkludera ytterligare argument, såsom JSONPP:s stöd för S3DB-webbtjänster.
Eftersom JSONP använder skripttaggar är samtal i princip öppna för världen. Av denna anledning kan JSONP vara olämpligt för att lagra känslig data.
Genom att aktivera skripttaggar från avlägsna webbplatser kan de överföra allt innehåll på webbplatsen. Om fjärrplatsen har sårbarheter som tillåter Javascript-injektion, kan den ursprungliga webbplatsen också påverkas av dem.
JSONPP (parameteriserad JSON med stoppning) Parametriserad JSON med stoppning - utveckling av JSONP-idén
JSONPP inkluderar käll-URL, namnet på funktionen som kommer att bearbeta JSON-data, en rad för eval efter att ha tagit emot data och en rad för eval efter att ha avslutat bearbetningen av data:
JSON_call(SRC, JSONP, JSONPP, ONLOAD) ;
vänder till slut
Ans = JSONP(SRC) ( eval(JSONPP(ans) ); eval(ONLOAD) ; )
I allmänhet är antalet parametrar inte viktigt för själva JSONPP-idén. SRC, JSONP, JSONPP (och deras bearbetning på serversidan och sedan på klientsidan) räcker för att det ska vara JSONPP.
Låt oss titta på exemplet med att arbeta med S3DB-tjänsten.
Funktion s3db_jsonpp_call(src, next_eval) ( var call = "call_" + Math .random () .toString () .replace (/\./g, "" ); var headID = document.getElementsByTagName ("huvud" ) [ 0 ] ; var script = document.createElement ("script") ; script.id = call; script.type = "text/javascript" ; // med vadderad, parametriserad json src = src+ "&format=jsonpp&jsonp=s3db_jsonpp&jsonpp=" + next_eval+ "&onload=remove_element_by_id("" + script.id + "")" ; script.src = src; headID.appendChild (script) ; // hämta svar ) funktion s3db_jsonpp(ans, jsonpp) ( eval(jsonpp) ; return ans ; ) funktion remove_element_by_id(id) ( var e = document.getElementById (id) ; e.parentNode .removeChild (e) ; return false ; )
I exemplet skapar funktionen s3db_jsonpp_call() ett skriptelement i DOM i huvuddelen, vars src motsvarar JSONPP-anropet.
Efter att ha fått ett svar från servern kommer s3db_jsonpp() att anropas - det skickas i anropsparametrarna, som det ska vara enligt JSONP-regler.
Inside s3db_jsonpp() kommer eval(jsonpp) att avfyras och returnera värdet ans.
Att anropa eval(onload) leder till exekvering av remove_element_by_id() med id för det skapade skriptet i huvudet och i slutändan till radering, eftersom det ändå inte kommer att användas eftersom id:t i exemplet genererades slumpmässigt i början av funktionen s3db_jsonpp_call() . Detta anrop finns i serversvaret.
ObjektreferenserJSON-standarden stöder inte objektreferenser, men Dojo Toolkit visar hur standard JSON kan stödja sådana referenser med hjälp av ytterligare konventioner. I synnerhet ger modulen dojox.json.ref stöd för flera former av länkar, inklusive cirkulära, flera, mellandokument och lata länkar.
Se även Anmärkningar- Officiellt format hemsida på ryska
- json.js, json2.js är ett bibliotek utvecklat av Douglas Crockford för att arbeta med JSON-data i JavaScript. Utökar ett objekt med metoden toJSONString, som sedan finns i vilket objekt som helst, och konverterar det till en JSON-formatsträng.
- json-rpc.org (engelska)
| Sammansatt dokumentformat OOXML (SpreadsheetML, PresentationML, WordprocessingML) |
JSON eller JavaScript Object Notation är ett format som implementerar en ostrukturerad textrepresentation av strukturerad data baserat på principen om nyckel-värdepar och ordnade listor. Även om JSON har sitt ursprung i JavaScript, stöds det på de flesta språk, antingen inbyggt eller med hjälp av speciella bibliotek. Vanligtvis används Json för att utbyta information mellan webbklienter och webbservern.
Under de senaste 15 åren har JSON blivit en formell standard för datautbyte och används praktiskt taget överallt på Internet. Idag används den av nästan alla webbservrar. En annan anledning till denna popularitet var det faktum att många databaser stödde JSON. Moderna relationsdatabaser som PostgreSQL och MySQL stöder nu lagring och export av data i JSON. Databaser som MongoDB och Neo4j stöder också JSON, även om MongoDB använder en något modifierad version av JSON. I den här artikeln ska vi titta på vad JSON är, dess fördelar jämfört med XML, dess nackdelar och när det är bäst att använda det.
För att förstå varför JSON-formatet behövs och hur det fungerar behöver du övning. Låt oss först titta på detta exempel:
{
"firstName": "Jonathan",
"efternamn": "Freeman",
"loginCount": 4,
"isWriter": sant,
"worksWith": ["Spantree Technology Group", "InfoWorld"],
"husdjur": [
{
"namn": "Lilly",
"typ": "Tvättbjörn"
}
]
}
I detta ramverk har vi tydligt definierat några av en persons egenskaper. Först bestämde vi förnamn, efternamn, antal inloggningar i systemet, om denna person är en författare, en lista över företag som han arbetar med och en lista över husdjur. Denna eller en liknande struktur kan överföras från servern till en webbläsare eller mobilapplikation, som sedan kan göra vad den behöver med denna data, till exempel visa den eller spara den.
JSON är ett allmänt dataformat med ett minsta antal värdetyper - strängar, tal, booleaner (ett eller noll), listor, objekt och null. Även om JSON är en delmängd av JavaScript, har de flesta populära programmeringsspråken dessa typer av data, vilket gör JSON till en bra kandidat för att skicka data mellan program skrivna på olika språk.
Varför ska du använda JSON?För att förstå användbarheten och betydelsen av JSON måste vi förstå lite om historien om interaktivitet på Internet. I början av 2000-talet började webbsidornas interaktivitet förändras. På den tiden tjänade webbläsaren bara för att visa information, och webbservern gjorde allt arbete med att förbereda innehåll för visning. När en användare klickade på en knapp i webbläsaren skickades en förfrågan till servern, där en HTML-sida sammanställdes och skickades, redo att visas. Denna mekanism var långsam och ineffektiv. Detta krävde att webbläsaren återrenderade allt på sidan, även om en liten del av data ändrades.
Vid den tiden debiterades överföringar baserat på mängden data som överfördes, så utvecklarna insåg att det var mycket dyrt att ladda om en hel sida och övervägde ny teknik för att förbättra användargränssnittet. Sedan visade sig möjligheten att göra webbförfrågningar i bakgrunden, som lades till i Internet Explorer 5, vara ett ganska genomförbart tillvägagångssätt för att stegvis ladda data för visning. Istället för att ladda om sidan kommer att klicka på knappen helt enkelt skicka en webbförfrågan som körs i bakgrunden. Innehållet kommer att uppdateras så snart det har laddats. Det kan styras med JavaScript, ett universellt programmeringsspråk för webbläsare.
Till en början överfördes data i XML-format, men det var svårt att använda i JavaScript. JavaScript hade redan objekt som användes för att representera data i språket, så Douglas Crockford tog JS-objektsyntaxen och använde den som specifikationen för ett nytt datautbytesformat kallat JSON. Det här formatet var mycket lättare att läsa och analysera i en JavaScript-webbläsare. Snart började utvecklare använda JSON istället för XML.
Nuförtiden är snabbt JSON-datautbyte de facto-standarden för överföring av data mellan server och klient, mobilapplikationer och till och med interna systemtjänster.
JSON vs XMLSom jag sa ovan var och är huvudalternativet till JSON XML. Men XML blir mindre vanligt i nya system. Och det är väldigt lätt att förstå varför. Nedan är ett exempel på hur du skriver data du såg ovan i Json via XML:
Jonathan
Fri man
4
Sann
Spantree Technology Group
InfoWorld
Lilly
tvättbjörn
Förutom redundansen i koden, som i huvudsak tog dubbelt så mycket utrymme för att skriva data, introducerar XML också en viss tvetydighet när man analyserar datastrukturen. Att konvertera XML till ett JavaScript-objekt kan ta tiotals till hundratals rader kod och kräver finjustering för varje objekt som tolkas. Konvertering av JSON till ett JavaScript-objekt görs på en rad och kräver inga förkunskaper om objektet som tolkas.
JSON-begränsningarÄven om JSON är ett relativt komprimerat och flexibelt dataformat som är lätt att arbeta med i många programmeringsspråk, har det vissa nackdelar. Här är några begränsningar:
- Ingen struktur. Å ena sidan innebär det att du har fullständig flexibilitet att presentera data på vilket sätt du vill. Å andra sidan kan du enkelt lagra ostrukturerad data.
- Endast en typ av nummer. IEEE-754 flyttal och dubbel precisionsformat stöds. Det är ganska mycket, men du kan inte använda de olika numeriska typerna som andra språk har.
- Ingen datumtyp. Utvecklare måste använda strängrepresentationer av datum, vilket kan orsaka inkonsekvenser i formateringen. Eller använd som datum antalet millisekunder som har gått sedan början av Unix-epoken (1 januari 1970).
- Inga kommentarer - Du kommer inte att kunna kommentera fält som kräver dem direkt i koden.
- Utförlig – Även om JSON är mindre utförlig än XML, är det inte det mest koncisa datautbytesformatet. För avancerade eller specialiserade tjänster vill du använda mer effektiva format.
Om du utvecklar programvara som interagerar med en webbläsare eller inbyggd mobilapplikation är det bättre att använda JSON. Användningen av XML är utfasad. För kommunikation mellan servrar kanske JSON inte är särskilt effektivt och det är bättre att använda en serialiseringsram som liknar Apache Avro eller Apache Thrift. Även här är JSON inget dåligt val och kan ge dig allt du behöver. Men det finns inget exakt svar vad man ska välja.
Om du använder MySQL-databaser kommer ditt program att vara mycket beroende av vad som görs i databasen. I relationsdatabaser som stöder JSON anses det vara god praxis att använda så lite av det som möjligt. Relationsdatabaser designades för data med ett specifikt schema. Även om de flesta av dem nu stöder JSON-dataformatet kommer prestandan att arbeta med det att vara betydligt lägre.
SlutsatserJSON är ett dataformat som främst syftar till att skicka data mellan webbservrar och webbläsare eller mobilapplikationer. Formatet har en enkel design och flexibilitet, det är lätt att läsa och förstå, och det är lätt att arbeta med sådan data i de flesta programmeringsspråk. Avsaknaden av ett strikt schema tillåter flexibilitet i formatet, men denna flexibilitet kan ibland göra data svår att läsa och förstå.
Du kan ha svårt att arbeta med JSON på starkt skrivna språk som Scala eller Elm, men formatets utbredda användning innebär att det finns verktyg och bibliotek för att hjälpa till med även komplexa problem. Nu vet du vad json är och hur man använder det.
Vad är JSON och vad kan det göra? I den här artikeln kommer du att lära dig hur du använder JSON för att enkelt arbeta med data. Vi kommer också att titta på hur man arbetar med JSON med PHP och JavaScript.
Om du har utvecklat webbplatser eller webbapplikationer i allmänhet, är chansen stor att du har hört talas om JSON, åtminstone i förbigående. Men exakt vad betyder JSON? Vad kan detta dataformat göra och hur kan det användas?
I den här artikeln kommer vi att lära oss grunderna för att arbeta med json-formatet. Vi kommer att följa följande ämnen:
- Vad är JSON-format?
- Hur skapar man JSON-strängar?
- Enkelt exempel på JSON-data
- Jämför JSON med XML
Låt oss börja!
Vad är JSON-format?JSON är ett enkelt, textbaserat sätt att lagra och överföra strukturerad data. Med en enkel syntax kan du enkelt lagra både enkla siffror och strängar, såväl som arrayer och objekt, utan att använda något annat än text. Du kan också länka objekt och arrayer, vilket gör att du kan skapa komplexa datastrukturer.
När JSON-strängen väl har skapats kan den enkelt skickas till vilken applikation eller dator som helst eftersom det bara är text.
JSON har många fördelar:
- Den är kompakt
- Den är läsbar för människor och lätt att läsa av datorer
- Det kan enkelt konverteras till mjukvaruformat: numeriska värden, strängar, booleskt format, nollvärde, matriser och associativa matriser.
- Nästan alla programmeringsspråk har funktioner som låter dig läsa och skapa json-dataformat.
Bokstavligen står förkortningen JSON för JavaScript Object Notation. Som beskrivits tidigare är detta format baserat på att skapa objekt, något som liknar associativa arrayer i andra programmeringsspråk.
Vilka syften används JSON för?Mest av allt används json för att utbyta data mellan javascript och serversidan (php). Med andra ord för ajax-teknik. Detta är mycket praktiskt när du skickar flera variabler eller hela datamatriser.
Så här ser det ut i ett exempel:
Så här förstoras bilden utan att sidan laddas om i webbläsaren. Detta är mycket praktiskt när vi behöver ta emot delar av data eller överföra en liten mängd information till servern.
Allas favorit jQuery har funktionerna getJSON() och parseJSON(), som hjälper dig att arbeta med formatet genom ajax-förfrågningar.
Hur skapar man JSON-strängar?
Nedan är de grundläggande reglerna för att skapa JSON-strängar:
- JSON-strängen innehåller både en array av värden och ett objekt (en associativ array med namn/värdepar).
- Arrayen måste vara inslagen inom hakparenteser, [ och ], och kan innehålla en lista med värden som är separerade av koma.
- Objekt lindas med lockiga armar, ( och ), och innehåller även komaavgränsade namn/värdepar.
- Namn/värdepar består av fältnamnet (i dubbla citattecken) följt av ett kolon (:) följt av fältets värde.
- Värdena i en array eller ett objekt kan vara:
- Numeriskt (heltal eller prickad bråkdel)
- Strängar (inslagna i dubbla citattecken)
- Boolean (sant eller falskt)
- Andra arrayer (inslagna inom hakparenteser [ och ])
- Andra föremål (lindade i lockiga armar ( och ))
- Nullvärde
Viktig! Om du använder dubbla citattecken i värden, undvik dem med ett snedstreck: \". Du kan också använda hex-kodade tecken, precis som du gör i andra programmeringsspråk.
Enkelt exempel på JSON-dataFöljande exempel visar hur du kan spara data i "vagnen" i en onlinebutik med JSON-formatet:
("orderID": 12345, "shopperName": "John Smith", "shopperEmail": " [e-postskyddad]", "contents": [ ( "productID": 34, "productName": "SuperWidget", "quantity": 1 ), ( "productID": 56, "productName": "WonderWidget", "quantity": 3 ) ], "orderCompleted": true )
Låt oss dela upp denna data bit för bit:
Slutligen, eftersom JSON är identisk med objekt i JavaScript, kan du enkelt ta det här exemplet och skapa ett JavaScript-objekt från det:
var cart = ("orderID": 12345, "shopperName": "John Smith", "shopperEmail": " [e-postskyddad]", "contents": [ ( "productID": 34, "productName": "SuperWidget", "quantity": 1 ), ( "productID": 56, "productName": "WonderWidget", "quantity": 3 ) ], "orderCompleted": true );
Jämför JSON med XMLI de flesta fall kommer du att tänka på JSON som ett alternativ till XML - åtminstone inom webbapplikationer. Ajax-konceptet använder ursprungligen XML för att utbyta data mellan servern och webbläsaren, men på senare år har JSON blivit mer populärt för att överföra ajax-data.
Även om XML är en beprövad teknik som används av många applikationer, är fördelarna med JSON-formatet att det är mer kompakt och lättare att skriva och läsa.
Här är JSON-exemplet ovan, endast omskrivet i XML-format:
orderID 12345 shopperName John Smith shopperE-post [e-postskyddad] innehåll produkt-ID 34 produktnamn SuperWidget kvantitet 1 produkt-ID 56 produktnamn WonderWidget kvantitet 3 orderCompleted true
Som du kan se är den flera gånger längre än JSON. Faktum är att det här exemplet är 1128 tecken långt, medan JSON-versionen bara är 323 tecken. XML-versionen är också svårare att läsa.
Naturligtvis kan man inte bedöma med bara ett exempel, men även små mängder information tar mindre plats i JSON-formatet än i XML.
Hur man arbetar med JSON via PHP och JS?Nu kommer vi till den mest intressanta delen - den praktiska sidan av JSON-formatet. Låt oss först hylla JavaScript, sedan ska vi se hur du kan manipulera JSON genom PHP.
Skapa och läsa JSON-format med JavaScript
Även om JSON-formatet är enkelt är det svårt att skriva manuellt när man utvecklar webbapplikationer. Dessutom måste du ofta konvertera JSON-strängar till variabler och sedan använda dem i din kod.
Lyckligtvis tillhandahåller många programmeringsspråk verktyg för att arbeta med JSON-strängar. Huvudidén varav:
För att skapa JSON-strängar börjar du med variabler som innehåller några värden och skickar dem sedan genom en funktion som förvandlar data till en JSON-sträng.
När du läser JSON-strängar börjar du med en JSON-sträng som innehåller vissa data, skickar strängen genom en funktion som skapar variabler som innehåller data.
Låt oss se hur detta görs i JavaScript.
Skapa en JSON-sträng från en JavaScript-variabelJavaScript har en inbyggd metod, JSON.stringify(), som tar en javascript-variabel och returnerar en json-sträng som representerar innehållet i variabeln. Låt oss till exempel använda ett tidigare skapat objekt och konvertera det till en JSON-sträng.
var cart = ("orderID": 12345, "shopperName": "John Smith", "shopperEmail": " [e-postskyddad]", "contents": [ ( "productID": 34, "productName": "SuperWidget", "quantity": 1 ), ( "productID": 56, "productName": "WonderWidget", "quantity": 3 ) ], "orderCompleted": true ); alert (JSON.stringify(cart));
Detta är vad som kommer att visas på skärmen:
("orderID":12345,"shopperName":"John Smith","shopperEmail":" [e-postskyddad]", "contents":[("productID":34,"productName":"SuperWidget","quantity":1), ("productID":56,"productName":"WonderWidget","quantity":3) ], "orderCompleted":true)
Observera att JSON.stringify() matar ut JSON-strängar utan mellanslag. Det är svårt att läsa, men det är mer kompakt, vilket är viktigt när man skickar data.
Skapa en JavaScript-variabel från en JSON-strängDet finns flera sätt att analysera JSON-strängar, det mest acceptabla och säkra är att använda metoden JSON.parse(). Det tar en JSON-sträng och returnerar ett JavaScript-objekt eller en array som innehåller JSON-data. Här är ett exempel:
var jsonString = " \ ( \ "orderID": 12345, \ "shopperName": "John Smith", \ "shopperEmail": " [e-postskyddad]", \ "contents": [ \ ( \ "productID": 34, \ "productName": "SuperWidget", \ "quantity": 1 \), \ ( \ "productID": 56, \ "productName": " WonderWidget", \"quantity": 3\ ) \ ], \"orderCompleted": true \ ) \"; var cart = JSON.parse(jsonString); alert(cart.shopperEmail); alert(cart.contents.productName);
Här skapade vi en variabel, jsonString, som innehåller JSON-strängen från de tidigare exemplen. Sedan skickade vi den här strängen genom JSON.parse() för att skapa ett objekt som innehåller JSON-data, som lagrades i variabeln varukorg. Slutligen kontrollerar vi datatillgänglighet och visar lite information med hjälp av varningsmodalfönstret.
Följande information kommer att visas:
I en riktig webbapplikation bör din JavaScript-kod få en JSON-sträng som svar från servern (efter att ha skickat en AJAX-förfrågan), sedan analysera strängen och visa kundvagnsinnehållet för användaren.
Skapa och läsa JSON-format med PHPPHP, liksom JavaScript, har funktioner som låter dig konvertera variabler till JSON-format och vice versa. Låt oss titta på dem.
Skapa en JSON-sträng från en PHP-variabelJson_encode() tar en PHP-variabel och returnerar en JSON-sträng som representerar variabelns data. Här är vårt exempel på en "vagn" skriven i PHP:
Den här koden ger exakt samma resultat som JavaScript-exemplet - en giltig JSON-sträng som representerar innehållet i variablerna:
("orderID":12345,"shopperName":"John Smith","shopperEmail":" [e-postskyddad]","contents":[("productID":34,"productName":"SuperWidget","quantity":1),("productID":56,"productName":"WonderWidget","quantity":3) ],"orderCompleted":true)
I verkligheten bör ditt PHP-skript skicka en JSON-sträng som ett svar på en AJAX-förfrågan, där JavaScript kommer att använda JSON.parse() för att omvandla strängen till variabler.
I funktionen json_encode() kan du ange ytterligare parametrar som låter dig konvertera vissa tecken till hex.
Skapa en PHP-variabel från en JSON-strängI likhet med ovan finns det en json_decode()-funktion som låter dig avkoda JSON-strängar och sätta innehållet i variabler.
Precis som med JavaScript kommer den här koden att mata ut följande:
[e-postskyddad] WonderWidget
Som standard returnerar json_decode() JSON-objekt som PHP-objekt. I likhet med vanlig syntax använder vi -> för att komma åt egenskaperna för ett objekt.
Om du senare vill använda data som en associativ array, skicka helt enkelt den andra parametern true till funktionen json_decode(). Här är ett exempel:
$cart = json_decode($jsonString, true); echo $cart["shopperEmail"] . "
"; echo $cart["contents"]["productName"] . "
";
Detta ger samma resultat:
[e-postskyddad] WonderWidget
Du kan också skicka ytterligare argument till funktionen json_decode() för att bestämma behandlingen av stora tal och rekursion.
Avslutningsvis om JSON-formatetOm du ska skapa en webbapplikation med Ajax-teknik kommer du säkerligen att använda JSON-formatet för att utbyta data mellan servern och webbläsaren.
Du har säkert någonsin hört talas om JSON. Vad är det? Vad kan det göra och hur man använder det?
I den här handledningen kommer vi att täcka grunderna i JSON och täcka följande punkter:
- Vad är JSON?
- Vad används JSON till?
- Hur skapar man en JSON-sträng?
- Ett enkelt exempel på en JSON-sträng.
- Låt oss jämföra JSON och XML.
- Hur arbetar man med JSON i JavaScript och PHP?
JSON är ett enkelt, textbaserat sätt att lagra och överföra strukturerad data. Med en enkel syntax kan du enkelt lagra allt från ett enstaka nummer till strängar, matriser och objekt i vanlig text. Du kan också länka samman arrayer och objekt för att skapa komplexa datastrukturer.
När JSON-strängen väl har skapats är det lätt att skicka den till ett annat program eller till en annan plats i nätverket eftersom det är vanlig text.
JSON har följande fördelar:
- Den är kompakt.
- Dess meningar är lätta att läsa och komponera av både människor och datorer.
- Det kan enkelt konverteras till en datastruktur för de flesta programmeringsspråk (siffror, strängar, booleaner, arrayer, etc.)
- Många programmeringsspråk har funktioner och bibliotek för att läsa och skapa JSON-strukturer.
Namnet JSON står för JavaScript Object Notation. Som namnet antyder är det baserat på ett sätt att definiera objekt (ungefär som att skapa associativa arrayer på andra språk) och arrayer.
Vad används JSON till?Den vanligaste användningen av JSON är att skicka data från servern till webbläsaren. JSON-data levereras vanligtvis med AJAX, vilket gör att webbläsaren och servern kan kommunicera utan att behöva ladda om sidan.
Du kan också använda JSON för att skicka data från webbläsaren till servern genom att skicka en JSON-sträng som en parameter för GET- eller POST-förfrågningar. Men denna metod är mindre vanlig, eftersom dataöverföring via AJAX-förfrågningar kan förenklas. Till exempel kan produkt-ID:t inkluderas i URL:en som en del av en GET-förfrågan.
jQuery-biblioteket har flera metoder, såsom getJSON() och parseJSON(), som gör det enkelt att hämta data med JSON genom AJAX-förfrågningar.
Hur skapar man en JSON-sträng?Det finns några grundläggande regler för att skapa en JSON-sträng:
- JSON-strängen innehåller antingen en array av värden eller ett objekt (en associativ array av namn/värdepar).
- Array omges av hakparenteser ([ och ]) och innehåller en kommaseparerad lista med värden.
- Ett objekt omges av krulliga klammerparenteser (( och )) och innehåller en kommaseparerad lista med namn/värdepar.
- namn/värdepar består av fältnamnet inom dubbla citattecken, följt av ett kolon (:) och fältvärdet.
- Menande i en array eller ett objekt kan det finnas:
- Tal (heltal eller flyttal)
- Sträng (inom dubbla citattecken)
- Booleskt värde (sant eller falskt)
- En annan array (omsluten av hakparenteser)
- Ett annat föremål (omslutet av lockiga hängslen)
- nullvärde
För att inkludera dubbla citattecken i en sträng måste du använda ett omvänt snedstreck: \" . Som med många programmeringsspråk kan du sätta kontrolltecken och hexadecimalkoder i en sträng genom att föregå dem med ett snedstreck. Se JSON-webbplatsen för detaljer.
Enkelt JSON-strängexempelNedan är ett exempel på beställning i JSON-format:
( "orderID": 12345, "shopperName": "Vanya Ivanov", "shopperEmail": " [e-postskyddad]", "contents": [ ( "productID": 34, "productName": "Superprodukt", "quantity": 1 ), ( "productID": 56, "productName": "Miracle product", "quantity": 3 ) ], "orderCompleted": true )
Låt oss titta på raden i detalj:
- Vi skapar ett objekt med hjälp av hängslen (( och )).
- Objektet har flera namn/värdepar: "orderID": 12345 En egenskap med namnet "orderId" och ett heltalsvärde 12345 "shopperName": "Vanya Ivanov" en egenskap med namnet "shopperName" och strängvärdet "Vanya Ivanov " "shopperEmail": " [e-postskyddad]" En egenskap med namnet "shopperEmail" med ett strängvärde " [e-postskyddad]" "contents": [ ... ] En egenskap med namnet "contents" vars värde är en array "orderCompleted": true En egenskap med namnet "orderCompleted" och det booleska värdet true
- Det finns 2 objekt i arrayen "innehåll" som representerar enskilda objekt i ordningen. Varje objekt innehåller 3 egenskaper: produkt-ID , produktnamn och kvantitet .
Förresten, eftersom JSON bygger på att deklarera JavaScript-objekt, kan du snabbt och enkelt göra ovanstående JSON-sträng till ett JavaScript-objekt:
var cart = ( "orderID": 12345, "shopperName": "Vanya Ivanov", "shopperEmail": " [e-postskyddad]", "contents": [ ( "productID": 34, "productName": "Superprodukt", "quantity": 1 ), ( "productID": 56, "productName": "Miracle product", "quantity": 3 ) ], "orderCompleted": true );
Jämförelse av JSON och XMLPå många sätt kan du tänka på JSON som ett alternativ till XML, åtminstone i webbapplikationsutrymmet. Konceptet med AJAX baserades ursprungligen på användningen av XML för att överföra data mellan servern och webbläsaren. Men på senare år har JSON blivit allt mer populärt för att transportera AJAX-data.
Medan XML är en beprövad teknik som används i ett stort antal applikationer, har JSON fördelen av att vara ett mer kompakt och lättare att känna igen dataformat.
Så här skulle exemplet ovan i XML se ut:
orderID 12345 shopperName Vanya Ivanov shopperE-post [e-postskyddad] innehåll produkt-ID 34 produktnamn Superprodukt kvantitet 1 produkt-ID 56 produktnamn Mirakel produkt kvantitet 3 orderCompleted true
XML-versionen är betydligt större. I verkligheten är den 1128 tecken lång, medan JSON-versionen bara är 323 tecken lång. XML-versionen är också ganska svår att förstå.
Naturligtvis är detta ett radikalt exempel. Och det är möjligt att skapa en mer kompakt XML-post. Men även den kommer att vara betydligt längre än JSON-motsvarigheten.
Arbeta med en JSON-sträng i JavaScriptJSON har ett enkelt format, men att skapa en JSON-sträng manuellt är ganska tråkigt. Dessutom behöver du ofta ta en JSON-sträng, konvertera dess innehåll till en variabel som kan användas i kod.
De flesta programmeringsspråk har verktyg för att enkelt konvertera variabler till JSON-strängar och vice versa.
Skapa en JSON-sträng från en variabelJavaScript har en inbyggd JSON.stringify()-metod som tar en variabel och returnerar en JSON-sträng som representerar dess innehåll. Låt oss till exempel skapa ett JavaScript-objekt som innehåller orderinformationen från vårt exempel och sedan skapa en JSON-sträng från det:
var cart = ( "orderID": 12345, "shopperName": "Vanya Ivanov", "shopperEmail": " [e-postskyddad]", "contents": [ ( "productID": 34, "productName": "Superprodukt", "quantity": 1 ), ( "productID": 56, "productName": "Miracle product", "quantity": 3 ) ], "orderCompleted": true ); alert (JSON.stringify(cart));
Denna kod kommer att producera:
Observera att metoden JSON.stringify() returnerar en JSON-sträng utan mellanslag. Den är svårare att läsa, men den är mer kompakt för överföring över nätverket.
Det finns flera sätt att tolka en JSON-sträng i JavaScript, men det säkraste och mest pålitliga är att använda den inbyggda metoden JSON.parse(). Den tar emot en JSON-sträng och returnerar ett JavaScript-objekt eller en array som innehåller data. Till exempel:
var jsonString = " \ ( \ "orderID": 12345, \ "shopperName": "Vanya Ivanov", \ "shopperEmail": " [e-postskyddad]", \ "contents": [ \ ( \ "productID": 34, \ "productName": "Superprodukt", \ "quantity": 1 \), \ ( \ "productID": 56, \ "productName": "Mirakelvaror", \"kvantitet": 3\ ) \ ], \"orderCompleted": true \ ) \"; var cart = JSON.parse(jsonString); alert(cart.shopperEmail); alert(cart.contents.productName);
Vi skapade en jsonString-variabel som innehåller JSON-strängen i vår exempelordning. Vi skickar sedan den här strängen till metoden JSON.parse(), som skapar ett objekt som innehåller JSON-data och lagrar det i variabeln varukorg. Allt som återstår är att kontrollera genom att visa egenskaperna för shopperEmail-objektet och produktnamnet för innehållsmatrisen.
Som ett resultat kommer vi att få följande utdata:
I en riktig applikation skulle din JavaScript-kod ta emot ordern som en JSON-sträng i ett AJAX-svar från serverskriptet, skicka strängen till metoden JSON.parse() och sedan använda data för att visa den på användarens sida.
JSON.stringify() och JSON.parse() har andra funktioner, som att använda återuppringningsfunktioner för att anpassa vissa data omvandla. Sådana alternativ är mycket användbara för att konvertera olika data till korrekta JavaScript-objekt.
Arbeta med en JSON-sträng i PHPPHP har, liksom JavaScript, inbyggda funktioner för att arbeta med JSON-strängar.
Skapa en JSON-sträng från en PHP-variabelFunktionen json_encode() tar en PHP-variabel och returnerar en JSON-sträng som representerar innehållet i variabeln. Här är vårt beställningsexempel, skrivet i PHP:
Den här koden returnerar exakt samma JSON-sträng som i JavaScript-exemplet:
("orderID":12345,"shopperName":"Vanya Ivanov","shopperEmail":" [e-postskyddad]","contents":[("productID":34,"productName":"Superprodukt","quantity":1),("productID":56,"productName":"Miracle product","quantity": 3)],"orderCompleted":true)
I en riktig applikation kommer ditt PHP-skript att skicka denna JSON-sträng som en del av ett AJAX-svar till webbläsaren, där JavaScript-koden, med metoden JSON.parse() tolkar den tillbaka till en variabel för visning på användarens sida .
Du kan skicka olika flaggor som det andra argumentet till funktionen json_encode(). Med deras hjälp kan du ändra principerna för att koda innehållet i variabler till en JSON-sträng.
Skapa en variabel från en JSON-strängFör att konvertera en JSON-sträng till en PHP-variabel, använd metoden json_decode(). Låt oss ersätta vårt exempel för JavaScript med metoden JSON.parse() med PHP-kod:
Precis som med JavaScript kommer den här koden att producera:
[e-postskyddad] Mirakel produkt
Som standard returnerar funktionen json_decode() JSON-objekt som PHP-objekt. Det finns generiska PHP-objekt av klassen stdClass. Det är därför vi använder -> för att komma åt egenskaperna för objektet i exemplet ovan.
Om du behöver ett JSON-objekt som en associerad PHP-array måste du skicka true som det andra argumentet till funktionen json_decode(). Till exempel:
$cart = json_decode($jsonString, true); echo $cart["shopperEmail"] . "
"; echo $cart["contents"]["productName"] . "
";
Denna kod kommer att producera samma utdata:
[e-postskyddad] Mirakel produkt
Du kan också skicka andra argument till funktionen json_decode() för att specificera rekursionsdjupet och hur man hanterar stora heltal.
SlutsatsÄven om JSON är lätt att förstå och använda är det ett mycket användbart och flexibelt verktyg för att överföra data mellan applikationer och datorer, speciellt när man använder AJAX. Om du planerar att utveckla en AJAX-applikation råder det ingen tvekan om att JSON kommer att bli ett viktigt verktyg i din verkstad.
