SOURCE

// Q1
(function () {
    console.log('Q1：')
    let Q = 'I?♣love♣??♣the♣?great♣?♣?wall♣in♣?beijing'
    // 替换大写
    Q.match(/♣\?\w/ig).forEach(item => {
        item = item.replace(/\?/ig, '\\?')
        const reg = new RegExp(`${item}`, 'ig')
        const str = item.replace(/♣\\\?/ig, '').toLocaleUpperCase()
        Q = Q.replace(reg, ` ${str}`)
    })
    // 去除乱码与问号
    Q = Q.replace(/[♣?]/ig, ' ')
    // 合并连续空格
    Q = Q.replace(/ * /ig, ' ')
    console.log(Q)
    console.log('end')
    console.log('\n')
})();

// Q2
(function () {
    console.log('Q2：')

    /**
     * @parma {Number} start @default 0 起始值
     * @parma {Number} end 终止值
     * @parma {Number} interval @default 2 间隔数
     * @return Array
    */
    function createArr(start, end, interval) {
        let arr = []
        function push(index) {
            if (index === 0) {
                arr[index] = start
            } else {
                arr[index] = arr[index - 1] + interval
            }
            if (arr[index] >= end) {
                return
            }
            push(index + 1)
        }
        push(0)
        return arr
    }
    console.log(createArr(0, 100, 2))
    console.log('end')
    console.log('\n')
})();

// Q3
(function () {
    console.log('Q3：')
    /**
     * @parma {Array} orderList 需要顺序延时调用 的方法集合 若此项为对象则为调用，为函数则不调用
     * @parma {Function} orderList.value 需要调用的目标函数
     * @parma {Number} orderList.time 延迟时间
     * @parma {Array} loopList 需要循环调用 的方法集合 若此项为对象则为调用，为函数则不调用
     * @parma {Function} loopList.value 需要调用的目标函数
     * @parma {Number} loopList.time 循环间隔时间
     * @return undefined
    */
    function fncDispatch(orderList, loopList) {
        let num, t

        function initTimer() {
            num = 0
            t = setInterval(() => {
                num += 1
                console.log(`第 ${num} s`)
            }, 1000)
        }
        initTimer()

        // 过滤不需要调用的方法
        orderList = orderList.filter(item => {
            return typeof item === 'object' && !Array.isArray(item)
        })
        loopList = loopList.filter(item => {
            return typeof item === 'object' && !Array.isArray(item)
        })

        // 顺序延时调用
        function orderInit(index) {
            const item = orderList[index]
            if (index === orderList.length) {
                clearInterval(t)
                initTimer()
                console.log('往复调用')
                orderInit(0)
                return
            }
            setTimeout(() => {
                item.value()
                orderInit(index + 1)
            }, item.time)
        }
        orderInit(0)

        // 循环调用
        function loopItemInit(item) {
            setTimeout(() => {
                item.value()
                loopItemInit(item)
            }, item.time)
        }
        for (let i of loopList) {
            loopItemInit(i)
        }
    }

    fncDispatch([
        {
            value() {
                console.log('5秒后调用')
            },
            time: 5000,
        },
        {
            value() {
                console.log('再5秒后调用')
            },
            time: 5000,
        },
        function () {
            console.log('无需执行')
        }
    ], [
            {
                value() {
                    console.log('每2s调用一次')
                },
                time: 2000
            },
            {
                value() {
                    console.log('每5s调用一次')
                },
                time: 5000,
            },
            function () {
                console.log('无需执行')
            }
        ])
})();