Technology sharing

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Quando ante finem necessitatem habet petitiones concurrentes? Exempli gratia, si interface magnam copiam notitiarum uno tempore reddit, navigatrum in reddendo vel etiam fragore impelletur. Hoc tempore, simul in batches 6 petitiones emittere possumus, ad vitandum adhaesionis vel fragoris .

Quomodo ergo ante finem imperium concurrentibus petitionibus agit?

Clavis notiones pro ante-finem potestate petitionum concurrentium

Exempli gratia, si petitiones 20 sunt, sequi debes 3 Post primam coetus petitionem absolvet, secundus coetus petetur, et sic de aliis.

Praecipua notio est petitionem methodi et parametri in ordine condere, deinde 3 ad tempus postulare, deinde post 3 proximam petitionem peractam. Postquam singulae petitiones redeunt, eventus salvantur, et postquam omnes petitiones redditae sunt, omnes eventus redduntur.

API design

pControl : Concurrentia postulatio moderatoris, numerus maximus concursus transiens;
add : Rogationem et ambitum adde;
start : Satus postulatio, promissio reditus, transi postulatio completur.then Omnia eventa posside;

Code

function pControl(limit) {
  const taskQueue = [] // {task: Function, params: any[]}[]
  return {
    add,
    start
  }

  function add(task, params) {
    taskQueue.push({
      task,
      params
    })
  }

  function start() {
    return runAllTasks()
  }

  function runAllTasks() {
    const allResults = []
    return new Promise((resolve) => {

      runTask()

      function runTask() {
        if (taskQueue.length === 0) {
          // 递归结束
          return resolve(allResults)
        }
        const needRunSize = Math.min(taskQueue.length, limit)
        const tasks = taskQueue.splice(0, needRunSize)
        const promises = tasks.map(({
          task,
          params
        }) => task(params))
        Promise.all(promises).then((resList) => {
          allResults.push(...resList)
          // NOTE 递归调用的位置很关键
          runTask()
        })
      }
    })
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

Clavis codice interpretatione

• pControl: Hoc munus refert objectum continens add etstart Duo modi;add Adjicere opera et parametros;start Petitio incipiendi, clausura est.

• runAllTasks; Redit apromiseac deinde innew PromiseInternus supplicium recursivelyrunTask, runTask saltusPromise.all Petitiones concurrentes in iudiciumPromise.all().then() iterum vocarunTask, unum effectum postulationum redire, et secundae petitiones exsecutioni mandare.

Clavis est ad intellegentes coetus exspectans est .then recursive vocamus.

Cogitans: Potestne runAllTasks impleri utens ansa?

Uti necesse est async 和 for 循环 + await ：

async function runAllTasks2() {
  const allResults = []
  const groupArr = []
  let startIndex = 0
  // 划分分组
  while (startIndex < taskQueue.length) {
    const arr = taskQueue.slice(startIndex, startIndex + limit)
    groupArr.push(arr)
    startIndex += limit
  }
  for (let index = 0; index < groupArr.length; index++) {
    const pList = groupArr[index].map(({
      task,
      params
    }) => task(params))
    const res = await Promise.all(pList)
    allResults.push(...res)
  }
  return allResults
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Non potest esse in pro loop .then aliter ansa proxima ante ansam non exspectabit.

usus for of Exsecutio iterativa:

async function runAllTasks2() {
  const allResults = []
  const groupArr = []
  let startIndex = 0
  // 划分分组
  while (startIndex < taskQueue.length) {
    const arr = taskQueue.slice(startIndex, startIndex + limit)
    groupArr.push(arr)
    startIndex += limit
  }
  // 迭代分组
  const it = groupArr.entries()
  for (const [key, value] of it) {
    const pList = value.map(({
      task,
      params
    }) => task(params))
    const res = await Promise.all(pList)
    allResults.push(...res)
  }
  return allResults
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Quomodo ansas uti et simul promittere?

for 、 while 、 for...of Ad structuras ansa imperativi, si effectum exspectantem in ansa consequi vis, uti debesasync munus fascia in loopawait ,Ex servitio.then 。

forEach 、 map 、 filter De functionibus ansa structurae tales quales effectus insidiae non sustinent, quia hae structurae ansa functionis synchronae sunt et moram non sustinent.

async et循环 + await Coniuncti ad effectum spei consequi inter loramenta.

promise.then et递归 Coniuncti ad effectum spei consequi inter loramenta.

API meliorem facere ut facilius utatur

1. Parametri set default: dapControlFac idoneum default valorem, pone ad6eo quod idem nomen domain in 6 petitiones navigatoris concurrentes sunt.
2. incipe ad callback: Per callback, consequi potes petitionem cuiusque coetus et numerum cognoscere petitionum instantiarum peractarum.

Haec duo meliora sunt simplicia. Primum usum inspiciamus:

const asyncTaskControl = pControl() // 默认 6 
asyncTaskControl.add(task, params1)
asyncTaskControl.add(task, params2)
// ...
asyncTaskControl.add(task, params10)

asyncTaskControl.start((res, doneSize) => {
  // 获取每组请求的结果 和当前完成了多少请求
  console.log(res) // [{index:number,result:data}] 
  console.log(doneSize)
}).then(allResults => {
  // 所有请求结果
  console.log(allResults)
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Quid faciam callback initium?

Commodum est usoribus ut proventus currentium petitionum concurrentium consequi et progressum complementum computare.

Encapsulate praedicta munera into p-control NPM sarcina emissio

npm: p-control

accessible npm i p-control Download and use.

summarium

• .then Recursus deducta consequi exspectationem inter opera asynchrona;
• for、whileExspecta loop acasync + awaitAdhibetur in compositione ad exspectationem inter asynchronas operas assequendas;
• ususPromise.allMultiplices asynchronos munerum exsecutionem simul exsecutioni mandare.