I-convert ang JSON sa XML JavaScript Object Notation ↔ Extensible Markup Language Libre Online Ligtas
Ihulog ang JSON file mo at kunin ang XML. Binabasa at isinusulat ito rito, sa iyong browser, kaya hindi lumalabas sa device mo ang file — at nakasulat sa ibaba kung ano ang pinananatili ng paglipat at kung ano ang hindi, sa halip na ikaw pa ang tumuklas.
I-convert ang file mo
Ihulog dito ang JSON file mo, o pumili ng isa.
Hindi kailanman lumalabas sa device na ito ang file mo. Lahat ay tumatakbo sa iyong browser.
Walang ina-upload
I-convert mula sa JSON
I-convert sa JSON
Saan galing ang mga format na ito
Ang CSV ang pinakaluma at pinakakulang sa pamantayan: talahanayang isinulat bilang mga linya ng teksto, ginagamit mula pa noong dekada 1970 at tinukoy lang sa sulat noong 2005, nang desidido na ng bawat program kung ano ang separator at kailan maglalagay ng panipi. Ang XML ay lumago mula sa SGML noong 1998 para sa mga dokumentong dapat magdala ng mahigpit na istruktura at masuri laban sa schema. Hinugot ni Douglas Crockford ang JSON mula sa JavaScript noong mga 2001, sadyang pinaliit sa mga object, array, numero at string — at ang minimalismong iyon ang dahilan kung bakit nito naagaw ang web. Ang YAML ang madaling basahing pinsan nito, kung saan ang indentation ang gumagawa ng trabahong ginagawa ng mga bracket sa iba. Ang nag-iisang mahalaga sa pag-convert sa pagitan nila: patag ang CSV, isang grid ng mga hilera at column, habang ang JSON, XML at YAML ay mga puno.
Saan mo sila nakakasalubong
Ang CSV ang ine-export ng spreadsheet at ibinibigay ng accountant, platform ng tindahan o bank statement. Ang JSON ang wika ng mga web service at kung saan parami nang parami isinusulat ang mga configuration file. Nananatili ang XML sa mas lumang sistema ng negosyo, sa mga pamantayan ng invoicing at sa loob mismo ng mga format ng office. Ang YAML ay kung saan mano-manong sumusulat ng mga setting ang mga tao. Ang pag-convert sa pagitan nila ang pang-araw-araw na trabaho ng paglilipat ng data mula sa pinaggawaan patungo sa pinagkakailanganan.
Mga tanong ng mga tao
Bumukas ang CSV ko bilang isang column sa Excel. Bakit?
Dahil iba ang separator na inaasahan ng spreadsheet mo. Sinusunod ng Excel ang list separator ng regional settings ng computer, na tuldok-kuwit saanman ang kuwit ay ginagamit na bilang decimal mark — iyon ay, karamihan ng kontinental na Europa. Ang file na pinaghihiwalay ng kuwit ay magmumukhang iisang column ng teksto. Gamitin ang import dialog at sabihin nang tahasan ang separator, sa halip na i-double-click ang file. Ang parehong regional setting ang dahilan kung bakit minsan dumarating bilang petsa ang 3.5.
Bakit hindi maging maayos na spreadsheet ang nakapugad kong JSON?
Dahil patag ang spreadsheet at puno ang JSON. Ang hilera ay may isang halaga bawat column; ang JSON object ay may listahan sa loob ng field sa loob ng ibang listahan. Ang pag-convert ay nangangahulugang pagpili kung paano ito papatagin: pagsasama ng mga nakapugad na pangalan sa isang mahabang heading ng column, o pag-uulit ng magulang na hilera para sa bawat anak. Kompromiso ang dalawa, at walang mababawi nang awtomatiko — kaya ang pagbalik mula sa spreadsheet patungo sa orihinal na hugis ay karaniwang nangangailangan ng desisyon ng tao.
Nawawalan ba ng kalidad ang file?
Depende sa kayang hawakan ng dalawang format. Ang pag-convert sa pagitan ng mga format na nag-iimbak ng parehong bagay — PNG sa BMP, WAV sa FLAC — ay walang nawawala. Ang pag-convert tungo sa format na nagtatapon ng impormasyon para makatipid ng espasyo, gaya ng JPEG o MP3, ay may nawawalang kaunti sa bawat pagkakataon, at hindi ito ibinabalik ng pag-convert pabalik. Kung may mapagpipilian, mas pinipili ng pahinang ito na panatilihin ang orihinal na kalidad kaysa gumawa ng pinakamaliit na file.
Ina-upload ba saanman ang file ko?
Hindi. Nangyayari ang conversion sa loob ng iyong browser, sa sarili mong makina; hindi kailanman lumalabas doon ang file at walang server dito na makatatanggap nito. Kaya ang malaking file ay nalilimitahan ng sarili mong memorya at hindi ng upload, at kaya walang mako-convert mo na lalabas sa log ng sinuman — kasama ang amin. Kinukuha ng mga tool sa audio at video ang kanilang conversion engine mula sa site na ito sa unang beses na gamitin mo ang mga ito, humigit-kumulang tatlumpung megabyte, isang beses lang; pagkatapos noon, ang trabaho ay nangyayari pa rin nang buo sa makina mo.
Bakit kino-convert ng mga tao ang JSON sa XML
Ang JSON ang wika ng makabagong web code: magaan, nababasa at nauunawaan ng bawat programming language. Ang XML ang mas luma at mas pormal na kapatid nito, isinusulat sa mga tag na nagbubukas at nagsasara, at ito pa rin ang kinakailangang format sa nakakagulat na dami ng lugar. Mga accounting program, sistema ng buwis at customs, platform ng public procurement, product feed, workflow sa paglalathala, enterprise software at mahabang listahan ng mas lumang web service ay pawang umaasa ng XML. Kapag nasa JSON ang data mo at XML ang wika ng sistemang dapat tumanggap nito, kailangan ng conversion. Kaya kino-convert ng mga tao ang JSON sa XML: nasa isang anyo ang impormasyon nila, at ang kabilang anyo ang hinihingi ng destinasyon.
Karaniwan ang mga sitwasyon. Isang developer na kailangang magpadala ng data mula sa makabagong application patungo sa serbisyong ginawa ilang taon na ang nakararaan. Isang tindahang nag-e-export ng mga produkto bilang JSON at kailangang magbigay ng feed sa marketplace na gusto ay XML. Isang koponang nangangailangan ng configuration sa markup form na mas gusto ng isang tool. Isang estudyanteng gustong makita kung ano ang hitsura ng parehong data sa dalawang notasyon. Sa bawat kaso, handa na ang nilalaman, at ang notasyon lang ang magkaiba.
Kino-convert ng pahinang ito ang JSON sa XML sa loob ng browser mo. Binabasa at isinusulat dito ang file mo, kaya hindi kailanman lumalabas sa device mo ang file, na mahalaga para sa mga order, invoice at anumang pribado. At sinasabi ng pahina nang maaga kung ano ang pinananatili ng paglipat at kung ano ang hindi, sa halip na hayaan kang madiskubre ito mismo. Sa ibaba makikita mo kung paano gumagana ang conversion, kung paano tinatrato ang mga pangalan, listahan at attribute, at ano ang gagawin sa mga key na hindi tinatanggap ng XML.
Paano gumagana ang conversion
Dinadala ang buong puno
Binabasa ang JSON file mo sa loob ng browser mo, at isinusulat bilang XML ang buong puno. Ang mga object ay nagiging mga element, ang mga key nila ang nagiging pangalan ng mga child element, at ang mga halaga ang nagiging teksto sa loob. Ang nesting sa JSON ay nesting sa XML, kaya ang hugis na nakikita mo sa mga brace ay ang hugis na makukuha mo sa mga tag.
Ang dokumento ay pinapangalanan ayon sa nag-iisang key
Kailangan ng XML na dokumento ng eksaktong isang root element. Kung may isang key lang ang JSON object mo, ang key na iyon ang magpapangalan sa dokumento. Ito ang maginhawang kaso: ang XML file na ginawang JSON at ibinalik ay kamukha ng sarili nito, dahil ang root element ay nagiging nag-iisang key at bumabalik bilang root element. Kung maraming key ang JSON mo sa itaas, binabalot sila ng converter sa isang root element para maayos ang pagkakabuo ng resulta.
Inuulit ng mga listahan ang element
Inuulit ng array ang element nito. Ang key na products na may hawak na listahan ng tatlong record ay nagbibigay ng tatlong product element na magkakasunod, na siyang paraan ng XML sa pagpapahayag ng listahan. Pinananatili ang pagkakasunod.
Ang pinananatili
Ang buong puno
Dinadala ang bawat object, bawat listahan at bawat halaga. Walang itinatapon, at ang nesting ay ang nesting ng orihinal.
Mga attribute, sa pamamagitan ng @
Ang key na nagsisimula sa @ ay nagiging attribute. Ang record na may key na @id at key na name ay nagbibigay ng element na may attribute na id at child element na name. Ito ang parehong kombensiyong ginagamit ng kabaligtarang conversion, kaya ang XML na ginawang JSON at ibinalik ay nagpapanatili ng mga attribute nito.
Ang pagkakasunod
Pinananatili ng mga key ang pagkakasunod kung saan sila lumitaw sa JSON, kaya sinusunod ng mga element sa XML ang pagkakasunod ng pinagmulan.
Ang dapat mong malaman bago i-convert ang JSON sa XML
Anumang JSON key ay maaaring salita; ang pangalan ng XML ay hindi
Anumang JSON key ay maaaring salita, numero o parirala na may mga espasyo. Hindi puwede ang pangalan ng XML element: dapat itong magsimula sa titik o underscore at maaaring maglaman ng mga titik, digit, gitling, underscore at tuldok, ngunit walang espasyo. Ang key na hindi legal na pangalan ay hindi binabaluktot para maging isa. Nagiging item element ito na may name attribute, na isinusulat bilang item name="ang orihinal na key", kaya nasa file pa rin ang orihinal at mahahanap pa rin. Walang tahimik na pinapalitan ng pangalan.
Walang namespace, walang schema
Walang namespace, at walang binibigyan ng schema. Maayos ang pagkakabuo ng resulta, ngunit hindi na-validate. Mababasa ito ng anumang XML reader, ngunit kung natutugunan nito ang partikular na istrukturang hinihingi ng sistema ng buwis o ng marketplace ay hiwalay na tanong, at ang tumatanggap lang ang makakasagot nito. Kung hinihingi ng schema ang ilang pangalan ng element, kakailanganin mong gawing tugma ang mga JSON key bago pa man.
Teksto ang mga halaga
Walang mga uri ang XML: teksto ang bawat halaga sa mga tag. Ang mga numero, true, false at null ay isinusulat bilang teksto nila. Ang program na bumabasa ng XML ang dapat mag-interpret sa mga ito ayon sa nakikita nitong angkop.
Paano i-convert ang JSON sa XML dito
Idagdag ang file mo
Ihulog ang JSON file sa pahina o piliin ito mula sa device mo. Binabasa ito sa loob ng browser mo at hindi ina-upload.
I-convert
Pindutin ang button. Sandali lang ang file na may karaniwang laki. Iwanang bukas ang pahina hanggang matapos.
I-download at suriin
I-download ang XML at buksan ito sa text editor o browser. Tingnan ang simula at ang dulo, at tiyaking ang mga pangalan ng element ay ayon sa inaasahan mo at lumilitaw ang mga attribute kung saan mo ito nilayon.
Mas malapitang pagtingin sa JSON at XML
Dalawang paraan ng pagsulat ng puno
Parehong naglalarawan ang JSON at XML ng puno ng mga halaga. Isinusulat ito ng JSON gamit ang mga brace at bracket, at kilala lang nito ang mga object, listahan, string, numero, boolean at null. Isinusulat ito ng XML gamit ang mga tag na nagbubukas at nagsasara, at nagdaragdag ng mga attribute, namespace at pinaghalong nilalaman. Magkatugma sila para sa data, gaya ng mga record at setting, at hindi magkatugma para sa mga dokumento, kung saan magkakahalo ang teksto at markup.
Bakit mahalaga ang mga kombensiyon
Walang mga attribute ang JSON, walang root element at walang konsepto ng pag-uulit ng element. Kaya ang anumang conversion ay nangangailangan ng mga kombensiyon: ang @ para sa mga attribute, ang nag-iisang key para sa root, ang pag-uulit ng mga element para sa mga listahan. Simple at pare-pareho ang mga kombensiyong ginagamit dito, at tugma ang mga ito sa mga ginagamit kapag mula XML patungong JSON, na siyang nagpapahintulot sa round trip na gumana sa mga karaniwang kaso.
Mga walang laman na halaga
Ang walang laman na string at ang null ay parehong nauuwi sa walang laman na element. Kung mahalaga ang pagkakaiba sa sistemang tumatanggap, markahan ito sa data bago mong i-convert ang JSON sa XML, halimbawa sa pamamagitan ng hiwalay na flag.
Mga karaniwang sitwasyon nang detalyado
Mga feed para sa marketplace at comparison site
Maraming platform ang humihingi ng product feed sa XML. Kung JSON ang ine-export ng software ng tindahan mo, i-convert ang JSON sa XML, suriin ang mga pangalan ng element laban sa espesipikasyon ng platform at i-upload.
Mas lumang mga serbisyo at enterprise system
Umaasa ng XML ang mga sistemang ginawa noong panahon ng SOAP at mga unang API. Ang makabagong application ay maaaring gumawa ng JSON at ipa-convert ito para sa kanila.
Configuration para sa mga tool na mas gusto ang XML
Binabasa ng ilang build tool, content system at desktop program ang mga setting nila mula sa XML. Ang configuration na isinulat bilang JSON ay maaaring gawing anyong kailangan nila.
Pag-aaral at paghahambing
Ang pagtingin sa parehong data sa dalawang notasyon ay mahusay na paraan para maunawaan kung paano sila nagkakaiba. Mag-paste ng maliit na JSON, i-convert ito at ihambing ang dalawa nang magkatabi.
Praktikal na payo bago i-convert ang JSON sa XML
Tiyaking balido ang JSON
Ang nawawalang kuwit o nawawalang panipi ay magpapatigil sa conversion. Kung may iniulat na error ang pahina, buksan ang file sa editor na nagha-highlight ng mga problema sa JSON at ayusin ang linyang itinuturo nito.
Gawing legal na pangalan ng element ang mga key
Kung alam mong susuriin ang XML laban sa schema, gumamit ng mga key na balidong pangalan at tugma sa schema. Kung hindi, itatago ng converter ang mga ito nang ligtas bilang item element, na tama ngunit maaaring hindi ang inaasahan ng tumatanggap.
Pumili ng iisang top-level na key
Kung gusto mong may partikular na pangalan ang root element ng XML mo, balutin ang data mo sa object na may iisang key na iyon bago mong i-convert ang JSON sa XML.
Malalaking file
Tumatakbo ang lahat sa device mo, kaya nangangailangan ng memorya ang napakalaking file. Para sa mga file na ilang megabyte, gumamit ng computer, at hatiin ang data kung nahihirapan ang pahina.
Mga tanong ng mga tao bago mag-convert
Ano ang nagpapangalan sa root element?
Ang object na may iisang key ay nagpapangalan sa dokumento ayon sa key na iyon.
Paano ako makakakuha ng attribute?
Simulan ang key sa @. Nagiging attribute ito ng element.
Ano ang nangyayari sa key na may espasyo?
Hindi ito legal na pangalan ng element, kaya nagiging item element ito na may name attribute na may hawak ng orihinal na key. Walang nawawala.
Papasa ba ang XML sa pagsusuri ng schema?
Maayos ang pagkakabuo ng resulta, hindi na-validate. Nakadepende sa mga pangalan ng element at istruktura mo kung natutugunan nito ang isang schema.
Ina-upload ba ang file ko?
Hindi. Tumatakbo ang conversion sa iyong browser at hindi kailanman lumalabas sa device mo ang file.
Makakabalik ba ako sa JSON?
Oo. Binabasa muli ng XML sa JSON ang puno ng XML, na may parehong mga kombensiyon para sa mga attribute.
Matalinong pagpili kapag kino-convert ang JSON sa XML
Kailangan ba talaga ang XML?
Kung tumatanggap ng JSON ang sistemang tatanggap, gamitin ang JSON. Mag-convert lang kapag kinakailangan ang XML.
Iba pang target
Para sa configuration na ine-edit ng mga tao, mas komportableng basahin ang JSON sa YAML. Para sa mga talahanayan, nagsisilbi sa mga spreadsheet ang JSON sa CSV at JSON sa XLSX.
Itago ang JSON
Ang JSON ang master. Hawak nito ang mga uri. Itago ito, at ituring ang XML bilang kopyang ginawa para sa partikular na tatanggap.
Pagkuha ng magandang resulta pagkatapos ng conversion
Buksan ito sa browser
Ipinapakita ng browser ang XML bilang puno na maaaring i-collapse. Buksan ang file at palawakin ang mga element. Kung mukhang inaasahan mo ang istruktura, matino ito.
Ihambing ang ilang record sa pinagmulan
Kumuha ng ilang record sa gitna at suriin ang mga ito laban sa JSON. Isang minuto lang ito at sinasabi nitong tapat ang conversion.
Idagdag ang kailangan ng tatanggap
Kung humihingi ang tatanggap ng linya ng deklarasyon, namespace o reference sa stylesheet, idagdag ang mga ito sa text editor. Hindi bahagi ng data ang mga ito at hindi isinusulat para sa iyo.
Paghahanda ng JSON para maayos itong ma-convert
Gumamit ng regular na istruktura
Kapag kino-convert mo ang JSON sa XML, pinakamahusay na nako-convert ang regular na data: mga listahan ng record na may parehong mga key, bawat key ay legal na pangalan. Ang irregular na data ay nagbibigay ng tamang ngunit magulong resulta.
Magpasya kung ano ang attribute
Madalas na mga attribute sa XML ang mga identifier, code at flag. Markahan ang mga ito sa JSON ng @, at ang resulta ay magmumukhang XML na isinulat ng tao.
Subukan muna sa maliit na bahagi
Kung malaki ang file mo, kunin ang mga unang record sa test file at i-convert iyon. Ang mabilis na pagtingin sa resulta ay nagpapakita kung ang hugis ay ayon sa inaasahan mo.
Pagtutugma ng XML sa tatanggap nito
Tingnan muna ang espesipikasyon
Bago mo i-convert ang JSON sa XML para sa marketplace, portal ng buwis o kasosyo, basahin kung ano ang hinihingi nila. Karamihan ay naglalathala ng paglalarawan ng mga element na inaasahan nila, ang pagkakasunod ng mga ito at kung alin ang kinakailangan. Ang pag-align ng mga pangalan ng key mo rito ay gumugugol ng ilang minuto sa JSON at nakakatipid ng bigong upload sa susunod.
Maaaring mahalaga ang pagkakasunod
Ang ilang XML schema ay nangangailangan ng mga element sa takdang pagkakasunod. Pinananatili ng converter ang pagkakasunod ng mga key mo, kaya kung igigiit ng tatanggap ang isang sequence, isulat ang mga JSON key sa sequence na iyon. Eksaktong sinusunod ng resulta ang isinulat mo.
Idagdag ang deklarasyon kung kinakailangan
Kaugalian ang linya sa itaas na nagsasaad ng bersyon at ng encoding at igigiit ito ng ilang tatanggap. Hindi ito bahagi ng data, kaya hindi ito isinusulat para sa iyo. Idagdag ito nang mano-mano sa text editor, bago ang unang element.
Bantayan ang mga espesyal na character
Ang mga ampersand, angle bracket at panipi sa loob ng mga halaga ay isinusulat sa kanilang escaped na anyo, kaya nananatiling balido ang XML anuman ang laman ng teksto. Hindi mo kailangang ihanda ang mga ito sa JSON.
Magtabi ng sample na tinanggap
Kapag tinanggap ng tatanggap ang isang file, magtabi ng kopya ng eksaktong file na iyon at ng JSON na gumawa nito. Kapag nabigo ang susunod na upload, ang paghahambing nito sa gumana ay agad na makakahanap ng pagkakaiba.
Ulitin ang conversion sa halip na mag-edit nang mano-mano
Kapag nagbago ang data, baguhin ang JSON at i-convert muli ang JSON sa XML. Ang pag-edit ng XML nang mano-mano ay nag-iiwan ng dalawang bersyong unti-unting nagkakalayo.
Privacy at paghawak
Bakit mahalaga ang lokal na conversion para sa data
Madalas na naglalaman ang mga data file ng pribado: mga kliyente, order, invoice, setting. Maraming online converter ang nag-a-upload ng file mo sa server, pinoproseso ito at ibinabalik ang resulta, at sa ilang panahon ay nasa makinang hindi mo kontrolado ang kopya. Dito, ang sarili mong browser ang gumagawa ng trabaho, kaya nananatili ang data sa device mo.
Ano ang nangyayari kapag umalis ka
Kapag isinara mo ang pahina, nawawala sa browser ang na-convert na file, kaya i-download muna ito. Walang anumang tungkol sa data mo ang itinatago.
Kung may magkamali
Sinasabi ng pahina na hindi balidong JSON ang file
Maaaring may nawawalang kuwit, nawawalang panipi o bracket na hindi nagsasara. Buksan ang file sa editor na nagha-highlight ng mga error sa JSON at ayusin ang linyang itinuturo nito.
Tinatanggihan ng tatanggap ang XML
Maayos ang pagkakabuo ng resulta ngunit hindi na-validate. Ihambing ito sa espesipikasyon ng tatanggap at ayusin ang mga pangalan ng key at ang istruktura ng JSON.
Nagyeyelo ang pahina sa malaking file
Tumatakbo ang lahat sa device mo, at nangangailangan ng memorya ang malaking file. Subukan ulit sa computer, o hatiin ang data.
Mga kaugnay na tool
Sakop ng parehong pamilya ng mga tool ang mga kalapit na gawain. Para bumalik, gamitin ang XML sa JSON. Para sa mga configuration file, nagko-convert sa pagitan ng dalawang iyon ang JSON sa YAML at YAML sa JSON. Para sa mga talahanayan, may JSON sa CSV, CSV sa JSON, JSON sa XLSX at XLSX sa JSON.
Isang halimbawang nalutas
Sabihin nating nag-e-export ang software ng tindahan mo ng 300 produkto bilang JSON, at humihingi ang marketplace ng XML feed na may root element na pinangalanang catalogue. Babalutin mo ang listahan mo sa object na may iisang key na catalogue, ihuhulog ang file dito at pipindutin ang button. Pagkalipas ng sandali, magda-download ka ng XML na ang root ay catalogue at may hawak na 300 product element, bawat isa ay may id nito bilang attribute dahil isinulat mo ang key bilang @id. I-upload mo ang feed, at tinatanggap ito ng marketplace. Mananatili ang JSON sa folder mo bilang pinagmulan.
Maikling checklist
Bago mag-convert
Tiyaking balido ang JSON. Piliin ang pangalan ng root. Markahan ang mga attribute ng @. Itago ang JSON.
Habang nagko-convert
Manatili sa pahina hanggang handa na ang file.
Pagkatapos mag-convert
Buksan ang XML, suriin ang mga pangalan ng element, mga attribute at mga listahan, at subukan ito sa tatanggap.
Mga karaniwang pagkakamali
Pag-aakalang na-validate ang resulta
Maayos ang pagkakabuo ng XML, hindi sinuri laban sa anumang schema. I-validate ito laban sa mga patakaran ng tatanggap.
Paggamit ng mga key na may espasyo o simbolo
Nagiging item element ang mga ito na may name attribute. Gumamit ng legal na pangalan kung inaasahan ito ng tatanggap.
Pagbura sa JSON
Itago ito. Hawak nito ang mga uring hindi kaya ng XML.
Nananatili sa device mo ang data mo
Lokal na nangyayari ang conversion. Binabasa ng sarili mong browser ang file mo, isinusulat muli roon at ibinabalik bilang XML. Walang ina-upload, kaya walang kopya sa server at walang ibang makakabasa nito. Para sa data na may pribadong nilalaman, iyon ang ligtas na paraan para i-convert ang JSON sa XML.
Buod
Para i-convert ang JSON sa XML dito, ihulog ang file at pindutin ang button. Binabasa at isinusulat ito sa browser mo, kaya hindi kailanman lumalabas sa device mo ang file. Pinananatili ang buong puno. Ang object na may iisang key ay nagpapangalan sa dokumento ayon sa key na iyon, kaya ang XML file na ginawang JSON at ibinalik ay kamukha ng sarili nito; inuulit ng array ang element nito; ang key na nagsisimula sa @ ay nagiging attribute. Anumang JSON key ay maaaring salita; ang pangalan ng XML element ay hindi. Ang key na hindi legal na pangalan ay hindi binabaluktot para maging isa: nagiging item element ito na may name attribute, kaya nasa file pa rin ang orihinal at mahahanap pa rin. Walang namespace, at walang binibigyan ng schema: maayos ang pagkakabuo ng resulta, hindi na-validate.