XML 模块

XML解析和序列化模块,提供XML与JavaScript对象之间的相互转换功能。

功能特性

• ✅ XML字符串解析为对象
• ✅ 对象序列化为XML
• ✅ 支持复杂XML结构
• ✅ 自动处理编码
• ✅ 保留XML结构信息

基本使用

解析XML字符串

const xml = require('xml');

// 简单XML解析
const xmlString = `
<?xml version="1.0" encoding="UTF-8"?>
<user>
    <name>John Doe</name>
    <email>john@example.com</email>
    <age>30</age>
</user>
`;

const obj = xml.parse(xmlString);
console.log('解析结果:', obj);
// 输出: { user: { name: 'John Doe', email: 'john@example.com', age: '30' } }

// 访问数据
console.log('姓名:', obj.user.name);
console.log('邮箱:', obj.user.email);

复杂XML结构

const xml = require('xml');

const complexXml = `
<?xml version="1.0"?>
<catalog>
    <book id="bk101">
        <author>Gambardella, Matthew</author>
        <title>XML Developer's Guide</title>
        <price>44.95</price>
    </book>
    <book id="bk102">
        <author>Ralls, Kim</author>
        <title>Midnight Rain</title>
        <price>5.95</price>
    </book>
</catalog>
`;

const catalog = xml.parse(complexXml);
console.log('目录:', catalog);

// 访问书籍信息
if (Array.isArray(catalog.catalog.book)) {
    catalog.catalog.book.forEach(function(book) {
        console.log('书名:', book.title);
        console.log('作者:', book.author);
        console.log('价格:', book.price);
    });
}

处理属性

const xml = require('xml');

const xmlWithAttrs = `
<person id="123" status="active">
    <name>Jane Smith</name>
    <role type="admin">Administrator</role>
</person>
`;

const person = xml.parse(xmlWithAttrs);
console.log('完整对象:', JSON.stringify(person, null, 2));

// XML属性通常会以特殊方式存储（取决于解析器实现）

对象转XML

const xml = require('xml');

// 创建对象
const userData = {
    user: {
        name: 'John Doe',
        email: 'john@example.com',
        age: '30',
        active: 'true'
    }
};

// 转换为XML
const xmlString = xml.stringify(userData);
console.log('生成的XML:', xmlString);

复杂对象转XML

const xml = require('xml');

const catalog = {
    catalog: {
        book: [
            {
                author: 'Gambardella, Matthew',
                title: "XML Developer's Guide",
                price: '44.95'
            },
            {
                author: 'Ralls, Kim',
                title: 'Midnight Rain',
                price: '5.95'
            }
        ]
    }
};

const xmlOutput = xml.stringify(catalog);
console.log('XML输出:', xmlOutput);

API参考

xml.parse(xmlString)

将XML字符串解析为JavaScript对象。

参数：

• xmlString (string): XML格式的字符串

返回值： object - 解析后的JavaScript对象

示例：

const obj = xml.parse('<root><item>value</item></root>');
console.log(obj.root.item); // 'value'

xml.stringify(object)

将JavaScript对象转换为XML字符串。

参数：

• object (object): 要转换的JavaScript对象

返回值： string - XML格式的字符串

示例：

const xmlStr = xml.stringify({ root: { item: 'value' } });
console.log(xmlStr); // '<root><item>value</item></root>'

数据类型处理

文本内容

const xml = require('xml');

// 简单文本
const simple = xml.parse('<message>Hello World</message>');
console.log(simple.message); // 'Hello World'

// 带换行的文本
const multiline = xml.parse(`
<description>
    This is a long
    description with
    multiple lines
</description>
`);
console.log(multiline.description);

数组处理

const xml = require('xml');

// XML中的重复元素会被解析为数组
const xmlList = `
<items>
    <item>Item 1</item>
    <item>Item 2</item>
    <item>Item 3</item>
</items>
`;

const items = xml.parse(xmlList);
console.log('项目列表:', items.items.item);
// 输出: ['Item 1', 'Item 2', 'Item 3']

// 转换回XML
const backToXml = xml.stringify({
    items: {
        item: ['Item 1', 'Item 2', 'Item 3']
    }
});
console.log(backToXml);

嵌套结构

const xml = require('xml');

const nested = `
<company>
    <name>Tech Corp</name>
    <departments>
        <department>
            <name>Engineering</name>
            <employees>
                <employee>
                    <name>Alice</name>
                    <title>Engineer</title>
                </employee>
                <employee>
                    <name>Bob</name>
                    <title>Senior Engineer</title>
                </employee>
            </employees>
        </department>
    </departments>
</company>
`;

const company = xml.parse(nested);
console.log('公司名:', company.company.name);
console.log('部门:', company.company.departments.department.name);

// 访问员工信息
const employees = company.company.departments.department.employees.employee;
if (Array.isArray(employees)) {
    employees.forEach(function(emp) {
        console.log(`${emp.name} - ${emp.title}`);
    });
}

注意事项

1. 编码处理：模块自动处理UTF-8编码，确保XML声明中的编码一致。
2. 属性处理：XML属性的处理方式可能因实现而异。
3. 命名空间：复杂的XML命名空间可能需要特殊处理。
4. 特殊字符：XML特殊字符（<, >, &等）会自动转义。
5. 空元素：空XML元素可能被解析为空字符串或null。
6. 数组识别：单个元素不会自动转换为数组，需要手动检查。

实际应用场景

XML配置文件解析

const xml = require('xml');

function loadConfig(xmlContent) {
    const config = xml.parse(xmlContent);
    
    return {
        host: config.configuration.database.host,
        port: parseInt(config.configuration.database.port),
        username: config.configuration.database.username,
        password: config.configuration.database.password,
        options: config.configuration.database.options
    };
}

const configXml = `
<?xml version="1.0"?>
<configuration>
    <database>
        <host>localhost</host>
        <port>5432</port>
        <username>admin</username>
        <password>secret123</password>
        <options>
            <poolSize>10</poolSize>
            <timeout>30000</timeout>
        </options>
    </database>
</configuration>
`;

const config = loadConfig(configXml);
console.log('数据库配置:', config);

API响应处理

const xml = require('xml');

function parseApiResponse(xmlResponse) {
    const response = xml.parse(xmlResponse);
    
    if (response.response.status === 'success') {
        return {
            success: true,
            data: response.response.data
        };
    } else {
        return {
            success: false,
            error: response.response.error
        };
    }
}

const apiXml = `
<?xml version="1.0"?>
<response>
    <status>success</status>
    <data>
        <id>12345</id>
        <name>Product Name</name>
        <price>99.99</price>
    </data>
</response>
`;

const result = parseApiResponse(apiXml);
if (result.success) {
    console.log('产品信息:', result.data);
}

数据导出为XML

const xml = require('xml');

function exportUsersToXml(users) {
    const xmlData = {
        users: {
            user: users.map(function(u) {
                return {
                    id: u.id.toString(),
                    name: u.name,
                    email: u.email,
                    joined: u.joinDate
                };
            })
        }
    };
    
    return xml.stringify(xmlData);
}

// 示例数据
const users = [
    { id: 1, name: 'Alice', email: 'alice@example.com', joinDate: '2023-01-15' },
    { id: 2, name: 'Bob', email: 'bob@example.com', joinDate: '2023-02-20' },
    { id: 3, name: 'Charlie', email: 'charlie@example.com', joinDate: '2023-03-10' }
];

const xmlExport = exportUsersToXml(users);
console.log('导出的XML:', xmlExport);

XML数据转换

const xml = require('xml');

// XML格式转换器
function convertXmlFormat(inputXml) {
    // 解析输入XML
    const data = xml.parse(inputXml);
    
    // 转换数据结构
    const converted = {
        newFormat: {
            version: '2.0',
            items: []
        }
    };
    
    // 假设原格式有products
    if (data.catalog && data.catalog.product) {
        const products = Array.isArray(data.catalog.product) 
            ? data.catalog.product 
            : [data.catalog.product];
        
        converted.newFormat.items = products.map(function(p) {
            return {
                itemId: p.id,
                itemName: p.name,
                itemPrice: p.price
            };
        });
    }
    
    // 输出新格式XML
    return xml.stringify(converted);
}

const oldFormatXml = `
<catalog>
    <product>
        <id>1</id>
        <name>Widget</name>
        <price>19.99</price>
    </product>
    <product>
        <id>2</id>
        <name>Gadget</name>
        <price>29.99</price>
    </product>
</catalog>
`;

const newFormatXml = convertXmlFormat(oldFormatXml);
console.log('新格式:', newFormatXml);

XML验证和清理

const xml = require('xml');

function validateAndCleanXml(xmlString) {
    try {
        // 解析XML
        const data = xml.parse(xmlString);
        
        // 验证必需字段
        if (!data.record || !data.record.id) {
            throw new Error('缺少必需字段: id');
        }
        
        // 清理数据
        const cleaned = {
            record: {
                id: data.record.id.toString().trim(),
                name: (data.record.name || '').toString().trim(),
                email: (data.record.email || '').toString().trim().toLowerCase()
            }
        };
        
        // 转换回XML
        return {
            valid: true,
            xml: xml.stringify(cleaned)
        };
        
    } catch (error) {
        return {
            valid: false,
            error: error.toString()
        };
    }
}

const inputXml = `
<record>
    <id>  123  </id>
    <name>  John Doe  </name>
    <email>  JOHN@EXAMPLE.COM  </email>
</record>
`;

const result = validateAndCleanXml(inputXml);
if (result.valid) {
    console.log('清理后的XML:', result.xml);
} else {
    console.error('验证失败:', result.error);
}

批量处理XML文件

const xml = require('xml');

function processXmlBatch(xmlStrings) {
    const results = [];
    
    for (let i = 0; i < xmlStrings.length; i++) {
        try {
            const data = xml.parse(xmlStrings[i]);
            results.push({
                index: i,
                success: true,
                data: data
            });
        } catch (error) {
            results.push({
                index: i,
                success: false,
                error: error.toString()
            });
        }
    }
    
    return results;
}

const xmlBatch = [
    '<item><id>1</id><name>Item 1</name></item>',
    '<item><id>2</id><name>Item 2</name></item>',
    '<item><id>3</id><name>Item 3</name></item>'
];

const batchResults = processXmlBatch(xmlBatch);
console.log('处理结果:', batchResults);

// 统计
const successCount = batchResults.filter(r => r.success).length;
console.log(`成功: ${successCount}/${batchResults.length}`);

最佳实践

1. 错误处理：始终使用try-catch包裹解析操作
2. 数据验证：解析后验证数据结构和必需字段
3. 类型检查：检查解析结果是对象还是数组
4. 编码一致：确保XML声明的编码与实际内容一致
5. 特殊字符：处理用户输入时注意XML特殊字符转义
6. 性能考虑：对于大型XML文档，考虑流式处理或分批处理

调试技巧

const xml = require('xml');

// 美化输出以便调试
function debugXml(xmlString) {
    console.log('原始XML:');
    console.log(xmlString);
    console.log('\n解析结果:');
    
    try {
        const obj = xml.parse(xmlString);
        console.log(JSON.stringify(obj, null, 2));
        
        console.log('\n转换回XML:');
        const backToXml = xml.stringify(obj);
        console.log(backToXml);
        
        return obj;
    } catch (error) {
        console.error('解析错误:', error);
        return null;
    }
}

// 使用
debugXml('<root><item>test</item></root>');