برنامه نویسی ناهمزمان یا همان برنامه نویسی نامتقارن برای توسعه ی هر نرم افزاری مدرنی که نیاز به انجام عملیات بدون مسدود کردن رابط کاربری یا رشته اصلی دارد ضروری است، در برنامه نویسی با زبان Kotlin، یکی از محبوب ترین کتابخانه ها برای برنامه نویسی ناهمزمان، کوروتین (Kotlin Coroutines) است، در مقاله ی flow در کاتلین قصد دارم شما را بصورت کلی با فلو به همراه معرفی اپراتور های فلو آشنا کنم، پس تا انتهای این مقاله از آکادمی نوری با من همراه باشید.

بدلیل این که اشاره ای به کوروتین و برنامه نویسی ناهمزمان داشتم، توضیحات کوتاهی در مورد این که برنامه نویسی ناهمزمانی چیست و کوروتین چیست ارائه می دهم، اما اگر علاقه دارید تا بیشتر در مورد کوروتین و کاربرد هایش بدانید پیشنهاد می کنم از مقاله ی کوروتین چیست آکادمی نوری دیدن کنید تا بتوانید به کمک آن اطلاعات خود را در زمینه ی کوروتین و کاربرد هایش افزایش دهید، در ادامه توضیحات مختصر و کلی در مورد کوروتین را خواهیم داشت.

flow در کاتلین

همان طور که می دانید بحث اصلی این مقاله در مورد flow در اندروید است، اما چرا دارم در ابتدای مقاله در مورد کتابخانه ی کوروتین توضیح می دهم؟ در ادامه متوجه این موضوع خواهید شد.

کوروتین چیست؟

Coroutine ها رشته های سبک وزنی هستند که به توسعه دهندگان اجازه می دهند کد های ناهمزمان را به سبک متوالی و همزمان بنویسند، در حالی که از کوروتین ها می توان برای حل بسیاری از مشکلات برنامه نویسی ناهمزمان استفاده کرد، آنها همه مشکلات را حل نمی کنند، به خصوص وقتی صحبت از جریان داده می شود.
اگر از کوروتین اطلاعات کافی ندارید، ممکن است نتوانید با کمک موارد مختصری که در این بخش گفته شده آن را درک کنید، می توانید اول از هر چیزی از مقاله ای که در بالا معرفی کردم دیدن کنید و آن را بخوانید و سپس به این مقاله مراجعه کنید.

Flow افزودنی جدیدی به کتابخانه کوروتین در اندروید است که راهی برای نمایش و پردازش جریان‌ های داده ناهمزمان به صورت غیر مسدود کننده و متوالی فراهم می‌کند؛ فلو نوعی توالی ناهمزمان است که مقادیر متعددی را در طول زمان منتشر می‌ کند و آن را برای مدیریت جریان‌ های داده از منابعی مانند حسگر ها، پایگاه‌ های داده یا درخواست‌ های شبکه ایده‌آل می‌کند.

در این مقاله از آکادمی نوری، نگاهی دقیق‌ تر به flow در کاتلین خواهیم داشت و برخی موارد رایج و پر استفاده از این کتابخانه قدرتمند را بررسی می‌ کنیم، با من همراه باشید.

فلو در اندروید چیست؟

به طور خلاصه، فلو یک جریان ناهمزمان از داده است که می تواند به روشی غیر مسدود کننده پردازش شود، این شبیه به دنباله ای از داده ها است، اما برخلاف یک دنباله، می تواند مقادیری را به صورت ناهمزمان در طول زمان منتشر کند! با Flow، توسعه‌ دهندگان می‌ توانند جریان‌ های داده را با استفاده از یک سبک برنامه‌ نویسی متوالی و عملکردی نمایش داده و همچنین پردازش کنند.

فلو در واقع جزوی از کاتلین به شمار می آید و بهتر است بدانید کهبه آن کاتلین‌فلو هم گفته می شود؛ فلو جریانی از داده را می سازد و همچنین نیازی به دریافت در حالات مختلف وجود ندارد، خودش دریافت را انجام می دهد.
فلو با الگوی Observable ساخته شده است و همچنین دنباله ای از داده ها است که به صورت آسنکرون است که برای انتقال و آپدیت داده ها مورد استفاده قرار می گیرد.

به طور کلی دو نوع Observable داریم که به observable گرم و observable سرد تقسیم می شوند، فلو از نوع observable سرد است، این یعنی زمانی اطلاعات منتشر می شوند که یک دریافت کننده یا Observer وجود داشته باشد، اگر گیرنده هایی که اطلاعات را دریافت می کنند وجود نداشته باشند هیچ نتیجه ای را نخواهیم داشت.
بنابراین زمانی که هم Observable و هم Observer حاضر باشند، فلو می تواند نتیجه‌ بخش باشد.

flow در کاتلین با کمک یک سری متد ها اطلاعات را می سازد که به دو نوع مستقیم و غیر مستقیم بحش بندی می شوند، همان طور که به این موضوع اشاره هم داشتیم.

با استفاده از فلو می توانیم به صورت اپشنال قبل از این که دیتا توسط Observer ها دریافت شود تغییراتی بر روی دیتا ها صورت بگیرد و در نهایت بعد از این که تغییرات مد نظر بر روی دیتا ها انجام شد دریافت کننده ها یا همان Observer ها دیتا را تحویل بگیرند و سپس عملیات ها بر روی آن ها انجام شود.

مزایای flow در اندروید

یکسری از مواردی که می توان به عنوان مزایای فلو نام برد را برایتان در این بخش از مقاله ی flow در کاتلین عنوان می کنم:

• پشتیبانی تمام و کمال از کوروتین
• سازگاری کامل با کاتلین
• پر سرعت و انعطاف پذیر
• سادگی چشم نواز به نسبت RxJava
• امکان ایجاد تغییرات قبل از تحویل داده ها
  ( همانند سانسور )

حال تا به این جای مقاله به موارد مفیدی از flow در اندروید اشاره داشتیم، در ادامه بعد از یکسری توضیحات و مثال های کوچک قصد داریم به اپراتور ها در فلو بپردازیم، با من همراه باشید.

در اینجا یک مثال از یک Flow ساده است که دنباله ای از اعداد صحیح را منتشر می کند:

fun simpleFlow(): Flow<Int> = flow {
for (i in 1..10) {
delay(1000)
emit(i)
}
}

در این مثال با استفاده از تابع flow builder یک فلو ایجاد می کنیم، در داخل فلو از یک حلقه for برای انتشار دنباله ای از اعداد صحیح از 1 تا 10 با تاخیر 1 ثانیه بین هر انتشار استفاده می کنیم.

برای جمع آوری و دریافت مقادیر منتشر شده توسط Flow از عملگر collect استفاده می کنیم. در اینجا مثالی از نحوه ی دریافت مقادیر منتشر شده توسط simpleFlow ما آورده شده است:

fun main() = runBlocking<Unit> {
simpleFlow().collect { value ->
println (value)
}
}

در این مثال، ما از عملگر collect برای دریافت و استفاده از مقادیر ارسال شده استفاده می کنیم، عملگر collect یک تابع تعلیق است که منتظر مقدار بعدی منتشر شده توسط Flow است و سپس آن را در لامبدای ارسال شده به آن پردازش می‌ کند.

و اما اپراتور ها در flow، به بخش اپراتور های فلو خوش آمدید، در ادامه یکسری از اپراتور های رایج در فلو را خواهیم داشت، با من همراه باشید.

اپراتورها در فلو

برای این که بتوانید از فلو استفاده کنید نیازی نیست تا کتابخانه ای را ایمپورت کنید، چرا که فلو جزوی از کاتلین است و در آن وجود دارد.
در ادامه با معرفی اپراتور ها با من همراه باشید.

اپراتور map در فلو

اپراتور map هر مقداری که توسط فلو انتقال داده می شود را با اعمال یک تغییر به observer تحویل می دهد، در ادامه برای اپراتور مپ در فلو مثالی را داریم.

fun simpleFlow(): Flow>Int> = flow {
  for (i in 1..10) {
    delay(1000)
    emit(i)
  }
}

در قطعه کد بالا جریان داده را ساختیم و حال قصد داریم با استفاده از اپراتور map داده ها را با تغییرات اعمال شده دریافت کنیم، به شکل زیر:

fun main() = runBlocking<Unit> {
  simpleFlow().map { it * 2 }
.collect { value ->
  println (مقدار)
 }
}

در مثال بالا با استفاده از عملگر map عدد های 0 تا 10 را که با فلو ساختیم را با اعمال ضرب در 2 به observer تحویل می دهیم.

اپراتور filter در فلو

با استفاده از این اپراتور می توانیم تعیین کنیم فقط مقادیری که با خواسته های ما تناسب دارند را داشته باشیم، در ادامه یک مثال برای اپراتور filter در فلو را داریم.

fun simpleFlow(): Flow<Int> = flow {
for(i in 1..10) {
delay(1000)
emit(i)
}
}

داده ها ساخته شدند.

fun main() = runBlocking<Unit> {
simpleFlow()
.filter { it % 2 == 0 }
.collect { value ->
println (value)
}
}

اینجا با کمک اپراتور filter تعیین کردیم که فقط اعداد زوج از داده هایی که با فلو ساختیم را داشته باشیم.

اپراتور emit در فلو

در مثال هایی که در بخش های بالا داشتیم قطعا اپراتور emit را دیده اید، شاید به دلیل سادگی کاربردش کمی از عملکرد آن را درک کرده باشید، اما این اپراتور دقیقا چه کاری می کند؟ در ادامه ی مقاله ی flow در کاتلین به این اپراتور هم نیز می پردازیم.

اپراتور یا عملگر emit در فلو وظیفه ی ارسال اطلاعات را به عهده دارد، بعد از این که عملیات ها بر روی دیتا ها صورت گرفت و به انتهای کار رسیدیم، با استفاده از این اپراتور دیتای نهایی را ارسال می کنیم.

برای این که بتوانید کامل تر و بهتر مبحث فلو را یاد بگیرید، می توانید با تهیه ی دوره ی نخبگان معماری اندروید آکادمی نوری به خوبی این مبحث را به کمک پروژه های عملی یاد بگیرید.

flow در کاتلین یکی از مباحث مهم و پر کاربرد و گسترده ای است که مطالب زیادی در مورد آن وجود دارد، همچنین اپراتور هایی که فلو دارد، همگی نمی توانند در یک مقاله جای بگیرند، این مبحث به صورت سریالی و در مقاله های پشت سر هم ارائه داده می شود و می توانید با دنبال کردن این مقالات از مبحث فلو اطلاعات خوبی داشته باشید، از این که تا به اینجای  مقاله ی flow در کاتلین با من همراه بودید از شما سپاسگزارم❤.