判斷JavaScript中的兩個變量是否相等的操作符

var eq = function (a, b, aStack, bStack) {
	// Identical objects are equal. `0 === -0`, but they aren't identical.
	// See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
	//除了0 === -0這個特例之外，其余所有a === b的例子都代表它們相等。
	//應(yīng)當判斷0 !== -0，但是JavaScript中0 === -0。
	//下面這行代碼就是為了解決這個問題。
	//當a !== 0或者1/a === 1/b時返回true，一旦a === 0并且1/a !== 1/b就返回false。
	//而a === 0且1/a !== 1/b就代表a，b有一個為0，有一個為-0。
	if (a === b) return a !== 0 || 1 / a === 1 / b;
	//一旦a、b不嚴格相等，就進入后續(xù)檢測。
	//a == b成立但是a === b不成立的例子中需要排除null和undefined，其余例子需要后續(xù)判斷。
	// `null` or `undefined` only equal to itself (strict comparison).
	//一旦a或者b中有一個為null就代表另一個為undefined，這種情況可以直接排除。
	if (a == null || b == null) return false;
	// `NaN`s are equivalent, but non-reflexive.
	//自身不等于自身的情況，一旦a，b都為NaN，則可以返回true。
	if (a !== a) return b !== b;
	// Exhaust primitive checks
	//如果a，b都不為JavaScript對象，那么經(jīng)過以上監(jiān)測之后還不嚴格相等的話就可以直接斷定a不等于b。
	var type = typeof a;
	if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;
	//如果a，b是JavaScript對象，還需要做后續(xù)深入的判斷。
	return deepEq(a, b, aStack, bStack);
};

var deepEq = function (a, b, aStack, bStack) {
	// Unwrap any wrapped objects.
	//如果a，b是_的一個實例的話，需要先把他們解包出來再進行比較。
	if (a instanceof _) a = a._wrapped;
	if (b instanceof _) b = b._wrapped;
	// Compare `[[Class]]` names.
	//先根據(jù)a，b的Class字符串進行比較，如果兩個對象的Class字符串都不一樣，
	//那么直接可以認為兩者不相等。
	var className = toString.call(a);
	if (className !== toString.call(b)) return false;
	//如果兩者的Class字符串相等，再進一步進行比較。
	//優(yōu)先檢測內(nèi)置對象之間的比較，非內(nèi)置對象再往后檢測。
	switch (className) {
		// Strings, numbers, regular expressions, dates, and booleans are compared by value.
		//如果a，b為正則表達式，那么轉(zhuǎn)化為字符串判斷是否相等即可。
		case '[object RegExp]':
		// RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')
		case '[object String]':
			// Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
			// equivalent to `new String("5")`.
			//如果a， b是字符串對象，那么轉(zhuǎn)化為字符串進行比較。因為一下兩個變量：
			//var x = new String('12');
			//var y = new String('12');
			//x === y是false，x === y也是false，但是我們應(yīng)該認為x與y是相等的。
			//所以我們需要將其轉(zhuǎn)化為字符串進行比較。
			return '' + a === '' + b;
		case '[object Number]':
			//數(shù)字對象轉(zhuǎn)化為數(shù)字進行比較，并且要考慮new Number(NaN) === new Number(NaN)應(yīng)該要成立的情況。
			// `NaN`s are equivalent, but non-reflexive.
			// Object(NaN) is equivalent to NaN.
			if (+a !== +a) return +b !== +b;
			// An `egal` comparison is performed for other numeric values.
			//排除0 === -0 的情況。
			return +a === 0 ? 1 / +a === 1 / b : +a === +b;
		case '[object Date]':
		//Date類型以及Boolean類型都可以轉(zhuǎn)換為number類型進行比較。
		//在變量前加一個加號“+”，可以強制轉(zhuǎn)換為數(shù)值型。
		//在Date型變量前加一個加號“+”可以將Date轉(zhuǎn)化為毫秒形式；Boolean類型同上（轉(zhuǎn)換為0或者1）。
		case '[object Boolean]':
			// Coerce dates and booleans to numeric primitive values. Dates are compared by their
			// millisecond representations. Note that invalid dates with millisecond representations
			// of `NaN` are not equivalent.
			return +a === +b;
		case '[object Symbol]':
			return SymbolProto.valueOf.call(a) === SymbolProto.valueOf.call(b);
	}
 
	var areArrays = className === '[object Array]';
	//如果不是數(shù)組對象。
	if (!areArrays) {
		if (typeof a != 'object' || typeof b != 'object') return false;
 
		// Objects with different constructors are not equivalent, but `Object`s or `Array`s
		// from different frames are.
		//比較兩個非數(shù)組對象的構(gòu)造函數(shù)。
		var aCtor = a.constructor, bCtor = b.constructor;
		if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor &&
			_.isFunction(bCtor) && bCtor instanceof bCtor)
			&& ('constructor' in a && 'constructor' in b)) {
			return false;
		}
	}
	// Assume equality for cyclic structures. The algorithm for detecting cyclic
	// structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
 
	// Initializing stack of traversed objects.
	// It's done here since we only need them for objects and arrays comparison.
	//初次調(diào)用eq函數(shù)時，aStack以及bStack均未被傳遞，在循環(huán)遞歸的時候，會被傳遞進來。
	//aStack和bStack存在的意義在于循環(huán)引用對象之間的比較。
	aStack = aStack || [];
	bStack = bStack || [];
	var length = aStack.length;
	
	while (length--) {
		// Linear search. Performance is inversely proportional to the number of
		// unique nested structures.
		if (aStack[length] === a) return bStack[length] === b;
	}
 
	// Add the first object to the stack of traversed objects.
	//初次調(diào)用eq函數(shù)時，就把兩個參數(shù)放入到參數(shù)堆棧中去，保存起來方便遞歸調(diào)用時使用。
	aStack.push(a);
	bStack.push(b);
 
	// Recursively compare objects and arrays.
	//如果是數(shù)組對象。
	if (areArrays) {
		// Compare array lengths to determine if a deep comparison is necessary.
		length = a.length;
		//長度不等，直接返回false認定為數(shù)組不相等。
		if (length !== b.length) return false;
		// Deep compare the contents, ignoring non-numeric properties.
		while (length--) {
			//遞歸調(diào)用。
			if (!eq(a[length], b[length], aStack, bStack)) return false;
		}
	} else {
		// Deep compare objects.
		//對比純對象。
		var keys = _.keys(a), key;
		length = keys.length;
		// Ensure that both objects contain the same number of properties before comparing deep equality.
		//對比屬性數(shù)量，如果數(shù)量不等，直接返回false。
		if (_.keys(b).length !== length) return false;
		while (length--) {
			// Deep compare each member
			key = keys[length];
			if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;
		}
	}
	// Remove the first object from the stack of traversed objects.
	//循環(huán)遞歸結(jié)束，把a，b堆棧中的元素推出。
	aStack.pop();
	bStack.pop();
	return true;
};

var a = {
  name: 'test'
};
a['test1'] = a;
var b = {
  name: 'test'
};
b['test1'] = b;
_.isEqual(a, b);
//true

aStack = aStack || [];
bStack = bStack || [];
var length = aStack.length;
while (length--) {
  // Linear search. Performance is inversely proportional to the number of
  // unique nested structures.
  if (aStack[length] === a) return bStack[length] === b;
}

var size = a.size;
// Ensure that both objects are of the same size before comparing deep equality.
if (b.size !== size) return false;
while (size--) {
  // Deep compare the keys of each member, using SameValueZero (isEq) for the keys
  if (!(isEq(a.keys().next().value, b.keys().next().value, aStack, bStack))) return false;
  // If the objects are maps deep compare the values. Value equality does not use SameValueZero.
  if (className === '[object Map]') {
    if (!(eq(a.values().next().value, b.values().next().value, aStack, bStack))) return false;
  }
}