对象

语言类型

• string
• number
• boolean
• null
• undefined
• object

内置对象

• String
• Number
• Boolean
• Object
• Function
• Array
• Date
• RegExp
• Error

var str = "I am a string";

原始值"I am a string"并不是对象而是字面量，并且是一个不可变的值。如果要对这个字面量上进行一些操作，比如获取长度、访问其中某个字符等，那需要将其转换为 String 对象

内容

属性访问

var myObject = {
    a: 2,
};
myObject.a; //2
myObject["a"]; //2

. 操作符要求属性名满足标识符的命名规范，[".."] 语法可以接受任意 UTF-8/Unicode 字符串作为属性名。

可计算属性名

ES6 增加了可计算属性名，可以使用 [] 包裹表达式来当做属性名。

var prefix = "foo";
var myObject = {
    [prefix + "bar"]: "hello",
    [prefix + "baz"]: "world",
};
myObject["foobar"]; //hello
myObject["foobaz"]; //world

属性与方法

函数用于不会属于一个对象，对象只是拥有函数的引用。将其称为（对象的）方法不妥。

数组

var myArray = ["foo", "42", "bar"];
myArray["3"] = "barz";
myArray.length = 4;
myArray[3]; //barz
myArray.bar = "barz";
myArray.length; //4
myArray.bar; //barz

复制对象

function anotherFunction() {}
var anotherObject = {
    c: true,
};
var anotherArray = [];
var myObject = {
    a: 2,
    b: anotherFunction,
    c: anotherObject,
    d: anotherArray,
};
//深复制
var newObj = JSON.parse(JSON.stringify(myObject));
newObj.a; //2
newObj.b === anotherFunction; //false
newObj.c === anotherObject; //false
newObj.d === anotherArray; //false
//ES6 浅复制
var newerObj = Object.assign({}, myObject);
newerObj.a; //2
newerObj.b === anotherFunction; //true
newerObj.c === anotherObject; //true
newerObj.d === anotherArray; //true

属性描述符

var myObject = {};
Object.defineProperty(myObject, "a", {
    value: 2,
    writable: true,
    configurable: true,
    enumerable: true,
});
myObject.a; //2

1. Writable 决定是否可以修改属性的值
2. Configurable 决定是否可以使用 defineProperty(..) 方法来修改属性描述符，同时还会禁止使用 delete object.a 删除属性（delete 仅用于删除属性，不要看做释放内存的工具）
3. Enumerable 决定属性是否出现在对象属性的枚举中。

不变性

1. 对象常量 writeable:false 和 configurable:false
2. 禁止拓展 Object.preventExtensions(..) 禁止向对象中添加新属性
3. 密封 Object.seal(..) 调用禁止拓展并把所有属性标记为 configurable:false
4. 冻结 Object.freeze(..) 调用密封并把所有属性标记为 writeable:false

Getter Setter

var myObject = {
    get a() {
        return this._a_;
    },
};
Object.defineProperty(myObject, "a", {
    set: function (val) {
        this._a_ = val * 2;
    },
});
myObject.a = 2;
myObject.a; //4

存在性

var myObject = {
    a: 2,
};
"a" in myObject; //true
"b" in myObject; //false
myObject.hasOwnProperty("a"); //true
myObject.hasOwnProperty("b"); //false

in 操作符会检察属性是否在对象及其[[Prototype]]原型中, hasOwnProperty 只会检查属性是或否在 myObject 对象中。

枚举

var myObject = {};
Object.defineProperty(myObject, "a", { enumerable: true, value: 2 });
Object.defineProperty(myObject, "b", { enumerable: false, value: 3 });
// for..in 循环可以用来遍历对象的可枚举属性列表
for (var k in myObject) {
    console.log(k, myObject);
}
// "a" 2
myObject.propertyIsEnumerable("a"); //true
myObject.propertyIsEnumerable("b"); //false
Object.keys(myObject); // ["a"]
Object.getOwnPropertyNames(myObject); // ["a","b"]

遍历

遍历属性的值

• ES5: forEach(..) every(..) some(..)
• ES6: for..of （迭代器）

var myArray = [1, 2, 3];
for (var v of myArray) {
    console.log(v);
}
//1
//2
//3
var it = myArray[Symbol.iterator]();
it.next(); //{value: 1, done: false}
it.next(); //{value: 2, done: false}
it.next(); //{value: 3, done: false}
it.next(); //{value: undefined, done: true}

定义一个迭代器 Symbol.iterator

var myObject = {
    a:2,
    b:3
};
Object.defineProperty(myObject,Symbol.iterator,{
    enumerable:false,
    writable:false,
    configurable:true,
    value:function(){
        var o = this;
        var idx = 0;
        var ks = Object.keys(o);
        return {
            next: function(){
                return {
                    value: o[ks[idx++]],
                    done:(idx > ks.length)
                };
            }
        }
    }
});