json总结

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，采用完全独立于语言的文本格式，是理想的数据交换格式。同时，JSON是 JavaScript 原生格式，这意味着在 JavaScript 中处理 JSON数据不须要任何特殊的 API 或工具包。

    本文主要是对JS操作JSON的要领做下总结。

    在JSON中，有两种结构：对象和数组。

    1. 一个对象以“{”（左括号）开始，“}”（右括号）结束。每个“名称”后跟一个“:”（冒号）；“‘名称/值’ 对”之间运用 “,”（逗号）分隔。 名称用引号括起来；值如果是字符串则必须用括号，数值型则不须要。例如：

    var o={"xlid":"cxh","xldigitid":123456,"topscore":2000,"topplaytime":"2009-08-20"}；

    2. 数组是值（value）的有序集合。一个数组以“[”（左中括号）开始，“]”（右中括号）结束。值之间运用 “,”（逗号）分隔。

    例如：

    var jsonranklist=[{"xlid":"cxh","xldigitid":123456,"topscore":2000,"topplaytime":"2009-08-20"},{"xlid":"zd","xldigitid":123456,"topscore":1500,"topplaytime":"2009-11-20"}];


 
2. 数组是值（value）的有序集合。一个数组以“[” 开始，“]”结束。值之间运用 “,”分隔。例如：
 
var jsonList=
[
   {
     "str":"abc",
     "intstr":1322323456,
     "max":6753,
     "time":"2012-10-19"
   },                   　　　　
   {
     "str":"cde",
     "intstr":782144556,
     "max":15400,
     "time":"2012-10-19"
   }
];

 
一个详细的 json 格式数据实例
 
 

// 描述一个人

var person = {
    "Name": "Bob",
    "Age": 32,
    "Company": "IBM",
    "Engineer": true
}

// 获取这个人的信息

var personAge = person.Age;

// 描述几个人

var members = [
    {
        "Name": "Bob",
        "Age": 32,
        "Company": "IBM",
        "Engineer": true
    },
    {
        "Name": "John",
        "Age": 20,
        "Company": "Oracle",
        "Engineer": false
    },
    {
        "Name": "Henry",
        "Age": 45,
        "Company": "Microsoft",
        "Engineer": false
    }
]

// 读取其中John的公司名称

var johnsCompany = members[1].Company;

// 描述一次会议

var conference = {
    "Conference": "Future Marketing",
    "Date": "2012-6-1",
    "Address": "Beijing",
    "Members":
    [
        {
            "Name": "Bob",
            "Age": 32,
            "Company": "IBM",
            "Engineer": true
        },
        {
            "Name": "John",
            "Age": 20,
            "Company": "Oracle",
            "Engineer": false
        },
        {
            "Name": "Henry",
            "Age": 45,
            "Company": "Microsoft",
            "Engineer": false
        }
    ]
}

// 读取参会者Henry是否工程师

var henryIsAnEngineer = conference.Members[2].Engineer;
 

    为了方便地处理JSON数据，JSON提供了json.js包，下载地址：http://www.json.org/json.js

    在数据传输流程中，json是以文本，即字符串的形式传递的，而JS操作的是JSON对象，所以，JSON对象和JSON字符串之间的相互转换是关键。例如：

    JSON字符串:

    var str1 = '{ "name": "cxh", "sex": "man" }';

    JSON对象:

    var str2 = { "name": "cxh", "sex": "man" };

    一、JSON字符串转换为JSON对象

    要运用上面的str1，必须运用下面的要领先转化为JSON对象：

    //由JSON字符串转换为JSON对象

    var obj = eval('(' + str + ')');

或者

    var obj = str.parseJSON(); //由JSON字符串转换为JSON对象

    或者

    var obj = JSON.parse(str); //由JSON字符串转换为JSON对象

    然后，就可以这样读取：

    Alert(obj.name);

    Alert(obj.sex);

    特别留心：如果obj本来就是一个JSON对象，那么运用 eval（）函数转换后（哪怕是多次转换）还是JSON对象，但是运用 parseJSON（）函数处理后会有疑问（抛出语法异常）。

    二、可以运用 toJSONString()或者全局要领 JSON.stringify()将JSON对象转化为JSON字符串。

    例如：

    var last=obj.toJSONString(); //将JSON对象转化为JSON字符

    或者

    var last=JSON.stringify(obj); //将JSON对象转化为JSON字符

    alert(last);

    留心：

    上面的多个要领中，除了eval()函数是js自带的之外，其他的多个要领都来自json.js包。新版本的 JSON 修改了 API，将 JSON.stringify() 和 JSON.parse() 两个要领都注入到了 Javascript 的内建对象里面，前者变成了 Object.toJSONString()，而后者变成了 String.parseJSON()。如果提示找不到toJSONString()和parseJSON()要领，则说明您的json包版本太低。


JSON简介
JSON: JavaScrip 对象表示法（JavaScrip Object Notation）
JSON是存储和交换文本信息的语法。
·JSON是轻量级的文本数据交换格式
·JSON独立于语言和平台
·JSON具有自我描述性，更易理解

JSON与XML
JSON类似XML,比XML更小，更快，更易解析。
·没有结束标签
·更短
·读写的速度更快
·使用数组
·不使用保留字

JSON语法
·数据在name-value对中
·数据由逗号分隔
·花括号保存对象
·方括号保存数组
·value可以是数字（int，float）、字符串（双引号中）、布尔值、数组（方括号中）、对象（花括号中）、null

JSON对象
JSON对象在花括号中书写，对象可以包含多个name-value对：
{"firstName":"John","lastName":"Doe"}

JSON数组
JSON数组在方括号中书写，数组可以包含多个对象：
根部的{}表示这是一个整体的JSON对象，"employees"表示其中一个键，这个键比较特别，它对应的值是一个JSON数组，这个数组中又包含了3个JSON对象。注意数组中的每个值也需要用逗号隔开。

{
   "employees":[
        {"firstName":"John","lastName":"Doe"},
        {"firstName":"Anna","lastName":"Smith"},
        {"firstName":"Peter","lastName":"Jones"}
   ],
  "animal","cat"
}
其实有点类似：
List<Map<String, Object>> listItems = new ArrayList<Map<String, Object>>()；
Map<String, Object>listItem = new HashMap<String, Object>( );
或者（ExpanableListView用到）：
List<String> names = new ArrayList<String>( );
List<ArrayList<String>> details = new ArrayList<ArrayList<String>>( );
读取JSON数据
assets/test.json

{
    "languages":[
        {"id":1,"ide":"Eclipse","name":"Java"},
        {"id":2,"ide":"XCode","name":"Swift"},
        {"id":3,"ide":"Visual Studio","name":"C#"},
    ],
    "cat","it"
}
try {
        InputStream is = getResources().getAssets().open("test.json");
        InputStreamReader isr = new InputStreamReader(is, "UTF-8");
        BufferedReader br = new BufferedReader(isr);
        //将文本中的数据，都读取到一个StringBuilder当中
        String line;
        StringBuilder builder = new StringBuilder();
        while((line=br.readLine()) != null ){
            builder.append(line);
        }
        br.close();
        isr.close();

        JSONObject root = new JSONObject(builder.toString());
        //根据键，获得键对应的值，由于值是String类型，所以用getString
        System.out.println("cat="+root.getString("cat"));
        //根据键，获得键对应的数组，由于值是一个数组，所以用getJSONArray
        JSONArray array = root.getJSONArray("languages");
        //由于要遍历数组，所以创建一个for循环
        for(int i=0;  i < array. length();  i++){
            //由于每一个数组当中的元素，也是一个新的JSON对象
            JSONObject  lan = array.getJSONObject(i);
            System.out.println("-------------------");
            System.out.println("id="+lan.getInt("id"));
            System.out.println("ide="+lan.getString("name"));
            System.out.println("name="+lan.getString("name"));
            Log.i("tag","-------");
        }

    } catch (IOException e) {
        e.printStackTrace();
    } catch (JSONException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
创建JSON数据

try {
        //首先创建对象中的一个单个键值对
        JSONObject root = new JSONObject();
        root.put("cat", "it");
        //另一个键值对的值是一个数组，数组里装了3个JSON对象，所以再分别搞3个JSONObject对象存放键值对
        JSONObject lan1 = new JSONObject();
        lan1.put("id", "1");
        lan1.put("ide", "Eclipse");
        lan1.put("name","Java");
        JSONObject lan2 = new JSONObject();
        lan2.put("id", "2");
        lan2.put("ide", "XCode");
        lan2.put("name","Swift");
        JSONObject lan3 = new JSONObject();
        lan3.put("id", "2");
        lan3.put("ide", "Visual Studio");
        lan3.put("name","C#");
        //在将这3个对象存入一个数组
        JSONArray array = new JSONArray();
        array.put(lan1);
        array.put(lan2);
        array.put(lan3);
        //再将数组作为键"languages"的值，构成一个对象
        root.put("languages", array);
        //本例中只将内容输出出来
        System.out.println(root.toString());

    } catch (JSONException e) {
        e.printStackTrace();
    }

1、要使用JSON，先下下载json.js文件。下载地址：https://github.com/douglascrockford/JSON-js
Js代码  
定义一个json对象  
var jsonObject={};  
给对象属性赋值  
jsonObject.productId=123;  
jsonObject.singleType=1;  
  
json数组  
var jsonArray = new Array();  
jsonArray.push(jsonObject);  
可以用jquery的each进行循环  
$.each(jsonArray,function(index,jsonObject){  
  
})  
  
从json对象获取值  
var productId=jsonObject.productId;  
  
将json对象转换成字符串，用于将值放到隐藏域传到后台  
var jsonString  = JSON.stringify(jsonObject);  
{"productId":123,"singleType":1}  
  
JSON这个工具下面的两个js工具类提供的，已经在模板上对所有ftl页面进行引用了         
  
如果是转换数组结果为  
[{"productId":123,"singleType":1},{"productId":456,"singleType":2}]  
  
将json格式字符串转换成对象，用于从隐藏域获取value后，转换成对象来操作  
var jsonObject = JSON.parse('{"productId":123,"singleType":1}');  
var jsonArray = JSON.parse('[{"productId":123,"singleType":1},{"productId":456,"singleType":2}]');  
  
java：  
隐藏域中的json字符串传到后台后转换成JSONObject对象  
JSONObject jb = JSONObject.fromObject("{\"productId\":123,\"singleType\":1}");  
从jsonobject获取属性  
Long productId = jb.getLong("productId");  
Double price = jb.getDouble("price");  
如果jb中没有productId属性，则会抛异常  
  
json数组JSONArray  
JSONArray js = JSONArray.fromObject("[{\"productId\":123,\"singleType\":1},{\"productId\":456,\"singleType\":2}]");  
然后循环成JSONObject来获取属性  


js中json操作——函数构造法、eval、JSON.stringify、JSON.parse

chape 发布于 3年前，共有 0 条评论



函数构造定义法返回

var strJSON = "{name:'json name'}";//得到的JSON
var obj = new Function("return" + strJSON)();//转换后的JSON对象
alert(obj.name);//json name


js中著名的eval函数

var strJSON = "{name:'json name'}";//得到的JSON
var obj = eval( "(" + strJSON + ")" );//转换后的JSON对象
alert(obj.name);//json name
注意：对象表达式{'name':'json name'}必须用“（）”扩住，否则
var strJSON = "{name:'json name'}";
var obj = eval(strJSON);
alert(obj.constructor);//String 构造函数
alert(obj.name);//undefine
必须把对象表达式扩起来eval执行才能生成一个匿名对象!

JSON.stringify方法

作用：这个函数的作用主要是为了系列化对象的。  
        可能有些人对系列化这个词过敏，我的理解很简单。就是说把原来是对象的类型转换成字符串类型（或者更确切的说是json类型的）。就这么简单。打个比方说，你有一个类，那么你可以通过这个方法转换成相应的json类型的。
语法：  
JSON.stringify(value [, replacer] [, space]) 
value：是必须要的字段。就是你输入的对象，比如数组啊，类啊等等。 
replacer：这个是可选的。它又分为2种方式，一种是方法，第二种是数组。 
情况一：我们先说数据，通过我们后面的实验可以知道，它是和第一个有关系的。一般来说，我们系列化后的结果是通过键值对来进行表示的。 
比如说： 
name:"lan",age:25 
所以，如果这种形式的话，如果第二个的值在第一个存在，那么的话就以第二个的值做key，第一个值为value进行表示，如果不存在，sorry，忽略。【是不是有点抽象，我也这么觉得，不过你等一下看实验 就OK了。。呼呼。】 
情况二：如果是方法，那很简单，就是说把系列化后的每一个对象（记住 是每一个）传进方法里面进行处理。 
space：很好理解，用什么来做分隔符的。 
1.如果省略的话，那么显示出来的值 就没有分隔符。直接输出来 
2.如果是一个数字的话，那么它就定义缩进几个字符，当然 如果大于10 ，则最大值为10. 
3.如果是一些转义字符，比如“\t”，表示回车，那么它每行一个回车。 
4.如果仅仅是字符串，OK，就在每行输出值的时候把这些字符串附加上去就OK。当然，最大长度也是10个字符。 
开始用实例说明；  
1.只有一个参数的情况下：  
var student = new Object(); 
student.name = "Lanny"; 
student.age = "25"; 
student.location = "China"; 
var json = JSON.stringify(student); 
alert(student); 

结果如下: 

有些人可能会怀疑JSON.stringify的作用，OK。那假如，我们不要这个函数。代码下面的样子：  
var student = new Object(); 
student.name = "Lanny"; 
student.age = "25"; 
student.location = "China"; 

// var json = JSON.stringify(student); 
alert(student); 

　恭喜你 得到的结果是： 


2.第二个参数存在，并且第二个参数还是function的时候 

var students = new Array() ; 
students[0] = "Lanny"; 
students[1] = "dong"; 
students[2] = "I love you"; 
var json = JSON.stringify(students,switchUpper); 
function switchUpper(key, value) { 
return value.toString().toUpperCase(); 
} 
alert(json); 

//var json = JSON.stringify(students, function (key,value) { 
//return value.toString().toUpperCase(); 
//}); 
　上面的方法也可以换成下面的，2个都是一样，只是写法有那么一点点的不一样而已。 
　得到结果如下： 

3.第二个参数存在，并且第二个参数不是function，而是数组的时候。 
3.1 【误区】如果第一个参数是数组，第二个参数也是数组的话，只显示第一个参数的值。 
比如：

var students = new Array() ; 
students[0] = "Lanny"; 
students[1] = "dong"; 
students[2] = "I love you"; 
var stu = new Array(); 
stu[0] = "1"; 
stu[1] = "2"; 
var json = JSON.stringify(students,stu); 
alert(json); 
得到的结果就是： 

第二个被忽略了，只是第一个被系列化了。 

3.2 如果第一个是对象（这里说的对象就像在C#里面可以进行new的），第二个是数组的。 

那么如果第二个的value在第一个存在，那么的话就以第二个的值做key，第一个值为value进行表示  
var student = new Object(); 
student.qq = "5485891512"; 
student.name = "Lanny"; 
student.age = 25; 

var stu = new Array(); 
stu[0] = "qq"; 
stu[1] = "age"; 
stu[2] = "Hi";//这个student对象里不存在。 

var json = JSON.stringify(student,stu); 
alert(json); 

　得到的结果如下： 

因为stu[2] = "Hi";这个Hi 在第一个找不到，所以就不进行显示了。 

4.第三个参数 

4.1.如果省略的话，那么显示出来的值 就没有分隔符。直接输出来 

比如： 
var student = new Object(); 
student.qq = "5485891512"; 
student.name = "Lanny"; 
student.age = 25; 

var stu = new Array(); 
stu[0] = "qq"; 
stu[1] = "age"; 
stu[2] = "Hi"; 

var json = JSON.stringify(student,stu); 
alert(json); 

　输出的就是： 

4.2.如果是一个数字的话，那么它就定义缩进几个字符，当然 如果大于10 ，则最大值为10.  

var student = new Object(); 
student.qq = "5485891512"; 
student.name = "Lanny"; 
student.age = 25; 

var stu = new Array(); 
stu[0] = "qq"; 
stu[1] = "age"; 
stu[2] = "Hi"; 

var json = JSON.stringify(student,stu,100);//注意这里的100 
alert(json); 

那么得到的是： 

空开来了10个字符。 

4.3.如果是一些转义字符，比如“\t”，表示回车，那么它每行一个回车。 

也是一样。 

4.4.如果仅仅是字符串，OK，就在每行输出值的时候把这些字符串附加上去就OK。当然，最大长度也是10个字符。 

如果是var json = JSON.stringify(student,stu,“HaiKou”);//


JSON.parse(text, reviver)方法


参数：

text必需。 一个有效的 JSON 字符串。

reviver可选。 一个转换结果的函数。 将为对象的每个成员调用此函数。 如果成员包含嵌套对象，则先于父对象转换嵌套对象。 对于每个成员，会发生以下情况：

如果 reviver 返回一个有效值，则成员值将替换为转换后的值。
如果 reviver 返回它接收的相同值，则不修改成员值。
如果 reviver 返回 null 或 undefined，则删除成员。

返回值：

一个对象或数组。

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>JSON.parse()</title>
<script type="text/javascript" src="json2.js"></script>
<script type="text/javascript">
var data='{'
+'"root":'
+'['
+'{"name":"1","value":"0"},'
+'{"name":"6101","value":"西安市"},'
+'{"name":"6102","value":"铜川市"},'
+'{"name":"6103","value":"宝鸡市"},'
+'{"name":"6104","value":"咸阳市"},'
+'{"name":"6105","value":"渭南市"},'
+'{"name":"6106","value":"延安市"},'
+'{"name":"6107","value":"汉中市"},'
+'{"name":"6108","value":"榆林市"},'
+'{"name":"6109","value":"安康市"},'
+'{"name":"6110","value":"商洛市"}'
+']'
+'}';



//示例1：此示例使用 JSON.parse 将 JSON 字符串转换为对象
var jsontext = '{"firstname":"Jesper","surname":"Aaberg","phone":["555-0100","555-0120"]}';
var contact = JSON.parse(jsontext);
document.write(contact.surname + ", " + contact.firstname + ", "+ contact.phone);



//dateReviver
//var dateObj = new Date(Date.UTC('2008', +'01' - 1, +'01', +'12', +'00', +'00'))
//alert(dateObj.toUTCString())

//示例2：此示例使用 JSON.parse 反序列化 ISO 格式的日期字符串, 将返回Date格式对象。
var jsontext2 = '{ "hiredate": "2008-01-01T12:00:00Z", "birthdate": "2008-12-25T12:00:00Z" }';
var dates = JSON.parse(jsontext2, dateReviver);
document.write("<br /><br />"+dates.birthdate.toUTCString());
function dateReviver(key, value) {
var a;
if (typeof value === 'string') {
a = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
if (a) {
return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4],
+a[5], +a[6]));
}
}
return value;
};

</script>
</head>
<body>
</body>
</html>

上面代码中有示例1功能为将json字符串转化为json对象。（注意！json字符串的格式一定要标准，key和value一定要用双引号包括，否则会出线示例2功能介绍reviver修改返回结果的功能。

jquery对象转json  jquery.json.js使用
实例
<html>
<head>
<title>jquery对象转json  jquery.json.js使用</title>
<meta charset="utf-8" />
<script src="jquery-1.9.1.js"></script>
<script src="jquery.json.js"></script>
<script>
$(function(){
var obj=new Object();
obj.name="张三";
obj.age="12";
obj.job="php";
var strjson = $.toJSON(obj);
$(".strjson").text(strjson);
//alert(strjson);
});
</script>
</head>
<body>
<div>
对象：<pre style="color:red;">
var obj=new Object();
obj.name="张三";
obj.age="12";
obj.job="php";</pre>
</div>
<div>
json字符串：<span class="strjson">var obj ={name:"andy",age:20,job:"javascript"};</span>
</div>
</body>
</html>
2
$(function(){
var obj=new Object();
obj.name="张三";
obj.age="12";
obj.job="php";
//转换成json字符串
var strjson = $.toJSON(obj);
$(".strjson").text(strjson);
//alert(strjson);
});

//下面是对json对象的增删查改操作

//声明json对象

var jsonObj2={persons:[{name:"jordan",sex:"m",age:"40"}, {name:"bryant",sex:"m",age:"28"}, {name:"McGrady",sex:"m",age:"27"} ]};

var persons=jsonObj2.persons;
var str="";

var person={name:"yaoMing",sex:"m",age:"26"};
//以下为json对象的操作，去掉注释可以查看操作结果
//jsonObj2.persons.push(person);//数组最后加一条记录
//jsonObj2.persons.pop();//删除最后一项
//jsonObj2.persons.shift();//删除第一项
jsonObj2.persons.unshift(person);//数组最前面加一条记录 只要适合Javascript的方法都是可以用在JSON对象的数组中的！所以还有另外的方法splice( )进行crud操作！ //删除
//jsonObj2.persons.splice(0,2);//开始位置,删除个数
//替换不删除
var self={name:"tom",sex:"m",age:"24"};
var brother={name:"Mike",sex:"m",age:"29"};
jsonObj2.persons.splice(1,0,self,brother,self);//开始位置,删除个数,插入对象
//替换并删除
//jsonObj2.persons.splice(0,1,self,brother);//开始位置,删除个数,插入对象

for(var i=0;i<persons.length;i++){ var cur_person=persons[i]; str+=cur_person.name+"'sex is "+cur_person.sex+" and age is "+cur_person.age+"<br><br>"; }
document.writeln(str);
//转换为json文本
var myjsonobj = JSON.stringify(jsonObj2);
document.writeln(myjsonobj);
</script>