Hacker News

Mae API ffrydiau gwell yn bosibl ar gyfer JavaScript

Sylwadau

14 min read Via blog.cloudflare.com

Mewayz Team

Editorial Team

Hacker News

Mae gan JavaScript's Streams API Broblem - Ac O'r diwedd Mae Datblygwyr yn Siarad Amdani

Os ydych chi erioed wedi ceisio defnyddio'r Streams API yn JavaScript ar gyfer unrhyw beth y tu hwnt i enghraifft gwerslyfr, rydych chi wedi teimlo'r ffrithiant. Mae'r hyn a ddylai fod yn dyniad cain, y gellir ei gyfansoddi ar gyfer trin data dilyniannol - darllen ffeiliau, prosesu ymatebion HTTP, trawsnewid setiau data mewn amser real - yn aml yn datganoli i boelerplate verbose, semanteg pwysedd cefn dryslyd, ac arwyneb API sy'n teimlo'n debycach i fenter Java na JavaScript modern. Mae'r sgwrs ynghylch adeiladu gwell ffrydio cyntefig wedi bod yn mudferwi mewn cynigion TC39, trafodaethau fframwaith, a phrosiectau ffynhonnell agored ers blynyddoedd. Yn 2026, mae'n cyrraedd pwynt tyngedfennol. Nid y cwestiwn yw a yw API ffrydiau gwell yn bosibl - dyna beth yw "gwell" mewn gwirionedd, a beth sydd wedi bod yn ein dal yn ôl.

Lle mae'r API Ffrydiau Cyfredol yn Byrhau

Roedd Safon Ffrydiau WHATWG, sy'n pweru ReadableStream, WritableStream, a TransformStream ar draws porwyr ac amseroedd rhedeg fel Node.js a Deno, yn gyflawniad peirianyddol gwirioneddol. Daeth â phwysau ôl, canslo, ac iteriad async i drin data gwe-frodorol. Ond yn ymarferol, mae'r API yn gofyn gormod o'r datblygwr am weithrediadau cyffredin. Mae creu ffrwd drawsnewid syml yn gofyn am gychwyn TransformStream gyda dull trawsnewid, rheoli rheolwyr, a thrin semanteg fflysio yn ofalus - i gyd ar gyfer yr hyn sy'n gyfystyr â map() dros dalpiau.

Cymharwch hyn â sut mae datblygwyr yn gweithio gydag araeau. Mae Array.prototype.map()(), filter()(), a reduce()) yn gyfansoddadwy, yn ddarllenadwy, ac mae angen seremoni bron sero arnynt. Nid yw'r API Streams yn cynnig unrhyw ran o'r cyfansawdd ergonomig hwn allan o'r bocs. Mae pibellu ffrydiau gyda'i gilydd trwy waith .pipeThrough(), ond adeiladu'r camau trawsnewid eu hunain yw lle mae datblygwyr yn colli oriau ac amynedd. Mae trin gwallau ar draws cadwyni pibellog yn bwynt poen arall - nid yw gwallau'n lluosogi'n reddfol, ac mae dadfygio piblinell sydd wedi torri yn aml yn golygu bod mewnosod logio dros dro yn trawsnewid dim ond i ddarganfod lle mae data'n cael ei ollwng neu ei lygru.

Mae eliffant Node.js yn yr ystafell hefyd. Mae gan Node ei weithrediad ffrwd etifeddiaeth ei hun (stream.Readable, stream.Writable), sy'n rhagddyddio safon WHATWG o bron i ddegawd. Mae'r ddwy system yn rhyngweithredol yn unig trwy gyfleustodau addasydd, ac mae llawer o becynnau npm yn dal i ddefnyddio'r API hŷn. Mae datblygwyr sy'n gweithio ar draws amgylcheddau - rendrad ar ochr y gweinydd, swyddogaethau ymyl, prosesu ar sail porwr - yn cael eu gorfodi i jyglo dau dyniad anghydnaws ar gyfer yr un cysyniad.

Sut y gallai API Ffrydiau Gwell Edrych

Mae nifer o gynigion ac arbrofion cymunedol yn cyfeirio at ddyfodol mwy cyfeillgar i ddatblygwyr. Mae'r syniadau craidd yn cydgyfeirio o hyd ar rai egwyddorion: cyfansoddiad swyddogaethol, aliniad iterator async, a plât boeler llai. Dychmygwch allu ysgrifennu piblinellau data ffrydio mor naturiol ag y byddwch yn ysgrifennu trawsnewidiadau arae - cadwyno .map(), .filter(), a .take() yn uniongyrchol ar ffrwd ddarllenadwy heb fod angen adeiladu gwrthrychau TransformStream canolradd.

Nid yw hyn yn ddamcaniaethol. Mae'r cynnig Iterator Helpers (sydd bellach ar Gam 4 yn TC39) eisoes yn dod â .map(), .filter(), .take(), .drop(), a .flatMap() i iterators cydamserol. Mae ymestyn y patrwm hwn i iteryddion asyncroneiddio — a thrwy estyniad, i ffrydiau darllenadwy sy'n amlygu [Symbol.asyncIterator] — yn gam nesaf naturiol. Mae rhai amseroedd rhedeg a llyfrgelloedd eisoes wedi dechrau arbrofi gyda'r dull hwn, gan adael i ddatblygwyr ysgrifennu cod fel:

Y tyniad ffrydio mwyaf pwerus yw un sy'n diflannu. Pan all datblygwyr fynegi trawsnewidiadau data fel cadwyn o swyddogaethau syml - heb boeni am reolwyr, strategaethau ciwio, neu bwysau ôl â llaw - maen nhw'n adeiladu'n gyflymach, yn cludo llai o fygiau, ac yn mwynhau gweithio gyda ffrydio data mewn gwirionedd.

Nid disodli'r API Streams lefel isel yn gyfan gwbl yw'r nod. Bydd yna bob amser achosion defnydd - protocolau arfer, rheolaeth cof manwl, gweithrediadau codec deuaidd - lle mae mynediad uniongyrchol i reolwyr yn hanfodol. Ond ar gyfer y 90% o achosion defnydd sy'n ymwneud â darllen, trawsnewid, ac ysgrifennu data dilyniannol, dylai'r haen tynnu gydweddu â symlrwydd y dasg.

Gwersi o Ecosystemau Eraill

Nid JavaScript yw'r iaith gyntaf i ymgodymu ag ergonomeg ffrydio. Mae nodweddion Iterator a Stream Rust yn cynnig tyniad cyfansawdd, cost sero sy'n galluogi datblygwyr i gadwyno gweithrediadau heb ddyrannu casgliadau canolraddol. Mae modiwl Stream Elixir yn darparu cyfrif diog gyda chystrawen lân, sy'n gyfeillgar i bibellau. Roedd hyd yn oed Java, sy'n aml yn cael ei feirniadu am eirfa, wedi cyflwyno java.util.stream.Stream yn Java 8 gydag API rhugl y byddai datblygwyr JavaScript yn ei adnabod ac yn eiddigeddus ohono.

Yr hyn y mae’r ecosystemau hyn yn ei rannu yw ymrwymiad i wneud yr achos cyffredin yn ddibwys. Mae darllen ffeil, hidlo llinellau, ac ysgrifennu canlyniadau yn cymryd 3-5 llinell o god cyfansawdd. Yn API Streams cyfredol JavaScript, gall yr un gweithrediad ehangu'n hawdd i 20-30 llinell pan fyddwch chi'n cyfrif am adeiladu nant, trin gwallau, a rhwygo'n iawn. Nid yw'r bwlch yn ymwneud â gallu - mae'n ymwneud ag ergonomeg.

Mae ymagwedd Python hefyd yn addysgiadol. Mae swyddogaethau generadur gyda cynnyrch yn darparu ffordd naturiol o gynhyrchu a defnyddio data dilyniannol yn ddiog. Mae gan JavaScript swyddogaethau generadur hefyd, ond mae eu pontio i'r API Streams yn gofyn am eu lapio mewn adeiladwyr ReadableStream gyda rheolwyr sy'n seiliedig ar dynnu. Byddai integreiddio tynnach rhwng generaduron a ffrydiau - lle gallai swyddogaeth generadur ddod yn ffrwd ddarllenadwy yn uniongyrchol - yn dileu categori cyfan o boelerplat.

Yr Effaith Fyd-Eang ar Ddatblygu Ceisiadau

Nid yw hyn yn bryder academaidd. Mae ffrydio data wrth wraidd cymwysiadau gwe modern. Digwyddiadau a anfonwyd gan weinyddion, ymatebion HTTP talpedig, dangosfyrddau dadansoddeg amser real, prosesu uwchlwytho ffeiliau, ffrydio allbwn model AI - nodweddion bob dydd yw'r rhain, nid achosion ymyl. Pan fo'r ffrydio cyntefig yn anodd ei ddefnyddio, mae datblygwyr naill ai'n ei osgoi'n gyfan gwbl (gan glustogi popeth i'r cof, nad yw'n graddio) neu'n adeiladu piblinellau bregus, anodd eu cynnal sy'n dod yn ffynhonnell digwyddiadau cynhyrchu.

Ystyriwch beth sy'n digwydd ar raddfa. Mae platfform fel Mewayz, sy'n prosesu data ar draws 207 o fodiwlau busnes integredig - o biblinellau CRM ac anfonebu i gyfrifiadau cyflogres ac olrhain fflyd - yn trin llawer iawn o ddata dilyniannol yn fewnol. Mae gweithrediadau allforio, cynhyrchu adroddiadau, prosesu digwyddiadau gwewook, a diweddariadau dangosfwrdd amser real i gyd yn elwa o ffrydio effeithlon. Pan fydd y cyntefig iaith sylfaenol yn gwneud ffrydio'n anodd, mae'r gost yn lluosi ar draws pob modiwl a phob llif data. Yn y pen draw, mae peirianwyr llwyfan yn adeiladu tyniadau ffrydio mewnol ar ben tyniadau'r iaith, gan ychwanegu cymhlethdod na ddylai fod yn angenrheidiol.

💡 DID YOU KNOW?

Mewayz replaces 8+ business tools in one platform

CRM · Invoicing · HR · Projects · Booking · eCommerce · POS · Analytics. Free forever plan available.

Start Free →
  • Prosesu ffeiliau: Mae uwchlwytho a dosrannu ffeiliau CSV gyda 100K+ o resi yn gofyn am ffrydio er mwyn osgoi blinder cof - ond mae'r API cyfredol yn gwneud hyd yn oed berf sylfaenol trawsnewid rhes wrth res
  • Dangosfyrddau amser real: Mae ffrydio data dadansoddeg o weinydd i gleient trwy SSE neu WebSocket yn elwa o drawsnewidiadau cyfansawdd (agregu, hidlo, throtlo) sy'n boenus i'w mynegi heddiw
  • Ffrydio ymateb AI: Wrth i nodweddion wedi'u pweru gan LLM ddod yn safonol mewn offer busnes, mae ffrydio ymatebion tocyn-wrth-tocyn i'r UI yn ddisgwyliad gwaelodlin - ac yn achos defnydd perffaith ar gyfer trawsnewid llif cadwynadwy
  • Gweithrediadau swp: Mae prosesu cyflogres ar gyfer miloedd o weithwyr, cynhyrchu anfonebau swmp, neu gysoni cofnodion CRM â systemau allanol i gyd yn golygu ffrydio data trwy gamau dilysu, trawsnewid ac allbwn
  • Piblinellau Webhook: Mae amlyncu, dilysu, llwybro a phrosesu digwyddiadau bachu gwe sy'n dod i mewn o integreiddiadau trydydd parti yn ei hanfod yn lwyth gwaith ffrydio

Beth Sy'n Cael Ei Gynnig Mewn Gwirionedd

Mae ecosystem JavaScript yn symud ar sawl ffrynt. Mae cynnig TC39 Iterator Helpers eisoes wedi glanio, gan ddod â chyfansoddiad swyddogaethol i iteryddion cydamserol. Byddai'r estyniad naturiol — Async Iterator Helpers - yn dod â'r un .map(), .filter(), .reduce(), .take(), a .flatMap() dulliau i async iterators, sy'n gweithredu ffrydiau darllenadwy . Byddai hyn ynddo'i hun yn gwella profiad y datblygwr yn ddramatig ar gyfer y patrymau ffrydio mwyaf cyffredin.

Y tu hwnt i TC39, mae datblygiadau arloesol ar lefel amser rhedeg hefyd yn gwthio'r ffin. Mae Deno wedi arbrofi gyda mwy o gyfleustodau ffrwd ergonomig. Mae'r Blwch Offer Web Streams a llyfrgelloedd cymunedol tebyg yn darparu swyddogaethau cynorthwyol sy'n lapio rhannau llafar yr API. Ac mae momentwm cynyddol y tu ôl i'r syniad o llyfrgell safonol ffrwd-frodorol - set o gyfleustodau integredig wedi'u hoptimeiddio ar gyfer gweithrediadau ffrydio cyffredin fel hollti llinell, dosrannu JSON, prosesu CSV, a chywasgu y mae datblygwyr yn ei dynnu o npm ar hyn o bryd.

Mae yna hefyd ddadl gref dros gwell semanteg gwall. Yn yr API heddiw, gall gwall mewn cadwyn bibellog adael nentydd mewn cyflyrau amwys - wedi'u treulio'n rhannol, gyda chloeon hongian ar ddarllenwyr. Gallai API diwygiedig fabwysiadu lluosogiad gwall strwythuredig tebyg i fath Result Rust neu fabwysiadu confensiwn lle mae gwallau'n llifo drwy'r biblinell fel gwerthoedd, gan ganiatáu i gamau i lawr yr afon drin neu adfer ohonynt heb dorri'r gadwyn gyfan. Byddai hyn yn drawsnewidiol ar gyfer dibynadwyedd cynhyrchu.

Pam Mae Hyn yn Bwysig Mwy nag Erioed yn 2026

Mae tri thueddiad cydgyfeiriol yn gwneud ffrydio API ergonomeg yn fwy brys nawr nag ar unrhyw adeg yn hanes JavaScript. Yn gyntaf, mae cyfrifiadura ymylol - Gweithwyr Cloudflare, Vercel Edge Functions, Deno Deploy - yn gweithredu o dan gyfyngiadau cof a CPU llym lle nad yw byffro ymatebion neu setiau data cyfan yn ymarferol. Ffrydio yw'r unig opsiwn, ac mae datblygwyr sy'n defnyddio i'r amgylcheddau hyn angen API nad yw'n eu hymladd.

Yn ail, mae integreiddio AI wedi gwneud ffrydio yn nodwedd sy'n wynebu'r defnyddiwr. Pan fydd cynorthwyydd AI yn cynhyrchu ymateb, mae defnyddwyr yn disgwyl gweld tocynnau'n ymddangos mewn amser real, nid aros am yr ymateb cyfan i glustogi. Bellach mae angen defnydd cadarn o ffrwd ochr y cleient ar bob platfform SaaS - o systemau gweithredu busnes fel Mewayz i offer AI annibynnol. Mae'r API presennol yn gweithio i hyn, ond gallai profiad y datblygwr o ddosrannu, trawsnewid, a rendro allbwn AI wedi'i ffrydio fod yn sylweddol well gyda gweithredwyr ffrydiau cyfansawdd.

Yn drydydd, mae symudiad pentwr llawn JavaScript yn golygu bod datblygwyr yn trin ffrydiau ar y ddwy ochr i ffin y rhwydwaith. Efallai y bydd un peiriannydd yn ysgrifennu ffrwd ochr y gweinydd sy'n prosesu canlyniadau ymholiad cronfa ddata, yn eu peipio trwy drawsnewidiad, yn eu hanfon fel ymateb HTTP talpedig, ac yna'n defnyddio'r un ffrwd honno ar y cleient i wneud UI blaengar. Pan fo'r API ffrydio yn lletchwith, mae'r ffrithiant hwnnw i'w deimlo ar bob haen o'r pentwr.

Symud Ymlaen: Beth Gall Datblygwyr Ei Wneud Heddiw

Tra bod yr iaith yn esblygu, nid yw datblygwyr yn sownd i aros. Gall sawl strategaeth ymarferol wella'r profiad ffrydio mewn prosiectau cyfredol. Mae defnyddio generaduron async fel y prif batrwm awduro — a'u lapio yn ReadableStream.from() lle mae'r amser rhedeg yn ei gefnogi - yn darparu cystrawen lawer glanach na rheolaeth rheolydd â llaw. Mae llyfrgelloedd fel it-pipe a streaming-iterables yn cynnig cynorthwywyr cyfansawdd sy'n dod â chadwyni swyddogaethol i iterwyr cysoni heddiw.

Ar gyfer timau sy'n adeiladu cymwysiadau data-ddwys, mae buddsoddi mewn haen cyfleustodau ffrydio mewnol denau yn talu ar ei ganfed. Mae set o swyddogaethau streamMap()() sydd wedi'u dylunio'n dda, streamFilter(), a streamBatch() - pob un yn cymryd async iteradwy ac yn dychwelyd async iteradwy - yn darparu'r composability y mae'r API safonol yn ei ddiffyg, heb bwysau fframwaith ffrydio llawn. Dyma'r patrwm sy'n amrywio o brototeipiau cychwyn i lwyfannau sy'n trin miliynau o weithrediadau.

  1. Mabwysiadu generaduron async fel eich patrwm rhagosodedig ar gyfer cynhyrchu data ffrydio - maen nhw'n lanach, yn fwy profadwy, ac yn fwy cyfansawdd nag adeiladu ReadyStream â llaw
  2. Defnyddiwch ReadableStream.from() i bontio rhaglenni ailadroddadwy async i fyd ffrydiau'r we pan fydd angen rhyngopio ag APIs sy'n disgwyl achosion ReadableStream.
  3. Adeiladu neu fabwysiadu ffwythiannau cyfleustodau tenau ar gyfer gweithrediadau cyffredin (map, ffilter, swp, sbardun) dros bethau iteradwy async yn hytrach na llunio gwrthrychau TransformStream
  4. Eiriolwr yn TC39 a thrafodaethau amser rhedeg — mae angen lleisiau datblygwr ar y cynnig iterator iterator helpwr yn gwthio am flaenoriaethu
  5. Ysgrifennwch brofion yn erbyn eitemau iteradwy async, nid ffrydiau uniongyrchol - mae hyn yn gwneud eich rhesymeg ffrydio yn gludadwy ac yn haws i'w dilysu

Roedd yr API JavaScript Streams yn sylfaen angenrheidiol. Ond mae sylfeini i fod i gael eu hadeiladu, ac mae'r haen nesaf o dynnu - un sy'n gwneud ffrydio mor naturiol â gweithio gydag araeau - yn hwyr. Mae'r darnau yn eu lle: iteryddion async, swyddogaethau generadur, a phatrwm cynorthwywyr iterator. Yr hyn sydd ei angen nawr yw'r ewyllys ar y cyd i'w cydosod i safon sy'n cyd-fynd â sut mae datblygwyr yn meddwl am ddata dilyniannol mewn gwirionedd. Nid API gwell yn unig fydd y canlyniad - bydd yn datgloi ffrydio fel patrwm rhagosodedig yn hytrach na dewis olaf, gan wneud rhaglenni'n gyflymach, yn fwy cof-effeithlon, ac yn fwy dymunol i'w hadeiladu.

Cwestiynau Cyffredin

Beth sydd o'i le ar yr API JavaScript Streams cyfredol?

Mae'r API Streams cyfredol yn dioddef o boelerplate gormodol, semanteg pwysedd cefn dryslyd, ac arwyneb API rhy gymhleth sy'n annog pobl i beidio â mabwysiadu. Mae tasgau syml fel darllen ffeil neu brosesu ymateb HTTP yn gofyn am lawer mwy o god nag sydd angen. Mae datblygwyr yn aml yn troi at lyfrgelloedd trydydd parti neu batrymau hŷn fel galwadau yn ôl ac allyrwyr digwyddiadau, gan osgoi'r safon yn gyfan gwbl oherwydd bod yr ergonomeg yn teimlo'n agosach at fenter Java na JavaScript modern.

Sut byddai API Streams gwell yn gwella datblygiad gwe?

Byddai API Streams wedi'i ailgynllunio gyda chystrawen lanach, cefnogaeth iteru async wedi'i gynnwys, a dulliau cyfansoddi sythweledol yn symleiddio prosesu data amser real yn ddramatig. Gallai datblygwyr gadwyno trawsnewidiadau yn naturiol, trin backpressure yn dryloyw, ac ysgrifennu piblinellau ffrydio mewn ffracsiwn o'r cod. Byddai hyn yn gwneud rendro cynyddol, porthiannau data byw, a phrosesu ffeiliau mawr yn hygyrch i bob datblygwr JavaScript, nid dim ond y rhai sy'n barod i ymgodymu â chyntefigion lefel isel.

A all llwyfannau busnes modern drin ffrydio data amser real yn effeithiol?

Ydw - mae llwyfannau fel Mewayz, OS busnes 207-modiwl sy'n dechrau ar $19/mo, eisoes yn trosoledd piblinellau data effeithlon y tu ôl i'r llenni ar gyfer dadansoddeg, llifoedd gwaith awtomeiddio, ac adrodd byw. Wrth i safonau ffrydio wella yn JavaScript, bydd offer a adeiladwyd ar y pentwr gwe yn darparu profiadau amser real hyd yn oed yn gyflymach, o ddiweddariadau dangosfwrdd ar unwaith i brosesu ffeiliau di-dor ar draws modiwlau busnes integredig.

Pa ddewisiadau eraill sy'n bodoli tra bod yr API Streams yn esblygu?

Ar hyn o bryd mae datblygwyr yn dibynnu ar lyfrgelloedd fel ffrydiau Node.js, RxJS ar gyfer rhaglennu adweithiol, neu eneraduron async wedi'u paru â dolenni aros-o i drin data dilyniannol yn fwy ergonomaidd. Mae polyfills sy'n gydnaws â'r we a chynorthwywyr cam cynnig hefyd yn pontio bylchau yn yr API safonol. Yr allwedd yw dewis tyniadau sy'n cyd-fynd â'ch achos defnydd - p'un a yw hynny'n golygu patrymau gweladwy ar gyfer rhaglenni sy'n cynnwys llawer o ddigwyddiadau neu iteriad async syml ar gyfer tasgau trawsnewid data syml.