const formatNum=(row, column)=> { 
	// 获取单元格数据 
	let data = row[column.property];
	if(data == 0)
		return null;
	else
		return data
}
const formatTableDateTime=(row, column)=> {
	// 获取单元格数据
	let data = row[column.property];
	if(data == null)
		return null;

	let dt = new Date(data)
	return dt.getFullYear() + '-' + (dt.getMonth() + 1) + '-' + dt.getDate() + ' ' + dt.getHours() + ':' + dt.getMinutes()// + ':' + dt.getSeconds()
}
const formatTableDate=(row, column)=> {
	// 获取单元格数据
	let data = row[column.property];
	if(data == null)
		return null;

	let dt = new Date(data)
	return dt.getFullYear() + '-' + (dt.getMonth() + 1) + '-' + dt.getDate()
}
const formatDateTime=(data)=> {
	let dt = new Date(data)
	return dt.getFullYear() + '-' + (dt.getMonth() + 1) + '-' + dt.getDate() + ' ' + dt.getHours() + ':' + dt.getMinutes() + ':' + dt.getSeconds()
}
const formatDate=(data)=> {
	let dt = new Date(data)
	return dt.getFullYear() + '-' + (dt.getMonth() + 1) + '-' + dt.getDate()
}
const show_loading=()=> {
	const loading = ElLoading.service({
		lock: true,
		text: 'Loading',
		background: 'rgba(0, 0, 0, 0.7)',
	})
	return loading
}
const close_loading=(loading)=> {
	if(loading)
		return loading.close()

	loading = ElLoading.service({
		lock: true,
		text: 'Loading',
		background: 'rgba(0, 0, 0, 0.7)',
	})
	loading.close()
}

//单层对比
const objCompare=(o1,o2,o1IsSubset=false)=>{
	var props1 = Object.getOwnPropertyNames(o1);
	var props2 = Object.getOwnPropertyNames(o2);
	if (!o1IsSubset && props1.length != props2.length) {
			return false;
	}
	var max = props1.length
	for (var i = 0; i < max; i++) {
			var propName = props1[i];
			if (o1[propName] !== o2[propName]) {
					return false;
			}
	}
	return true;
}
//深度对比多层复杂对象是否相等
const 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;
}
export default () => ({ formatNum,formatTableDateTime,formatTableDate,formatDateTime,formatDate,
	show_loading,close_loading,objCompare,deepCompare})
