Co vám vadí na JavaScriptu v roce 2018?

[nojo_neznamy]

takze naposledy.

1) Petra - mnou prezentovany async kod byl SEKVENCNI - na paralelni jak ste chybne psala.

2) Vlado - Await/Async kod nemusi byt JEN sekvencni, muze byt I paralelni (pokud se vam nelibi muj priklad, vygooglete si to)

VLado, specialne pro vas, kdyz nemate cim prispet, uvital bych kdybyste nic nepsal.

[Reklama]

[Vlado]

Takže naposledy: si mimo. Promise.all() odpáli promisy paralelne, awaited promises sú spracované sériovo. Ten tvoj kód:

let call1 = work1();
let call2 = work2();
result = [await call1, await call2]

je vadný - najprv sa počká na call1, potom sa spustí call2, nie naraz. Keď už googliš pičoviny na stack overflow, tak sa pozri aj do komentárov daného riešenia, aspoň sa nabudúce nestrápniš poučovaním o tomto, čo neovládaš.

[agent]

Malý příklad na použití async / await.
zavolá se 4krát async funkce, která uvnitř přes await dlouho čeká na výsledek výpočtu. V jeden moment ta funkce "běží" 4krát vedle sebe paralelně.

https://jsfiddle.net/t1cm36un/

[Puff]

Malý příklad na použití async / await.
zavolá se 4krát async funkce, která uvnitř přes await dlouho čeká na výsledek výpočtu. V jeden moment ta funkce "běží" 4krát vedle sebe paralelně.

https://jsfiddle.net/t1cm36un/

Neběží paralelně, ale sériově, jen s kooperativním schedulerem.

[Vlado]

Malý příklad na použití async / await.
zavolá se 4krát async funkce, která uvnitř přes await dlouho čeká na výsledek výpočtu. V jeden moment ta funkce "běží" 4krát vedle sebe paralelně.

https://jsfiddle.net/t1cm36un/

To áno, ale ak následne v ďalšej funkcii potrebuješ výsledok všetkých štyroch, tak čo potom? Zistíš, že robíš kokotinu... Alebo mi prepíš nasledovný kód aby bol prehľadnejší, keď si myslíš, že to ide a že to bude stále paralelné:

Kód: [Vybrat]

function asyncFn1 () {
  // implementácia...
}

function asyncFn2 () {
//implementácia...
}

function asyncFn3 () {
//implementácia...
}

function asyncFn4 () {
//implementácia...
}

const parseResult = async promiseArr => {
  let [res1, res2, res3, res4] = await Promise.all(promiseArr)
  // do something with res1, res2, etc...
}

let runParallel = [asyncFn1, asyncFn2, asyncFn3, asyncFn4]
parseResult(runParallel)


[Reklama]

[nojo_neznamy]

Takže naposledy: si mimo. Promise.all() odpáli promisy paralelne, awaited promises sú spracované sériovo. Ten tvoj kód:

let call1 = work1();
let call2 = work2();
result = [await call1, await call2]

je vadný - najprv sa počká na call1, potom sa spustí call2, nie naraz. Keď už googliš pičoviny na stack overflow, tak sa pozri aj do komentárov daného riešenia, aspoň sa nabudúce nestrápniš poučovaním o tomto, čo neovládaš.

Milý Vlado. Jste speciální. Protože jste speciální, JEN PRO VÁS ve svém volném čase jsem nachystal kód.


async function serial() {

    await new Promise((res, rej) => {setTimeout(()=>{res()}, 1000);})
    await new Promise((res, rej) => {setTimeout(()=>{res()}, 2000);})
    await new Promise((res, rej) => {setTimeout(()=>{res()}, 3000);})
    console.log("done");
  }
 
serial(); run time ~ 6 seconds


async function parallel() {

    let t1 = new Promise((res, rej) => {setTimeout(()=>{res('t1')}, 1000);})
    let t2 = new Promise((res, rej) => {setTimeout(()=>{res('t2')}, 2000);})
    let t3 = new Promise((res, rej) => {setTimeout(()=>{res('t3')}, 3000);})
    console.log([await t1, await t2, await t3]);
  }
 
parallel(); // run time ~ 3 seconds

//Node 10.11+//

Omlouvat se nemusíte. Důležité je, že se nešíří bludné informace.

[Boo]

Jak promisy tak v async/await lze spoustet seriove i paralelne. Definujme si nejakou asynchronni funkci:

Kód: [Vybrat]

function fakeFeed(out, timeout) {
  return new Promise((resolve, reject) => {
    setTimeout(() => { console.log(out); resolve(out); }, timeout);
  })
}

async/await serial

Kód: [Vybrat]

async function main() {
  await fakeFeed('feed 1', 400);
  await fakeFeed('feed 2', 200);
}
main().then(
  fulfilled => console.log('feeds fulfilled'),
  rejected => console.log('error')
);
async/await paralell

Kód: [Vybrat]

async function main2() {
  const ff1 = fakeFeed('feed 1', 400);
  const ff2 = fakeFeed('feed 2', 200);
  await ff1;
  await ff2;
}
main2().then(
  fulfilled => console.log('feeds fulfilled'),
  rejected => console.log('error')
);
promise serial

Kód: [Vybrat]

fakeFeed('feed 1', 400)
  .then(fulfilled => fakeFeed('feed 2', 200))
  .then(fulfilled => console.log('feeds fulfilled'))
  .catch(rejected => console.log('error'))

promise paralell

Kód: [Vybrat]

Promise.all([
  fakeFeed('feed 1', 400),
  fakeFeed('feed 2', 200)
]).then(
  fulfilled => console.log('feeds fulfilled'),
  rejected => console.log('error')
)
V pripadne paralelniho spusteni dojde nejdriv "feed 2" az pak "feed 1". V pripade serioveho spousteni dojdou v takovem poradi jak byli volany.

[nojo_neznamy]

Boo napsal to totožné co já, jsem rád, že opět se prokázalo, že ti schopní, pilní a zkušení měli pravdu, kterou se nebáli obhájit. jen tak dál.

[kkt1]

Jaka je pravda? Ze js je stejne jako php pouzitelny primarne pro bastleni a lepeni?

[Boo]

Jaka je pravda? Ze js je stejne jako php pouzitelny primarne pro bastleni a lepeni?

Ty bys radeji jazyk ktery zadne bastleni a lepeni neumoznuje ? Sem s nim

[Puff]

Jak promisy tak v async/await lze spoustet seriove i paralelne. Definujme si nejakou asynchronni funkci:

Kód: [Vybrat]

function fakeFeed(out, timeout) {
  return new Promise((resolve, reject) => {
    setTimeout(() => { console.log(out); resolve(out); }, timeout);
  })
}

async/await serial

Kód: [Vybrat]

async function main() {
  await fakeFeed('feed 1', 400);
  await fakeFeed('feed 2', 200);
}
main().then(
  fulfilled => console.log('feeds fulfilled'),
  rejected => console.log('error')
);
async/await paralell

Kód: [Vybrat]

async function main2() {
  const ff1 = fakeFeed('feed 1', 400);
  const ff2 = fakeFeed('feed 2', 200);
  await ff1;
  await ff2;
}
main2().then(
  fulfilled => console.log('feeds fulfilled'),
  rejected => console.log('error')
);
promise serial

Kód: [Vybrat]

fakeFeed('feed 1', 400)
  .then(fulfilled => fakeFeed('feed 2', 200))
  .then(fulfilled => console.log('feeds fulfilled'))
  .catch(rejected => console.log('error'))

promise paralell

Kód: [Vybrat]

Promise.all([
  fakeFeed('feed 1', 400),
  fakeFeed('feed 2', 200)
]).then(
  fulfilled => console.log('feeds fulfilled'),
  rejected => console.log('error')
)
V pripadne paralelniho spusteni dojde nejdriv "feed 2" az pak "feed 1". V pripade serioveho spousteni dojdou v takovem poradi jak byli volany.

To je jak u blbejch. JS nikdy nic paralelně neprovádí, nanejvýš tak konkurenčně.

[agent]

Z hlediska uživatele/kódu je to paralelní dostatečně. Zbytek je věc interní implementace překladače/interpetu.

[nojo_neznamy]

Jak promisy tak v async/await lze spoustet seriove i paralelne. Definujme si nejakou asynchronni funkci:

Kód: [Vybrat]

function fakeFeed(out, timeout) {
  return new Promise((resolve, reject) => {
    setTimeout(() => { console.log(out); resolve(out); }, timeout);
  })
}

async/await serial

Kód: [Vybrat]

async function main() {
  await fakeFeed('feed 1', 400);
  await fakeFeed('feed 2', 200);
}
main().then(
  fulfilled => console.log('feeds fulfilled'),
  rejected => console.log('error')
);
async/await paralell

Kód: [Vybrat]

async function main2() {
  const ff1 = fakeFeed('feed 1', 400);
  const ff2 = fakeFeed('feed 2', 200);
  await ff1;
  await ff2;
}
main2().then(
  fulfilled => console.log('feeds fulfilled'),
  rejected => console.log('error')
);
promise serial

Kód: [Vybrat]

fakeFeed('feed 1', 400)
  .then(fulfilled => fakeFeed('feed 2', 200))
  .then(fulfilled => console.log('feeds fulfilled'))
  .catch(rejected => console.log('error'))

promise paralell

Kód: [Vybrat]

Promise.all([
  fakeFeed('feed 1', 400),
  fakeFeed('feed 2', 200)
]).then(
  fulfilled => console.log('feeds fulfilled'),
  rejected => console.log('error')
)
V pripadne paralelniho spusteni dojde nejdriv "feed 2" az pak "feed 1". V pripade serioveho spousteni dojdou v takovem poradi jak byli volany.

To je jak u blbejch. JS nikdy nic paralelně neprovádí, nanejvýš tak konkurenčně.

Parallel se v kontextu tehle terminologie vsude v JS pouziva to za prve. Za druhe, zdali tento interface bezi na implementaci neceho co umi vyuzit vice jader/threadu je naprosto bezpredmetne. (napriklad v Nodu pouzivam helper thread bezne pri hashovani hesel, a ten interface je KUPODIVU STEJNY, kdo by to byl cekal).

Musim to napsat znova, jsem velmi zklamany urovni znalosti Computer Science na rootu.

[Boo]

To je jak u blbejch. JS nikdy nic paralelně neprovádí, nanejvýš tak konkurenčně.

To je akorat presnejsi terminus technicus. Obzvlast Perl-iste jsou na tohle haklivy Jadro OS nebo prinejmensim pipeline u procaku vam to stejne naseka do seriovych front.

[Boo]

Musim to napsat znova, jsem velmi zklamany urovni znalosti Computer Science na rootu.

Neznalost je zaklad hejtovani. Kdyby si zdejsi osazenstvo vice osahalo systemd, vim, emacs a javascript tak by diskuze zrejme zely prazdnotou protoze by nebylo na co nadavat Ignorace k nicemu nevede, maximalne pak ignorantum ujde vlak az zjisti, ze JS se kupodivu pouziva vsude i pres jejich hejty.