1. var Test = function () {
    3. }
    4. var t = new Test();
    5.   t.__proto__ === Test.prototype;
    8. // Function Object Boolean String Number
    11. // Object->Function -> Test -> t
    14. // t.__proto__ -> Test.prototype
    16. // Test.__proto__ -> Function.prototype;
    18. // Function.__proto__ -> Object.prototype;
    23. // Function   Object   之间的关系
    24. // 共同点
    25. // 都是一个函数
    26. // 函数也是一个特殊的对象.
    27. // Function.__proto__ Object.__proto__
    28. // Function.prototype Object.prototype
    30. // Function 是所有函数的构造函数
    31. // Object.__proto__ ->Function.prototype
    34. function deepClone (target,origin) {
    35.   var tar = origin || {},
    36.     oStr = Object.prototype.toString,
    37.     arrayStr = '[object Array]';
    38.   for (var k in target) {
    39.     if (!target.hasOwnProperty(k)) {
    40.       return;
    41.      }
    42.     if (typeof target[k] === 'object' && target[k] !== null) {
    43.       if (oStr.call(target[k]) !== arrayStr) {
    44.         tar[k] =  deepClone(target[k],{});
    45.       } else {
    46.         tar[k] = deepClone(target[k], []);
    47.       }
    48.     } else {
    49.       tar[k] = target[k];
    50.     }
    51.   }
    52.   return tar;
    53. }
    58. Object.defineProperty(Object, 'assigns', {
    59.   value:function (tar) {
    60.     if (tar == null || tar == undefined) {
    61.       throw new TypeError('can not conver null or undefined to obect');
    62.     }
    63.     tar = Object(tar);
    64.     for (var i = 1; i < arguments.length; i++) {
    65.       for (var k in arguments[i]) {
    66.         tar[k] = arguments[i][k];
    67.       }
    68.     }
    69.     return tar;
    70.   }
    71. })
    73. // ES6 版本 四种相等判断算法
    75. // 全等 三等 ===
    76. //   等于 ==
    77. //   零值相等 + 0 === -0
    78. // 同值相等 - 0 !== +0 NaN === NaN
    80. // 严格相等 === Strict Equality
    81. // 非严格相等 loose
    82. // Object.is(v1, v2); ES6 判断两个参数是否是同一个值
    84. // 严格相等
    85. // 不进行类型转换 类型相同 值也相同
    86. // 1 === '1' 1 === 2;
    87. // 引用值必须是同一个地址
    88. // var obj = {} obj=== obj {}==={}//false
    89. // 两个NaN 或者是NaN和其他值都不相等
    90. // NaN === NaN false NaN === undefined? false
    91. // +0 和 -0 是否相等
    92. // -0 === +0;
    93. // + Infinity与-Infinity 相等
    94. // +Infinity === -Infinity 不相等
    97. // 如何定义a
    98. // a !== a 成立 a = NaN;
    101. // 非严格相等 Abstract Equality  抽象相等
    102. // 等式两边 都有可能被转换
    103. // 转换以后还是用严格相等来比较
    104. // ToPrimitive(A)通过尝试调用 A 的A.toString() 和 A.valueOf() 方法，将参数 A 转换为原始值（Primitive）。
    106. //  任何对象 和 undefined 和 null 都不想等
    107. //  窄对象 narrow Object -> document.all('div');
    108. // IE 4 document.all typeof document.all === 'undefined' IE10 之前typeof document.all === 'object'
    109. // document.all == undefined // true
    111. // 全等对结果的预测是更加清晰明确的.
    112. // 全等在不隐式类型转换的前提下会更快.
    114. // falsy值  "" '' `` +0 -0 false 8nBigInt null undefined NaN
    117. // 同值相等 same-value
    118. // 零值相等 same-value-0 +0=== -0;
    120. // -0 !=== +0 // false => 同值相等
    121. // NaN === NaN // true => 同值相等
    122. // 同值相等的底层实现是用Object.is 来实现的.
    123. // Object.is 是ES6 抛出的方法 ES5 并未暴露同值相等的方法
    125. Object.defineProperty(obj, 'myZero', {
    126.   value: -0,
    127.   enumerable: false,
    128.   configurable: false,
    129.   writable:false
    130. })
    131. Object.defineProperty(obj, 'myZero', {
    132.   value: -0,
    133.   enumerable: false,
    134.   configurable: false,
    135.   writable:false
    136. })
    138. var obj = {};
    139. const res = Object.is(obj, obj);//true
    140. // Object.is 判断标准就是同值相等.同一个引用相等. 不同引用不相等
    141. // 不进行隐式类型转换.