精华内容
下载资源
问答
  • json快速入门

    2018-05-02 16:19:56
    一、 什么是json 1. 是一种与开发语言无关的、轻量级的数据格式。全称JavaScript object notation 2. 优点:易与人的阅读和编写,易于程序解析与生产
  • JSON快速入门

    千次阅读 2014-01-27 23:17:34
    一、json是什么? JavaScript Object Notation 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。它基于JavaScript Programming Language , Standard ECMA-262 3rd Edition - December ...
    一、json是什么?
    JavaScript Object Notation 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。它基于JavaScript Programming Language , Standard ECMA-262 3rd Edition - December 1999 的一个子集。 JSON采用完全独立于语言的文本格式,但是也使用了类似于C语言家族的习惯(包括C, C++, C#, Java, JavaScript, Perl, Python等)。这些特性使JSON成为理想的数据交换语言。

     二、xml与json比较:
    xml:
        优点:
        (1).xml是一种通用的数据格式
        (2).不必把数据强加到已经定义好的格式中,而是要为数据自定义合适的标记
        (3).可以利用dom完全掌控文档
        缺点:
        (1).如果文档来自服务器,就必须保证文档含有正确的首部信息。若文档类型不正确,那么responseXML的值将为空。
        (2).当浏览器接收到长的xml文件后,dom解析可能会很复杂。
        (3)服务器端和客户端都需要花费大量代码来解析XML,导致服务器端和客户端代码变得异常复杂且不易维护;
    json:
           优点:

    (1)数据格式比较简单,易于读写,格式都是压缩的,占用带宽小;

    (2)易于解析,客户端JavaScript可以简单的通过eval_r()进行JSON数据的读取;

    (3)支持多种语言,包括ActionScript, C, C#, ColdFusion, Java, JavaScript, Perl, PHP, Python, Ruby等服务器端语言,便于服务器端的解析;

    (4)在PHP世界,已经有PHP-JSONJSON-PHP出现了,偏于PHP序列化后的程序直接调用,PHP服务器端的对象、数组等能直接生成JSON格式,便于客户端的访问提取;

    (5)因为JSON格式能直接为服务器端代码使用,大大简化了服务器端和客户端的代码开发量,且完成任务不变,并且易于维护。

    缺点:

    (1)没有XML格式这么推广的深入人心和喜用广泛,没有XML那么通用性;

    (2)JSON格式目前在Web Service中推广还属于初级阶段

    比较:

    (1)在可读性方面,JSONXML的数据可读性基本相同。JSONXML的可读性可谓不相上下,一边是建议的语法,一边是规范的标签形式,很难分出胜负。

    (2)在可扩展性方面,XML天生有很好的扩展性,JSON当然也有,没有什么是XML能扩展,JSON不能的。

    (3)在编码难度方面,XML有丰富的编码工具,比如Dom4jJDom等,JSON也有json.org提供的工具,但是JSON的编码明显比XML容易许多,即使不借助工具也能写出JSON的代码,可是要写好XML就不太容易了。

    (4)在解码难度方面,XML的解析得考虑子节点父节点,让人头昏眼花,而JSON的解析难度几乎为0。这一点XML输的真是没话说。

    (5)在流行度方面,XML已经被业界广泛的使用,而JSON才刚刚开始,但是在Ajax这个特定的领域,未来的发展一定是XML让位于JSON。到时Ajax应该变成Ajaj(Asynchronous Javascript and JSON)了。

    (6) JSONXML同样拥有丰富的解析手段。

    (7)JSON相对于XML来讲,数据的体积小。

    (8)JSONJavaScript的交互更加方便。

    (9)JSON对数据的描述性比XML较差。

    (10)JSON的速度要远远快于XML

    注:数据交换格式的轻量级和重量级的比较:

    轻量级和重量级是相对来说的,那么XML相对于JSON的重量级体现在哪呢?我想应该体现在解析上,XML目前设计了两种解析方式:DOM和 SAX;

      DOM是把一个数据交换格式XML看成一个DOM对象,需要把XML文件整个读入内存,这一点上JSON和XML的原理是一样的,但是XML要考虑父节点和子节点,这一点上JSON的解析难度要小很多,因为JSON构建于两种结构:key/value,键值对的集合;值的有序集合,可理解为数组;

      SAX不需要整个读入文档就可以对解析出的内容进行处理,是一种逐步解析的方法。程序也可以随时终止解析。这样,一个大的文档就可以逐步的、一点一点的展现出来,所以SAX适合于大规模的解析。这一点,JSON目前是做不到得。

      所以,JSON和XML的轻/重量级的区别在于:JSON只提供整体解析方案,而这种方法只在解析较少的数据时才能起到良好的效果;而XML提供了对大规模数据的逐步解析方案,这种方案很适合于对大量数据的处理。

    三、一个简单的json示例:
    var rich = {
                    "name":"sjj",
                    "age":"23",
                    "address":
                        [
                            {"province":"anhui","city":"anqing"},
                            {"province":"beijing","city":"haidian"}
                        ],
                    "wife":
                        {
                            "name":"gl",
                            "age":"20",
                            "husband":"sjj"
                        }
                };
                //js能够识别出json数据格式:
                alert(rich.name);
                
                alert(rich.address[0].province);
                alert(rich.address[0].city);
                alert(rich.address[1].province);
                alert(rich.address[1].city);
                
                alert(rich.wife.name);
                alert(rich.wife.age);
                alert(rich.wife.husband);
    四.json的书写格式
    json语法很简单,也很容易理解,具体如下:
    语法规则:
    • 数据在名称/值对中
    • 数据由逗号分隔
    • 花括号保存对象
    • 方括号保存数组
    JSON 值:
    • 数字(整数或浮点数)
    • 字符串(在双引号中)
    • 逻辑值(true 或 false)
    • 数组(在方括号中)
    • 对象(在花括号中)
    • null

    JSON 名称/值对

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

    "firstName" : "John"

    JSON 对象:

    JSON 对象在花括号中书写:对象可以包含多个名称/值对:

    { "firstName":"John" , "lastName":"Doe" }

    JSON 数组

    JSON 数组在方括号中书写:

    数组可包含多个对象:

    {
    "employees": [
    { "firstName":"John" , "lastName":"Doe" },
    { "firstName":"Anna" , "lastName":"Smith" },
    { "firstName":"Peter" , "lastName":"Jones" }
    ]
    }
      具体可以参考 http://json.org/
    可以看看下面这几幅图(类似编译原理上的自动机对应的转化图):





    五.java script中的eval方法与json格式
        一般情况下,我们的json数据都是从服务端获取到的,获取的json数据是以字符串的形式返回的。这个字符串虽然是json格式的,但是不能被直接使用,我们必须将该字符串转化为一个对象才能正常解析它,eval()函数可以用来将字符串转化为js代码。
        例如:        
    var data = "{'name':'rowandjj'}";//这是一个字符串!   
    data = eval("("+data+")");
    alert(data.name);//输出rowandjj
      我们注意到在eval函数中我们加了一个小括号,这是为什么呢?
        加上圆括号的目的是迫使eval函数在评估JavaScript代码的时候强制将括号内的表达式(expression)转化为对象,而不是作为语句(statement)来执行。举一个例子,例如对象{},如若不加外层的括号,那么eval会将大括号识别为JavaScript代码块的开始和结束标记,那么{}将会被认为是执行了一句空语句。
    六.解析json数据
        json数据的解析方式有几十种,比较常用的有google的Gson, json-org,另外就是json-lib。
    这里以json-lib为例:
        步骤:
             1.导入json-lib.jar包及其依赖包:
    commons-beanutils,commons-collections,commons-lang,commons-logging,ezmorph.
             2.编写代码:
    package cn.edu.chd.test;
    import java.util.ArrayList;
    import java.util.List;
    import net.sf.json.JSONArray;
    import net.sf.json.JSONObject;
    import net.sf.json.JsonConfig;
    import cn.edu.chd.domain.Person;
    /**
     * @author Rowand jj
     *
     *使用json-lib解析与构造json数据
     */
    public class JSONDemo
    {
        public static void main(String[] args)
        {
    //        func1();
    //        func2();
            func3();
        }
        
        /**
         * 转换javabean到json格式
         */
        public static void func1()
        {
            Person p = new Person("rowandjj",23);
            JSONObject jsonObj = JSONObject.fromObject(p);//构造jsonobject对象,参数是一个javabean对象
            
            System.out.println(jsonObj.toString());//将java对象转化为json数据--->{"age":23,"name":"rowandjj"}
            System.out.println(jsonObj.getString("name"));//可以获取到属性值---->rowandjj
        }
        
        /**
         * 将list<javabean>集合转化为json数据
         */
        public static void func2()
        {
            List<Person> list = new ArrayList<Person>();
            list.add(new Person("zhangsan",11));
            list.add(new Person("lisi",12));
            list.add(new Person("wangwu",13));
            
            JSONArray jsonArr = JSONArray.fromObject(list);//将集合数据转化为json数据
    //        [{"age":11,"name":"zhangsan"},{"age":12,"name":"lisi"},{"age":13,"name":"wangwu"}]
            System.out.println(jsonArr.toString());//返回结果如上
            
            System.out.println(jsonArr.getJSONObject(0).getString("name"));//返回json数组第一个元素的name属性值,即zhangsan
        }
        
        /**
         *过滤掉javabean对象中的一些属性值,将剩下的属性-值转化为json格式 
         */
        public static void func3()
        {
            Person p = new Person("rowandjj",23);
            
            JsonConfig config = new JsonConfig();
            config.setExcludes(new String[]{"age"});//过滤掉age属性
            JSONObject jsonObj = JSONObject.fromObject(p,config);//将过滤器传入
            System.out.println(jsonObj.toString());//{"name":"rowandjj"}
        }
    }
    七.案例
        1.模拟服务端(这里用一个servlet处理请求)向客户端发送json数据, 客户端获取数据并显示。
    请求的servlet:
    package cn.edu.chd.web;
    import java.io.IOException;
    import java.io.PrintWriter;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    public class JSONServlet extends HttpServlet
    {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp)
                throws ServletException, IOException
        {
            resp.setContentType("text/html;charset=utf-8");
            resp.setCharacterEncoding("utf-8");
            
            PrintWriter writer = resp.getWriter();
            
            String jsondata = "{'name':'Rowandjj','job':'student'}";//返回给客户端的json数据
            writer.println(jsondata);
        }
    页面(部分):
        <body>
            <div
                style="text-align: center; font-size: 25px; font-weight: bold; color: blue;">
                我的名字叫
                <span id="name"></span>
                <br />
                我的职业是
                <span id="job"></span>
            </div>
        </body>
    js脚本:
     <script type="text/javascript">
        window.onload = function() {
                var xhr = createXmlHttpRequest();
                xhr.open("get","/AJAX/servlet/JSONServlet?time="+new Date().getTime());
                xhr.send(null);
                
                xhr.onreadystatechange = function()
                {
                    if(xhr.readyState == 4)
                    {
                        if(xhr.status == 200 || xhr.status == 304)
                        {
                       var data = xhr.responseText;//获取返回的json数据,注意,这里的数据是字符串类型
                          data = eval("("+data+")");//将json字符串转化为json对象
                            var name = data.name;
                            var job = data.job;
                            
                            document.getElementById("name").innerText = name;
                            document.getElementById("job").innerText = job;
                        }
                    }
                }
        }
        function createXmlHttpRequest() {//创建XMLHttpRequest对象
            var xmlHttp;
            try { //Firefox, Opera 8.0+, Safari
                xmlHttp = new XMLHttpRequest();
            } catch (e) {
                try { //Internet Explorer
                    xmlHttp = new ActiveXObject("Msxml2.XMLHTTP");
                } catch (e) {
                    try {
                        xmlHttp = new ActiveXObject("Microsoft.XMLHTTP");
                    } catch (e) {
                    }
                }
            }
            return xmlHttp;
        }
    </script>
    显示效果:


    展开全文
  • Jackson Json 快速入门

    2019-02-04 08:31:20
    文章目录Jackson Json 快速入门Java对象转换为JsonPOJO的转换多态条件下的转换集合转换Json转换为Java对象转换为POJO多态条件的转换集合转换Jackson Json 注解 Jackson Json 快速入门 Java对象转换为Json 总体来说,...

    Jackson Json 快速入门

    Java对象转换为Json

    总体来说,从Java到Json,Jakson提供了三种方式:Java对象、JsonNode Tree、Json流。因为是要快速入门,所以下文中主要使用第一种方式,也就是通过ObjectMapper实现从Java到Json以及从Json到Java的功能。详细教程传送门;基本上是使用ObjectMapper的write型API。

    POJO的转换

    创建User类:

    将其转换为字符串并输出到控制台,结果如下:

    public class User {
    	protected String name;
    	protected int id;
    	public User(){
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	@Override
    	public String toString() {
    		return "User{" +
    				"name='" + name + '\'' +
    				", id=" + id +
    				'}';
    	}
    }
    
    public static void main(String[] args){
        	User user=new User();
    		user.setId(666);
    		user.setName("落花流水存心阁");
    		String userJson=writer.writeValueAsString(user);
    		System.out.println(userJson);
    }
    
    //输出
    {
      "name" : "落花流水存心阁",
      "id" : 666
    }
    

    多态条件下的转换

    创建User类的子类VIP以及SuperVIP类:

    public class SuperVIP extends User {
    	private String[] privileges;
    
    	public String[] getPrivileges() {
    		return privileges;
    	}
    
    	public void setPrivileges(String[] privileges) {
    		this.privileges = privileges;
    	}
    
    	public SuperVIP(String[] privileges) {
    		this.privileges = privileges;
    	}
    
    	public SuperVIP() {
    	}
    
    	@Override
    	public String toString() {
    		return "SuperVIP{" +
    				"privileges=" + Arrays.toString(privileges) +
    				", name='" + name + '\'' +
    				", id=" + id +
    				'}';
    	}
    }
    public class VIP extends User{
    	private String privilege;
    
    	public VIP() {
    	}
    
    	public VIP(String privilege) {
    		this.privilege = privilege;
    	}
    
    	public String getPrivilege() {
    		return privilege;
    	}
    
    	public void setPrivilege(String privilege) {
    		this.privilege = privilege;
    	}
    
    	@Override
    	public String toString() {
    		return "VIP{" +
    				"privilege='" + privilege + '\'' +
    				", name='" + name + '\'' +
    				", id=" + id +
    				'}';
    	}
    }
    public static void main(String[] args){
    String basicPrivilege="超大容量";
    		VIP vip=new VIP(basicPrivilege);
    		vip.setId(777);
    		vip.setName("落花流水存心阁");
    		String vipJson=writer.writeValueAsString(vip);
    		System.out.println(vipJson);
    
    //		writer.writeValue(System.out,vip);
    //		System.out.println("我不会出现");
    
    		String superPrivilege="高速下载";
    		String[] privileges=new String[2];
    		privileges[0]=basicPrivilege;
    		privileges[1]=superPrivilege;
    		SuperVIP superVIP=new SuperVIP(privileges);
    		superVIP.setId(888);
    		superVIP.setName("落花流水存心阁");
    		String superVipJson=writer.writeValueAsString(superVIP);
    		System.out.println(superVipJson);
    
    		String privilegeJson=writer.writeValueAsString(privileges);
    		System.out.println(privilegeJson);
    }
    
    //输出
    {
      "name" : "落花流水存心阁",
      "id" : 777,
      "privilege" : "超大容量"
    }
    {
      "name" : "落花流水存心阁",
      "id" : 888,
      "privileges" : [ "超大容量", "高速下载" ]
    }
    

    集合转换

    创建User的List,然后将其转换为Json字符串,输出到控制台:

    public static void main(String[] args){
        List<User> users=new ArrayList<>(3);
    	users.add(user);
    	users.add(vip);
    	users.add(superVIP);
        System.out.println(mapper.writeValueAsString(users));
    }
    //输出
    [{"name":"落花流水存心阁","id":666},{"name":"落花流水存心阁","id":777,"privilege":"超大容量"},{"name":"落花流水存心阁","id":888,"privileges":["超大容量","高速下载"]}]
    

    会发现这里虽然结果ok,但是这样的Json是无法反序列化的,因为使用Jackson并不知道该Json字符串同类的关联,也就无法创建对象了。

    为User类添加关于类型的注释并在序列化时提供相关信息:

    @JsonTypeInfo(use =JsonTypeInfo.Id.CLASS, property = "@class")
    @JsonSubTypes({ @Type(value = VIP.class, name = "vip"), @Type(value = SuperVIP.class, name = "supervip") })
    public class User{}
    
    public static void main(String[] args){
    	List<User> users=new ArrayList<>(3);
    	users.add(user);
    	users.add(vip);
    	users.add(superVIP);
    	String usersJson=mapper.writerFor(new TypeReference<List<User>>() {
    }).writeValueAsString(users);
    	System.out.println(usersJson);
    }
    

    输出:

    [{"@class":"com.xiaomo.util.json.example.fast_understand.User","name":"落花流水存心阁","id":666},{"@class":"com.xiaomo.util.json.example.fast_understand.VIP","name":"落花流水存心阁","id":777,"privilege":"超大容量"},{"@class":"com.xiaomo.util.json.example.fast_understand.SuperVIP","name":"落花流水存心阁","id":888,"privileges":["超大容量","高速下载"]}]
    
    

    因为泛型在编译的时候擦除了类信息,所以这里使用了TypeReference这一在运行时标记目标List类别的对象;

    Json转换为Java对象

    我们将上一节的输出,作为这一节的输入~ 相应的,我们使用ObjectMapperd对象的read系API。

    转换为POJO

    操作比较常规,传入相对应的class对象即可:

    String userJson="{\n" +
    		"  \"@class\" : \"com.xiaomo.util.json.example.fast_understand.User\",\n" +
    		"  \"name\" : \"落花流水存心阁\",\n" +
    		"  \"id\" : 666\n" +
    		"}";
    //转换为POJO
    User user=objectMapper.readValue(userJson,User.class);
    System.out.println("普通用户的用户名:"+user.getName());
    
    

    多态条件的转换

    String vipJson="{\n" +
    		"  \"@class\" : \"com.xiaomo.util.json.example.fast_understand.VIP\",\n" +
    		"  \"name\" : \"落花流水存心阁\",\n" +
    		"  \"id\" : 777,\n" +
    		"  \"privilege\" : \"超大容量\"\n" +
    		"}";
    String superVipJson="{\n" +
    		"  \"@class\" : \"com.xiaomo.util.json.example.fast_understand.SuperVIP\",\n" +
    		"  \"name\" : \"落花流水存心阁\",\n" +
    		"  \"id\" : 888,\n" +
    		"  \"privileges\" : [ \"超大容量\", \"高速下载\" ]\n" +
    		"}";
    
    //多态条件下的转换
    User vip=objectMapper.readValue(vipJson,User.class);
    System.out.println("VIP的用户名:"+vip.getName());
    System.out.println("通过父类反序列化的VIP是不是VIP:"+(vip instanceof VIP));
    SuperVIP superVIP=objectMapper.readValue(superVipJson,SuperVIP.class);
    System.out.println("SuperVIP的权限:");
    for(String s:superVIP.getPrivileges()){
    	System.out.println(s);
    }
    

    这里,我们使用的是含类信息的Json字符串,此时可以传入父类的class。因为Json字符串里已经包含了Jackson所需要的创建对象的信息。

    如果使用不含类信息的Json字符串,则应该使用对应类的class对象。

    集合转换

    String userListJson="[{\"@class\":\"com.xiaomo.util.json.example.fast_understand.User\",\"name\":\"落花流水存心阁\",\"id\":666},{\"@class\":\"com.xiaomo.util.json.example.fast_understand.VIP\",\"name\":\"落花流水存心阁\",\"id\":777,\"privilege\":\"超大容量\"},{\"@class\":\"com.xiaomo.util.json.example.fast_understand.SuperVIP\",\"name\":\"落花流水存心阁\",\"id\":888,\"privileges\":[\"超大容量\",\"高速下载\"]}]\n";
    
    //有类信息的集合转换
    List<User> userList=objectMapper.readValue(userListJson,new TypeReference<List<User>>(){});
    System.out.println("集合转换结果");
    for(User u:userList){
    	System.out.println(u);
    }
    

    集合转换时,需要注意的是使用含有类信息的Json字符串,同时与序列化一样,需要传入标志集合泛型类别的TypeReference;

    Jackson Json 注解

    注:以下具体代码示例见 Ignore fields in JSON using Jackson

    1. 类级别的忽略字段注解:@JsonIgnoreProperties
    2. 字段级别的忽略注解:@JsonIgnore

    注:以下具体代码示例见 Json annotations and dynamic beans

    1. 关联Java字段和Json属性的注解:@JsonProperty
    2. 指定反序列化时所使用的构造函数的注解:@JsonCreator
    3. 指定处理无法和Java字段对应的Json属性的getter与setter方法,多用于反序列化时处理多余或者不想处理的Json属性:@JsonAnyGetter和@JsonAnySetter

    注:以下具体代码示例见 Jackson List serializationJson Polymorphism

    1. 在Json字符串中存储类信息的注解:@JsonTypeInfo,使用于父类,指定类信息的属性名以及对应属性值的值。@JsonSubTypes,使用于父类,指定子类;

    需要注意的是:使用ObjectMapper对象输出Json结果时,可以指定输出流,但是输出后Jackson(JsonFactory)将尝试关闭该流;所以如何指定System.out为输出流,则以后out流关闭,控制台再也看不到结果。以下为源代码中writeValue的注释:

    Note: method does not close the underlying stream explicitly
    here; however, {@link JsonFactory} this mapper uses may choose
    to close the stream depending on its settings (by default,
    it will try to close it when {@link JsonGenerator} we construct
    is closed).

    项目源码免费获取 个人博客,百度网盘地址+提取码,文件无密~

    展开全文
  • 本资源为我个人观看慕课网上《JSON快速入门(Java版)》课程所写的代码,希望能够帮到各位。课程网址为:http://www.imooc.com/learn/523
  • 参考npm 与 package.json 快速入门教程 转载于:https://blog.51cto.com/quietnight/2309958
     
    

    转载于:https://blog.51cto.com/quietnight/2309958

    展开全文
  • JSON快速入门指南

    千次阅读 2016-04-22 18:46:36
    本文从JSON定义、语法规则及JSON解析与序列化等方面对JSON数据格式进行简要的使用说明,并重点阐述对JSON.parse()和JSON.stringify()方法的使用。

    JSON是什么

    JSON(JavaScript对象表示法 JavaScript Object Notation),是存储和交换文本信息的语法,轻量级的文本数据交换格式,类似XML,但是比XML更小、更快、更容易解析。
    JSON独立于各种编程语言平台,并且几乎所有的主流编程语言都内置了对JSON数据格式的支持。


    JSON语法规则

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

    • 数据以名/值 对的形式表示
    • 数据之间以逗号分隔
    • 花括号保存对象
    • 方括号保存数组

    JSON值

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

    "username": "Jessica"

    JSON值可以包含以下多种类型:

    • 数字(整数和浮点数)
    • 字符串(在双引号中)
    • 逻辑值(true或false)
    • 数组(在方括号中)
    • 对象(在花括号中)
    • null

    JSON对象和JSON数组

    JSON对象包含在花括号中,可以包含多个名/值对,其值可以为数组;JSON数组包含在方括号中,可以包含多个对象。JSON既可以以花括号开头,也可以以方括号开头,JSON对象和JSON数组可以互相嵌套,如:

    {
        "users": [
            {"username":"Jacky",age:30},
            {"username":"Jessica",age:23},
            {"username":"James",age:42}
        ]
    }

    JSON文件

    • json文件的后缀为:”.json”
    • JSON文件的MIME类型为:“application/json”

    JSON解析和序列化

    早期的JSON解析器基本上就是使用JavaScript的eval()函数。由于JSON是JavaScript语法的子集,因此eval()函数可以解析并返回JavaScript对象和数组。
    ECMAScript 5对解析JSON的行为进行了规范,定义了全局对象JSON。

    JSON解析

    使用JSON.parse()把字符串解析为JSON对象或数组。

    //返回JSON对象
    var jsonStr1 = '{"username":"Jessica","age":23}';
    var jsonObj = JSON.parse(jsonStr1);
    console.log(jsonObj.username); //Jessica
    console.log(jsonObj.age) //23
    
    //返回JSON数组
    var jsonStr2 = '[{"username":"Jacky","age":30}, {"username":"Jessica","age":23}]';
    var jsonArr = JSON.parse(jsonStr2);
    for(var i=0;i<jsonArr.length;i++) {
        console.log(jsonArr[i].username); //Jacky Jessica
    }

    JSON序列化

    使用JSON.stringify()把JSON对象或数组序列化为字符串。

    //序列化JSON对象
    var jsonObj = {
        "username": "Jessica",
        "age": 23
    };
    var jsonStr1 = JSON.stringify(jsonObj);
    console.log(jsonStr1); //{"username":"Jessica","age":23}
    
    //序列化JSON数组
    var jsonArr = [
        {"username":"Jacky","age":30},
        {"username":"Jessica","age":23}
    ];
    var jsonStr2 = JSON.stringify(jsonArr, null, 2);
    console.log(jsonStr2); 
    /* 输出结果:
    [
      {
        "username": "Jacky",
        "age": 30
      },
      {
        "username": "Jessica",
        "age": 23
      }
    ]
    */

    *另外,当序列化后的字符串比较长时,可以通过设置JSON.stringify()方法的第三个参数,使字符串进行缩进,方便调试。

    展开全文
  • 当时通用的数据交换语言是XML,但是Douglas Crockford觉得XML的生成和解析都太麻烦,所以他提出了一种简化格式,也就是JsonJson的规格非常简单,只用一个页面几百个字就能说清楚,而且Douglas Crockford声称这个...
  • 一、JSON简介 1、什么是JSON   JSON是行业使用广泛的一种数据格式。   JSON(JavaScript Object Notation)是一种轻量级的数据交换格式。简单地说,JSON可以将 JavaScript 对象中表示的一组数据转换为字符串,然后...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,538
精华内容 17,815
关键字:

json快速入门