js

一、查值的类型（可用于拷贝）

/*
 * @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"]))