§

Mag-paste ng XML

§

Mga Opsyon

Mode
Indent
XML declaration
Mga self-closing void tag
§

Na-format na output

xml

Ang XML formatting ay mahalaga sa Pilipinas sa maraming sitwasyon: ang mga Philippine ecommerce platform tulad ng Lazada PH at Shopee ay gumagamit ng XML-based na RSS feed para sa mga produkto at promosyon; ang mga SOAP web service ng ilang Philippine government agency tulad ng BIR at SSS ay nagpapalitan ng mga XML payload; at ang mga developer na nagtatrabaho sa mga HL7 FHIR na rekord ng pasyente para sa mga ospital na PhilHealth-accredited ay regular na nangangailangan ng pretty-printed na XML para sa pag-debug. Ang mga developer na gumagawang CI/CD pipeline sa GitHub Actions o GitLab CI ay madalas na nag-iinspect ng mga Maven POM file at Gradle XML build script sa mga pull request, kung saan ang malinis na indentation ay nagpapabilis ng code review.

// Mga Kaugnay na Tool

./json-formatter
JSON Formatter
Mag-format, mag-validate, at mag-minify ng JSON sa iyong browser.
→
./json-minifier
JSON Minifier
Mag-minify ng JSON at iulat ang byte savings sa iyong browser.
→
./url-encoder
URL Encoder
Percent-encode ng mga string para sa ligtas na transportasyon sa mga URL.
→
./
Lahat ng Tool
I-browse ang buong koleksyon ng mga online tool ng Ultim8Soft.
→

Ano ang XML formatting?

XML (Extensible Markup Language) ay isang W3C-standardised na text format para sa mga structured na dokumento at pagpapalitan ng data. Ang formatting — tinatawag din na pretty-printing o beautifying — ay kumukuha ng isang well-formed na XML source at muling ino-indent ito para ang bawat element, attribute, comment, processing instruction, at CDATA section ay madaling i-scan. Ang parsed na document tree ay nananatiling buo; ang inter-element na whitespace lamang ang nagbabago.

Paano gumagana ang XML formatting?

Ang iyong input ay pinoproseso nang buo sa iyong browser gamit ang native na DOMParser at XMLSerializer API kasama ang isang custom na recursive indenter. Ang mga high-level na hakbang ay:

  1. Ang iyong input ay binabasa nang verbatim mula sa textarea — ang bawat byte na na-paste mo ay napanatili sa memory nang lokal.
  2. Pina-parse ito ng browser gamit ang new DOMParser().parseFromString(text, 'application/xml'). Kung ang input ay hindi well-formed, nag-i-embed ang parser ng isang <parsererror> node na ang text payload ay nagdadala ng line at column hint ng engine — ipinapakita ang mga ito nang verbatim sa error strip.
  3. Sa isang matagumpay na parse, ang isang custom indenter ay lumalakad sa DOM tree nang depth-first, inilalabas ang bawat element, attribute set, CDATA section, comment, at processing instruction sa sariling linya sa kasalukuyang lalim. Ang mga self-closing void tag ay iginagalang kapag naka-on ang opsyon.
  4. Ang minify mode ay binabago ang pipeline: ang XMLSerializer().serializeToString(doc) ay naglalabas ng single-line na form, pagkatapos ang isang guarded regex ay nag-aalis ng inter-element na whitespace nang hindi hinahawakan ang teksto sa loob ng mga CDATA block o mga non-whitespace text node.
  5. Ang output ay isinusulat sa readonly na textarea, ang error strip ay nililinis, at ang Download button ay nagbabalot ng resulta bilang isang .xml na file na maaari mong ipadala o ilakip sa isang ticket.

Bakit pretty-print ang XML gamit ang tool na ito?

  • Privacy: ang bawat pass ng pag-parse, pag-format, at pag-minify ay nangyayari sa iyong browser. Ang XML ay hindi kailanman umaabot sa aming mga server — walang upload, walang telemetry, walang account.
  • Tumpak na mga error: kapag ang input ay malformed, inilalabas ng parser ang eksaktong linya at column na iniuulat ng browser engine mismo, hindi isang synthetic na hula — ang parehong mga numero na makikita mo sa DevTools.
  • Tapat na round-trip: mag-format pagkatapos ay i-minify at makukuha mo ang byte-equivalent ng iyong orihinal na dokumento (maliban sa XML declaration na opsyon) — ang formatting ay hindi muling nag-canonicalise ng mga namespace o nagsusulat muli ng pagkakasunod ng attribute.
  • Mabilis: ang purong DOMParser kasama ang isang ~60-linya na indenter ay humahawak ng multi-megabyte na mga SOAP envelope at OOXML chunk nang agad, nang walang panlabas na library na ida-download.

Ano ang mga karaniwang aplikasyon ng XML formatting?

Lumalabas ang pretty-printing ng XML sa web publishing, enterprise integration, at data archival:

  • Pag-inspeksyon ng RSS / Atom feed: mag-paste ng podcast o katawan ng news feed para kumpirmahin ang channel metadata, pagkakasunod ng item, at mga namespace prefix bago mag-publish.
  • Pag-debug ng SOAP: i-format ang isang envelope na kinopya mula sa Wireshark o isang SOAP client log para ang mga seksyon ng Header, Body, at Fault ay makita nang isang tingin.
  • Pag-audit ng sitemap: muling i-indent ang isang sitemap.xml na kinuha mula sa isang kakumpitensya o sa iyong sariling staging site para mabilang ang mga entry at kumpirmahin ang mga hreflang alternate bawat URL.

Ano ang hitsura ng isang halimbawa ng XML formatting?

Ang pag-paste ng isang 3-element na <feed><entry><title>Hello</title></entry></feed> at pagpindot ng I-format gamit ang 2-espasyong indent na opsyon ay nagbubunga ng isang apat na-linya na dokumento na ang bawat element ay nasa sariling linya, naka-indent ayon sa lalim. Ang paglipat sa Minify sa parehong input ay binubulusok ito pabalik sa orihinal na byte-string. Ang round-tripping ay walang pagkawala para sa anumang well-formed na dokumento.

Tumatakbo ba ito nang offline?

Oo. Ang format at minify pipeline ay purong DOMParser + XMLSerializer kasama ang isang maliit na recursive indenter, lahat ay tumatakbo sa loob ng browser tab. Walang na-upload, walang service worker ang nagpo-proxy ng iyong input, at ang page ay gumagawa ng zero network request para sa format step mismo. Ang tanging panlabas na trapiko ay ang standard na mga page-load asset (CSS, font, analytics) — ang iyong XML ay hindi kailanman umaabot sa Ultim8Soft.

Nagbabago ba ng dokumento ang formatting?

Walang semantic na pagbabago. Ang formatting ay nagsusulat lamang ng whitespace sa pagitan ng mga element. Ang mga pangalan ng element, halaga ng attribute, text content, mga CDATA payload, comment, at processing instruction ay napanatili nang byte-for-byte. Ang mga namespace declaration at prefix ay iniingatan nang eksaktong tulad ng isinulat ng input — hindi muling nag-canonicalise o nagsusunod-sunod ng attribute ang formatter. Ang output ay nagpa-parse sa parehong DOM tree tulad ng input, maliban sa opsyonal na XML declaration toggle.

Paano hinahawakan ang CDATA / comment / processing instruction?

Ang bawat isa ay inilalabas nang verbatim sa sariling linya sa kasalukuyang lalim ng indent. Ang mga CDATA payload ay nakabalot sa <![CDATA[…]]> nang walang muling pag-indent sa loob — sinasabi ng spec na ang CDATA content ay opaque, kaya hindi ito kailanman hinahawakan ng formatter. Ang mga comment ay gumagamit ng <!-- … -->; ang mga processing instruction ay gumagamit ng <?target data?>. Ang lahat ng tatlo ay nakakaligtas sa isang format → minify → format round-trip na buo ang nilalaman.

Ano ang pagkakaiba sa pagitan ng formatting at minifying ng XML?

Pinapalawak ng formatting ang whitespace para mabasa ng mga tao ang document tree; inaalis ito ng minifying para sa pagdadala at pag-iimbak. Parehong gumagana sa parsed na DOM, hindi sa raw na byte string, kaya ang isang round-trip na format → minify sa isang well-formed na dokumento ay nagbubunga ng byte-equivalent ng orihinal na minified na form. Gamitin ang format direction kapag kailangan mong basahin o mag-diff ng XML payload, at ang minify direction kapag gusto mong ipadala ito sa isang metered API gateway o i-embed ito sa loob ng isa pang dokumento.

Ang XML formatter na ito ay gumagamit ng parehong parser na ginagamit ng iyong browser para sa mga AJAX XHR response at SVG document, kaya ang anumang well-formed na XML — RSS, Atom, SOAP, sitemap, OOXML, SVG — ay nagra-round-trip nang malinis. Mag-paste ng anumang XML sa itaas, kopyahin ang output, o i-download ito bilang .xml.