Extindeți TMS WEB Core cu bibliotecile JS cu Andrew: Epic JSON Primer (partea 1)
Pentru restul acestui document, vom lucra de trei ori – arătând versiunea JavaScript (JS), versiunea Wrapper TMS WEB Core (WC) și versiunea Delphi (PAS) a fiecărui scenariu, prezentată ca un bloc de cod potrivit pentru includerea (și testat!) într-un proiect TMS WEB Core, care le acceptă pe toate cele trei fără probleme. Dacă lucrați la o parte a unui proiect care a folosit doar codul Delphi VCL, ați putea folosi doar codul PAS la fel de bine acolo. Sau dacă lucrați la o parte a unui proiect care folosea JavaScript pur, atunci codul JS din blocurile asm… end ar funcționa la fel de bine în acel mediu. Vom discuta chiar și puțin despre trecerea între aceste trei medii.
Pentru început, va trebui să știm cum să definim variabile pentru a face referire la obiecte JSON. De asemenea, va trebui să știm cum să le furnizăm JSON (uneori denumit serializare) și cum să vedem ce conțin (de serializare). De dragul simplității, ne vom arăta munca folosind console.log () care funcționează atât în Delphi, cât și în JavaScript în mediul nostru TMS WEB Core. Pur și simplu înlocuiți cu ShowMessage sau cu o altă ieșire de depanare echivalentă dacă lucrați în orice alt mediu.
Dar de ce trebuie să definim variabile? Ei bine, una dintre diferențele cheie dintre JavaScript și Delphi este modul în care sunt gestionate tipurile de date. Delphi este un limbaj puternic tipizat, ceea ce înseamnă că, la aproape fiecare pas, tipul de date atribuit unei variabile este cunoscut, de obicei înainte de a fi utilizată. Și aceste tipuri de date tind să fie destul de specifice în natură. Un obiect JSON nu este neapărat interschimbabil cu o matrice JSON, de exemplu. JavaScript, pe de altă parte, este un limbaj slab tipizat (unii ar putea spune chiar netipizat). Tipurile de date sunt un fel de gândire ulterioară și puteți scrie tot felul de coduri fără a fi nevoie să vă gândiți la ce fel de date circulă prin ele.
Există compromisuri semnificative pentru ambele abordări. JSON este, de asemenea, foarte strâns legat de limbajul JavaScript în sine, iar unele aspecte ale limbajului JavaScript care au evoluat de-a lungul anilor au condus la îmbunătățiri semnificative în utilizarea JSON în acel mediu. Rezultatul general este că codul JS pe care îl vom arăta tinde să fie foarte scurt, uneori puțin criptic, dar adesea foarte eficient. Echivalentele Delphi trebuie adesea să lucreze mai mult pentru a realiza același lucru, dar nu întotdeauna mai puțin eficient, așa cum vom vedea.
Folosirea codului JS în TMS WEB Core implică doar împachetarea lui într-un bloc asm…. Nu folosim alte biblioteci sau cod de suport pentru a ne face munca aici. Variațiile WC în mod similar vor funcționa fără nimic special în ceea ce privește mediul TMS WEB Core. Clasele pe care le vom folosi sunt prezente implicit, denumite colectiv clase TJS* . Pentru Delphi, totuși, avem nevoie de un pas suplimentar mic de a adăuga WEBlib.JSON la clauza de utilizare a proiectului nostru (sau Formular etc.). Aceasta aduce clasele TJSON* pe care le vom folosi.
Iată, atunci, exemplul nostru de procedură WebButtonClick pe care o vom folosi în aproape fiecare exemplu care urmează. Va începe cu orice variabile JS, WC sau PAS de care avem nevoie și apoi va conține blocuri de cod aferente fiecăreia. Sperăm că într-un mod ușor de urmărit. Urmat, în cele mai multe cazuri, ceea ce ar trebui să fie de așteptat ca rezultat prin console.log (). Vom renunța la unele dintre comentarii și spații albe pe măsură ce mergem pentru a menține lucrurile puțin mai ordonate. Dar intenția este ca fiecare exemplu să stea pe cont propriu, astfel încât să nu fie nevoie să căutați prin exemplele anterioare pentru a găsi fragmente de cod lipsă. Deci da, puțin repetitiv îmi dau seama, dar cu un scop.
Nu se întâmplă nimic prea remarcabil aici. Doar pentru distracție, țineți cont de următoarele.
De asemenea, o notă importantă despre alocarea memoriei. Deoarece principalul obiectiv aici este proiectele TMS WEB Core, nu mă deranjez prea mult să eliberez obiectele care sunt create. Cu siguranță, există anumite domenii în care acest lucru este destul de important, mai ales atunci când lucrați cu aplicații desktop (VCL și FireMonkey, de exemplu). În JavaScript (în care sunt compilate aplicațiile TMS WEB Core, în cele din urmă), aceasta este puțin o problemă, deoarece există un sistem de colectare a gunoiului care se ocupă de acest gen de lucruri. Așa că am omis în mod deliberat orice fel de eliberare de obiecte. Dacă utilizați oricare dintre codurile PAS într-o aplicație desktop, asigurați-vă că vă eliberați obiectele când ați terminat cu ele!
Dacă aveți deja date JSON, fie într-un șir definit local, fie dintr-o altă sursă, acestea pot fi transmise direct într-un obiect JSON, chiar dacă nu a fost inițializat încă. Aici folosim un exemplu care este în mod deliberat mai mare decât lungimea unui șir standard Delphi. WideStrings funcționează bine deoarece pot stoca o cantitate imensă de informații (potențial gigaocteți în unele cazuri). Rețineți că, în acest caz, eșantionul de date este un Array. Vom avea o mulțime de exemple răsturnând înainte și înapoi între Arrays și Objects ca construcție JSON de nivel superior.
procedura TForm1.WebButton1Click(Expeditor: TObject);
var
WC_Array: TJSArray;
PAS_Array: TJSONArray;
BigSampleData: WideString;
ÎNCEPE
// Credit: https://gist.github.com/ggordonutech/c04f47fcdad76f8e5e77ee38a9614773
BigSampleData := '['+
'{"id":1,"name":"Banana","description":"O banană este un fruct comestibil – din punct de vedere botanic o boabă – produs de mai multe tipuri de plante cu flori erbacee mari din genul Musa. În unele țări, bananele folosite pentru gătit pot fi numite pătlagini, diferențiându-le de banana de desert","photoUrl":"http://www.pngall.com/wp-content/uploads/2016/04/Banana-PNG.png"},' +
'{"id":2,"name":"Apple","description":"Un măr este un fruct dulce, comestibil, produs de un măr. Meri sunt cultivați în întreaga lume și sunt cea mai răspândită specie din gen. Malus.","photoUrl":"https://images.freshop.com/00852201002228/ad2f58915e3267700906f1025ef8917f_medium.png"},'+
'{"id":3,"name":"Piersic","description":"Piersicul este un copac foios originar din regiunea de nord-vest a Chinei, între bazinul Tarim și versanții nordici ai Munților Kunlun, unde a fost prima dată domesticită și cultivată. Are un fruct suculent comestibil numit piersică sau nectarină.","photoUrl":"http://icons.iconarchive.com/icons/artbees/paradise-fruits/256/Peach-icon.png „},’+
'{"id":4,"name":"Capsuni","description":"Fructul este larg apreciat pentru aroma caracteristica, culoarea rosu aprins, textura suculenta si dulceata.","photoUrl":"https: //static.wixstatic.com/media/2cd43b_7415c9b79d664508b6f62a6953403b75~mv2.png/v1/fill/w_256,h_256,fp_0.50_0.50/2cd463403b75~mv2.png/v1/fill/w_256,h_256,fp_0.50_0.50/2cd463403b75~463403b74463403b74463403b75463403b7463403b75
'{"id":5,"name":"Tomato","description":"Roșia este boaba comestibilă, adesea roșie, a plantei Solanum lycopersicum, cunoscută în mod obișnuit ca plantă de tomate. Specia își are originea în vestul de sud. America și America Centrală.","photoUrl":"https://www.kampexport.com/sites/kampexport.com/files/images/legume/image/tomates_256_1.jpg"},'+
'{"id":6,"name":"Cherry","description":"O cireș este fructul multor plante din genul Prunus și este o drupă cărnoasă. Cireșele comerciale sunt obținute din soiuri din mai multe specii, precum dulcele Prunus avium și acru Prunus cerasus.","photoUrl":"https://cdn.shopify.com/s/files/1/0610/2881/products/cherries.jpg?v=1446676415"} „+
']';
asm
var JS_Array = JSON.parse(BigSampleData);
console.log('JS Array = '+JSON.stringify(JS_Array));
Sfârşit;
WC_Array := TJSArray(TJSJSON.parseObject(BigSampleData));
console.log('WC Array = '+TJSJSON.stringify(WC_Array));
PAS_Array := TJSONObject.ParseJSONValue(BigSampleData) ca TJSONArray;
console.log('PAS Array = '+PAS_Array.ToString);
Sfârşit;
Ieșirea console.log a fost omisă pentru concizie.
Pentru o muncă JSON mai simplă, aceasta vă arată, de asemenea, cum este posibil să creați obiecte JSON complexe prin construirea unui șir care este formatat corespunzător. Elemente suplimentare ar putea fi adăugate într-o buclă, de exemplu, fără a fi nevoie să utilizați oricare dintre celelalte clase JSON. Rețineți că trebuie să aveți JSON valid când ați terminat de construit șirul dvs.
04: Accesarea valorilor obiectelor JSON.
JavaScript nu îi pasă prea mult de tipuri, așa că sintaxa sa poate fi considerabil mai simplă. În Delphi, trebuie să fim clari când vine vorba de tipuri. Aici știm că este un șir, așa că îl aruncăm ca atare, dar mai târziu vom avea exemple în care nu știm neapărat ce este în momentul proiectării, așa că va trebui să ne adaptăm abordarea în consecință.
procedura TForm1.WebButton1Click(Expeditor: TObject);
var
WC_Object: TJSObject;
PAS_Object: TJSONObject;
SampleObjectData: WideString;
ÎNCEPE
SampleObjectData := '{"apple":"fructe","banana":"fructe","orange":"fructe","morcov":"legume","cartofi":"legume"}';
asm var JS_Object = JSON.parse(SampleObjectData); Sfârşit;
WC_Object := TJSJSON.parseObject(SampleObjectData);
PAS_Object := TJSONObject.ParseJSONValue(SampleObjectData) ca TJSONObject;
asm console.log('JS Morcov: '+JS_Object['morcov']); Sfârşit;
console.log('WC Morcov: '+șir(WC_Object['morcov']));
console.log('PAS Morcov: '+(PAS_Object.getValue('morcov') ca TJSONString).Value);
Sfârşit;
Ieșire console.log:
JS Morcov: legume
WC Morcov: legume
PAS Morcov: legume
05: Accesarea valorilor JSON Array.
Utilizarea JSON Arrays nu este mult diferită de alte matrice Delphi, doar că tipul nu trebuie setat atunci când matricea este definită și nici nu este fix pentru toate elementele Array. În comparație cu accesarea obiectelor JSON, codul JavaScript nu se schimbă prea mult, dar codul Delphi trebuie să treacă prin mai multe cercuri.
procedura TForm1.WebButton1Click(Expeditor: TObject);
var
WC_Array: TJSArray;
PAS_Array: TJSONArray;
const
SampleArrayData = '[{"name":"apple","type":"fruct"},{"name":"banana","type":"fruit"},{"name":"orange"," tip":"fructe"},{"name":"morcov","type":"legume"},{"name":"cartof","tip":"legume"}]';
ÎNCEPE
asm var JS_Array = JSON.parse(SampleArrayData); Sfârşit;
WC_Array := TJSArray(TJSJSON.parseObject(SampleArrayData));
PAS_Array := TJSONObject.ParseJSONValue(SampleArrayData) ca TJSONArray;
asm console.log('JS Array[3] este: '+JS_Array[3].nume+' / '+JS_Array[3].tip); Sfârşit;
console.log('WC Array[3] este: '+șir(TJSObject(WC_Array[3])['nume'])+' / '+șir(TJSObject(WC_Array[3])['tip'])) ;
console.log('PAS Array[3] este: '+((PAS_Array[3] ca TJSONObject).getValue('nume') ca TJSONString).Value+' / '+((PAS_Array[3] ca TJSONObject).getValue ('tip') ca TJSONString).Valoare);
Sfârşit;
Ieșire console.log:
JS Array[3] este: morcov / legume
WC Array[3] este: morcov / legume
PAS Array[3] este: morcov / legume
06: Numărarea elementelor obiect JSON.
Uneori ați putea dori să știți câte obiecte sunt în JSON. Acesta este doar primul nivel de numărare și nu traversează orice obiecte sau matrice imbricate pe care le-ați putea avea. O să ne uităm la asta puțin mai târziu. Pentru cei aventuroși, JavaScript are alte câteva trucuri în mânecă atunci când vine vorba de definirea tastelor ca simboluri în JavaScript. Dar vom privi dincolo de acestea, deoarece s-ar putea să nu fie atât de aplicabile în general în afara JavaScript. Verificați Object.getOwnPropertySymbols dacă credeți că acest tip de lucru s-ar putea aplica în cazul dvs.
procedura TForm1.WebButton1Click(Expeditor: TObject);
var
WC_Object: TJSObject;
PAS_Object: TJSONObject;
const
SampleObjectData = '{"apple":"fructe","banana":"fructe","orange":"fructe","morcov":"legume","cartofi":"legume"}';
ÎNCEPE
asm var JS_Object = JSON.parse(SampleObjectData); Sfârşit;
WC_Object := TJSJSON.parseObject(SampleObjectData);
PAS_Object := TJSONObject.ParseJSONValue(SampleObjectData) ca TJSONObject;
asm console.log('JS Object Elements: '+Object.keys(JS_Object).length); Sfârşit;
console.log('Elemente obiect WC: '+IntToStr(lungime(TJSObject.keys(WC_Object))));
console.log('Elementele obiectului PAS: '+IntToStr(PAS_Object.count));
Sfârşit;
Ieșire console.log:
Elemente obiect JS: 5
Elemente obiect WC: 5
Elementele obiectului PAS: 5
Rețineți că numărarea obiectelor în primele două cazuri pare să implice extragerea tuturor valorilor cheie din obiecte într-o matrice separată, unde este apoi raportată lungimea matricei. Nu m-am uitat la sursa Delphi pentru a vedea dacă face același lucru sau dacă pur și simplu urmărește separat. Probabil că vom afla în câțiva pași atunci când ne uităm pe scurt la performanță.
07: Lungimea matricei JSON.
Acest lucru este puțin mai ușor, deoarece tablourile sunt în general, din necesitate, puțin mai conștiente de sine.
procedura TForm1.WebButton1Click(Expeditor: TObject);
var
WC_Array: TJSArray;
PAS_Array: TJSONArray;
const
SampleArrayData = '[{"name":"apple","type":"fruct"},{"name":"banana","type":"fruit"},{"name":"orange"," tip":"fructe"},{"name":"morcov","type":"legume"},{"name":"cartof","tip":"legume"}]';
ÎNCEPE
asm var JS_Array = JSON.parse(SampleArrayData); Sfârşit;
WC_Array := TJSArray(TJSJSON.parseObject(SampleArrayData));
PAS_Array := TJSONObject.ParseJSONValue(SampleArrayData) ca TJSONArray;
asm console.log('JS Array Length: '+JS_Array.length); Sfârşit;
console.log('WC Array Length: '+IntToStr(WC_Array.length));
console.log('Lungimea matricei PAS: '+IntToStr(PAS_Array.Count));
Sfârşit;
Ieșire console.log:
Lungimea matricei JS: 5
Lungimea matricei WC: 5
Lungimea matricei PAS: 5
08: Verificarea tipurilor de obiecte JSON.
Adesea, JSON va conține date într-un format care este, mai mult sau mai puțin, previzibil. De exemplu, ne vom aștepta la un Array of Objects, sau poate la un Object cu o grămadă de Arrays. De obicei, nu trebuie să scriem cod pentru a descoperi care sunt tipurile de date ale conținutului JSON pe care le navigăm, mai ales dacă noi suntem cei care îl creăm. Acest lucru cu siguranță ajută la simplificarea lucrurilor. Cu toate acestea, poate apărea dacă trebuie să procesați JSON din altă parte sau dacă doriți puțin mai multă toleranță la erori în codul dvs. sau dacă aveți de-a face cu JSON care vine din sălbăticie și nu știți la ce să vă așteptați .
JavaScript va fi adesea destul de bucuros să treacă peste orice fel de probleme cu tipurile de date. Face diverse presupuneri și continuă, uneori lăsându-vă cu lacune în interfața de utilizare (sau mai rău) acolo unde v-ați aștepta la date, dacă totul nu se încadrează în locul așteptat. Delphi, pe de altă parte, nu acceptă acest tip de lucruri, așa că este probabil să se oprească chiar în mijlocul a ceea ce face dacă încercați să treceți un tip de date drept altul într-un mod în care nu este pregătit. pentru. Din fericire, lista tipurilor pe care probabil că le vom întâlni este foarte scurtă, așa că verificarea acestora nu este prea greoaie. Trebuie doar să verificăm șiruri, numere, adevărat, fals, nul, matrice sau obiect. Iată, atunci, o modalitate de a face acest lucru pentru fiecare dintre cele trei medii ale noastre. Desigur, este puțin plictisitor, dar își face treaba.
procedura TForm1.WebButton1Click(Expeditor: TObject);
var
WC_Object: TJSObject;
PAS_Object: TJSONObject;
const
SampleObjectData = '{"a":"un text","b":12,"c":3.14159,"d":["Delphi","JavaScript"],"e":true,"f":false ,"g":null,"h":{"somekey":"somevalue"}}';
funcția WC_IdentifyType(Ceva: TJSObject; Key:String):String;
var i: întreg;
ÎNCEPE
Rezultat := 'Necunoscut';
dacă (Ceva[cheie] = zero) atunci
ÎNCEPE
if string(Ceva[Key]) = 'null'
apoi Rezultat:= 'Null'
else Rezultat := 'CHEIA NU GĂSITĂ';
Sfârşit
altfel
ÎNCEPE
dacă (Ceva [Cheie] = Adevărat) atunci Rezultat := „Adevărat”
else if (Ceva[Cheie] = Fals) atunci Rezultat := 'Fals'
else if (TJSJSON.stringify(Something[Key]).startsWith('"')) atunci Result := 'String'
else if (TJSJSON.stringify(Something[Key]).startsWith('{')) then Result := 'Object'
else if (TJSJSON.stringify(Something[Key]).startsWith('[')) then Result := 'Array'
else Rezultat := 'Număr';
Sfârşit;
Sfârşit;
funcția PAS_IdentifyType(Ceva: TJSONObject; Key:String):String;
var i: întreg;
ÎNCEPE
Rezultat := 'Necunoscut';
dacă nu (Something.get(Key) este TJSONPair) atunci
ÎNCEPE
i := 0;
Rezultat := 'CHEIA NU GĂSITĂ';
in timp ce (i < Ceva.Numara) fac
ÎNCEPE
dacă Something.Pairs[i].ToString.StartsWith('"'+Key+'":') atunci
ÎNCEPE
Rezultat := 'Null';
pauză;
Sfârşit;
i := i +1;
Sfârşit;
Sfârşit
altfel
ÎNCEPE
Rezultat := Copy(Something.get(Key).JSONValue.ClassName, 6, MaxInt);
Sfârşit;
Sfârşit;
ÎNCEPE
asm var JS_Object = JSON.parse(SampleObjectData); Sfârşit;
WC_Object := TJSJSON.parseObject(SampleObjectData);
PAS_Object := TJSONObject.ParseJSONValue(SampleObjectData) ca TJSONObject;
asm
funcția JS_IdentifyType(Ceva, cheie) {
var rezultat = 'Necunoscut';
dacă (Ceva[Cheie] === nedefinit) {rezultat = 'CHEIE NU GĂSITĂ'}
else if (Ceva[Cheie] === null) {rezultat = „Null”}
else if (Ceva[Cheie] === adevărat) {rezultat = „Adevărat”}
else if (Ceva[Cheie] === fals) {rezultat = „Fals”}
else if (Array.isArray(Something[Key])) {rezultat = 'Array'}
else if (tip de Something[Key] === 'șir') {rezultat = 'Șir'}
else if (tip de Ceva[Cheie] === „număr”) {rezultat = „Număr”}
else if (tip de Something[Key] === 'obiect') {rezultat = 'Obiect'}
returnare(rezultat);
}
console.log('JS a: '+JS_IdentifyType(JS_Object, 'a'));
console.log('JS b: '+JS_IdentifyType(JS_Object, 'b'));
console.log('JS c: '+JS_IdentifyType(JS_Object, 'c'));
console.log('JS d: '+JS_IdentifyType(JS_Object, 'd'));
console.log('JS e: '+JS_IdentifyType(JS_Object, 'e'));
console.log('JS f: '+JS_IdentifyType(JS_Object, 'f'));
console.log('JS g: '+JS_IdentifyType(JS_Object, 'g'));
console.log('JS h: '+JS_IdentifyType(JS_Object, 'h'));
console.log('JS X: '+JS_IdentifyType(JS_Object, 'X'));
Sfârşit;
console.log('WC a: '+WC_IdentifyType(WC_Object, 'a'));
console.log('WC b: '+WC_IdentifyType(WC_Object, 'b'));
console.log('WC c: '+WC_IdentifyType(WC_Object, 'c'));
console.log('WC d: '+WC_IdentifyType(WC_Object, 'd'));
console.log('WC e: '+WC_IdentifyType(WC_Object, 'e'));
console.log('WC f: '+WC_IdentifyType(WC_Object, 'f'));
console.log('WC g: '+WC_IdentifyType(WC_Object, 'g'));
console.log('WC h: '+WC_IdentifyType(WC_Object, 'h'));
console.log('WC X: '+WC_IdentifyType(WC_Object, 'X'));
console.log('PAS a: '+PAS_IdentifyType(PAS_Object, 'a'));
console.log('PAS b: '+PAS_IdentifyType(PAS_Object, 'b'));
console.log('PAS c: '+PAS_IdentifyType(PAS_Object, 'c'));
console.log('PAS d: '+PAS_IdentifyType(PAS_Object, 'd'));
console.log('PAS e: '+PAS_IdentifyType(PAS_Object, 'e'));
console.log('PAS f: '+PAS_IdentifyType(PAS_Object, 'f'));
console.log('PAS g: '+PAS_IdentifyType(PAS_Object, 'g'));
console.log('PAS h: '+PAS_IdentifyType(PAS_Object, 'h'));
console.log('PAS X: '+PAS_IdentifyType(PAS_Object, 'X'));
Sfârşit;
Ieșire console.log:
JS a: String
JS b: Număr
JS c: Număr
JS d: Matrice
JS e: Adevărat
JS f: Fals
JS g: Nul
JS h: Obiect
JS X: CHEIA NU GĂSITĂ
WC a: Snur
WC b: Număr
WC c: Număr
WC d: Matrice
WC e: Adevărat
WC f: Fals
WC g: Nul
WC h: Obiect
WC X: CHEIA NU GĂSITĂ
PAS a: Snur
PAS b: Număr
PAS c: Număr
PAS d: Matrice
PAS e: Adevărat
PAS f: Fals
PAS g: Nul
PAS h: Obiect
PAS X: CHEIA NU GĂSITĂ
Veți observa cât de ușor este acest lucru în JavaScript, în mare parte datorită relației strânse dintre JSON și limbajul JavaScript în general.
09: Verificați dacă obiectul JSON conține o cheie.
Acest lucru poate deveni mai complicat atunci când trebuie să găsim mai întâi porțiunea de JSON care ne interesează, dar deocamdată vom presupune că este doar primul nivel. De asemenea, rețineți că standardul JSON nu spune nimic despre intrările duplicate în Objects sau Arrays.
procedura TForm1.WebButton1Click(Expeditor: TObject);
var
WC_Object: TJSObject;
PAS_Object: TJSONObject;
const
SampleObjectData = '{"apple":"fructe","banana":"fructe","orange":"fructe","morcov":"legume","cartofi":"legume"}';
ÎNCEPE
asm var JS_Object = JSON.parse(SampleObjectData); Sfârşit;
WC_Object := TJSJSON.parseObject(SampleObjectData);
PAS_Object := TJSONObject.ParseJSONValue(SampleObjectData) ca TJSONObject;
asm
dacă (JS_Object['morcov']) {console.log('Obiectul JS conține morcov')}
else {console.log('Obiectul JS nu conține morcov')}
if (JS_Object['Batman']) { console.log('JS Object contains Batman')}
else {console.log('Obiectul JS nu conține Batman')}
Sfârşit;
dacă WC_Object['morcov'] <> nil
apoi console.log('Obiectul WC conține morcov')
else console.log('Obiectul WC nu conține morcov');
dacă WC_Object['Batman'] <> nil
apoi console.log('Obiectul WC conține Batman')
else console.log('Obiectul WC nu conține Batman');
dacă PAS_Object.getValue('morcov') <> nil
apoi console.log('Obiectul PAS conține morcov')
else console.log('Obiectul PAS nu conține morcov');
dacă PAS_Object.getValue('Batman') <> nil
apoi console.log('Obiectul PAS conține Batman')
else console.log('Obiectul PAS nu conține Batman');
Sfârşit;
Ieșire console.log:
Obiectul JS conține morcov
JS Object nu conține Batman
Obiectul WC conține morcov
Obiectul WC nu conține Batman
Obiectul PAS conține morcov
Obiectul PAS nu conține Batman
10: Găsiți șirul în matrice JSON.
La fel ca obiectele, vrem uneori să aflăm dacă un Array conține un anumit element. De asemenea, vrem deseori să știm unde apare în Array, este valoarea indexului. Prin convenție, o valoare de -1 înseamnă că nu este în Array. Pentru a face lucrurile mai complicate, Arrays pot conține lucruri foarte diferite, așa că găsirea a ceea ce căutați nu este întotdeauna atât de simplă. Să începem doar cu o matrice de valori șir. Aici, JavaScript are o funcție indexOf() la îndemână care simplifică destul de mult lucrurile. Delphi TJSONArray nu pare să aibă asta, dar este destul de ușor să adăugați un echivalent.
procedura TForm1.WebButton1Click(Expeditor: TObject);
var
WC_Array: TJSArray;
PAS_Array: TJSONArray;
const
SampleArrayData = '["măr","banana","portocale","morcov","cartofi"]';
funcția FindArrString(AJSONArray: TJSONArray; SearchString:String):Integer;
var
i: întreg;
ÎNCEPE
Rezultat := -1;
i := 0;
în timp ce i < AJSONArray.Count do
ÎNCEPE
if (AJSONArray[i].Value = SearchString) atunci
ÎNCEPE
Rezultat := i;
pauză;
Sfârşit;
i := i + 1;
Sfârşit;
Sfârşit;
ÎNCEPE
asm var JS_Array = JSON.parse(SampleArrayData); Sfârşit;
WC_Array := TJSArray(TJSJSON.parseObject(SampleArrayData));
PAS_Array := TJSONObject.ParseJSONValue(SampleArrayData) ca TJSONArray;
asm
console.log('JS Array: poziția morcov = '+JS_Array.indexOf('morcov'));
console.log('JS Array: Batman position = '+JS_Array.indexOf('Batman'));
Sfârşit;
console.log('WC Array: poziția morcov = '+IntToStr(WC_Array.indexOf('morcov')));
console.log('WC Array: Batman position = '+IntToStr(WC_Array.indexOf('Batman')));
console.log('PAS Array: poziția morcov = '+IntToStr(FindArrString(PAS_Array,'morcov')));
console.log('PAS Array: Batman position = '+IntToStr(FindArrString(PAS_Array,'Batman')));
Sfârşit;
Ieșire console.log:
JS Array: poziția morcov = 3
JS Array: Poziția Batman = -1
WC Array: poziția morcov = 3
WC Array: Poziția Batman = -1
Matrice PAS: poziția morcov = 3
PAS Array: Poziția Batman = -1
11: Găsiți cheia în matricea JSON.
Ar fi convenabil dacă am avea doar matrice de valori șir și nimic mai complicat decât atât, dar de obicei va fi aproape întotdeauna mai complicat. Următorul pas este să găsiți indexul Array corespunzător unei anumite chei. În cele din urmă, vom ajunge la ceva și mai generic și, prin urmare, mai util puțin mai târziu. Pentru moment, căutarea unei chei înseamnă că știm că Matricea noastră este populată cu obiecte. JavaScript are o modalitate elegantă de a face acest lucru care nu se traduce foarte bine (sau cel puțin nu am idee cum să-l scriu!) pentru implementarea WC, așa că aici abordările pentru WC și PAS sunt mai mult sau mai puțin aceleași. Rețineți, de asemenea, că un Array of Objects poate avea mai multe perechi Cheie:Valoare în fiecare element Array, așa că va trebui să știm pe care îl vom folosi ca Cheie pentru Matrice.
procedura TForm1.WebButton1Click(Expeditor: TObject);
var
WC_Array: TJSArray;
PAS_Array: TJSONArray;
const
SampleArrayData = '[{"name":"apple","type":"fruct"},{"name":"banana","type":"fruit"},{"name":"orange"," tip":"fructe"},{"name":"morcov","type":"legume"},{"name":"cartof","tip":"legume"}]';
funcția WC_FindArrKey(AJSArray: TJSArray; SearchKeyName:String; SearchKey:String):Integer;
var
i: întreg;
ÎNCEPE
Rezultat := -1;
i := 0;
în timp ce i < AJSArray.Lungimea do
ÎNCEPE
dacă (TJSObject(AJSArray[i])[SearchKeyName] = SearchKey) atunci
ÎNCEPE
Rezultat := i;
pauză;
Sfârşit;
i := i + 1;
Sfârşit;
Sfârşit;
funcția PAS_FindArrKey(AJSONArray: TJSONArray; SearchKeyName:String; SearchKey:String):Integer;
var
i: întreg;
ÎNCEPE
Rezultat := -1;
i := 0;
în timp ce eu < AJSONArray.Count do
ÎNCEPE
dacă (((AJSONArray[i] ca TJSONObject).getValue(SearchKeyName) ca TJSONSTring).Value = SearchKey) atunci
ÎNCEPE
Rezultat := i;
pauză;
Sfârşit;
i := i + 1;
Sfârşit;
Sfârşit;
ÎNCEPE
asm var JS_Array = JSON.parse(SampleArrayData); Sfârşit;
WC_Array := TJSArray(TJSJSON.parseObject(SampleArrayData));
PAS_Array := TJSONObject.ParseJSONValue(SampleArrayData) ca TJSONArray;
asm
console.log('JS Array: poziția morcov = '+JS_Array.findIndex(obj => obj.name == 'morcov'));
console.log('JS Array: Batman position = '+JS_Array.findIndex(obj => obj.name == 'Batman'));
Sfârşit;
console.log('WC Array: poziția morcov = '+IntToStr(WC_FindArrKey(WC_Array,'nume','morcov')));
console.log('WC Array: Batman position = '+IntToStr(WC_FindArrKey(WC_Array,'name','Batman')));
console.log('PAS Array: poziția morcov = '+IntToStr(PAS_FindArrKey(PAS_Array,'nume','morcov')));
console.log('PAS Array: Batman position = '+IntToStr(PAS_FindArrKey(PAS_Array,'name','Batman')));
Sfârşit;
Ieșire console.log:
JS Array: poziția morcov = 3
JS Array: Poziția Batman = -1
WC Array: poziția morcov = 3
WC Array: Poziția Batman = -1
Matrice PAS: poziția morcov = 3
PAS Array: Poziția Batman = -1
12: Adăugarea șirurilor de caractere la un obiect JSON.
Desigur, obiectele JSON nu trebuie în niciun fel să fie statice. Adăugarea unui element nou este una dintre sarcinile mai ușoare din această listă. Aici, doar adăugăm un alt element similar celorlalți. Mai târziu vom vedea cum poate fi extins acest lucru pentru a adăuga obiecte mai complexe altor obiecte mai complexe.
procedura TForm1.WebButton1Click(Expeditor: TObject);
var
WC_Object: TJSObject;
PAS_Object: TJSONObject;
const
SampleObjectData = '{"apple":"fructe","banana":"fructe","orange":"fructe","morcov":"legume","cartofi":"legume"}';
ÎNCEPE
asm var JS_object = JSON.parse(SampleObjectData); Sfârşit;
WC_Object := TJSJSON.parseObject(SampleObjectData);
PAS_Object := TJSONObject.ParseJSONValue(SampleObjectData) ca TJSONObject;
asm JS_object['ananas'] = 'fructe'; Sfârşit;
WC_Object['ananas'] := 'fructe';
PAS_Object.AddPair('ananas','fructe');
asm console.log('JS object = '+JSON.stringify(JS_object)); Sfârşit;
console.log('WC object = '+TJSJSON.stringify(WC_Object));
console.log('PAS object = '+PAS_Object.ToString);
Sfârşit;
Ieșire console.log:
Obiect JS = {"apple":"fructe","banana":"fructe","orange":"fructe","morcov":"legume","cartofi":"legume","ananas":"fructe "}
Obiect WC = {"apple":"fructe","banana":"fructe","orange":"fructe","morcov":"legume","cartofi":"legume","ananas":"fructe "}
Obiect PAS = {"apple":"fructe","banana":"fructe","orange":"fructe","morcov":"legume","cartofi":"legume","ananas":"fructe "}
13: Adăugarea șirurilor la o matrice JSON.
Aici facem același lucru, dar adăugăm la un Array în loc de un Object. Pe măsură ce Array-urile sunt ordonate, există și opțiunea de a adăuga un element în Array. Cele mai comune alegeri aici ar fi să adăugați la sfârșitul matricei, la începutul matricei sau într-un anumit punct al matricei. În ultimul caz, vom căuta poziția unui element existent, astfel încât să putem adăuga un element nou chiar înaintea acestuia.
procedura TForm1.WebButton1Click(Expeditor: TObject);
var
WC_Array: TJSArray;
PAS_Array: TJSONArray;
i: întreg;
tmparray: TJSONArray;
const
SampleArrayData = '[{"name":"apple","type":"fruct"},{"name":"banana","type":"fruit"},{"name":"orange"," tip":"fructe"},{"name":"morcov","type":"legume"},{"name":"cartof","tip":"legume"}]';
ÎNCEPE
asm var JS_Array = JSON.parse(SampleArrayData); Sfârşit;
WC_Array := TJSArray(TJSJSON.parseObject(SampleArrayData));
PAS_Array := TJSONObject.ParseJSONValue(SampleArrayData) ca TJSONArray;
// #1: Adăugați ananas la sfârșitul matricei
// #2: adăugați ridiche la începutul matricei
// #3: adăugați piersici înaintea morcovului în matrice
asm
// #1: Adăugați ananas la sfârșitul matricei
JS_Array.push({"name":"ananas","tip":"fructe"});
// #2: adăugați ridiche la începutul matricei
JS_Array.unshift({"name":"ridish","type":"vegetable"});
// #3: adăugați piersici înaintea morcovului în matrice
JS_Array.splice(JS_Array.findIndex(obj => obj.name == 'morcov'),0,{"name":"piersică","tip":"fructe"});
Sfârşit;
// #1: Adăugați ananas la sfârșitul matricei
WC_Array.push(TJSJSON.parseObject('{"name":"ananas","type":"fruct"}'));
// #2: adăugați ridiche la începutul matricei
WC_Array.unshift(TJSJSON.parseObject('{"name":"ridish","type":"vegetable"}'));
// #3: adăugați piersici înaintea morcovului în matrice
i := 0;
în timp ce i < WC_Array.length do
ÎNCEPE
dacă șir (TJSObject(WC_Array[i])['nume']) = 'morcov', atunci
ÎNCEPE
WC_Array.splice(i,0,TJSJSON.parseObject('{"name":"piersici","tip":"fructe"}'));
pauză;
Sfârşit;
i := i + 1;
Sfârşit;
// #1: Adăugați ananas la sfârșitul matricei
PAS_Array.Add(TJSONObject.ParseJSONValue('{"name":"pineapple","type":"fruit"}') ca TJSONObject);
// #2: adăugați ridiche la începutul matricei
tmparray := TJSONObject.ParseJSONValue('[{"name":"ridish","type":"vegetable"}]') ca TJSONArray;
i := 0;
în timp ce i < PAS_Array.count do
ÎNCEPE
tmparray.Add(Pas_Array[i] ca TJSONObject);
i := i + 1;
Sfârşit;
PAS_Array := tmpArray;
// #3: adăugați piersici înaintea morcovului în matrice
PAS_Array.Add(TJSONObject.ParseJSONValue('{"name":"pineapple","type":"fruit"}') ca TJSONObject);
tmparray := TJSONObject.ParseJSONValue('[]') ca TJSONArray;
i := 0;
în timp ce i < PAS_Array.count do
ÎNCEPE
if (((Pas_Array[i] ca TJSONObject).getValue('nume') ca TJSONString).Value = 'morcov')
apoi tmpArray.Add(TJSONObject.ParseJSONValue('{"name":"peach","type":"fruit"}') ca TJSONObject);
tmparray.Add(Pas_Array[i] ca TJSONObject);
i := i + 1;
Sfârşit;
PAS_Array := tmpArray;
asm console.log('JS array = '+JSON.stringify(JS_Array)); Sfârşit;
console.log('WC array = '+TJSJSON.stringify(WC_Array));
console.log('PAS array = '+PAS_Array.ToString);
Sfârşit;
Ieșire console.log:
Matrice JS = [{"name":"ridish","type":"vegetable"},{"name":"apple","type":"fruct"},{"name":"banana"," tip":"fructe"},{"name":"orange","type":"fructe"},{"name":"piersici","tip":"fructe"},{"nume":" morcov","type":"vegetable"},{"name":"cartof","type":"vegetable"},{"name":"ananas","type":"fructe"}]
Matrice WC = [{"name":"ridish","type":"vegetable"},{"name":"apple","type":"fruct"},{"name":"banana"," tip":"fructe"},{"name":"orange","type":"fructe"},{"name":"piersici","tip":"fructe"},{"nume":" morcov","type":"vegetable"},{"name":"cartof","type":"vegetable"},{"name":"ananas","type":"fructe"}]
Matrice PAS = [{"name":"ridish","type":"vegetable"},{"name":"apple","type":"fruct"},{"name":"banana"," tip":"fructe"},{"name":"orange","type":"fructe"},{"name":"piersici","tip":"fructe"},{"nume":" morcov","type":"vegetable"},{"name":"cartof","type":"vegetable"},{"name":"ananas","type":"fructe"}]
Mai mult lucru de data aceasta, deoarece câteva dintre diferențele de limbă dintre JavaScript și Delphi încep să devină mai evidente. Mai degrabă decât doar sintaxă, există funcții de bază care nu există pentru TJSONObject, de exemplu. Nu este prea greu de rezolvat dacă este cu adevărat important, dar cred că acesta este un moment bun pentru a sublinia că, probabil, cel mai bine ar fi să nu presupunem că ordinea Array este importantă - doar adăugați-o și sortați-o mai târziu. Nu întotdeauna cea mai bună abordare, dar, ca de obicei, avem opțiuni.
14: Adăugarea altor tipuri la un obiect JSON.
Deși este probabil ca șirurile de caractere să fie cel mai frecvent tip de date utilizat atunci când lucrați cu JSON, adăugarea celorlalte tipuri este probabil să apară din când în când. Rețineți că pentru aplicațiile desktop (VCL și FireMonkey, de exemplu) aceasta este o zonă care necesită puțină atenție suplimentară. În primul rând, aceste funcții ar trebui probabil incluse într-o încercare... cu excepția blocului, deoarece pot încerca să aloce memorie și să nu o obțină, sau pot să aloce memorie și să nu o elibereze ulterior. Totuși, nu o problemă pentru TMS WEB Core 🙂
procedura TForm1.WebButton1Click(Expeditor: TObject);
var
WC_Object: TJSObject;
PAS_Object: TJSONObject;
ÎNCEPE
asm
var JS_Object = {};
JS_Object['a'] = 'un text';
JS_Object['b'] = 12;
JS_Object['c'] = 3,14159;
JS_Object['d'] = ["Delphi","JavaScript"];
JS_Object['e'] = adevărat;
JS_Object['f'] = fals;
JS_Object['g'] = nul;
JS_Object['h'] = {"somekey":"somevalue"};
Sfârşit;
WC_Object := TJSObject.new;
WC_Object['a'] := 'un text';
WC_Object['b'] := 12;
WC_Object['c'] := 3,14159;
WC_Object['d'] := TJSArray(TJSJSON.parseObject('["Delphi","JavaScript"]'));
WC_Object['e'] := adevărat;
WC_Object['f'] := false;
WC_Object['g'] := null;
WC_Object['h'] := TJSJSON.parseObject('{"somekey":"somevalue"}');
PAS_Object := TJSONObject.Create;
PAS_Object.AddPair('a','un text');
PAS_Object.AddPair('b',TJSONNumber.Create(12));
PAS_Object.AddPair('c',TJSONNumber.Create(3.14159));
PAS_Object.AddPair('d',TJSONObject.ParseJSONValue('["Delphi","JavaScript"]') ca TJSONArray);
PAS_Object.AddPair('e',TJSONTrue.Create);
PAS_Object.AddPair('f',TJSONFalse.Create);
PAS_Object.AddPair('g',TJSONNull.Create);
PAS_Object.AddPair('h',TJSONObject.ParseJSONValue('{"somekey":"somevalue"}') ca TJSONObject);
asm console.log('JS Object = '+JSON.stringify(JS_Object)); Sfârşit;
console.log('WC Object = '+TJSJSON.stringify(WC_Object));
console.log('PAS Object = '+PAS_Object.ToString);
Sfârşit;
Ieșire console.log:
Obiect JS = {"a":"un text","b":12,"c":3.14159,"d":["Delphi","JavaScript"],"e":true,"f":false ,"g":null,"h":{"somekey":"somevalue"}}
Obiect WC = {"a":"un text","b":12,"c":3.14159,"d":["Delphi","JavaScript"],"e":true,"f":false ,"g":null,"h":{"somekey":"somevalue"}}
Obiect PAS = {"a":"un text","b":12,"c":3.14159,"d":["Delphi","JavaScript"],"e":true,"f":false ,"g":null,"h":{"somekey":"somevalue"}}
15: Ștergeți elementul obiect JSON.
Aici, eliminăm o pereche Cheie/Valoare dintr-un Obiect. Pentru obiectele JSON mici, probabil că acest lucru nu este mare lucru, deși este probabil costisitor în comparație cu unele dintre celelalte operațiuni, dacă este făcut în mod repetat în bucle scurte, de exemplu. În JavaScript, acest lucru se face, în mod ciudat, folosind o declarație de ștergere în loc de un fel de funcție atașată la Obiectul însuși. Pentru WC și PAS, nu pare să existe un echivalent, așa că o facem pe calea grea. Rețineți că acesta arată, de asemenea, un exemplu de o modalitate de a itera și prin toate elementele Object.
procedura TForm1.WebButton1Click(Expeditor: TObject);
var
WC_Object: TJSObject;
PAS_Object: TJSONObject;
i: întreg;
tmp_wc_object: TJSObject;
tmp_pas_object: TJSONObject;
const
SampleObjectData = '{"apple":"fructe","banana":"fructe","orange":"fructe","morcov":"legume","cartofi":"legume"}';
ÎNCEPE
asm var JS_Object = JSON.parse(SampleObjectData); Sfârşit;
WC_Object := TJSJSON.parseObject(SampleObjectData);
PAS_Object := TJSONObject.ParseJSONValue(SampleObjectData) ca TJSONObject;
// Înșelător de simplu, dar de ce este o declarație și nu o funcție? Ciudat de inconsecvent.
asm delete JS_Object['morcov']; Sfârşit;
// Nicio opțiune de ștergere în Delphi
i := 0;
tmp_wc_object := TJSObject.new;
în timp ce i < lungime(TJSObject.keys(WC_Object)) fac
ÎNCEPE
dacă nu (String(TJSObject.keys(WC_Object)[i]) = 'morcov')
apoi tmp_wc_object[String(TJSObject.keys(WC_Object)[i])] := WC_Object[String(TJSObject.keys(WC_Object)[i])];
i := i + 1;
Sfârşit;
WC_Object := tmp_wc_object;
// De ce ești TJSONObject.RemovePair?
tmp_pas_object := TJSONObject.Create;
i := 0;
în timp ce i < PAS_Obiect.Număr do
ÎNCEPE
dacă nu(PAS_Object.Pairs[i].toString.startsWith('"morcov":'))
apoi tmp_pas_object.AddPair(PAS_Object.Pairs[i]);
i := i + 1;
Sfârşit;
PAS_Object := tmp_pas_object;
asm console.log('JS object = '+JSON.stringify(JS_Object)); Sfârşit;
console.log('WC object = '+TJSJSON.stringify(WC_Object));
console.log('PAS object = '+PAS_Object.ToString);
Sfârşit;
Ieșire console.log:
Obiect JS = {"apple":"fructe","banana":"fructe","orange":"fructe","cartofi":"legume"}
Obiect WC = {"apple":"fructe","banana":"fructe","orange":"fructe","cartofi":"legume"}
Obiect PAS = {"apple":"fructe","banana":"fructe","orange":"fructe","cartofi":"legume"}
16: Ștergeți elementul șir de matrice JSON.
Ștergerea elementelor din Arrays este poate puțin neobișnuită, având în vedere modul în care sunt utilizate în mod normal Arrays, dar ce naiba, de ce nu? În general, nu este recomandabil, deoarece este posibil ca implementarea de bază (ei bine, implementarea JavaScript în acest caz) memoria consumată de elementul Array care este șters să nu fie de fapt eliberată, ci mai degrabă lăsată în Array ca valoare nulă. În WC și PAS, recreăm de fapt matricea, așa că aceasta este o problemă mai puțin, deși costul general de a face asta este, probabil, mult mai rău. Ca și anterior, atunci când ștergeți elemente JSON Object, acest lucru este probabil inofensiv la scară mică, dar dacă acest lucru se întâmplă mult într-o buclă scurtă, s-ar putea foarte bine să doriți să luați în considerare o altă abordare. Aici doar ștergem al treilea element al Array.
procedura TForm1.WebButton1Click(Expeditor: TObject);
var
WC_Array: TJSArray;
PAS_Array: TJSONArray;
i: întreg;
tmp_pas_Array: TJSONArray;
const
SampleArrayData = '["măr","banana","portocale","morcov","cartofi"]';
ÎNCEPE
asm var JS_Array = JSON.parse(SampleArrayData); Sfârşit;
WC_Array := TJSArray(TJSJSON.parseObject(SampleArrayData));
PAS_Array := TJSONObject.ParseJSONValue(SampleArrayData) ca TJSONArray;
asm JS_Array.splice(3,1); Sfârşit;
WC_Array.splice(3,1);
// Nu TJSONArray.Remove() ???
i := 0;
tmp_PAS_Array := TJSONArray.Create;
în timp ce (i < PAS_Array.Count) do
ÎNCEPE
dacă eu <> 3
apoi tmp_pas_Array.Add(PAS_Array[i].Value);
i := i + 1;
Sfârşit;
PAS_Array := tmp_pas_array;
asm console.log('JS Array = '+JSON.stringify(JS_Array)); Sfârşit;
console.log('WC Array = '+TJSJSON.stringify(WC_Array));
console.log('PAS Array = '+PAS_Array.ToString);
Sfârşit;
Ieșire console.log:
JS Array = ["măr","banane","portocale","cartofi"]
WC Array = ["măr","banane","portocale","cartofi"]
PAS Array = ["măr","banane","portocale","cartofi"]
17: Ștergeți cheia JSON Array.
În acest exemplu, să presupunem că elementul Array pe care dorim să-l ștergem are o anumită valoare într-una dintre chei. Acest lucru este similar cu localizarea cheilor în Array, cu doar pasul suplimentar de ștergere odată ce îl găsim. Sau în cazul PAS, recrearea matricei, dar pur și simplu nu adăugarea elementului de potrivire.
procedura TForm1.WebButton1Click(Expeditor: TObject);
var
WC_Array: TJSArray;
PAS_Array: TJSONArray;
i: întreg;
tmparray: TJSONArray;
const
SampleArrayData = '[{"name":"apple","type":"fruct"},{"name":"banana","type":"fruit"},{"name":"orange"," tip":"fructe"},{"name":"morcov","type":"legume"},{"name":"cartof","tip":"legume"}]';
ÎNCEPE
asm var JS_Array = JSON.parse(SampleArrayData); Sfârşit;
WC_Array := TJSArray(TJSJSON.parseObject(SampleArrayData));
PAS_Array := TJSONObject.ParseJSONValue(SampleArrayData) ca TJSONArray;
asm JS_Array.splice(JS_Array.findIndex(obj => obj.name == 'morcov'),1); Sfârşit;
i := 0;
în timp ce i < WC_Array.length do
ÎNCEPE
dacă șir (TJSObject(WC_Array[i])['nume']) = 'morcov', atunci
ÎNCEPE
WC_Array.splice(i,1);
pauză;
Sfârşit;
i := i + 1;
Sfârşit;
tmparray := TJSONObject.ParseJSONValue('[]') ca TJSONArray;
i := 0;
în timp ce i < PAS_Array.count do
ÎNCEPE
dacă nu (((Pas_Array[i] ca TJSONObject).getValue('nume') ca TJSONString).Valoare = 'morcov')
apoi tmparray.Add(Pas_Array[i] ca TJSONObject);
i := i + 1;
Sfârşit;
PAS_Array := tmpArray;
asm console.log('JS array = '+JSON.stringify(JS_Array)); Sfârşit;
console.log('WC array = '+TJSJSON.stringify(WC_Array));
console.log('PAS array = '+PAS_Array.ToString);
Sfârşit;
Ieșire console.log:
Matrice JS = [{"name":"apple","type":"fruct"},{"name":"banana","type":"fruct"},{"name":"orange"," tip":"fructe"},{"name":"cartof","tip":"legume"}]
Matrice WC = [{"name":"apple","type":"fruct"},{"name":"banana","type":"fruct"},{"name":"orange"," tip":"fructe"},{"name":"cartof","tip":"legume"}]
Matrice PAS = [{"name":"apple","type":"fruct"},{"name":"banana","type":"fruct"},{"name":"orange"," tip":"fructe"},{"name":"cartof","tip":"legume"}]
18: Actualizați elementul obiect JSON.
Ștergerea unui element de obiect și adăugarea unuia nou este o abordare, mai ales dacă schimbați numele unei chei. Dar dacă actualizați doar o singură valoare într-un obiect JSON mare, puteți, de asemenea, să actualizați valoarea direct. Vom vorbi despre duplicate într-un moment (nu există duplicate?!), dar se dovedește că în practică nu există mare diferență între adăugarea unui element și actualizarea unui element existent cu o valoare nouă.
procedura TForm1.WebButton1Click(Expeditor: TObject);
var
WC_Object: TJSObject;
PAS_Object: TJSONObject;
const
SampleObjectData = '{"apple":"fructe","banana":"fructe","orange":"fructe","morcov":"legume","cartofi":"legume"}';
ÎNCEPE
asm var JS_Object = JSON.parse(SampleObjectData); Sfârşit;
WC_Object := TJSJSON.parseObject(SampleObjectData);
PAS_Object := TJSONObject.ParseJSONValue(SampleObjectData) ca TJSONObject;
asm JS_Object['morcov'] = 'nu fructe'; Sfârşit;
WC_Object['morcov'] := 'nu fructe';
PAS_Object.AddPair('morcov','nu fructe');
asm console.log('JS object = '+JSON.stringify(JS_Object)); Sfârşit;
console.log('WC object = '+TJSJSON.stringify(WC_Object));
console.log('PAS object = '+PAS_Object.ToString);
Sfârşit;
Ieșire console.log:
Obiect JS = {"apple":"fructe","banana":"fructe","orange":"fructe","morcov":"nu fructe","cartofi":"legume"}
obiect WC = {"apple":"fructe","banana":"fructe","orange":"fructe","morcov":"nu fructe","cartofi":"legume"}
Obiect PAS = {"apple":"fructe","banana":"fructe","orange":"fructe","morcov":"nu fructe","cartofi":"legume"}
19 : chei de obiect JSON duplicate.
Nu este prima surpriză pe care am întâlnit-o când am pregătit acest material, ci una curioasă, totuși. Nu există nimic în standardele JSON pe care le-am întâlnit care să facă referiri la chei duplicate. Termenul „cheie” ar putea implica faptul că este unic, dar acesta nu este nici măcar termenul folosit în standarde. Și, de fapt, dacă transmiteți JSON cu chei duplicate unui instrument de formatare sau validare, acesta îl va formata și valida la fel și va elimina cheile duplicate. Important este că ultima valoare este folosită în cazul cheilor duplicate. Acest lucru este surprinzător pentru mine, deoarece „ultima valoare” chiar nu ar trebui să aibă o semnificație în teoria mulțimilor, dar totuși iată-ne. Dacă tratați numele cheilor ca chei reale, atunci aceasta nu este, în mod natural, o problemă. Faptul că este tratat în acest fel sugerează că, de fapt, aceasta ar trebui clarificată ca una dintre regulile specificate de la început.
procedura TForm1.WebButton1Click(Expeditor: TObject);
var
WC_Object: TJSObject;
PAS_Object: TJSONObject;
const
SampleObjectData = '{"une cheie":"valoare 1", "o cheie":"valoare 2", "o cheie":"valoare 3", "unor cheie":"valoare 4", "o cheie":" valoarea 5"}';
ÎNCEPE
asm var JS_Object = JSON.parse(SampleObjectData); Sfârşit;
WC_Object := TJSJSON.parseObject(SampleObjectData);
PAS_Object := TJSONObject.ParseJSONValue(SampleObjectData) ca TJSONObject;
asm console.log('JS Object = '+JSON.stringify(JS_Object)); Sfârşit;
console.log('WC Object = '+TJSJSON.stringify(WC_Object));
console.log('PAS Object = '+PAS_Object.ToString);
Sfârşit;
Ieșire console.log:
Obiect JS = {"some key":"value 5"}
obiect WC = {"some key":"value 5"}
Obiect PAS = {"o cheie":"valoare 5"}
Partea 2 vine în curând...
