تحويل XML إلى JSON: الاصطلاحات والمزالق وأمثلة الكود

تسحب استجابة من نقطة طرفية SOAP، أو من تغذية RSS، أو من ملف sitemap.xml، فتجدها بصيغة XML. لكن مكدّسك يعمل بـ JSON أصالةً: JavaScript في الواجهة الأمامية، وREST في الوسط، ومخزن مستندات في القاع. لذا تحتاج إلى تحويل XML إلى JSON، وتمدّ يدك إلى محلّل متوقعًا أن تكون العملية سطرًا واحدًا.

وغالبًا ما تكون كذلك، حتى يخيّب الناتج توقّعك. مصفوفة توقّعتها تظهر ككائن مفرد. سمة id تتلاشى. رمز بريدي مثل 01234 يعود رقمًا هو 1234. لا شيء من هذا خلل في محلّلك. إنها نتيجة تعيين نموذجي بيانات لا يتطابقان، والسبيل الوحيد لتحويل XML إلى JSON بموثوقية هو فهم الاصطلاحات التي تردم الفجوة بينهما.

يغطّي هذا الدليل سبب وجود تلك الاصطلاحات، وأربع طرق لإجراء التحويل (المتصفح، JavaScript، Python، سطر الأوامر)، وقاعدتي @_ و#text اللتين تشترك فيهما كل المكتبات الكبرى، والمزالق الخمسة التي تسبّب فقدان بيانات صامتًا، وكيفية إعادة تحويل JSON إلى XML لرحلة ذهاب وإياب نظيفة. الأمثلة حقيقية وقابلة للتشغيل، فالصقها في Node أو Python أو في الصدفة لتنتج المخرجات الموضّحة في التعليقات.

لماذا يحتاج تحويل XML إلى JSON إلى اصطلاحات (لا مجرد إعادة تنسيق)

يبدو XML وJSON متشابهين ظاهريًا — كلاهما شجرة من بيانات مسمّاة ومتداخلة — لكن نموذجيهما الأساسيين يتباعدان بطرق ذات أثر. فعناصر XML تستطيع حمل سمات، واحتواء محتوى مختلط (نص متشابك مع عناصر فرعية)، والعيش تحت مساحات أسماء. أما JSON فلا يملك أيًّا من هذه المفاهيم. لديه كائنات ومصفوفات وأربعة أنواع قياسية. تحويل أحدهما إلى الآخر ليس إعادة تنسيق؛ إنه ترجمة بين نموذجين، أحدهما يعبّر عن أشياء لا يستطيع الآخر تمثيلها.

قبل أن تحوّل أي شيء، يجدر بك التأكد من أن المصدر صالح فعلًا. فأي & غير محجوب أو وسم غير متطابق سيُرفَض عند المحلّل، لذا فإن تمرير المُدخل عبر منسّق XML للتحقق من سلامة التكوين أولًا يوفّر عليك جولة من الأخطاء المربكة.

وهنا يفترق النموذجان:

البُعد	XML	JSON
أنواع العقد	عناصر، سمات، نص، محتوى مختلط	كائنات، مصفوفات، نص، رقم، قيمة منطقية، null
قيد الجذر	يلزم عنصر جذر واحد بالضبط	لا قيد على الجذر
السمات	نعم (`id="P01"`)	لا توجد (تحتاج اصطلاح `@_`)
العناصر المتكرّرة	الأشقّاء المتماثلو الاسم مشروعون	مفاتيح الكائن لا يمكن أن تتكرّر (تحتاج اصطلاح مصفوفة)
نظام الأنواع	النص بلا نوع — كل شيء سلسلة نصية	أنواع أصيلة
مساحات الأسماء	نعم (`xmlns`)	لا توجد

ولأن النموذجين لا يتطابقان، فإن كل تحويل من XML إلى JSON مدفوع بالاصطلاحات، لا إعادة تنسيق بلا فقد. والخبر السار أن الاصطلاحات ليست اعتباطية: فـ fast-xml-parser (في Node.js)، وxmltodict (في Python)، وJAXB (في Java) كلها التقت على العلامتين نفسيهما — @_ للسمات، و#text لنص المحتوى المختلط. تعلّمها مرة واحدة فتنتقل معك عبر أزمنة التشغيل. وهذا هو السبب نفسه وراء ظهور عدم تطابق أشكال البيانات في تحويلات أخرى أيضًا، مثل أسئلة استدلال الأنواع في دليل تحويل CSV إلى JSON.

كيفية تحويل XML إلى JSON: 4 طرق

اختر الطريقة التي تناسب سياقك: لصق سريع لمرة واحدة، أو خدمة Node، أو خط معالجة Python، أو سكربت صدفة في التكامل المستمر.

الطريقة 1 — أداة قائمة على المتصفح (بلا إعداد، الخصوصية أولًا)

للتحويل العابر مرة واحدة، أو لـ XML تفضّل ألّا تلصقه في موقع عشوائي، تكون الأداة العاملة داخل المتصفح أسرع مسار. الصق XML في محوّل XML إلى JSON، فيظهر JSON فورًا — بلا تثبيت، بلا حساب، بلا رفع. كل شيء يعمل داخل محرك JavaScript في متصفحك، فلا تغادر البيانات الجهاز.

تلك التفصيلة الأخيرة أهم مما تبدو. فأغلفة SOAP تحمل رموز WS-Security، والإعدادات الداخلية تحمل سلاسل اتصال، والصادرات تحمل سجلات عملاء. ولأن لا شيء يُنقَل، فإن الأداة آمنة لـ XML الذي يحتوي على بيانات اعتماد أو حمولات حسّاسة. ويمكنك التأكد بنفسك: افتح تبويب الشبكة وراقب صفر طلب يُطلَق أثناء التحويل.

الطريقة 2 — JavaScript / Node.js (fast-xml-parser)

في Node، يُعدّ fast-xml-parser الخيار المعياري. غير أن إعداداته الافتراضية ستفاجئك — إذ تُتجاهَل السمات وتُقحَم القيم في أنواع — لذا فإن الخيارات أدناه هي ما تريده فعلًا لتحويل أمين:

// تحويل XML إلى JSON في Node.js باستخدام fast-xml-parser
import { XMLParser } from 'fast-xml-parser';

const xml = `<catalog>
  <product id="P01">
    <name>Wireless Headphones</name>
    <price currency="USD">79.99</price>
  </product>
</catalog>`;

const parser = new XMLParser({
  ignoreAttributes: false,    // أبقِ السمات (الافتراضي يُسقطها!)
  attributeNamePrefix: '@_',  // تصبح السمات مفاتيح ببادئة @_
  textNodeName: '#text',      // نص المحتوى المختلط يذهب تحت #text
  parseAttributeValue: false, // لا إقحام أنواع على السمات
  parseTagValue: false,       // لا إقحام أنواع على نص العنصر
});

const result = parser.parse(xml);
console.log(JSON.stringify(result, null, 2));
// {
//   "catalog": {
//     "product": {
//       "@_id": "P01",
//       "name": "Wireless Headphones",
//       "price": {
//         "@_currency": "USD",
//         "#text": "79.99"
//       }
//     }
//   }
// }

الإعدادان اللذان ينساهما الناس هما ignoreAttributes: false وparseTagValue: false. الأول يُبقي سمتي id وcurrency؛ والثاني يمنع المحلّل من تحويل "79.99" إلى عدد عشري، و"01234" إلى 1234. وسنعود إلى سبب كون الحفاظ على النص هو الافتراضي الآمن في قسم المزالق.

إن أردت صفر اعتمادية في المتصفح، فإن DOMParser الأصلي يقوم بالتحليل نيابة عنك، وتتجوّل أنت في DOM بنفسك:

// تحويل XML إلى JSON بصفر اعتمادية في المتصفح باستخدام DOMParser
function xmlToJson(node) {
  // عنصر نصّي فقط ← قيمة نصية
  const children = Array.from(node.children);
  if (children.length === 0 && node.attributes.length === 0) {
    return node.textContent.trim();
  }

  const obj = {};
  // السمات ← بادئة @_
  for (const attr of node.attributes) {
    obj['@_' + attr.name] = attr.value;
  }
  // عنصر بسمات ونص معًا ← #text
  if (children.length === 0) {
    obj['#text'] = node.textContent.trim();
    return obj;
  }
  // التكرار داخل الأبناء، وجمع الأشقّاء المتماثلي الاسم في مصفوفات
  for (const child of children) {
    const value = xmlToJson(child);
    if (obj[child.tagName] === undefined) {
      obj[child.tagName] = value;
    } else {
      if (!Array.isArray(obj[child.tagName])) obj[child.tagName] = [obj[child.tagName]];
      obj[child.tagName].push(value);
    }
  }
  return obj;
}

const doc = new DOMParser().parseFromString(
  '<catalog><product id="P01"><name>Wireless Headphones</name></product></catalog>',
  'text/xml'
);
const json = { [doc.documentElement.tagName]: xmlToJson(doc.documentElement) };
console.log(JSON.stringify(json, null, 2));
// { "catalog": { "product": { "@_id": "P01", "name": "Wireless Headphones" } } }

إن DOMParser متوافق مع XML 1.0، ويتعامل مع CDATA ومراجع الكيانات، ويُبلّغ عن أخطاء سلامة التكوين — كل ذلك بلا تثبيت أي حزمة. والمقايضة أنك تملك منطق التجوّل، بما في ذلك قاعدة جمع المصفوفات الموضّحة أعلاه.

الطريقة 3 — Python (xmltodict)

في Python، يطوي xmltodict المهمة كلها في خط معالجة قصير. وهو يستخدم @ بادئةً لسماته و#text للمحتوى المختلط افتراضيًا:

# تحويل XML إلى JSON في Python باستخدام xmltodict
import json
import xmltodict

xml = """<catalog>
  <product id="P01">
    <name>Wireless Headphones</name>
    <price currency="USD">79.99</price>
  </product>
</catalog>"""

data = xmltodict.parse(xml)
print(json.dumps(data, indent=2))
# {
#   "catalog": {
#     "product": {
#       "@id": "P01",
#       "name": "Wireless Headphones",
#       "price": {
#         "@currency": "USD",
#         "#text": "79.99"
#       }
#     }
#   }
# }

افتراضيًا يُبقي xmltodict كل قيمة سلسلةً نصية، وهو السلوك الذي تريده. والخيار الوحيد الجدير بمعرفته مسبقًا هو force_list، الذي يصلح مشكلة المفرد مقابل المتعدّد قبل أن تصل إلى كودك:

# force_list يضمن أن <product> دائمًا قائمة، حتى عند وجود واحد فقط
data = xmltodict.parse(xml, force_list={'product'})
products = data['catalog']['product']  # قائمة دائمًا الآن
for p in products:
    print(p['name'])

بدون force_list، يُنتج <product> واحد قاموسًا، واثنان يُنتجان قائمة — فتتعطّل حلقتك في حالة العنصر المفرد. وهذا هو المزلق رقم 1، الذي نتناوله أدناه.

الطريقة 4 — سطر الأوامر (yq / سطر Python واحد)

لسكربتات الصدفة وخطوط التكامل المستمر، يغطّي سطران مفردان معظم الحالات. فأداة yq لـ Mike Farah تقرأ XML وتصدر JSON مباشرة:

# باستخدام yq (نسخة Go من Mike Farah)
yq -p=xml -o=json '.' input.xml

# التمرير من stdin
cat sitemap.xml | yq -p=xml -o=json '.'

إن كان xmltodict موجودًا في بيئتك سلفًا، فإن سطر Python الواحد لا يحتاج أي ثنائي إضافي:

python3 -c "import sys, xmltodict, json; print(json.dumps(xmltodict.parse(sys.stdin.read()), indent=2))" < input.xml

كلاهما يتدفّق من stdin، فيندرجان مباشرة في خط معالجة — وهو مفيد لتحويل استجابة API في منتصف سكربت أو لتطبيع دفعة من الملفات في خطوة بناء.

شرح اصطلاحَي السمة @_ والنص #text

تتجاوز معظم صفحات المحوّلات الجزء الذي يهمّ فعلًا: ماذا تعني مفاتيح @_ و#text الغريبة ولماذا توجد. وحين تتقن هاتين القاعدتين يتوقّف الناتج عن أن يبدو اعتباطيًا.

السمات تُعيَّن إلى مفاتيح ببادئة @_. ليس للسمة مكافئ في JSON — فلا توجد خانة في الكائن لـ«بيانات وصفية عن هذا الكائن» متمايزة عن الابن. والاصطلاح هو منح السمات مفتاحًا ببادئة @_:

<user id="42" role="admin"/>
→ { "user": { "@_id": "42", "@_role": "admin" } }

ولماذا @_ تحديدًا؟ لأن لا اسم عنصر XML صالح يمكن أن يبدأ بـ @، فلا يمكن أن تتصادم البادئة أبدًا مع مفتاح عنصر فرعي حقيقي. إنها بادئة محجوزة بحكم قواعد XML نفسها. (xmltodict يستخدم @ مجرّدة؛ وfast-xml-parser يستخدم @_ افتراضيًا. والمبدأ متطابق.)

المحتوى المختلط يُعيَّن إلى #text. عندما يحمل عنصر سمةً وقيمة نصية معًا، يحتاج النص إلى مكان يعيش فيه إلى جانب مفاتيح السمات. وذلك هو #text:

<price currency="USD">29.99</price>
→ { "price": { "@_currency": "USD", "#text": "29.99" } }

عناصر النص الصرف تصبح قيمة نصية مباشرة. لا سمات، لا أبناء، مجرد نص — فلا حاجة إلى الالتفاف عبر #text. فـ <name>Alice</name> يصبح "name": "Alice". ولا يظهر مفتاح #text إلا حين تُجبر السمات قيمة العنصر على أن تكون كائنًا.

هذا اللاتماثل مصدر خلل خفيّ. فاسم العنصر نفسه قد يُنتج سلسلة نصية صرفة في مستند، وكائن @_/#text في آخر، تبعًا لما إذا كانت تلك النسخة بعينها قد حملت سمة. فـ <price> بلا سمة currency هو السلسلة "29.99"؛ ونفس <price currency="USD"> هو { "@_currency": "USD", "#text": "29.99" }. والكود الذي يقرأ node.price مباشرة يعمل لشكل واحد وينكسر بصمت على الآخر. والوصول الدفاعي هو فحص النوع: const amount = typeof node.price === 'object' ? node.price['#text'] : node.price;.

CDATA تصبح محتوى نصيًّا صرفًا. فقسم <![CDATA[if (a < b) return;]]> مجرّد آلية حجب، فتُجرَّد المحدّدات ويُحفَظ النص الداخلي: "if (a < b) return;". لا شيء خاص ينجو إلى JSON.

بمجرد أن يصبح لديك ناتج، الصقه في منسق JSON للتحقق من صحة مخرجات JSON والتأكد من أن البنية تطابق ما يتوقّعه مستهلِكك قبل أن توصلها بالكود.

5 مزالق في تحويل XML إلى JSON وكيف تتجنّبها

هذه هي الإخفاقات التي تتسلّل عبر مراجعة الكود وتظهر في الإنتاج. وكل واحد منها يعود إلى عدم تطابق النموذج من بداية هذا الدليل.

1. غموض المصفوفة (واحد مقابل كثير). يصبح <item> المفرد كائنًا؛ واثنان أو أكثر يصبحان مصفوفة. ويعتمد شكل JSON على عدد الأشقّاء الذين تصادف وجودهم في ذلك المستند بعينه. وكود المستهلك مثل result.items.item.forEach(...) يعمل أثناء الاختبار — حيث تحمل بياناتك التجريبية ثلاثة عناصر — ويرمي TypeError: not a function في الإنتاج حين يحمل سجلّ عنصرًا واحدًا بالضبط.

// شقيقا <book> ← مصفوفة
// <library><book>A</book><book>B</book></library>
// → { "library": { "book": ["A", "B"] } }

// <book> واحد ← كائن، وليس مصفوفة
// <library><book>A</book></library>
// → { "library": { "book": "A" } }

// طبّع الناتج كي تتصرّف الحالتان بصورة متطابقة
const books = [].concat(result.library?.book ?? []);
books.forEach(b => console.log(b)); // آمن لـ 0 أو 1 أو كثير

يستحق نمط [].concat(x ?? []) الحفظ: فالقيمة المفقودة تصبح []، والكائن المفرد يصبح [object]، والمصفوفة الموجودة تمرّ دون تغيير. وفي Python، مرّر force_list={'book'} إلى xmltodict.parse() فتكون القيمة دائمًا قائمة، وتتخطّى التطبيع كليًّا.

2. إسقاط السمات بصمت. تتجاهل عدة مكتبات السمات افتراضيًا — وfast-xml-parser يفعل ذلك بالضبط حتى تضبط ignoreAttributes: false. يبدو التحويل كأنه نجح، ويُحلَّل JSON على ما يرام، وقيم id وcurrency وstatus ببساطة قد ذهبت. اضبط العلَم صراحةً دائمًا بدل الوثوق بالافتراضي.

3. تسطيح مساحات الأسماء. يصبح إعلان xmlns مفتاحًا عاديًّا هو @_xmlns، والبادئة في <soap:Body> تنجو فقط كجزء من مفتاح السلسلة "soap:Body". أما الدلالات — أن بادئتين قد ترتبطان بنفس عنوان URI — فتضيع.

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Body>...</soap:Body>
</soap:Envelope>
→ {
    "soap:Envelope": {
      "@_xmlns:soap": "http://schemas.xmlsoap.org/soap/envelope/",
      "soap:Body": "..."
    }
  }

أصبحت البادئة soap: الآن مجرد نص في اسم مفتاح؛ لا شيء يدرك أنها مساحة أسماء. وإن تشارك عنصران من مساحتي أسماء مختلفتين اسمًا محليًّا، فقد يتصادمان. حين تكون المعالجة الدقيقة لمساحات الأسماء جزءًا من المتطلّب، أبقِ البيانات في محلّل واعٍ بمساحات الأسماء ولا تسطّحها إلى JSON أصلًا.

4. لا إقحام للأنواع — وهذا صواب. يجب ألّا يصبح <zip>01234</zip> هو 1234. فرموز الحسابات، والرموز البريدية، والمعرّفات المبطّنة، والأعشار الحسّاسة للدقّة، كلها تنكسر تحت الإقحام الصامت. والمحوّل الجيّد يُبقي كل شيء سلسلةً نصية ويدعك تُقحم النوع عمدًا:

// لا تعتمد على الإقحام الضمني
if (config.timeout > 25) { /* هشّ: "30" > 25 يصادف أن يعمل */ }

// أقحِم النوع صراحةً، فقط حيث تعرف النوع
if (parseInt(config.timeout, 10) > 25) { /* آمن */ }

5. مع الفقد: التعليقات وتعليمات المعالجة وترتيب المحتوى المختلط. تعليقات XML () وتعليمات المعالجة (<?xml-stylesheet ?>) لا مأوى لها في JSON فتُهمَل. والترتيب النسبي للنص المتشابك مع العناصر الفرعية قد لا يصمد في رحلة الذهاب والإياب. إن احتجت إلى حفظ كل بايت — لإعادة إصدار المستند المصدري بعينه — فلا تحوّل أصلًا؛ استخدم منسّق XML لإعادة التنسيق أو التصغير دون المساس بنموذج البيانات.

إعادة تحويل JSON إلى XML (الذهاب والإياب)

للاتجاه المعاكس التواؤه الخاص، لأن JSON ليس له قاعدة عنصر جذر، وXML يتطلّب واحدًا بالضبط. ويطبّق محوّل JSON إلى XML الرفيق اصطلاحَي @_/#text نفسيهما بالعكس، فرحلة JSON ← XML ← JSON تحفظ السمات والنص والبنية.

الجزء المثير هو تطبيع الجذر. فالمحوّل يحلّ متطلّب الجذر الواحد بأربع قواعد:

كائن بمفتاح واحد ← ذلك المفتاح يصبح الجذر: { "config": {...} } ← <config>...</config>.
كائن بمفاتيح متعدّدة ← يُلَفّ في <root>: { "a": 1, "b": 2 } ← <root><a>1</a><b>2</b></root>.
مصفوفة في المستوى الأعلى ← تُلَفّ كـ <root><item>...</item></root>، مع <item> اسمًا احتياطيًّا ثابتًا.
قيمة بدائية ← <root>value</root>.

وكل ما عدا ذلك يعكس الاتجاه الأمامي. فمفاتيح @_ تصبح سمات، و#text يصبح محتوى نصيًّا، ومصفوفة JSON تحت مفتاح تُنتج أشقّاء متكرّرين متماثلي الاسم — يُعاد استخدام اسم المفتاح، ولا يُفرَد أبدًا:

// تحويل JSON إلى XML في Node.js باستخدام fast-xml-parser
import { XMLBuilder } from 'fast-xml-parser';

const data = {
  catalog: {
    product: {
      '@_id': 'P01',
      name: 'Wireless Headphones',
      price: { '@_currency': 'USD', '#text': '79.99' },
    },
  },
};

const builder = new XMLBuilder({
  attributeNamePrefix: '@_', // مفاتيح @_ تصبح سمات
  textNodeName: '#text',     // مفتاح #text يصبح محتوى نصيًّا
  ignoreAttributes: false,   // عالِج مفاتيح @_
  format: true,              // طباعة أنيقة
});

console.log(builder.build(data));
// <catalog>
//   <product id="P01">
//     <name>Wireless Headphones</name>
//     <price currency="USD">79.99</price>
//   </product>
// </catalog>

تفصيلة واحدة يتولّاها الباني عنك: المحارف الخاصة في النص وقيم السمات (<، >، &، ") تُحجَب إلى مراجع كياناتها، فيبقى الناتج سليم التكوين.

الأسئلة الشائعة

كيف تُعيَّن سمات XML إلى JSON؟

تصبح السمات مفاتيح ببادئة @_، فـ id="42" يتحوّل إلى "@_id": "42". وهذا هو الاصطلاح المشترك بين fast-xml-parser وxmltodict، ولا تتصادم البادئة أبدًا مع أسماء العناصر لأن لا اسم عنصر صالح يبدأ بـ @.

لماذا يُبقي تحويل XML إلى JSON الأرقام سلاسل نصية؟

لأن المحوّل لا يُقحم الأنواع. فإجبار 01234 على أن يصير 1234 سيُسقط صفرًا بادئًا ذا معنى من الرموز البريدية وأرقام الحسابات والمعرّفات المبطّنة. والإبقاء على كل قيمة سلسلةً نصية هو الافتراضي الآمن؛ أقحِم النوع عمدًا في الأسفل حيث تعرف النوع.

هل تحويل XML إلى JSON بلا فقد؟

لا. فالتعليقات وتعليمات المعالجة تُهمَل، ودلالات مساحات الأسماء تُحفَظ جزئيًّا فقط، وترتيب المحتوى المختلط قد لا يصمد في رحلة الذهاب والإياب. وحين تحتاج إلى حفظ كل بايت، استخدم منسّق XML لإعادة تنسيق XML بدل تحويله إلى JSON.

كيف تُعالَج عناصر XML المتكرّرة في JSON؟

الابن المفرد المتماثل الاسم يصبح كائنًا؛ واثنان أو أكثر يصبحان مصفوفة. ولأن الشكل يعتمد على عدد الأشقّاء، يجب أن يطبّع كود مستهلِكك دائمًا إلى مصفوفة كي يتعامل مع حالتي العنصر الواحد والعناصر الكثيرة دون أن يتعطّل.

ماذا يحدث لمساحات أسماء XML عند التحويل إلى JSON؟

يصبح إعلان xmlns مفتاحًا عاديًّا هو @_xmlns، وتبقى البادئة داخل سلسلة اسم العنصر، كما في "soap:Body". ولا يُفسَّر الارتباط الدلالي للبادئة بعنوان URI، فقد تتسطّح مساحات أسماء متمايزة معًا.

كيف أعيد تحويل JSON إلى XML؟

استخدم محوّل JSON إلى XML الرفيق. فهو يطبّق اصطلاحَي @_ و#text نفسيهما بالعكس، فتُعاد تعيين السمات والمحتوى النصي والمصفوفات بصورة متماثلة. وهذا التماثل هو ما يجعل رحلة JSON ← XML ← JSON النظيفة ممكنة.

هل يمكنني تحويل XML بعناصر جذر متعدّدة؟

لا. فالعناصر المتعدّدة في المستوى الأعلى ليست XML سليم التكوين، فيرفض المحلّل المُدخل. لُفّ الشظايا في عنصر جذر واحد أولًا — حوّل <a/><b/> إلى <root><a/><b/></root> — ثم حوّل.

الخاتمة

تحويل XML إلى JSON مدفوع بالاصطلاحات، لا إعادة تنسيق. والقواعد ثابتة عبر أزمنة التشغيل: السمات تُعيَّن إلى مفاتيح @_، ونص المحتوى المختلط إلى #text، والأشقّاء المتكرّرون إلى مصفوفات، والقيم تبقى سلاسل نصية كي تنجو الأصفار البادئة والدقّة. والفخاخ التي يجب تذكّرها هي انزياح الشكل بين المفرد والمصفوفة، وإسقاط السمات بصمت، وفقدان التعليقات ودلالات مساحات الأسماء — ولا شيء منها خلل، وكلها متوقّعة بمجرد أن تعرف عدم تطابق النموذج الكامن خلفها.

حين تحتاج إلى تحويل سريع وخاص، الصق في محوّل XML إلى JSON — فهو يعمل كليًّا داخل متصفحك. تحقّق من المصدر أولًا بـ منسّق XML، واذهب في الاتجاه المعاكس بـ محوّل JSON إلى XML حين تحتاج إلى XML ذهابًا وإيابًا. ولمزيد عن كيف تشكّل نماذج صيغ البيانات سلوك التحويل، طالِع الملاحظات حول الفروق بين YAML وJSON.

تحويل XML إلى JSON: الاصطلاحات والمزالق وأمثلة الكود

تحويل XML إلى JSON: الاصطلاحات والمزالق وأمثلة الكود

لماذا يحتاج تحويل XML إلى JSON إلى اصطلاحات (لا مجرد إعادة تنسيق)

كيفية تحويل XML إلى JSON: 4 طرق

الطريقة 1 — أداة قائمة على المتصفح (بلا إعداد، الخصوصية أولًا)

الطريقة 2 — JavaScript / Node.js (fast-xml-parser)

الطريقة 3 — Python (xmltodict)

الطريقة 4 — سطر الأوامر (yq / سطر Python واحد)

شرح اصطلاحَي السمة @_ والنص #text

5 مزالق في تحويل XML إلى JSON وكيف تتجنّبها

إعادة تحويل JSON إلى XML (الذهاب والإياب)

الأسئلة الشائعة

كيف تُعيَّن سمات XML إلى JSON؟

لماذا يُبقي تحويل XML إلى JSON الأرقام سلاسل نصية؟

هل تحويل XML إلى JSON بلا فقد؟

كيف تُعالَج عناصر XML المتكرّرة في JSON؟

ماذا يحدث لمساحات أسماء XML عند التحويل إلى JSON؟

كيف أعيد تحويل JSON إلى XML؟

هل يمكنني تحويل XML بعناصر جذر متعدّدة؟

الخاتمة

مقالات ذات صلة

ما هو Lorem Ipsum؟ المعنى والأصل وكيفية استخدام النص النائب

تحويل JSON إلى TypeScript: توليد الواجهات والأنواع (دليل 2026)

شرح فضاء ألوان OKLCH — لماذا اعتمدته Tailwind v4