Comparación de las ventajas y desventajas de XML y JSON

Directorio de artículos

1. XML
2. JSON

1. XML

1. Introducción a XML

XML se refiere al lenguaje de marcado extensible (E X- tensible M arkup L anguage).
XML está diseñado para transmitir y almacenar datos; HTML está diseñado para mostrar datos.
Las etiquetas XML no están predefinidas, debe definir las etiquetas usted mismo.
XML está diseñado para ser autodescriptivo.
XML se utiliza en muchos aspectos del desarrollo web y a menudo se utiliza para simplificar el almacenamiento y el intercambio de datos.
El tipo de archivo del archivo XML es .xml y el tipo MIME del texto es application / xml o text / xml.

2. Sintaxis XML

<?xml version="1.0" encoding="UTF-8"?>
<note>
  <to>Tove</to>
  <from>Jani</from>
  <!-- 这是一个注释 -->
  <heading>Reminder</heading>
  <body>Don't forget me this weekend!</body>
</note>

La declaración XML debe colocarse en la primera línea del documento y es opcional.
El documento XML debe tener un elemento raíz (nota en este ejemplo).
Todos los elementos XML deben tener una etiqueta de cierre (algunos elementos en HTML no tienen que tener una etiqueta de cierre). La declaración no forma parte del documento XML en sí, no tiene etiqueta de cierre.
Las etiquetas XML distinguen entre mayúsculas y minúsculas.
XML debe estar anidado correctamente (a menudo ve elementos que no están anidados correctamente en HTML).
El valor del atributo XML debe estar entre comillas.
XML almacena nuevas líneas en LF.

3. Análisis de XML

Hay dos formas básicas de analizar XML: una se llama SAX y la otra se llama DOM.

SAX (API simple para XML, una interfaz simple para manipular XML)

El orden del archivo xml se analiza paso a paso, moviéndose a través de cada nodo desde el principio del documento para localizar un nodo específico.
Alta eficiencia, alta velocidad, sin presión de memoria.
Solo puede leer, no puede modificar, solo puede acceder secuencialmente, adecuado para analizar XML grande.
A menudo se usa para procesar grandes cantidades de datos en XML, para lograr acceso a datos en sistemas heterogéneos y para lograr multiplataforma.

DOM (Document Object Model) utiliza JAXP (API Java para análisis XML, es decir, API Java para análisis XML)

La conversión de un documento XML en una colección de modelos de objetos (generalmente llamado árbol DOM) se carga en la memoria, lo que consume memoria.
No solo se puede leer, sino que también se puede modificar, también es posible el acceso aleatorio y la velocidad de análisis es lenta.
El archivo XML se crea en la memoria para construir la estructura de atributos, y los nodos se pueden atravesar y modificar.
Generalmente se utiliza para analizar documentos XML pequeños para facilitar la operación.

4. Sección de código

Utilice la clase XMLParser nativa de Apple para el análisis de SAX.

// GET请求
let dataTask = session.dataTask(with: request) {
    
     (data, response, error) in

    if let resultData = data {
    
    
        // 使用XMLParser解析XML数据
        let parser = XMLParser(data: resultData)
        parser.delegate = self
        parser.parse()
    }
}

//MARK: - XMLParserDelegate

// 开始解析
func parserDidStartDocument(_ parser: XMLParser) {
    
    
    NSLog("开始解析\(#function)")
}

// 结束解析
func parserDidEndDocument(_ parser: XMLParser) {
    
    
    NSLog("结束解析\(#function)")
}

// 发现符号声明
func parser(_ parser: XMLParser, foundNotationDeclarationWithName name: String, publicID: String?, systemID: String?) {
    
    
    NSLog("发现符号声明\(#function), name:\(name), publicID:\(String(describing: publicID)), systemID:\(String(describing: systemID))")
}

// 发现未解析实体声明
func parser(_ parser: XMLParser, foundUnparsedEntityDeclarationWithName name: String, publicID: String?, systemID: String?, notationName: String?) {
    
    
    NSLog("发现未解析实体声明\(#function), name:\(name), publicID:\(String(describing: publicID)), systemID:\(String(describing: systemID)), notationName:\(String(describing: notationName))")
}

// 发现属性声明
func parser(_ parser: XMLParser, foundAttributeDeclarationWithName attributeName: String, forElement elementName: String, type: String?, defaultValue: String?) {
    
    
    NSLog("发现属性声明\(#function), attributeName:\(attributeName), elementName:\(elementName), type:\(String(describing: type)), defaultValue:\(String(describing: defaultValue))")
}

// 发现元素声明
func parser(_ parser: XMLParser, foundElementDeclarationWithName elementName: String, model: String) {
    
    
    NSLog("发现元素声明\(#function), elementName:\(elementName), model:\(model)")
}

// 发现内部实体声明
func parser(_ parser: XMLParser, foundInternalEntityDeclarationWithName name: String, value: String?) {
    
    
    NSLog("发现内部实体声明\(#function), name:\(name), value:\(String(describing: value))")
}

// 发现外部实体声明
func parser(_ parser: XMLParser, foundExternalEntityDeclarationWithName name: String, publicID: String?, systemID: String?) {
    
    
    NSLog("发现外部实体声明\(#function), name:\(name), publicID:\(String(describing: publicID)), systemID:\(String(describing: systemID))")
}

// 开始解析元素
func parser(_ parser: XMLParser, didStartElement elementName: String, namespaceURI: String?, qualifiedName qName: String?, attributes attributeDict: [String : String] = [:]) {
    
    
    NSLog("开始解析元素\(#function), \(elementName), elementName:\(elementName), namespaceURI:\(String(describing: namespaceURI)), qualifiedName:\(String(describing: qName)), attributeDict:\(attributeDict)")
}

// 结束解析元素
func parser(_ parser: XMLParser, didEndElement elementName: String, namespaceURI: String?, qualifiedName qName: String?) {
    
    
    NSLog("结束解析元素\(#function), elementName:\(elementName), namespaceURI:\(String(describing: namespaceURI)), qualifiedName:\(String(describing: qName))")
}

// 发现字符
func parser(_ parser: XMLParser, foundCharacters string: String) {
    
    
    NSLog("发现字符\(#function), charecters string\(string)")
}

2. JSON

1. Introducción a JSON

Es decir, JSON J AVA S cript O bject N otation (la notación de objetos JavaScript).
JSON es una sintaxis para almacenar e intercambiar información textual, similar a XML.
JSON es más pequeño, más rápido y más fácil de analizar que XML.
JSON es autodescriptivo y más fácil de entender.
El tipo de archivo del archivo JSON es .json y el tipo MIME del texto es application / json.

2. Sintaxis JSON

{
    "网址": [
    { "name":"百度" , "url":"www.baidu.com" }, 
    { "name":"apple" , "url":"www.apple.com" }, 
    ]
}

Reglas de sintaxis JSON

Los datos están en un par nombre / valor (clave: valor)
Los datos están separados por comas
Las llaves {} guardan el objeto
Los corchetes [] guardan la matriz, la matriz puede contener varios objetos

Valor JSON

Número (entero o punto flotante)
Cadena (entre comillas dobles)
Valor lógico (verdadero o falso)
Matriz (entre corchetes)
Objeto (entre llaves)
nulo

3. Sección de código

3.1 codificación JSON

Un objeto que codifica una instancia del tipo de datos como un objeto JSON.

struct GroceryProduct: Codable {
    
    
    var name: String
    var points: Int
    var description: String?
}

let pear = GroceryProduct(name: "Pear", points: 250, description: "A ripe pear.")

let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted

let data = try encoder.encode(pear)
print(String(data: data, encoding: .utf8)!)

Iniciar sesión:

{
  "name" : "Pear",
  "points" : 250,
  "description" : "A ripe pear."
}

3.2 decodificación JSON

Decodifica del objeto JSON en una instancia del tipo de datos.

struct GroceryProduct: Codable {
    
    
    var name: String
    var points: Int
    var description: String?
}

let json = """
{
    
    
    "name": "Durian",
    "points": 600,
    "description": "A fruit with a distinctive scent."
}
""".data(using: .utf8)!

let decoder = JSONDecoder()
let product = try decoder.decode(GroceryProduct.self, from: json)

print(product.name) // Prints "Durian"

3.3 Conversión entre JSON y Foundation

func json() {
    
    
    
    // 创建swift对象
    let user:[String: Any] = [
        "name": "张三",
        "tel": ["mobile": "131", "home": "0775"]
    ]
    
    // 首先判断能不能转换
    if (!JSONSerialization.isValidJSONObject(user)) {
    
    
        print("is not a valid json object")
        return
    }
    
    // swift对象转换成JSON数据
    let data = try? JSONSerialization.data(withJSONObject: user, options: [])
    // 打印
    let str = String(data:data!, encoding: String.Encoding.utf8)!
    print("JSON: \(str)")
     
    // 把JSON数据转换回swift对象
    let json = try? (JSONSerialization.jsonObject(with: data!, options:.allowFragments) as! [String: Any])
    // 打印
    let name = json?["name"]
    let mobile = (json?["tel"] as! [String: Any])["mobile"]
    let home = (json?["tel"] as! [String: Any])["home"]
    print("swift对象 name: \(name!), mobile: \(mobile!), home: \(home!)")
}