// 冒泡 三种方式， 冒泡，选择，快速排序；
// 时间复杂度/空间复杂度/稳定性，三方面评估

var arr = [1,3,2,34,523,32324,234,23,4,32];

function bubleSort(arr) {
    for (let index = 0; index < arr.length; index++) {
        for (let indexInner = index; indexInner < arr.length; indexInner++) {
            if(arr[index] > arr[indexInner]) {
                [arr[index], arr[indexInner]] = [arr[indexInner], arr[index]]
            }
        }
    }
    return arr;
}


function selectSort(arr) {
    for (let index = 0; index < arr.length - 1; index++) {
        for (let indexInner = index; indexInner < arr.length; indexInner++) {
            if(arr[index] > arr[indexInner]) {
                [arr[index], arr[indexInner]] = [arr[indexInner], arr[index]]
            }            
        }
    }
    return arr;
}

// 快排 ---> 递归实现
function quickSort(arr) {
    if(arr.length <= 1) {
        return arr;
    }
    var left = [],
        right = [],
        current = arr.splice(0,1); 
    for(let i = 0; i < arr.length; i++) {
        if(arr[i] < current) {
            left.push(arr[i])
        } else {
            right.push(arr[i])
        }
    }
    return quickSort(left).concat(current, quickSort(right));
}


// 斐波那契
function fb(n) {
    if(n === 1 || n === 2) {
        return 1;
    } else {
        return fb(n-1) + fb(n-2)
    }
}

// 尾递归优化 666
function fbByW(n, a1 = 1, a2 = 1) {
    if(n === 1) {
        return a1;
    } else if(n === 2) {
        return a2;
    }
    return fbByW(n-1, a2, a1+a2)
}



var a = {
    "name": 'ljq',
    age: 28,
    features: {
        love: 'xxz',
        link: '264@qq.com'
    }
}

var obj = new Proxy(a, {
    get: function (target, propKey, receiver) {
      console.log(`getting ${propKey}!`);
      return Reflect.get(target, propKey, receiver);
    },
    set: function (target, propKey, value, receiver) {
      console.log(`setting ${propKey}!`);
      return Reflect.set(target, propKey, value, receiver);
    }
});

// 防抖
// 触发高频事件后 n 秒后函数只会执行一次，如果 n 秒内高频事件再次被触发，则重新计算时间
function debounce(fn, time = 200) {
    // 创建定时器id
    let timer = null;
    return function () {
        if (timer) clearTimeout(timer);
        timer = setTimeout(() => {
            // 间隔内如果还有字符输入的话，就不会执行 fn 函数
            fn.apply(this, arguments)
        }, time);
    }
}


// 节流
//高频事件触发，但在 n 秒内只会执行一次，所以节流会稀释函数的执行频率
function throttle(fn, time = 200) {
    let run = true;
    return function () {
        if (!run) return;
        // 修改可执行标志run
        run = false;
        setTimeout(() => {
            fn.apply(this, arguments)
            run = true
        }, time)
    }
}


// 深度优先遍历 广度有限遍历 TODO？？
function deepTraversal(node) {
    let nodes = [];
    if (node !== null) {
        nodes.push(node);
        let children = node.children;
        for (let index = 0; index < children.length; index++) {
            deepTraversal(children[index])
        }
    }
    return nodes;
}

function wideTraversal(node) {
    let nodes = [],
        i = 0;
    if (node != null) {
        nodes.push(node);
        wideTraversal(node.nextElementSibling);
        node = nodes[i++];
        wideTraversal(node.firstElementChild);
    }
    return nodes;
}


// 深拷贝
// 需注意循环引用，利用hash； 特殊类型处理，Date/RegExp/Function等处理；
// 参考lodash.js实现

//Q: 使用 Set 方法去重，flat(Infinity)扁平化
var arr = [[1, 2, 2], [3, 4, 5, 5], [6, 7, 8, 9, [11, 12, [12, 13, [14]]]], 10];
Array.from(new Set(arr.flat(Infinity))).sort((a, b) => { return a - b })
//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]


// 数组扁平化
Array.prototype.myflat = function (d = Infinity) {
    return d > 0 ? 
        this.reduce((acc, val) => acc.concat(Array.isArray(val) ? val.myflat(d - 1) : val), [])
        : this.slice();
}

// 如何实现一个new，new实例发生了什么？
// new 操作符做了这些事：

// 创建一个全新的对象，这个对象的 __proto__ 要指向构造函数的原型对象
// 执行构造函数
// 返回值为 object 类型则作为 new 方法的返回值返回，否则返回上述全新对象
function myNew(fn, ...args) {
    let instance = Object.create(fn.prototype);
    let res = fn.apply(instance, args);
    return typeof res === 'object' ? res: instance;
}


// 柯里化 add(1)(2)(3)
function add() {
  let args = [].slice.call(arguments);
  
  let fn = function(){
   let fn_args = [].slice.call(arguments)
   return add.apply(null,args.concat(fn_args))
  }
  
  fn.toString = function(){
    return args.reduce((a,b)=>a+b)
  }
  
  return fn
}

// 执行结果 https://blog.csdn.net/yun_hou/article/details/88697954
async function async1() {
    console.log('async1 start')
    await async2()
    console.log('async1 end')
}
async function async2() {
    console.log('async2')
}
console.log('script start')
setTimeout(function() {
    console.log('setTimeout')},
0) 
async1()
new Promise(function(resolve) {
    console.log('promise1')
    resolve()
}).then(function() {
    console.log('promise2')
})
console.log('script end')


// script start
// async1 start
// async2
// promise1
// script end
// asnyc1 end
// promise2
// setTimeOut

//千位分隔符
function parseToMoney(num) {
    num = parseFloat(num.toFixed(3));
    let [integer, decimal] = String.prototype.split.call(num, '.');
    integer = integer.replace(/\d(?=(\d{3})+$)/g, '$&,');
    return integer + '.' + (decimal ? decimal : '');
}

// 解析URL params
// 1,自己封装；
// 2,使用现有new URL(url).searchParams
function parseParam(url) {
    const paramsStr = /.+\?(.+)$/.exec(url)[1]; // 将 ? 后面的字符串取出来
    const paramsArr = paramsStr.split('&'); // 将字符串以 & 分割后存到数组中
    let paramsObj = {};
    // 将 params 存到对象中
    paramsArr.forEach(param => {
      if (/=/.test(param)) { // 处理有 value 的参数
        let [key, val] = param.split('='); // 分割 key 和 value
        val = decodeURIComponent(val); // 解码
        val = /^\d+$/.test(val) ? parseFloat(val) : val; // 判断是否转为数字
  
        if (paramsObj.hasOwnProperty(key)) { // 如果对象有 key，则添加一个值
          paramsObj[key] = [].concat(paramsObj[key], val);
        } else { // 如果对象没有这个 key，创建 key 并设置值
          paramsObj[key] = val;
        }
      } else { // 处理没有 value 的参数
        paramsObj[param] = true;
      }
    })
  
    return paramsObj;
  }