一、查值的类型（可用于拷贝）
/*
* @Author: guojufeng@
* @Date: 2017-12-20 15:07:06
* @purpose 获取一个值的类型
* @param {variateName} target: 要获取类型的变量名或对象
* @output {string} result || "null": 返回的参数 - result或者null,为字符串形式的
*/
getType: function (target) {
if (target === null) {
console.log("getType类型判断为: " + target)
return "null";
}
let result = typeof (target);
if (result == "object") {
if (target instanceof Array) {
result = "array";
} else if (target instanceof Object) {
let target = Object.prototype.toString.call(target);
if (target == "[object Object]") {
result = "object";
} else {
result = target;
}
}
}
console.log("getType类型判断为: " + result)
return result; //返回类型值的字符串形式
}
应用：
var nu= null;// null 怎么算
var un= undefined;
var c = new Array;
var d = {};
console.log(getType(c),getType(d),getType(nu),getType(un))
二、深拷贝
接上一个方法，实现深拷贝。
/* 思路 */
查值的类型
三种方法：1、instanceof 2、Object.prototype.toString.call(target) 3、target.constuctor
如果是原始值
就直接复制
如果是引用值，
则进行遍历，查看每一项的具体类型
如果是数组，新建一个数组，forEach时把每一项抛进新数组
如果是对象，新建一个对象，for in时让新旧对象的键值一一对应
遍历过程中，再次判断引用类型值的每一项
如果是原始值，就直接复制
如果是引用值，就继续看具体类型、新建对应类型、一一遍历
遍历过程中，再次判断引用类型值的每一项，
如果是原始值，就直接复制
如果是引用值，就继续看具体类型、新建对应类型、一一遍历
遍历~~~【->-> 递归】
/*
* @Author: guojufeng@
* @Date: 2018-10-30 20:48:44
* @purpose 深度克隆
* @param {variateName} origin: 要克隆的对象变量名
* @output {对应值} 根据origin的类型返回的具体值
*/
function deepClone(origin) {
let type = getType(origin),
target;
if (type == "array") {
target = [];
/* 数组 */
origin.forEach(el = >{
console.log("ele", el) target.push(deepClone(el));
});
} else if (type == "object") {
/* 对象 */
target = {};
for (const key in origin) {
if (origin.hasOwnProperty(key)) {
/* 注意，只拷贝元素身上的，而不拷贝其原型上的值 */
const el = origin[key];
target[key] = deepClone(el);
}
}
} else if (type == "function") {
/* 函数 */
target = function() {};
target = origin;
} else {
/* 原始值 */
target = origin;
}
return target;
}
应用：
var test = [1, 2, null, undefined, false, [3, 4]];
var res = deepClone(test);
console.log(res, getType(res))
res.push(222);
console.log(res)
console.log(test)
var test1 = {
a: 1,
b: 2,
c: [1, 2],
d: function() {
console.log(this.d)
}
};
var res1 = deepClone(test1);
console.log(res1, getType(res1))
res1.b = 3;
res1.c.push('test');
console.log("res1修改值", res1);
console.log("test1原始值", test1);
res1.d = null;
console.log("res1修改值", res1);
console.log("test1原始值", test1);
简单类型的值克隆就不说了，这里举例了两个：一个克隆数组，一个克隆对象。
这个是克隆数组后，新数组增加值与元素组的比较。可以发现，新数组 res 虽然新增了值，但是对旧数组 test 没有影响。
说明这种引用类型的克隆不是简单的复制了一个指针。
还有这个对象的克隆，新对象 res1 增添自己属性上数组的值【res1.c.push('test');】以及修改销毁自身的函数【res1.d = null;】，对于原对象 test1 都没有任何影响。
三、纯数字数组的排序
升序、降序、乱序（主要是对sort方法的简单应用与封装）。
/*
* @Author: guojufeng@
* @Date: 2018-10-30 20:48:44
* @params {array}: 要排序的数组
* @params {type}: 数字，表示期望排序的顺序：1升序，2降序，3乱序
*/
function getSort(array, type) {
if (xingorg1Utils.getType(array) == "object") {
/* 伪数组转换为数组 */
array = Array.prototype.slice.call(array);
}
array.sort((a, b) = >{
/*
原理：返回值比较
当返回值为负数时，两个参数中前面的数放在前边
当返回值为正数时，两个参数中后面的数放在前边
当返回值为0时，参数位置不动
a,b代表当时比较的两位数，前边大于后边的，相减自然得正数。前边小于后边得，
*/
if (type == 1) {
return a - b;
// return 1;这样直接返回一个正数是不行额。
} else if (type == 2) {
return - a + b;
// return -1;这样直接返回一个负数是不行额。
} else if (type == 3) {
/* 原理就是，math randow返回得时0-1得开区间，拿返回得数减去0.5的话，则会随机返回正数或者负数。正数就前边得放前边，负数就后边的放前边。总之就是乱来。 */
let nowNum = Math.random();
// console.log(nowNum,nowNum-0.5)
return nowNum - 0.5;
}
}) return array;
}
应用：
var arr = [12,61,7,21,357,215357,923,9723,53,1];
console.log(getSort(arr,1))
console.log(getSort(arr,2))
console.log(getSort(arr,3))
四、数组去重
/* 思路 */
准备一个对象和一个新数组，
循环原数组时，将数组的值当做对象的键，且对应值为true（/1皆可），
然后每次拿原数组的下一个值都去判断一下对象中是否有这个值，
没有再push到新数组中去，最后返回新数组。
/*
* @Author: guojufeng@
* @Date: 2018-11-05 09:35:14
* 数组去重
* @params {arr}: 要去重的原数组
* @return {newArr}: 返回去重后的数组
*/
uniqArr: function (arr) {
var obj = {},
newArr = [];
obj[arr[0]] = true;
newArr.push(arr[0]);
arr.forEach((element) => {
if (!obj[element]) {
obj[element] = true;
newArr.push(element);
}
});
return newArr;
}
}
应用：
console.log(uniqArr([1, 2, 23, 1, 35, 1, 6, 34]))
console.log(uniqArr([1, 2, 23, 1, "gjf", 1, 6, "gjf","gfj"]))