sort方法原理、深浅拷贝、async,await异常捕获

sort方法原理

Array.prototype.sortTest = function (arguments) {
            let fn = arguments ? typeof arguments === "function" && arguments : (x, y) => x - y;
            for (var i = 0; i < this.length; i++) {
                for (var j = i + 1; j < this.length; j++) {
                    if (fn(this[i], this[j]) > 0) {
                        p = this[i];
                        this[i] = this[j];
                        this[j] = p;
                    };
                };
            };
            return this;
        }

        var add = (x, y) => x - y;
        var des = (x, y) => y - x;
        var arr = [10, 44, 5, 78, 1, 99];
        var arr1 = [10, 44, 5, 78, 1, 99];
        var arr2 = [10, 44, 5, 78, 1, 99];
        var arr3 = [10, 44, 5, 78, 1, 99];
        // console.log(arr.sortTest(add));//[1, 5, 10, 44, 78, 99]
        // console.log(arr1.sort(add));//[1, 5, 10, 44, 78, 99]
        // console.log(arr2.sortTest(des));//[99, 78, 44, 10, 5, 1]
        // console.log(arr3.sort(des));//[99, 78, 44, 10, 5, 1]

深浅拷贝

// 浅拷贝一
        function shallowCloneCopy(target) {
            if (typeof target === 'object' && target !== null) {
                const cloneTarget = Array.isArray(target) ? [] : {}
                for (let prop in target) {
                    if (target.hasOwnProperty(prop)) {
                        // cloneTarget[prop] = shallowClone(target[prop]) 深拷贝
                        cloneTarget[prop] = target[prop]

                    }
                }
                return cloneTarget
            } else {
                return target
            }
        }

        // 深拷贝二
        function shallowClone(target) {
            if (typeof target === 'object' && target !== null) {

                return JSON.parse(JSON.stringify(target))
            } else {
                return target
            }
        }

        const shallowCloneObj = shallowClone(obj1)

        console.log(shallowCloneObj === obj1)  // false，返回的是一个新对象
        console.log(shallowCloneObj.arry === obj1.arry)

        // 深拷贝第三种
        function clone(obj, hash = new WeakMap()) {
            // 判断是否为 null 或者 typeof 返回类型是否为 object
            if (obj == null || typeof obj !== "object") return obj;
            else if (obj instanceof Date) return new Date(obj);
            else if (obj instanceof RegExp) return new RegExp(obj);

            // 判断集合是否有这个属性，有则直接 return obj
            if (hash.has(obj)) return hash.get(obj)
            const newObj = new obj.constructor();

            // 将属性和拷贝后的值作为一个map
            hash.set(obj, newObj);

            // 遍历 obj
            for (let key in Object.getOwnPropertyDescriptors(obj)) {
                // 过滤掉原型身上的属性
                if (obj.hasOwnProperty(key)) {
                    // 递归拷贝
                    newObj[key] = clone(obj[key], hash);
                }

            }
            return newObj;
        }

async,await异常捕获

// 捕获async await异常
async function asyncAwaitError(fn) {
  try {
    let resp = await fn;
    return [null, resp];
  } catch (err) {
    return [err, null];
  }
}


//使用
async getList5() {
			let [err, res] = await this.asyncAwaitError(this.httpTest());
			console.log('res===>', res);
            console.log('err===>', err);
}