/**
 * 等待指定的時間/等待指定表達式成立
 * 如果未指定等待條件則立刻執(zhí)行
 * 注: 此實現(xiàn)在 nodejs 10- 會存在宏任務(wù)與微任務(wù)的問題，切記 async-await 本質(zhì)上還是 Promise 的語法糖，實際上并非真正的同步函數(shù)?。?！即便在瀏覽器，也不要依賴于這種特性。
 * @param param 等待時間/等待條件
 * @returns Promise 對象
 */
function wait(param) {
 return new Promise(resolve => {
 if (typeof param === 'number') {
 setTimeout(resolve, param)
 } else if (typeof param === 'function') {
 const timer = setInterval(() => {
 if (param()) {
 clearInterval(timer)
 resolve()
 }
 }, 100)
 } else {
 resolve()
 }
 })
}

/**
 * 將一個異步函數(shù)包裝為具有時序的異步函數(shù)
 * 注: 該函數(shù)會按照調(diào)用順序依次返回結(jié)果，后面的調(diào)用的結(jié)果需要等待前面的，所以如果不關(guān)心過時的結(jié)果，請使用 {@link switchMap} 函數(shù)
 * @param fn 一個普通的異步函數(shù)
 * @returns 包裝后的函數(shù)
 */
function mergeMap(fn) {
 // 當前執(zhí)行的異步操作 id
 let id = 0
 // 所執(zhí)行的異步操作 id 列表
 const ids = new Set()
 return new Proxy(fn, {
 async apply(_, _this, args) {
 const prom = Reflect.apply(_, _this, args)
 const temp = id
 ids.add(temp)
 id++
 await wait(() => !ids.has(temp - 1))
 ids.delete(temp)
 return await prom
 },
 })
}

;(async () => {
 // 模擬一個異步請求，接受參數(shù)并返回它，然后等待指定的時間
 async function get(ms) {
 await wait(ms)
 return ms
 }
 const fn = mergeMap(get)
 let last = 0
 let sum = 0
 await Promise.all([
 fn(30).then(res => {
 last = res
 sum += res
 }),
 fn(20).then(res => {
 last = res
 sum += res
 }),
 fn(10).then(res => {
 last = res
 sum += res
 }),
 ])
 console.log(last)
 // 實際上確實執(zhí)行了 3 次，結(jié)果也確實為 3 次調(diào)用參數(shù)之和
 console.log(sum)
})()

/**
 * 將一個異步函數(shù)包裝為具有時序的異步函數(shù)
 * 注: 該函數(shù)會丟棄過期的異步操作結(jié)果，這樣的話性能會稍稍提高（主要是響應(yīng)比較快的結(jié)果會立刻生效而不必等待前面的響應(yīng)結(jié)果）
 * @param fn 一個普通的異步函數(shù)
 * @returns 包裝后的函數(shù)
 */
function switchMap(fn) {
 // 當前執(zhí)行的異步操作 id
 let id = 0
 // 最后一次異步操作的 id，小于這個的操作結(jié)果會被丟棄
 let last = 0
 // 緩存最后一次異步操作的結(jié)果
 let cache
 return new Proxy(fn, {
 async apply(_, _this, args) {
 const temp = id
 id++
 const res = await Reflect.apply(_, _this, args)
 if (temp < last) {
 return cache
 }
 cache = res
 last = temp
 return res
 },
 })
}

;(async () => {
 // 模擬一個異步請求，接受參數(shù)并返回它，然后等待指定的時間
 async function get(ms) {
 await wait(ms)
 return ms
 }
 const fn = switchMap(get)
 let last = 0
 let sum = 0
 await Promise.all([
 fn(30).then(res => {
 last = res
 sum += res
 }),
 fn(20).then(res => {
 last = res
 sum += res
 }),
 fn(10).then(res => {
 last = res
 sum += res
 }),
 ])
 console.log(last)
 // 實際上確實執(zhí)行了 3 次，然而結(jié)果并不是 3 次調(diào)用參數(shù)之和，因為前兩次的結(jié)果均被拋棄，實際上返回了最后一次發(fā)送請求的結(jié)果
 console.log(sum)
})()

/**
 * 將一個異步函數(shù)包裝為具有時序的異步函數(shù)
 * 注: 該函數(shù)會按照調(diào)用順序依次返回結(jié)果，后面的執(zhí)行的調(diào)用（不是調(diào)用結(jié)果）需要等待前面的，此函數(shù)適用于異步函數(shù)的內(nèi)里執(zhí)行也必須保證順序時使用，否則請使用 {@link mergeMap} 函數(shù)
 * 注: 該函數(shù)其實相當于調(diào)用 {@code asyncLimiting(fn, {limit: 1})} 函數(shù)
 * 例如即時保存文檔到服務(wù)器，當然要等待上一次的請求結(jié)束才能請求下一次，不然數(shù)據(jù)庫保存的數(shù)據(jù)就存在謬誤了
 * @param fn 一個普通的異步函數(shù)
 * @returns 包裝后的函數(shù)
 */
function concatMap(fn) {
 // 當前執(zhí)行的異步操作 id
 let id = 0
 // 所執(zhí)行的異步操作 id 列表
 const ids = new Set()
 return new Proxy(fn, {
 async apply(_, _this, args) {
 const temp = id
 ids.add(temp)
 id++
 await wait(() => !ids.has(temp - 1))
 const prom = Reflect.apply(_, _this, args)
 ids.delete(temp)
 return await prom
 },
 })
}

;(async () => {
 // 模擬一個異步請求，接受參數(shù)并返回它，然后等待指定的時間
 async function get(ms) {
 await wait(ms)
 return ms
 }
 const fn = concatMap(get)
 let last = 0
 let sum = 0
 await Promise.all([
 fn(30).then(res => {
 last = res
 sum += res
 }),
 fn(20).then(res => {
 last = res
 sum += res
 }),
 fn(10).then(res => {
 last = res
 sum += res
 }),
 ])
 console.log(last)
 // 實際上確實執(zhí)行了 3 次，然而結(jié)果并不是 3 次調(diào)用參數(shù)之和，因為前兩次的結(jié)果均被拋棄，實際上返回了最后一次發(fā)送請求的結(jié)果
 console.log(sum)
})()

/**
 * 函數(shù)節(jié)流
 * 節(jié)流 (throttle) 讓一個函數(shù)不要執(zhí)行的太頻繁，減少執(zhí)行過快的調(diào)用，叫節(jié)流
 * 類似于上面而又不同于上面的函數(shù)去抖, 包裝后函數(shù)在上一次操作執(zhí)行過去了最小間隔時間后會直接執(zhí)行, 否則會忽略該次操作
 * 與上面函數(shù)去抖的明顯區(qū)別在連續(xù)操作時會按照最小間隔時間循環(huán)執(zhí)行操作, 而非僅執(zhí)行最后一次操作
 * 注: 該函數(shù)第一次調(diào)用一定會執(zhí)行，不需要擔心第一次拿不到緩存值，后面的連續(xù)調(diào)用都會拿到上一次的緩存值
 * 注: 返回函數(shù)結(jié)果的高階函數(shù)需要使用 {@link Proxy} 實現(xiàn)，以避免原函數(shù)原型鏈上的信息丟失
 *
 * @param {Number} delay 最小間隔時間，單位為 ms
 * @param {Function} action 真正需要執(zhí)行的操作
 * @return {Function} 包裝后有節(jié)流功能的函數(shù)。該函數(shù)是異步的，與需要包裝的函數(shù) {@link action} 是否異步?jīng)]有太大關(guān)聯(lián)
 */
const throttle = (delay, action) => {
 let last = 0
 let result
 return new Proxy(action, {
 apply(target, thisArg, args) {
 return new Promise(resolve => {
 const curr = Date.now()
 if (curr - last > delay) {
 result = Reflect.apply(target, thisArg, args)
 last = curr
 resolve(result)
 return
 }
 resolve(result)
 })
 },
 })
}

/**
 * 為異步函數(shù)添加自動超時功能
 * @param timeout 超時時間
 * @param action 異步函數(shù)
 * @returns 包裝后的異步函數(shù)
 */
function asyncTimeout(timeout, action) {
 return new Proxy(action, {
 apply(_, _this, args) {
 return Promise.race([
 Reflect.apply(_, _this, args),
 wait(timeout).then(Promise.reject),
 ])
 },
 })
}

;(async () => {
 // 模擬一個異步請求，接受參數(shù)并返回它，然后等待指定的時間
 async function get(ms) {
 await wait(ms)
 return ms
 }
 const time = 100
 const fn = asyncTimeout(time, throttle(time, get))
 let last = 0
 let sum = 0
 await Promise.all([
 fn(30).then(res => {
 last = res
 sum += res
 }),
 fn(20).then(res => {
 last = res
 sum += res
 }),
 fn(10).then(res => {
 last = res
 sum += res
 }),
 ])
 // last 結(jié)果為 10，和 switchMap 的不同點在于會保留最小間隔期間的第一次，而拋棄掉后面的異步結(jié)果，和 switchMap 正好相反！
 console.log(last)
 // 實際上確實執(zhí)行了 3 次，結(jié)果也確實為第一次次調(diào)用參數(shù)的 3 倍
 console.log(sum)
})()