一、JavaScript的设计是一个简单的基于对象的范式。
二、一个对象就是一系列属性的集合，一个属性包含一个名和一个值。一个属性的值可以是函数，这种情况下属性也被成为方法。
三、除了浏览器里面预定义的对象外，也可以定义自己的对象。

对象概述

一、JavaScript中，一个对象可以是一个单独的拥有属性和类型的实体。

【示例】与杯子做类比。一个杯子是一个对象（物体），拥有属性。杯子有颜色，图案，重量，由什么材质构成等等。

创建新对象

【见】创建新对象：https://www.yuque.com/tqpuuk/yrrefz/udepz0

对象的属性

【见】对象的属性：https://www.yuque.com/tqpuuk/yrrefz/kh1pz7

对象的方法

【见】对象的方法：https://www.yuque.com/tqpuuk/yrrefz/oq92lc

对象引用

【见】对象引用：https://www.yuque.com/tqpuuk/yrrefz/pc74bo

对象比较

一、在JavaScript中，object是一种引用类型。

通过引用来比较

一、两个独立声明的对象永远也不会相等，即使他们有相同的属性，只有在比较一个对象和这个对象的引用时，才会返回true

| 【示例】```javascript // 两个变量，两个具有同样的属性，但不相同的对象 var fruit = { name: ‘apple’ } var fruitbear = { name: ‘apple’ }

console.log(fruit == fruitbear) // false console.log(fruit === fruitbear) // false

 |
| --- |
| 【示例】```javascript
// 两个变量，同一个对象
var fruit = { name: 'apple' }
var fruitbeear = fruit // 将fruit的对象引用（reference）赋值给fruitbear
                                             // 也称为将fruitbear“指向”fruit对象
// fruit与fruitbear都指向同样的对象
console.log(fruit == fruitbear) // true
console.log(fruit === fruitbear) // true

| | —- |

| 【示例】这里a和b两个变量都引用同一个对象，所以它们相等：```javascript let a = {}; let b = a; // 复制引用

alert( a == b ); // true，都引用同一对象 alert( a === b ); // true

 |
| --- |

| 【示例】这里两个独立的对象则并不相等，即使它们看起来很像（都为空）：```javascript
let a = {};
let b = {}; // 两个独立的对象

alert( a == b ); // false

二、对于类似obj1 > obj2的比较，或者跟一个原始类型值的比较obj == 5，对象都会被转换为原始值。
1、说实话，很少需要进行这样的比较，通常是在编程错误的时候才会出现这种情况。 | | —- |

比较对象的属性、值是否相等

一、比较两个对象的属性和值是否一致

| 【示例】20220222-aSuncat：推荐该方法
- 由于obj没有length，我只能通过Object.keys()转化成数组
- 进入第二步，对象中的属性在另一个obj中是否存在。此处使用了Object.hasOwnProperty() 仅对该对象中的属性进行对比(避免obj继承了父级的属性)
- 承载第二步的基础对属性值进行比对。ES6中Object.is()来避免出现NaN不等于自身的问题
```javascript function compare(obj1,obj2){ const propObj1 = Object.getOwnPropertyNames(obj1); const propObj2 = Object.getOwnPropertyNames(obj2); if(propObj1.length !== propObj2.length){ return false } for(key in obj1){ if(obj2.hasOwnProperty(key)){ if( !Object.is(obj1[key],obj2[key])){ return false; } }else{ return false } } return true

}

 |
| --- |

| 【示例】下面的方法是在for循环比较对象的基础上发展而来，当对象是复合对象（对象的属性值是对象）时，就进行多层对象的比较```javascript
   function deepCompare(x, y) {
        var i, l, leftChain, rightChain;

        function compare2Objects(x, y) {
            var p;

            // remember that NaN === NaN returns false
            // and isNaN(undefined) returns true
            if (isNaN(x) && isNaN(y) && typeof x === 'number' && typeof y === 'number') {
                return true;
            }

            // Compare primitives and functions.     
            // Check if both arguments link to the same object.
            // Especially useful on the step where we compare prototypes
            if (x === y) {
                return true;
            }

            // Works in case when functions are created in constructor.
            // Comparing dates is a common scenario. Another built-ins?
            // We can even handle functions passed across iframes
            if ((typeof x === 'function' && typeof y === 'function') ||
                (x instanceof Date && y instanceof Date) ||
                (x instanceof RegExp && y instanceof RegExp) ||
                (x instanceof String && y instanceof String) ||
                (x instanceof Number && y instanceof Number)) {
                return x.toString() === y.toString();
            }

            // At last checking prototypes as good as we can
            if (!(x instanceof Object && y instanceof Object)) {
                return false;
            }

            if (x.isPrototypeOf(y) || y.isPrototypeOf(x)) {
                return false;
            }

            if (x.constructor !== y.constructor) {
                return false;
            }

            if (x.prototype !== y.prototype) {
                return false;
            }

            // Check for infinitive linking loops
            if (leftChain.indexOf(x) > -1 || rightChain.indexOf(y) > -1) {
                return false;
            }

            // Quick checking of one object being a subset of another.
            // todo: cache the structure of arguments[0] for performance
            for (p in y) {
                if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
                    return false;
                } else if (typeof y[p] !== typeof x[p]) {
                    return false;
                }
            }

            for (p in x) {
                if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
                    return false;
                } else if (typeof y[p] !== typeof x[p]) {
                    return false;
                }

                switch (typeof(x[p])) {
                    case 'object':
                    case 'function':

                        leftChain.push(x);
                        rightChain.push(y);

                        if (!compare2Objects(x[p], y[p])) {
                            return false;
                        }

                        leftChain.pop();
                        rightChain.pop();
                        break;

                    default:
                        if (x[p] !== y[p]) {
                            return false;
                        }
                        break;
                }
            }

            return true;
        }

        if (arguments.length < 1) {
            return true; //Die silently? Don't know how to handle such case, please help...
            // throw "Need two or more arguments to compare";
        }

        for (i = 1, l = arguments.length; i < l; i++) {

            leftChain = []; //Todo: this can be cached
            rightChain = [];

            if (!compare2Objects(arguments[0], arguments[i])) {
                return false;
            }
        }

        return true;
    }