/*
我们要来判断两个对象是否相等：
首先特殊的是+0和-0，我们知道这两个值是等同的，结果是true
*/
console.log(+0==-0)//true
// 表现2
//(-0).toString() // '0'
//(+0).toString() // '0'
// 表现3
-0 < +0 // false
+0 < -0 // false
/*
但是也有其特殊的差异性
1/+0=+lnfinit 正无穷大
1/-0=-lnfinity 负无穷大
这是因为 JavaScript 采用了IEEE_754 浮点数表示法(几乎所有现代编程语言所采用)，这是一种二进制表示法，
按照这个标准，最高位是符号位(0 代表正，1 代表负)，剩下的用于表示大小。而对于零这个边界值 ，
1000(-0) 和 0000(0)都是表示 0 ，这才有了正负零的区别。
我们再使用 math.round（-0.1）四舍五入的时候得到这个-0
那么我们如何去区分呢
*/
function kio(a,b){
if(a===b){
//首先a和b是相等的 然后走进这里，如果a不等于0，那么a和b就不能判断，或者b不等于零也不能判读，，
//而1/a和1/b的判断是核心，因为1/+0得到是正无穷大+lnfinity 而1/b得到是负无穷大 是不成里相等的，所有就区分了
//+0和-0的区别
return a!==0 || 1/a==1/b
}
return false
}
kio(0,-0)
console.log( kio(-0,+0))
/*
上面说了+0和-0的区别 还有一个nan这个值 ，这个值有个特点就是nan不等于他自己nan
*/
function kop(a,b){
/*if(a!==b){
return true
}else{
return false
}*/
if(a!==a){
return b!==b
}
}
kop(NaN,NaN)
console.log(kop(NaN,NaN))
/*
根据上面的代码，我们写出来了+0和-0，NaN之间怎么去判断区别的，那么我们下面可以写一个总结的版本的
*/
function kio(a,b){
//首先我们先来区别+0和-0
if(a===b) return a!==0 || 1/a==1/b;
//然后我们阿里判断当a等于null和b等于null的情况
if(a==null||b==null) return false;
//这里是判断NaN的情况
if(a!==a) return b!==b;
//判断参数a的类型，如果是基本类型，这里可以直接返回false
/*
也许你会好奇是不是少了一个 `typeof b !== function`?
试想如果我们添加上了这句，当 a 是基本类型，而 b 是函数的时候，就会进入 deepEq 函数，而去掉这一句，
就会进入直接进入 false，实际上 基本类型和函数肯定是不会相等的，所以这样做代码又少，又可以让一种情况更早退出。
*/
var type=typeof a
if(type!="function" && type!=="object" && typeof b!=="object" ) return false
// 更复杂的对象使用 deepEq 函数进行深度比较
return deepEq(a, b);
}
/*
下面我们如何比较：
"cur"和new String("cur") 据我们知道typeof是不能获得对象形式的数据类型的，因为最后都会的大object，而我们学的还有一种办法
,就是object.prototype.tostring,call()如果是data，match会获得“【object data】”，这种字符串，但是"cur"和new String("cur")返回
的都是[object string] ,所以就没办法去比较了，其实还是有的，用隐式类型转换
+" "这个是可以转换为字符串的方式的
字符串的比较规则是，如果两边都是字符串，那么就一一对比字符编码，来判断是否相等
*/
console.log("cur"+" "===new String("cur") +" ")
/*
那么下面可以封装一个判断函数
*/ var tostrign=Object.prototype.toString()
function jio(a,b){
var classaa=Object.prototype.toString.call(a)
if(classaa!==Object.prototype.toString.call(b)) return false;
switch(classaa){
//case:'[Object object]':
//return "aaaa"
case '[Object string]':
return " "+a===" "+b;
case '[object Number]':
if (" "+a !== " "+a) return " "+b !== " "+b;
return +a === 0 ? 1 / +a === 1 / b : +a === +b;
//case '[object Date]':
//return "aaaa"
case '[object Boolean]':
return " "+a === " "+b;
}
}
jio(true,false)
console.log(jio(NaN,NaN))
console.log(jio(true,new Boolean(true)))
/*
判断两个函数是否相等呢？
function Person() {
this.name = name;
}
function Animal() {
this.name = name
}
var person = new Person('Kevin');
var animal = new Animal('Kevin');
eq(person, animal)
我们要判断，这两个函数，是否相等，我们能判断么？？？他俩相等么？
虽然 `person` 和 `animal` 都是 `{name: 'Kevin'}`，但是 `person` 和 `animal` 属于不同构造函数的实例，
为了做出区分，我们认为是不同的对象。
```js
//Object.create() 方法会使用指定的原型对象及其属性去创建一个新的对象。
var attrs = Object.create(null);
attrs.name = "Bob";
eq(attrs, {name: "Bob"}); // ???
```
尽管 `attrs` 没有原型，`{name: "Bob"}` 的构造函数是 `Object`，但是在实际应用中，只要他们有着相同的键值对，
我们依然认为是相等。
从函数设计的角度来看，我们不应该让他们相等，但是从实践的角度，我们让他们相等，
所以相等就是一件如此随意的事情吗？！对啊，我也在想：undersocre，你怎么能如此随意呢！！！
哎，吐槽完了，我们还是要接着写这个相等函数，我们可以先做个判断，对于不同构造函数下的实例直接返回 false。
*/
function isFunction(obj) {
return toString.call(obj) === '[object Function]'
}
function deepEq(a, b) {
// 接着上面的内容
var areArrays = className === '[object Array]';
// 不是数组
if (!areArrays) {
// 过滤掉两个函数的情况
if (typeof a != 'object' || typeof b != 'object') return false;
var aCtor = a.constructor, bCtor = b.constructor;
// aCtor 和 bCtor 必须都存在并且都不是 Object 构造函数的情况下，aCtor 不等于 bCtor，
// 那这两个对象就真的不相等啦
if (aCtor == bCtor && !(isFunction(aCtor) && aCtor instanceof aCtor && isFunction(bCtor)
&& bCtor instanceof bCtor) && ('constructor' in a && 'constructor' in b)) {
return false;
}
}
// 下面还有好多判断
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
