JavaScript માટે વધુ સારી સ્ટ્રીમ API શક્ય છે

જાવાસ્ક્રિપ્ટની સ્ટ્રીમ્સ API માં સમસ્યા છે — અને વિકાસકર્તાઓ આખરે તેના વિશે વાત કરી રહ્યા છે

જો તમે જાવાસ્ક્રિપ્ટમાં સ્ટ્રીમ્સ APIનો ઉપયોગ પાઠ્યપુસ્તકના ઉદાહરણ સિવાયની કોઈપણ વસ્તુ માટે કરવાનો પ્રયાસ કર્યો હોય, તો તમે ઘર્ષણ અનુભવ્યું છે. ક્રમિક ડેટાને હેન્ડલ કરવા માટે એક ભવ્ય, કંપોઝેબલ એબ્સ્ટ્રેક્શન શું હોવું જોઈએ — ફાઇલો વાંચવી, HTTP પ્રતિસાદોની પ્રક્રિયા કરવી, ડેટાસેટ્સને વાસ્તવિક સમયમાં રૂપાંતરિત કરવું — ઘણી વાર વર્બોઝ બોઈલરપ્લેટ, ગૂંચવણમાં મૂકે છે બેકપ્રેશર સિમેન્ટિક્સ અને API સપાટી જે આધુનિક JavaScript કરતાં એન્ટરપ્રાઇઝ જાવા જેવી લાગે છે. TC39 દરખાસ્તો, ફ્રેમવર્ક ચર્ચાઓ અને ઓપન-સોર્સ પ્રોજેક્ટ્સમાં વર્ષોથી વધુ સારી સ્ટ્રીમિંગ પ્રિમિટિવ બનાવવાની આસપાસની વાતચીત ઉકળતી રહી છે. 2026 માં, તે ટિપીંગ પોઈન્ટ પર પહોંચી રહ્યું છે. પ્રશ્ન એ નથી કે બહેતર સ્ટ્રીમ API શક્ય છે કે કેમ — તે ખરેખર "વધુ સારું" જેવું દેખાય છે અને અમને શું રોકી રહ્યું છે.

જ્યાં વર્તમાન સ્ટ્રીમ્સ API ટૂંકી પડે છે

WHATWG સ્ટ્રીમ્સ સ્ટાન્ડર્ડ, જે સમગ્ર બ્રાઉઝર્સ અને Node.js અને Deno જેવા રનટાઈમ્સમાં ReadableStream, WritableStream અને TransformStreamને શક્તિ આપે છે, તે એક વાસ્તવિક એન્જિનિયરિંગ સિદ્ધિ હતી. તે વેબ-નેટિવ ડેટા હેન્ડલિંગમાં બેકપ્રેશર, કેન્સલેશન અને અસિંક પુનરાવર્તન લાવ્યા. પરંતુ વ્યવહારમાં, API સામાન્ય કામગીરી માટે વિકાસકર્તાને ઘણું પૂછે છે. એક સરળ ટ્રાન્સફોર્મ સ્ટ્રીમ બનાવવા માટે ટ્રાન્સફોર્મ પદ્ધતિ સાથે TransformStreamને ઇન્સ્ટન્ટ કરવાની જરૂર છે, કંટ્રોલર્સને મેનેજ કરવું અને ફ્લશ સિમેન્ટિક્સને કાળજીપૂર્વક હેન્ડલ કરવું જરૂરી છે - આ બધું જ એક map() જેટલા હિસ્સામાં છે.

ડેવલપર્સ એરે સાથે કેવી રીતે કામ કરે છે તેની સાથે આની સરખામણી કરો. Array.prototype.map(), filter(), અને reduce() કંપોઝેબલ, વાંચી શકાય તેવા છે અને લગભગ શૂન્ય સમારંભની જરૂર છે. સ્ટ્રીમ્સ API આમાંથી કોઈ પણ અર્ગનોમિક કમ્પોઝિબિલિટી ઑફ ધ બૉક્સની બહાર પ્રદાન કરતું નથી. .pipeThrough() દ્વારા એકસાથે પાઈપિંગ સ્ટ્રીમ્સ કામ કરે છે, પરંતુ રૂપાંતરનાં તબક્કાઓ પોતે જ બનાવવા માટે વિકાસકર્તાઓ કલાકો અને ધીરજ ગુમાવે છે. પાઈપવાળી સાંકળો પર હેન્ડલ કરવામાં ભૂલ એ અન્ય પીડા બિંદુ છે — ભૂલો સાહજિક રીતે પ્રચારિત થતી નથી, અને તૂટેલી પાઈપલાઈનને ડીબગ કરવાનો અર્થ એ થાય છે કે ડેટા ક્યાં છોડવામાં આવે છે અથવા દૂષિત થઈ રહ્યો છે તે શોધવા માટે અસ્થાયી લોગિંગ રૂપાંતરણ દાખલ કરવું.

રૂમમાં Node.js હાથી પણ છે. નોડનું પોતાનું લેગસી સ્ટ્રીમ અમલીકરણ છે (stream.Readable, stream.Writable), જે લગભગ એક દાયકા પહેલા WHATWG માનક ધરાવે છે. બે સિસ્ટમો ફક્ત એડેપ્ટર ઉપયોગિતાઓ દ્વારા જ ઇન્ટરઓપરેબલ છે, અને ઘણા npm પેકેજો હજુ પણ જૂના API નો ઉપયોગ કરે છે. સર્વર-સાઇડ રેન્ડરિંગ, એજ ફંક્શન્સ, બ્રાઉઝર-આધારિત પ્રોસેસિંગ - સમગ્ર વાતાવરણમાં કામ કરતા વિકાસકર્તાઓને સમાન ખ્યાલ માટે બે અસંગત એબ્સ્ટ્રેક્શન્સને જગલ કરવાની ફરજ પાડવામાં આવે છે.

કેવી સારી સ્ટ્રીમ્સ API જેવી દેખાઈ શકે છે

કેટલીક દરખાસ્તો અને સમુદાય પ્રયોગો વધુ વિકાસકર્તા-મૈત્રીપૂર્ણ ભવિષ્ય તરફ નિર્દેશ કરે છે. મુખ્ય વિચારો થોડા સિદ્ધાંતો પર એકરૂપ થતા રહે છે: કાર્યકારી રચના, એસિંક ઇટરરેટર ગોઠવણી, અને ઘટેલી બોઇલરપ્લેટ. તમે એરે ટ્રાન્સફોર્મેશન્સ લખો છો તેટલી જ કુદરતી રીતે સ્ટ્રીમિંગ ડેટા પાઇપલાઇન્સ લખવામાં સક્ષમ હોવાની કલ્પના કરો — ચેઇનિંગ .map(), .filter(), અને .take() સીધા વાંચી શકાય તેવા સ્ટ્રીમ પર મધ્યવર્તી ટ્રાન્સફોર્મસ્ટ્રીમ ઑબ્જેક્ટ્સ બનાવવાની જરૂર વગર.

આ કાલ્પનિક નથી. ઇટેરેટર હેલ્પર્સ પ્રસ્તાવ (હવે TC39 માં સ્ટેજ 4 પર છે) પહેલેથી જ .map(), .filter(), .take(), .drop(), અને .flatMap() સિંક્રનસ ઇટરને લાવે છે. આ પેટર્નને એસિંક ઇટરેટર્સ સુધી વિસ્તૃત કરવું — અને એક્સ્ટેંશન દ્વારા, વાંચી શકાય તેવા સ્ટ્રીમ્સ કે જે [Symbol.asyncIterator] ને એક્સપોઝ કરે છે તે આગળનું કુદરતી પગલું છે. કેટલાક રનટાઇમ્સ અને લાઇબ્રેરીઓએ પહેલેથી જ આ અભિગમ સાથે પ્રયોગ કરવાનું શરૂ કરી દીધું છે, વિકાસકર્તાઓને આના જેવા કોડ લખવા દે છે:

સૌથી શક્તિશાળી સ્ટ્રીમિંગ એબ્સ્ટ્રેક્શન એ અદૃશ્ય થઈ જાય છે. જ્યારે ડેવલપર્સ ડેટા ટ્રાન્સફોર્મેશનને સરળ કાર્યોની સાંકળ તરીકે વ્યક્ત કરી શકે છે — નિયંત્રકો, કતારબદ્ધ વ્યૂહરચનાઓ અથવા મેન્યુઅલ બેકપ્રેશર વિશે ચિંતા કર્યા વિના — તેઓ વધુ ઝડપથી બનાવે છે, ઓછા બગ્સ મોકલે છે અને ખરેખર સ્ટ્રીમિંગ ડેટા સાથે કામ કરવાનો આનંદ માણે છે.

ધ્યેય નિમ્ન-સ્તરની સ્ટ્રીમ્સ API ને સંપૂર્ણપણે બદલવાનો નથી. ત્યાં હંમેશા ઉપયોગના કિસ્સાઓ હશે — કસ્ટમ પ્રોટોકોલ, ફાઈન-ગ્રેઇન્ડ મેમરી કંટ્રોલ, બાઈનરી કોડેક અમલીકરણ — જ્યાં ડાયરેક્ટ કંટ્રોલર એક્સેસ આવશ્યક છે. પરંતુ ઉપયોગના 90% કિસ્સાઓ માટે જેમાં વાંચન, રૂપાંતર અને ક્રમિક ડેટા લખવાનો સમાવેશ થાય છે, એબ્સ્ટ્રેક્શન લેયર કાર્યની સરળતા સાથે મેળ ખાતું હોવું જોઈએ.

અન્ય ઇકોસિસ્ટમમાંથી પાઠ

સ્ટ્રીમિંગ એર્ગોનોમિક્સ સાથે કુસ્તી કરવા માટે JavaScript એ પ્રથમ ભાષા નથી. રસ્ટના ઇટરરેટર અને સ્ટ્રીમ લક્ષણો એક કંપોઝેબલ, શૂન્ય-ખર્ચિત અમૂર્તતા પ્રદાન કરે છે જે વિકાસકર્તાઓને મધ્યવર્તી સંગ્રહો ફાળવ્યા વિના સાંકળ કામગીરી કરવા દે છે. એલિક્સિરનું સ્ટ્રીમ મોડ્યુલ સ્વચ્છ, પાઇપ-ફ્રેંડલી સિન્ટેક્સ સાથે આળસુ ગણના પ્રદાન કરે છે. જાવા, જે ઘણી વખત વર્બોસિટી માટે ટીકા કરવામાં આવે છે, તેણે જાવા 8 માં અસ્ખલિત API સાથે java.util.stream.Stream રજૂ કર્યું હતું જેને JavaScript વિકાસકર્તાઓ ઓળખશે અને ઈર્ષ્યા કરશે.

આ ઇકોસિસ્ટમ્સ જે શેર કરે છે તે સામાન્ય કેસને તુચ્છ બનાવવાની પ્રતિબદ્ધતા છે. ફાઇલ વાંચવા, લાઇન ફિલ્ટર કરવા અને પરિણામો લખવા માટે કમ્પોઝેબલ કોડની 3-5 લાઇન લાગે છે. JavaScript ના વર્તમાન સ્ટ્રીમ્સ API માં, જ્યારે તમે સ્ટ્રીમ કન્સ્ટ્રક્શન, એરર હેન્ડલિંગ અને યોગ્ય ટિયરડાઉન માટે જવાબદાર છો ત્યારે સમાન ઑપરેશન સરળતાથી 20-30 રેખાઓ સુધી વિસ્તૃત થઈ શકે છે. અંતર ક્ષમતા વિશે નથી - તે અર્ગનોમિક્સ વિશે છે.

પાયથોનનો અભિગમ પણ ઉપદેશક છે. ઉપજ સાથે જનરેટર ફંક્શન્સ આળસથી ક્રમિક ડેટાનું ઉત્પાદન અને વપરાશ કરવાની કુદરતી રીત પ્રદાન કરે છે. JavaScriptમાં જનરેટર ફંક્શન્સ પણ છે, પરંતુ તેમને સ્ટ્રીમ્સ API પર બ્રિજિંગ કરવા માટે તેમને પુલ-આધારિત નિયંત્રકો સાથે ReadableStream કન્સ્ટ્રક્ટરમાં લપેટી લેવાની જરૂર છે. જનરેટર અને સ્ટ્રીમ્સ વચ્ચે ચુસ્ત એકીકરણ — જ્યાં જનરેટર ફંક્શન સીધું વાંચી શકાય તેવું સ્ટ્રીમ બની શકે — બોઈલરપ્લેટની સમગ્ર શ્રેણીને દૂર કરશે.

એપ્લિકેશન ડેવલપમેન્ટ પર વાસ્તવિક-વિશ્વની અસર

આ કોઈ શૈક્ષણિક ચિંતા નથી. સ્ટ્રીમિંગ ડેટા આધુનિક વેબ એપ્લિકેશન્સના હૃદયમાં છે. સર્વર દ્વારા મોકલવામાં આવેલી ઇવેન્ટ્સ, કટ્ડ HTTP પ્રતિસાદો, રીઅલ-ટાઇમ એનાલિટિક્સ ડેશબોર્ડ્સ, ફાઇલ અપલોડ પ્રોસેસિંગ, AI મોડલ આઉટપુટ સ્ટ્રીમિંગ — આ રોજિંદા સુવિધાઓ છે, કિસ્સાઓ નથી. જ્યારે સ્ટ્રીમિંગ આદિમનો ઉપયોગ કરવો મુશ્કેલ હોય છે, ત્યારે વિકાસકર્તાઓ કાં તો તેને સંપૂર્ણપણે ટાળે છે (બધું મેમરીમાં બફર કરે છે, જે માપમાં આવતું નથી) અથવા નાજુક, જાળવવા માટે મુશ્કેલ પાઇપલાઇન્સ બનાવે છે જે ઉત્પાદનની ઘટનાઓનો સ્ત્રોત બની જાય છે.

સ્કેલ પર શું થાય છે તે ધ્યાનમાં લો. Mewayz જેવું પ્લેટફોર્મ, જે 207 સંકલિત બિઝનેસ મોડ્યુલ્સમાં ડેટા પર પ્રક્રિયા કરે છે — CRM પાઇપલાઇન્સ અને ઇન્વૉઇસિંગથી લઈને પેરોલ ગણતરીઓ અને ફ્લીટ ટ્રેકિંગ સુધી — આંતરિક રીતે અનુક્રમિક ડેટાના વિશાળ વોલ્યુમને હેન્ડલ કરે છે. નિકાસ કામગીરી, રિપોર્ટ જનરેશન, વેબહૂક ઇવેન્ટ પ્રોસેસિંગ અને રીઅલ-ટાઇમ ડેશબોર્ડ અપડેટ્સ તમામ કાર્યક્ષમ સ્ટ્રીમિંગથી લાભ મેળવે છે. જ્યારે અન્ડરલાઇંગ લેંગ્વેજ પ્રિમિટિવ્સ સ્ટ્રીમિંગને મુશ્કેલ બનાવે છે, ત્યારે ખર્ચ દરેક મોડ્યુલ અને દરેક ડેટા ફ્લોમાં ગુણાકાર થાય છે. પ્લેટફોર્મ એન્જિનિયરો અંતમાં ભાષાના એબ્સ્ટ્રેક્શન્સની ટોચ પર આંતરિક સ્ટ્રીમિંગ એબ્સ્ટ્રેક્શન્સ બનાવે છે, જટિલતા ઉમેરે છે જે જરૂરી ન હોવી જોઈએ.

• ફાઇલ પ્રોસેસિંગ: 100K+ પંક્તિઓ સાથે CSV ફાઇલો અપલોડ કરવા અને પાર્સ કરવા માટે મેમરીનો થાક ટાળવા માટે સ્ટ્રીમિંગની જરૂર પડે છે — પરંતુ વર્તમાન API મૂળભૂત પંક્તિ-દર-પંક્તિ પરિવર્તન વર્બોઝ બનાવે છે
• રીઅલ-ટાઇમ ડેશબોર્ડ્સ: SSE અથવા WebSocket દ્વારા સર્વરથી ક્લાયંટ સુધી સ્ટ્રીમિંગ એનાલિટિક્સ ડેટા કમ્પોઝેબલ ટ્રાન્સફોર્મ્સ (એગ્રિગેશન, ફિલ્ટરિંગ, થ્રોટલિંગ) થી લાભ મેળવે છે જે આજે વ્યક્ત કરવા માટે પીડાદાયક છે
• AI પ્રતિસાદ સ્ટ્રીમિંગ: જેમ LLM-સંચાલિત સુવિધાઓ વ્યવસાયિક સાધનોમાં પ્રમાણભૂત બની જાય છે, UI પર ટોકન-બાય-ટોકન પ્રતિસાદોનું સ્ટ્રીમિંગ એ એક આધારરેખા અપેક્ષા છે — અને ચેઇનેબલ સ્ટ્રીમ ટ્રાન્સફોર્મ્સ માટે એક સંપૂર્ણ ઉપયોગ કેસ
• બેચ ઑપરેશન્સ: હજારો કર્મચારીઓ માટે પેરોલની પ્રક્રિયા કરવી, બલ્ક ઇન્વૉઇસ જનરેટ કરવું અથવા CRM રેકોર્ડ્સને બાહ્ય સિસ્ટમ્સ સાથે સમન્વયિત કરવું એ તમામમાં માન્યતા, રૂપાંતર અને આઉટપુટ તબક્કાઓ દ્વારા સ્ટ્રીમિંગ ડેટાનો સમાવેશ થાય છે
• વેબહુક પાઇપલાઇન્સ: તૃતીય-પક્ષ સંકલનમાંથી ઇનકમિંગ વેબહૂક ઇવેન્ટ્સને ઇન્જેસ્ટ કરવું, માન્ય કરવું, રૂટીંગ કરવું અને પ્રક્રિયા કરવી એ સ્વાભાવિક રીતે સ્ટ્રીમિંગ વર્કલોડ છે

વાસ્તવમાં શું પ્રસ્તાવિત કરવામાં આવી રહ્યું છે

જાવાસ્ક્રિપ્ટ ઇકોસિસ્ટમ બહુવિધ મોરચે આગળ વધી રહી છે. TC39 ઇટેરેટર હેલ્પર્સ પ્રસ્તાવ પહેલેથી જ ઉતરી ગયો છે, જે સિંક્રનસ ઇટરેટર્સ માટે કાર્યાત્મક રચના લાવે છે. કુદરતી એક્સ્ટેંશન — Async Iterator Helpers — એ જ .map(), .filter(), .reduce(), .take(), અને .flatMap() પદ્ધતિઓ લાવશે જે તેને પહેલાથી જ વાંચી શકાય તેવા સ્ટ્રીમ દ્વારા લાગુ કરી શકે છે. [Symbol.asyncIterator]. આ એકલા સૌથી સામાન્ય સ્ટ્રીમિંગ પેટર્ન માટે વિકાસકર્તાના અનુભવમાં નાટકીય રીતે સુધારો કરશે.

TC39 ઉપરાંત, રનટાઇમ-સ્તરની નવીનતાઓ પણ સીમાને આગળ ધપાવી રહી છે. ડેનોએ વધુ અર્ગનોમિક સ્ટ્રીમ યુટિલિટીઝ સાથે પ્રયોગ કર્યો છે. વેબ સ્ટ્રીમ્સ ટૂલબોક્સ અને સમાન સમુદાય પુસ્તકાલયો સહાયક કાર્યો પ્રદાન કરે છે જે API ના વર્બોઝ ભાગોને લપેટી લે છે. અને સ્ટ્રીમ-નેટિવ સ્ટાન્ડર્ડ લાઇબ્રેરીના વિચાર પાછળ વધતી ગતિ છે — લાઇન સ્પ્લિટિંગ, JSON પાર્સિંગ, CSV પ્રોસેસિંગ અને કમ્પ્રેશન જેવા સામાન્ય સ્ટ્રીમિંગ ઑપરેશન્સ માટે બિલ્ટ-ઇન, ઑપ્ટિમાઇઝ ઉપયોગિતાઓનો સમૂહ જે વિકાસકર્તાઓ હાલમાં npm થી ખેંચે છે.

વધુ સારી ભૂલ સિમેન્ટિક્સ માટે એક આકર્ષક દલીલ પણ છે. આજના API માં, પાઈપવાળી સાંકળમાં ભૂલ સ્ટ્રીમ્સને અસ્પષ્ટ સ્થિતિમાં છોડી શકે છે — આંશિક રીતે વપરાશ થાય છે, વાચકો પર લટકતા તાળાઓ સાથે. સંશોધિત API રસ્ટના પરિણામ પ્રકાર જેવું જ સંરચિત ભૂલ પ્રચારને અપનાવી શકે છે અથવા એક સંમેલન અપનાવી શકે છે જ્યાં ભૂલો મૂલ્યો તરીકે પાઇપલાઇનમાંથી વહે છે, જે સમગ્ર સાંકળને તોડ્યા વિના ડાઉનસ્ટ્રીમ તબક્કાઓને હેન્ડલ કરવા અથવા તેમાંથી પુનઃપ્રાપ્ત કરવાની મંજૂરી આપે છે. ઉત્પાદન વિશ્વસનીયતા માટે આ પરિવર્તનકારી હશે.

શા માટે આ 2026 માં પહેલા કરતા વધુ મહત્વપૂર્ણ છે

ત્રણ કન્વર્જિંગ વલણો જાવાસ્ક્રિપ્ટના ઇતિહાસમાં કોઈપણ સમયે કરતાં સ્ટ્રીમિંગ API એર્ગોનોમિક્સને વધુ તાકીદનું બનાવે છે. પ્રથમ, એજ કમ્પ્યુટિંગ — ક્લાઉડફ્લેર વર્કર્સ, વર્સેલ એજ ફંક્શન્સ, ડેનો ડિપ્લોય — સખત મેમરી અને CPU મર્યાદાઓ હેઠળ કાર્ય કરે છે જ્યાં સમગ્ર પ્રતિસાદો અથવા ડેટાસેટ્સને બફર કરવું ફક્ત વ્યવહારુ નથી. સ્ટ્રીમિંગ એ એકમાત્ર વિકલ્પ છે, અને આ વાતાવરણમાં જમાવતા વિકાસકર્તાઓને એક API ની જરૂર છે જે તેમની સાથે લડતું નથી.

બીજું, AI એકીકરણએ સ્ટ્રીમિંગને વપરાશકર્તા-સામનો કરવાની સુવિધા બનાવી છે. જ્યારે AI સહાયક પ્રતિસાદ જનરેટ કરે છે, ત્યારે વપરાશકર્તાઓ ટોકન્સ વાસ્તવિક સમયમાં દેખાય તેવી અપેક્ષા રાખે છે, બફરના સમગ્ર પ્રતિસાદની રાહ જોતા નથી. દરેક SaaS પ્લેટફોર્મ — Mewayz જેવી બિઝનેસ ઑપરેટિંગ સિસ્ટમ્સથી લઈને સ્ટેન્ડઅલોન AI ટૂલ્સ સુધી — હવે મજબૂત ક્લાયન્ટ-સાઇડ સ્ટ્રીમ વપરાશની જરૂર છે. વર્તમાન API આ માટે કામ કરે છે, પરંતુ સ્ટ્રીમ કરેલ AI આઉટપુટને પાર્સિંગ, ટ્રાન્સફોર્મિંગ અને રેન્ડર કરવાનો વિકાસકર્તા અનુભવ કંપોઝેબલ સ્ટ્રીમ ઓપરેટર્સ સાથે નોંધપાત્ર રીતે વધુ સારો હોઈ શકે છે.

ત્રીજું, ફુલ-સ્ટૅક JavaScript ચળવળનો અર્થ છે કે ડેવલપર્સ નેટવર્ક બાઉન્ડ્રીની બંને બાજુએ સ્ટ્રીમનું સંચાલન કરી રહ્યાં છે. સિંગલ એન્જિનિયર સર્વર-સાઇડ સ્ટ્રીમ લખી શકે છે જે ડેટાબેઝ ક્વેરી પરિણામો પર પ્રક્રિયા કરે છે, તેમને ટ્રાન્સફોર્મેશન દ્વારા પાઈપ કરે છે, તેમને કટ્ડ HTTP પ્રતિસાદ તરીકે મોકલે છે અને પછી પ્રગતિશીલ UI રેન્ડર કરવા માટે ક્લાયંટ પર તે જ સ્ટ્રીમનો ઉપયોગ કરે છે. જ્યારે સ્ટ્રીમિંગ API બેડોળ હોય છે, ત્યારે તે ઘર્ષણ સ્ટેકના દરેક સ્તર પર અનુભવાય છે.

આગળ વધવું: વિકાસકર્તાઓ આજે શું કરી શકે છે

જ્યારે ભાષા વિકસિત થાય છે, વિકાસકર્તાઓ રાહ જોતા અટકતા નથી. કેટલીક વ્યવહારુ વ્યૂહરચના વર્તમાન પ્રોજેક્ટ્સમાં સ્ટ્રીમિંગ અનુભવને સુધારી શકે છે. પ્રાથમિક ઓથરિંગ પેટર્ન તરીકે એસિંક જનરેટર્સનો ઉપયોગ કરવો — અને તેને ReadableStream.from() માં લપેટીને જ્યાં રનટાઈમ તેને સપોર્ટ કરે છે — મેન્યુઅલ કંટ્રોલર મેનેજમેન્ટ કરતાં વધુ સ્વચ્છ સિન્ટેક્સ પ્રદાન કરે છે. it-pipe અને streaming-iterables જેવી લાઇબ્રેરીઓ કંપોઝેબલ હેલ્પર્સ ઓફર કરે છે જે આજે એસિંક ઇટરેટર્સ માટે કાર્યાત્મક ચેઇનિંગ લાવે છે.

ડેટા-સઘન એપ્લિકેશનો બનાવતી ટીમો માટે, પાતળા આંતરિક સ્ટ્રીમિંગ યુટિલિટી લેયરમાં રોકાણ કરવાથી ડિવિડન્ડ મળે છે. સારી રીતે ડિઝાઈન કરેલ streamMap(), streamFilter(), અને streamBatch() ફંક્શન્સનો સમૂહ — દરેક એક async પુનરાવર્તિત લે છે અને એક async પુનરાવર્તિત પરત કરે છે — સંપૂર્ણ સ્ટ્રીમિંગ ફ્રેમવર્કના વજન વિના, પ્રમાણભૂત API નો અભાવ છે તે કમ્પોઝબિલિટી પ્રદાન કરે છે. આ એક એવી પેટર્ન છે જે સ્ટાર્ટઅપ પ્રોટોટાઇપથી માંડીને લાખો ઑપરેશનને હેન્ડલ કરતા પ્લેટફોર્મ્સ સુધી માપે છે.

સ્ટ્રીમિંગ ડેટા ઉત્પન્ન કરવા માટે તમારા ડિફોલ્ટ પેટર્ન તરીકે
1. અસિંક જનરેટર્સ અપનાવો — તે મેન્યુઅલ રીડેબલ સ્ટ્રીમ કન્સ્ટ્રક્શન કરતાં ક્લીનર, વધુ ટેસ્ટેબલ અને વધુ કંપોઝેબલ છે
2. જ્યારે તમને રીડેબલસ્ટ્રીમ ઇન્સ્ટન્સની અપેક્ષા હોય તેવા API સાથે ઇન્ટરઓપની જરૂર હોય ત્યારે વેબ સ્ટ્રીમ્સની દુનિયામાં એસિંક પુનરાવર્તિતતાને પુલ કરવા ReadableStream.from() નો ઉપયોગ કરો
ટ્રાન્સફોર્મસ્ટ્રીમ ઑબ્જેક્ટ્સ બનાવવાને બદલે એસિંક ઇટરેબલ પર સામાન્ય ઑપરેશન્સ (નકશો, ફિલ્ટર, બેચ, થ્રોટલ) માટે
3. પાતળા ઉપયોગિતા કાર્યો બનાવો અથવા અપનાવો
4. TC39 અને રનટાઇમ ચર્ચાઓમાં એડવોકેટ કરો — async iterator હેલ્પર્સ દરખાસ્તને વિકાસકર્તાના અવાજની પ્રાથમિકતા માટે દબાણ કરવાની જરૂર છે
5. એસિંક ઇટરેબલ સામે પરીક્ષણો લખો, સીધા સ્ટ્રીમ્સ નહીં — આ તમારા સ્ટ્રીમિંગ તર્કને પોર્ટેબલ અને માન્ય કરવામાં સરળ બનાવે છે