走进JavaScript——重拾对象

建立对象

Object构造器的参数若是为空或null、undefined将返回一个空的Object对象，若是为其余值则调用相应的构造器，如

new Object()
// Object {}
new Object(null)
// Object {}
new Object(undefined)
// Object {}
new Object(1)
// Number {[[PrimitiveValue]]: 1}
new Object("a")
// String {0: "a", length: 1, [[PrimitiveValue]]: "a"}
new Object({})
// Object {}
new Object([1,2,3])
// [1, 2, 3]
new Object(function(){})
// function (){}

若是传递多个参数取第一个，因为使用构造器来建立对象须要判断参数因此通常比咱们直接使用字面量{}建立对象要慢一些。

咱们也能够本身定义一个构造器来建立对象，以下

function CreateObj(){}
var obj = new CreateObj();
obj.a = 10;
// 10

这些方法建立的对象都不是一个真正干净的对象，若是但愿建立一个没有原型继承的空对象则可使用Object.create方法

Object.create(null)
// Object {} No Properties

对象直接量

var obj = {
    title: '晴天',
    content: '....'
};

key能够以字符串形式来写也能够按标识符来写，通常咱们会以标识符来写，当遇到须要使用一些不合法的标识符时咱们会以字符串的形式来写，如：

{1:2};
{.l:1};

因为以上对象属性名是不合法的，所以咱们须要使用字符串的形式来写。

{'1':2};
{'.l':1};

若是key和value名同样，value值能够不写

var a = 1;
var obj = {a};
console.log(obj);
// Object {a: 1}

若是但愿key是一个变量，咱们能够这样

var a = 'hello';
console.log({[a]:a});
Object {hello: "hello"}

在一个对象中不能有多个同名属性，若是相同最后一个将覆盖以前的

{
    a:123,
    a:456
}
// Object {a: 456}

对象不能有多个同名属性的特性，咱们可使用它来实现数组过滤重复项

var arr = [1,3,3,2,1,1],
    obj = {};
arr.forEach((item)=>obj[item] = item);
console.log(obj)
// Object {1: 1, 2: 2, 3: 3}

但因为对象的储存并非按照咱们填写的顺序来的，所以对于有顺序要求的咱们就不能使用上面的方式来实现了。

对象和数组在某些方面很是类似，所以只须要咱们按照数组的格式来写就能够将对象转换成一个数组

Array.from({
    '0':'hello',
    '1':'world',
    'length':2
})
// ["hello", "world"]

遍历对象

for in

var obj = {html:111,javascript:222};
for(let key in obj){
    console.log(obj[key]);
}
// 111
// 222

for in会将原型继承中的值也循环出来，所以咱们须要过滤一下

// 没过滤以前
Object.prototype.a = '捣乱的';
var obj = {html:111,javascript:222};
for(let key in obj){
    console.log(obj[key]);
}
// 111
// 222
// 捣乱的

// 过滤以后
Object.prototype.a = '捣乱的';
var obj = {html:111,javascript:222};
for(let key in obj){
    if(obj.hasOwnProperty(key)){
        console.log(obj[key]);
    }
}
// 111
// 222

咱们也能够用for来循环对象，不过咱们得先使用Object.keys来取对象的key

Object.prototype.a = '捣乱的';
var obj = {html:111,javascript:222};
var arr = Object.keys(obj);
for(let i = 0; i < arr.length; i++){
    console.log(obj[arr[i]]);
}
// 111
// 222

for of

Object.prototype.a = '捣乱的';
var obj = {html:111,javascript:222};
for(let key of Object.keys(obj)){
    console.log(obj[key]);
}
// 111
// 222

对象与其余值的运算

和对象、function相加会转换成字符串拼接，若是是其余值则会转换为数字

{} + null
// 0
{} + undefined
// NaN
{} + 'a'
// NaN
{} + '111'
// 111
{} + {}
// "[object Object][object Object]"
{} + [2]
// 2
{} + function(){}
// "[object Object]function (){}"

若是是相减则会将对象转换为-0（注意是-0），若是是对象减对象则是NaN

{} - ''
// -0
{} - []
// -0
{} - null
// -0
{} - undefined
// NaN
{} - {}
// NaN
{} - function(){}
// NaN
{} - 2
// -2

为何说对象被转换成负0而不是0呢，咱们用一个例子来证实

0 - 0
// 0
-0 - 0
// -0

因此说对象被转换成-0而不是0