对象

对象作为一种复杂的数据类型，是一组无序的数据集合。有若干个“键值对”{key: value} 构成。

var obj = {
    a: 'Hello Word'
}

解释：
obj ：变量obj
{} ：定义了一个对象
a：键名。（成员的名称）
Hello Word ： 键值。（成员的值）

定义一个对象，对象内部有键名和键值分别是a和Hello Word，它被赋值给变量obj。

注意：对象内部可包含多个键值对，每个键值对之间用逗号,分隔。

键名

1、对象的所有键名都是字符串，所以加不加引号都可以。但如果键名不符合标识名的条件(比如第一个字符为数字，或者含有空格或者运算符)，需加引号。

var obj = {                    var obj = {    
    a: 'Hello Word'      ===      'a': 'Hello Word'                                                           
}                               }

以下键名必须加引号。

var o = {
  '1p': "Hello World",
  'h w': "Hello World",
  'p+q': "Hello World"
};

2、如果键名是数值，会被自动转化为字符串。

var o ={
  1: 'a',
  3.2: 'b',
  1e2: true,
  1e-2: true,
  .234: true,
  0xFF: true
};

o
// Object {
//   1: "a",
//   3.2: "b",
//   100: true,
//   0.01: true,
//   0.234: true,
//   255: true
// }

3、属性可以动态创建，不必在对象声明时就指定。

var obj = {}
obj.foo = 456;
obj.foo //456

4、对象的引用
如果不同的变量名指向同一个对象，那么它们都是这个对象的引用，也就是说指向同一个内存地址。修改其中一个变量，会影响到其他所有变量。

var a1 = {};
var a2 = a1;

a1.a = 1;
a2.a //1

a2.b = 2;
a1.b  //2

上面代码中，a1和a2指向同一个对象，因此为其中任何一个变量添加属性，另一个变量都可以读写该属性。

如果取消某一个变量对于原对象的引用，不会影响到另一个变量。

//a1 和 a2 指向同一个对象，
var a1 = {};
var a2 = a1;
//a1的值变为1
a1 = 1;
a2 //{} ，这时对a2的值不影响。

对象采用大括号表示，这导致一个问题：如果行首是一个大括号，它是表达式还是语句？？

{foo: 342}

为了方便区分是表达式还是语音，JavaScript规定，如果行首是大括号，一律解释为语句(代码块), 大括号前面加上圆括号则为表达式（对象）

{foo: 342}  //语句。代码块
({foo: 342})  // 表达式。对象


//如：eval语句中反映得最明显
eval('{foo: 123}') // 123
eval('({foo: 123})') // {foo: 123}

5、键名又称为属性(property)，它的键值可以是任何数据类型。如果一个属性的值为函数，通常把这个属性称为“方法”，它可以像函数那样调用。

var a = {
    b:function(e){
        return 3 * e  //3 * 2
    }
}
a.b(2) 
//6

上面的对象就有一个方法b，它就是一个函数。

6、读取属性(键值)
读取对象的属性，有两种方法：
a、使用点.运算符
b、使用方括号[]运算符.

var a = {
    b: '你好'
}

a.b  //"你好"
a['b'] //“你好” 

注：使用[]需加引号在里面包裹键名，数字键可以不加引号。

7、属性赋值（键值）
给对象的属性赋值，有两种方法：
a、使用点.运算符
b、使用方括号[]运算符

a.b = '大家好'
a.['b'] = '很好'

上面代码分别使用点运算符和方括号运算符，对属性b赋值。

8、查看所有键名

查看一个对象本身的所有键名。可以用Object.keys方法

var a  = {
    key1: 123,
    key2: 456
}
Object.keys(a)  //['key1', 'key2']

9、删除属性（键名）
delete命令用于删除对象的属性，删除承购返回true

var a  = {
    key1: 123,
    key2: 456
}
Object.keys(a)  //['key1', 'key2']

delete a.key1 //true
a.key1 //undefined
Object.keys(a) //key2

注意：删除一个不存在的属性，delete不报错，而且返回true。

var a = {}
delete a.p //true

10、for...in循环
for...in循环用来遍历一个对象的全部属性（键值）。

var a = {a:1,b:2,c:3}

for(var i  in a){
    console.log(a[i])
}
//1
//2
//3

---

JSON

JSON格式是一种用于数据交换的文本格式

JSON对值的类型和格式有严格的规定。

1、复合类型的值只能是数组或对象，不能是函数、正则表达式对象、日期对象。

2、简单类型的值只有四种：字符串、数值（十进制表示）、布尔值和null（不能使用NaN，Infinity，-Infinity，undefined）

3、字符串必须使用双引号表示，不能使用单引号。

4、对象的键名必须当在双引号里面。

5、数组或对象最后一个成员的后面，不能加逗号。

6、JSON 是一种语法，用来序列化对象、数组、数值、字符串、布尔值和 null。

以下是合格的JSON值

["one", "two", "three"]

{ "one": 1, "two": 2, "three": 3 }

{"names": ["张三", "李四"] }

[ { "name": "张三"}, {"name": "李四"} ]

不合格的JSON。

{ name: "张三", 'age': 32 }  // 属性名必须使用双引号

[32, 64, 128, 0xFFF] // 不能使用十六进制值

{ "name": "张三", "age": undefined } // 不能使用undefined

{ "name": "张三",
  "birthday": new Date('Fri, 26 Aug 2011 07:13:10 GMT'),
  "getName": function() {
      return this.name;
  }
} // 不能使用函数和日期对象

处理JSON格式数据。

a、JSON.stringify() 把值转为字符串
b、JSON.parse()把字符串转化成对象

JSON.stringify()方法用于将一个值转化为字符串。该字符串符合JSON格式，并可以被JSON.parse方法还原。

格式：

JSON.stringify(value[, replacer [, space]])

参数：

• value（参数1）：
  将要序列化成 一个JSON 字符串的值。

• replacer（参数2）：
  过滤器。可以是数组、函数、null

  • 如果是数组，结果将值包含数组中列出的属性。如：例1

  • 如果是函数，在序列化过程中，被序列化的值的每个属性都会经过该函数的转换和处理。如：例2

  • 如果为null，对象所有的属性都会被序列化。如：例3

• space（参数3）：
  指定缩进用的空白字符串，用于美化输出。 如：例3

  • 数字。代表有多少的空格；上限为10。该值若小于1，则意味着没有空格。

  • 字符串。该字符串将被作为空格。

  • 如果该参数没有提供（或者为null）将没有空格。

JSON.stringify('abc')  //""abc""
JSON.stringify(1) //"1"
JSON.stringify(false) //"false"
JSON.stringify([]) //"[]"
JSON.stringify({}) //"{}"

JSON.stringify([1,"false",false]) 
//"[1,"false",false]"

JSON.stringify({name:"李四"})
//"{"name":"李四"}"

注意：对于原始类型的字符串，转换结果会带双引号。

//""foo"" === "foo"  //false
JSON.stringify('foo') === "foo" // false

JSON.stringify('foo') === "\"foo\"" // true

因为：
//JSON.stringify('foo')  ==> //""foo""
// "\"foo\""  ==> //""foo""
所以：
""foo"" === ""foo""  //true

例1：

var book = {
    "title":"内容1",
      "name":"luoshushu",
     "age":"23",
}
var jsonText = JSON.stringify(book,["name","age"])
//"{"name":"luoshushu","age":"23"}"

上面的代码：JSON.stringify()的第二个参数是一个数组，其中包含两个字符串："name" 和 "age"。这两个属性与将要序列化的对象中的属性是对应的，因此返回的结果字符串中，就只会包含这两个属性："{"name":"luoshushu","age":"23"}"

例2：

var book = {
    "title":"内容1",
      "name":"luoshushu",
     "age":"23",
}
var jsonText = JSON.stringify(book,function(key,value){
    switch(key){
      case "title":
        return undefined  //返回的是undefined相应的属性就会被忽略。
      case "age":
        return 50   //返回50.相应的属性就为50
      case "name":
        return "luoshushu1" //返回luoshushu1.相应的属性就为luoshushu1
      default:
        return value;
     }
})

//"{"name":"luoshushu1","age":50}"

以上代码：第二个参数是函数。传入的函数接收两个参数，属性（键）名和属性值。

例3：

var book = {
    "title":"内容1",
      "name":"luoshushu",
     "age":"23",
}
var jsonText = JSON.stringify(book,null,"********")

输出:

"{
********"title": "内容1",
********"name": "luoshushu",
********"age": "23"
}"


var jsonText = JSON.stringify(book,null,10)

输出:

"{
          "title": "内容1",
          "name": "luoshushu",
          "age": "23"
}"

---

JSON.parse()把字符串转化成对象。

格式：

JSON.parse(text[, reviver])

参数：

• text:
  要被解析成JavaScript值的字符串.

• reviver:
  如果是一个函数，则规定了原始值如何被解析改造，在被返回之前。

JSON.parse('{}') // {}
JSON.parse('true') // true
JSON.parse('"foo"') // "foo"
JSON.parse('[1, 5, "false"]') // [1, 5, "false"]
JSON.parse('null') // null

var o = JSON.parse('{"name": "阿三"}');
o.name // 阿三

stringify与parse

JavaScript对象和 JSON 的关系

JavaScript 对象的字面量写法只是长的像 JSON 格式数据，二者属于不同的范畴，JavaScript 对象中很多类型(函数、正则、Date) JSON 格式的规范并不支持，JavaScript 对象的字面量写法更宽松。