function promiseAll(promises){
    return new Promise((resolved, rejected) => {
        let resultCount = 0;
        let results = new Array(promises.length);

        for(let i = 0; i < promises.length; i++){
            promises[i].then(value => {
                resultCount++
                results[i] = value
                if(resultCount === promises.length){
                    return resolved(results)
                }
            }, error => {
                rejected(error)
            })
        }
    })
}

const data = [
  { id: 1, text: 't1', parentId: 0 },
  { id: 11, text: 't11', parentId: 1 },
  { id: 12, text: 't12', parentId: 1 },
  { id: 2, text: 't2', parentId: 0 },
  { id: 21, text: 't21', parentId: 2 },
  { id: 3, text: 't3', parentId: 0 }
]

function arrToTree(data, id, parentId, children){
  let cloneData = JSON.parse(JSON.stringify(data))
  return cloneData.filter(father => {
    let newArr = cloneData.filter(child => {
      return father[id] === child[parentId]
    })
    father[children] = newArr
    return father[parentId] === 0
  })
}

const treeData = arrToTree(data, 'id', 'parentId', 'children')

function deepClone(obj){
    function isObject(o){
        return (typeof o === 'object' || typeof o === 'function') && o !== null
    }

    if(!isObject(obj)){
        throw new Error('非对象')
    }

    let isArray = Array.isArray(obj)
    let newObj = isArray ? [...obj] : {...obj}
    Reflect.ownKeys(newObj).forEach(key => {
        newObj[key] = isObject(obj[key]) ? deepClone(obj[key]) : obj[key]
    })

    return newObj
}

const a = [];
console.log(a instanceof Array); //true

const a = [];
Object.prototype.toString.call(a); // "[object Array]"
Object.prototype.toString.apply(a); // "[object Array]"

const a = [];
Array.isArray(a); //true

function debounce(func, wait) {
    let timer = null;
    return function (...args){
        clearTimeout(timer);
        timer = setTimeout(() => {
            func.apply(this, args)
        }, wait)
    }
}

function debounce(event, wait, flag) {
    let timer = null;
    return function (...args) {
        clearTimeout(timer)
        if (!timer && flag) {
            event.apply(this, args)
        } else {
            timer = setTimeout(() => {
                event.apply(this, args)
            }, wait)
        }
    }
}

window.addEventListener('resize', debounce(handleResize, 200))

debounce(fetchSelectData, 300)

debounce(validator, 1000)

function throttle(func, wait) {
    let pre = 0, timer = null;
    return function (...args) {
        if (new Date() - pre > wait) {
            clearTimeout(timer);
            timer = null;
            pre = new Date();
            func.apply(this, args)
        } else {
            timer = setTimeout(() => {
                func.apply(this, args)
            }, wait)
        }
    }
}

window.addEventListener('scroll', throttle(handleScroll, 200))

throttle(fetchInput, 300)

function compose(...fns) { // fns是传入的函数
  const fn = fns.pop();
  return (...args) => {
    fn(...args);
    if (fns.length > 0) {
      compose(...fns);
    }
  };
}

(function(globalVariable){
    globalVariable.test = function(){}
    // ...声明各种变量、函数都不会污染全局作用域
})(globalVariable)

// AMD(require.js)
define(['./a', './b'], function(a, b){
    // 加载完毕可以使用
    a.do()
    b.do()
})

// CMD(sea.js)
define(function(require, exports, module){
    // 可以把require写在函数体的任意地方实现延迟加载
    var a = require('./a')
    a.do()
})

// 引入模块
const path = require('path')
// 导出模块
const path = () => {}
module.exports = path

// 引入模块
import path from 'path'
import { doSomeThing } from 'path'
// 导出模块
export const doSomeThing = () => {}
export default path

let p = new Proxy(target, handler)

let xiaoming = {
    name: '小明',
    age: 30
}
xiaoming = new Proxy(xiaoming, {
    get(target, key){
        let result = target[key]
        if(key === 'age') result += '岁'
        return result
    },
    set(target, key, value){
        if(key === 'age' && typeof value !== 'number'){
            throw Error('age字段必须是number类型')
        }
        return Reflect.set(target, key, value)
    }
})
console.log(`我叫${xiaoming.name} 我今年${xiaoming.age}了`) // 我叫小明，我今年30岁了

const PENDING = 'pending'
const RESOLVED = 'resolved'
const REJECTED = 'rejected'

function MyPromise(fn){
    const that = this
    that.state = PENDING
    that.value = null
    that.resolvedCallbacks = []
    that.rejectedCallbacks = []

    function resolve(value){
        if(that.state === PENDING){
            that.state = RESOLVED
            that.value = value
            that.resolvedCallbacks.map(cb => cb(that.value))
        }
    }

    function reject(value){
        if(that.state === PENDING){
            that.state = REJECTED
            that.value = value
            that.rejectedCallbacks.map(cb => cb(that.value))
        }
    }

    try{
        fn(resolve, reject)
    }catch(e){
        reject(e)
    }
}

MyPromise.prototype.then = function(onFulfilled, onRejected){
    const that = this
    onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : v => v
    onRejected = typeof onFulfilled === 'function' ? onRejected : err => { throw err }

    if(that.state === PENDING){
        that.resolvedCallbacks.push(onFulfilled)
        that.rejectedCallbacks.push(onRejected)
    }

    if(that.state === RESOLVED){
        onFulfilled(that.value)
    }

    if(that.state === REJECTED){
        onRejected(that.value)
    }
}

new MyPromise((resolve, reject) => {
    setTimeout(() => {
        resolve(1)
    }, 0)
}).then(value => {
    console.log(value)
})

typeof 1 // 'number'
typeof '1' // 'string'
typeof undefined // 'undefined'
typeof true // 'boolean'
typeof Symbol // 'symbol'

typeof [] // 'object'
typeof {} // 'object'
typeof console.log // 'function'

const Person = function() {}
const p1 = new Person()
p1 instanceof Person // true

var str = 'hello world'
str instanceof String // true

var str1 = new String('hello world')
str1 instanceof String // true

function foo(){
    console.log(this.a)
}
var a = 1
foo()

const obj = {
    a: 2,
    foo: foo
}
obj.foo()

const c = new foo()

function a(){
    return () => {
        return () => {
            console.log(this)
        }
    }
}
console.log(a()())

let a = {}
let fn = function() { console.log(this) }
fn.bind().bind(a) // window

function A(){
    let a = 1
    window.B = function(){
        console.log(a)
    }
}
A()
B() // 1

for(var i = 0;i <= 5; i++){
    setTimeout(function timer(){
        console.log(i)
    }, i * 1000)
}

for(var i = 0; i <= 5; i++){
    ;(function(j){
        setTimeout(function timer(){
            console.log(j)
        }, j * 1000)
    })(i)
}

for(var i = 1; i <= 5; i++){
    setTimeout(function timer(j){
        console.log(j)
    }, i * 1000, i)
}

for(let i = 0; i <= 5; i++){
    setTimeout(function timer(){
        console.log(i)
    }, i * 1000)
}

let a = {
    age: 1
}
let b = a
a.age = 2
console.log(b.age) // 2

let a = {
    age: 1
}
let b = Object.assign({}, a)
a.age = 2
console.log(b.age) // 1

let a = {
    age: 1
}
let b = {...a}
a.age = 2
console.log(b.age) // 1

let a = {
    age: 1,
    jobs: {
        first: 'FE'
    }
}
let b = {...a}
a.jobs.first = 'native'
console.log(b.jobs.first) // native

let a = {
    age: 1,
    jobs: {
        first: 'FE'
    }
}
let b = JSON.parse(JSON.stringify(a))
a.jobs.first = 'native'
console.log(b.jobs.first) // FE

let a = {
    age: undefined,
    sex: Symbol('male'),
    jobs: function(){},
    name: 'zhj'
}
let b = JSON.parse(JSON.stringify(a))
console.log(b) // {name: 'zhj'}

function deepClone(obj){
    function isObject(o){
        return (typeof o === 'object' || typeof o === 'function') && o !== null
    }

    if(!isObject(obj)){
        throw new Error('非对象')
    }

    let isArray = Array.isArray(obj)
    let newObj = isArray ? [...obj] : {...obj}
    Reflect.ownKeys(newObj).forEach(key => {
        newObj[key] = isObject(obj[key]) ? deepClone(obj[key]) : obj[key]
    })

    return newObj
}

let obj = {
    a: [1,2,3],
    b: {
        c: 2,
        d: 3
    }
}
let newObj = deepClone(obj)
newObj.b.c = 1
console.log(obj.b.c) // 2

function Parent(value){
    this.val = value
}
Parent.prototype.getValue = function(){
    console.log(this.val)
}
function Child(value){
    Parent.call(this, value)
}
Child.prototype = new Parent()

const child = new Child(1)
console.log(child.getValue()) // 1
console.log(child instanceof Parent) // true

function Parent(value){
    this.val = value
}
Parent.prototype.getValue = function(){
    console.log(this.val)
}
function Child(value){
    Parent.call(this, value)
}
Child.prototype = Object.create(Parent.prototype, {
    constructor: {
        value: Child,
        enumerable: false,
        writable: true,
        configurable: true
    }
})

const child = new Child(1)
console.log(child.getValue()) // 1
console.log(child instanceof Parent) // true

class Parent{
    constructor(value){
        this.val = value
    }
    getValue(){
        console.log(this.val)
    }
}
class Child extends Parent{
    constructor(value){
        super(value)
    }
}

const child = new Child(1)
console.log(child.getValue()) // 1
console.log(child instanceof Parent) // true

function flatten(arr){
    return [].concat(
        ...arr.map(x => Array.isArray(x) ? flatten(x) : x)
    )
}

function throttle(fn, delay = 60){
    let lock = false
    return (...args) => {
        if(lock) return;
        fn(...args);
        lock = true;
        setTimeout(() => {lock = false}, delay)
    }
}

function throttle(fn, delay, timer = null){
    return (...args) => {
        clearInterval(timer)
        timer = setTimeout(fn.bind(null, ...args), delay)
        // timer = setTimeout((...args) => fn(...args), delay)
    }
}

const curry = func => {
    const g = (...allArgs) => allArgs.length >= func.length ?
        func(...allArgs) : (...args) => g(...allArgs, ...args);
    return g;
}

Math.abs 求绝对值
Math.ceil 向上取整
Math.floor 向下取整
Math.max 求最大值
Math.min 求最小值
Math.random 0~1之间的随机数
Math.sqrt 平方根
Math.sign 求数值的符号
Math.pow 求幂

const pageNo = Math.ceil((index+1)/pageSize)

const max = Math.max(...A)

Math.round(min + Math.random() * (max-min))

function is_prime(n){
    if(n <= 1) return;
    const N = Math.floor(Math.sqrt(n));
    let is_prime = true;
    for(let i = 2; i <= N; i++){
        if(n % i === 0){
            is_prime = false
            break;
        }
    }
    return is_prime
}

Array.length 长度  [1,2,3].length -> 3
indexOf 获取元素的序号  [1,2,3].indexOf(2) -> 2
Array.isArray 判断是否是数组 Array.isArray([]) -> true
forEach 遍历  
push/pop/shift/unshift 入栈、出栈、入队、出队
map 映射-1对1  [1,2,3].map(x => x*2) -> [2,4,6]
reduce 聚合-多对1  [1,2,3].map((x, y) => x+y) -> 6
filter 筛选  [1,2,3].filter(x => x > 2) -> [3]
Array.from 创建数组
concat 合并数组  [1,2].concat([3,4]) -> [1,2,3,4]
slice  剪切
splice 删除/插入/替换
reduceRight 从右到左reduce
sort 排序
every 所有元素符合某个条件 [1,2,3].every(x => x>0) -> true

const largeArray = [
    {...},
    {...},
] // 10w

data: {
    id: 1
}

computed: {
    currentItem: function(){
        return largeArray.find(item => item.id === this.id)
    }
    stringId: function(){
        return String(this.id)
    }
}

template
    {{ storageMsg }}

computed: {
    storageMsg: function(){
        return sessionStorage.getItem('xxx')
    },
    time: function(){
        return Date.now()
    }
}

created(){
    sessionStorage.setItem('xxx', 111)
}

onClick(){
    sessionStorage.setItem('xxx', Math.random())
}

Vue.nextTick(() => {
    // TODO
})

await Vue.nextTick()
// TODO

<template>
    <div v-if="loaded" ref="test"></div>
</template>

async showDiv(){
    this.loaded = true;
    await Vue.nextTick();
    this.$refs.test.xxx(); // 才能获取到ref
}

/**
 * 包括vue构造函数，接收各种配置参数等等
 */
export default class Vue{
    constructor(options={}){
        this.$options = options;
        this.$data = options.data;
        this.$methods = options.methods;

        this.initRootElement(options);
        // 利用Object.defineProperty将data的属性注入到vue实例中
        this._proxyData(this.$data);
    }
    // 获取更元素，并存储到vue实例。简单检查一下传入的el是否合规
    initRootElement(options){
        if(typeof options.el === 'string'){
            this.$el = document.querySelector(options.el);
        }else if(options.el instanceof HTMLElement){
            this.$el = options.el;
        }

        if(!this.$el){
            throw new Error('传入的el不合法，请传入css selector或者HTMLElement')
        }
    }
    _proxyData(data){
        Object.keys(data).forEach(key => {
            Object.defineProperty(this, key, {
                enumerable: true,
                configurable: true,
                get(){
                    return data[key];
                },
                set(newValue){
                    if(data[key] === newValue){
                        return;
                    }
                    data[key] = newValue
                }
            })
        })
    }
}

import Vue from './myvue/vue.js';

const vm = new Vue({
    el: '#app',
    data: {
        msg: 'hello world'
    },
    methods: {
        handle(){
            alert(111)
        }
    }
})

console.log(vm)

function BubbleSort(array){
    let len = array.length;
    for(let i = 0; i < len; i++){
        for(let j = 0; j < len-i-1; j++){
            if(array[j] > array[j+1]){
                [array[j], [array[j+1]] = [array[j+1], array[j]];
            }
        }
    }
    return array;
}

function BubbleSort(originalArray){
    const array = [...originalArray];
    let swapped;
    for(let i = 0; i < array.length; i++){
        swapped = true;
        for(let j = 0; j < array.length - i - 1; j++){
            if(array[j] > array[j+1]){
                [array[j], array[j+1]] = [array[j+1], array[j]];
                swapped = false;
            }
        }
        if(swapped){
            break;
        }
    }
    return array;
}

function SelectionSort(originalArray){
    const array = [...originalArray];
    let len = array.length;
    for(let i = 0; i < len - 1; i++){
        let minIndex = i;
        for(let j = i + 1; j < len; j++){
            if(array[j] < array[minIndex]){
                minIndex = j;
            }
        }
        if(minIndex !== i){
            [array[minIndex], array[i]] = [array[i], array[minIndex]];
        }
    }
    return array;
}

function InsertionSort(originalArray){
    const array = [...originalArray];
    let len = array.length;
    for(let i = 0; i < len; i++){
        let temp = array[i]
        let j = i - 1;
        while(j >= 0 && array[j] > temp){
            array[j+1] = array[j];
            j--;
        }
        array[j+1] = temp;
    }
    return array;
}

function MergeSort(array){
    let len = array.length;
    if(len <= 1){
        return array;
    }
    let num = Math.floor(len / 2);
    let left = MergeSort(array.slice(0, num));
    let right = MergeSort(array.slice(num, len));
    return merge(left, right);

    function merge(left, right){
        let [l, r] = [0, 0];
        let result = [];
        while(l < left.length && r < right.length){
            if(left[l] < right[r]){
                result.push(left[l]);
                l++;
            }else{
                result.push(right[r]);
                r++;
            }
        }
        result = result.concat(left.slice(l, left.length));
        result = result.concat(right.slice(r, right.length));
        return result;
    }
}

function QuickSort(array){
    const len = array.length
    if(len <= 1){
        return array; // 如果只有一个数，就直接返回
    }

    let num = Math.floor(len / 2); // 找到中间数的索引值，如果是浮点数，则向下取整
    let numValue = array.splice(num, 1); // 找到中间数的值
    let left = []
    let right = []
    for(let i = 0; i < len; i++){
        if(array[i] < numValue){
            left.push(array[i]) // 基准点的左边数传到左边数组
        }else{
            right.push(array[i]) // 基准点的右边数传到右边数组
        }
    }
    return QuickSort(left).concat([numValue, QuickSort(right)]);
}