算法

[dlrandy]

'''javascript function sendReqs(urls: string[], max: number, callback: (...args) => void) {

function nestPromise(subUrls: string[], resolves: Response[] = []) {
    if (resolves.length >= urls.length) {
        return callback(...resolves);
    }
    // return nestPromise(subUrls.slice(0, max));
    return new Promise((resolve, reject) => {
        Promise.all(subUrls.slice(0, max).map(ul => fetch(ul)))
            .then(res => {
                nestPromise(subUrls.slice(max), resolves.concat(res));
            }).catch
    })
}

nestPromise(urls, []);

}

sendReqs([ 'https://my-json-server.typicode.com/typicode/demo/posts', 'https://my-json-server.typicode.com/typicode/demo/comments', 'https://my-json-server.typicode.com/typicode/demo/profile', 'https://my-json-server.typicode.com/typicode/demo/db' ], 2, (...res) => console.log(...res)); '''

[dlrandy]

编程面试题之最大并行任务池：1）给定一个 taskList 和 poolSize；2）task 是异步的，返回 promise；3）task 不会失败。要求：1）同时不能有超过 poolSize 的 task 在执行；2）所有 taskList 里的 task 最终都执行完毕。

[dlrandy]

function requestPool(taskList: Array<{ task: Promise<Object>, callback: Function }>, poolSize) {
    let running = 0, usePool = 0;
    function* run() {
        while (running < taskList.length) {
            yield taskList[running];
            running++;
        }
    }
    const it = run();
    let frameId = null;
    function doTask() {
        if (running >= taskList.length) {
            cancelAnimationFrame(frameId);
            return;
        }
        while (usePool < poolSize) {
            const { value, done } = it.next();
            console.log(value, done);
            if (done) { 
                return;
            }
            const {
                task,
                callback
            } = value;
            Promise.resolve(task).then(res => callback(res))
                .catch(err => console.error(err.message))
                .then(() => (usePool--));
            usePool++;
        }
        frameId = requestAnimationFrame(doTask);
    }
    doTask();
}

const tasks = [
    Promise.resolve(222),
    Promise.resolve(333),
    Promise.resolve(444),
    Promise.resolve(555),
    Promise.resolve(666),
    Promise.resolve(777),
    Promise.resolve(888),
    Promise.resolve(999),
    Promise.resolve(1000),
];

requestPool(tasks.map(t => ({
    task: t,
    callback: x => console.log(x)
})), 3)

[dlrandy]

@kunkun12 坤哥建议要支持连续调用， 简单实现了一下

function hollyFuck() { 
    let queue = [];
    let inProcessing = false;

    function requestPool(taskList: Array<{ task: Promise<Object>, callback: Function }>, poolSize) {
        if (inProcessing) { 
            queue.push([taskList, poolSize]);
            return;
        }
        inProcessing = true;
        let running = 0, usePool = 0;
    function* run() {
        while (running < taskList.length) {
            yield taskList[running];
            running++;
        }
    }
    const it = run();
    let frameId = null;
    function doTask() {
        if (running >= taskList.length) {
            cancelAnimationFrame(frameId);
            return;
        }
        while (usePool < poolSize) {
            const { value, done } = it.next();
            console.log(value, done);
            if (done) {
                cancelAnimationFrame(frameId);
                inProcessing = false;
                if (queue.length > 0) {
                    const [
                        nextCalls,
                        nextPoolsize
                    ] = queue.shift(); 
                    requestPool(nextCalls, nextPoolsize);
                }
                return;
            }
            const {
                task,
                callback
            } = value;
            Promise.resolve(task).then(res => callback(res))
                .catch(err => console.error(err.message))
                .then(() => (usePool--));
            usePool++;
        }
        frameId = requestAnimationFrame(doTask);
    }
    doTask();
    }
    return requestPool;
}

const tasks = [
    Promise.resolve(222),
    Promise.resolve(333),
    Promise.resolve(444),
    Promise.resolve(555),
    Promise.resolve(666),
    Promise.resolve(777),
    Promise.resolve(888),
    Promise.resolve(999),
    Promise.resolve(1000),
];

const main = hollyFuck();

main(tasks.map(t => ({
    task: t,
    callback: x => console.log(x)
})), 3);
main(tasks.map(t => ({
    task: t,
    callback: x => console.log(x)
})), 3);

[dlrandy]

给定字符串按权重排序

function orderByWeight(input) {
  var target = new Map()
  var arr = []
  input
    .split(' ')
    .reduce((sum, cur) => {
      var weight = 0
      cur
        .split('')
        .reduce((s, c) => {
          s += parseInt(c, 10)
          return weight = s
        }, weight)

      if (sum.has(weight)) {
        sum.set(weight, sum.get(weight).concat(cur))
      } else {
        sum.set(weight, [cur])
      }
      return sum
    }, target)

  var keys = [...target.keys()].sort((a, b) => (a - b))
  console.log(keys)
  keys.forEach(k => {
    arr = [
      ...arr,
      ...target
        .get(k)
        .sort((s1, s2) => s1.localeCompare(s2))
    ]
  })
  return arr.join(' ')

}
undefined
orderByWeight('56 65 74 100 99 68 86 180 90')