Terokai cara menggunakan pengaturcaraan reaktif dalam Node? Analisis Kelebihan dan Kekurangan

Artikel ini akan membolehkan anda meneroka pengaturcaraan reaktif dengan Node.js, dan memperkenalkan kaedah menggunakan pengaturcaraan reaktif dalam Node, serta faedah, kebaikan dan keburukannya semua orang!

Pengaturcaraan reaktif menyediakan aliran data lanjutan untuk mencipta dan memanipulasi strim acara dengan cara yang boleh diramal.

Artikel ini akan memberitahu pembangun Node.js cara menggunakan pengaturcaraan reaktif dalam Node, serta faedah dan keburukannya.

Artikel ini akan merangkumi kandungan berikut.

• Prinsip Asas Pengaturcaraan Reaktif

• Mengapa mempertimbangkan pengaturcaraan reaktif dalam Node.js?

• Bila menggunakan pengaturcaraan reaktif

• Faedah pengaturcaraan reaktif

• Kelemahan Pengaturcaraan Reaktif

• Pengenalan kepada penyelarasan dan faedah/keburukannya

• Pustaka pengaturcaraan reaktif untuk Node

Apa itu pengaturcaraan reaktif?

Ringkasnya, program dikatakan reaktif apabila perubahan dalam input menghasilkan perubahan yang sepadan dalam output, tanpa perlu mengemas kini secara manual perubahan dalam output. Ini membolehkan jurutera perisian memintas tekanan mengendalikan pelaksanaan besar secara manual.

Paradigma pengaturcaraan reaktif berfungsi menjadikan asas kod reaktif kami mudah dibaca dan difahami kerana ia mengurangkan panggilan balik, yang menjadikan blok kod tak segerak sukar dibaca.

Memandangkan pengaturcaraan reaktif mempunyai banyak kaitan dengan operasi tak segerak, pendekatan berfungsi memudahkan kami menentukan keputusan operasi tak segerak.

Prinsip Asas Pengaturcaraan Reaktif

Pengendali

Pengendali ialah kaedah yang amat bergantung kepada Observable. Mereka mempunyai senario penggunaan berikut.

• Menukar peristiwa tak segerak kepada Boleh Diperhatikan apabila mengendalikan permintaan tak segerak
• Menggabungkan urutan berbilang pembolehubah Boleh Dicerap menjadi pembolehubah Boleh Dicerap tunggal
• Pengendalian Ralat

Pengendali boleh diperhatikan termasuk kaedah

, [filter(...)](https://rxjs.dev/api/operators/filter), [mergeMap(...)](https://rxjs.dev/api/operators/mergeMap), [of](https://rxjs.dev/api/index/function/of), [from](https://rxjs.dev/api/index/function/from), dsb. [concat](https://rxjs.dev/api/index/function/concat)

Strim Boleh Dicerap

Strim

Boleh Diperhatikan ialah susunan berbilang nilai input yang diproses dari semasa ke semasa. Sebuah Observable memancarkan acara kepada pelanggannya, yang seterusnya mendengar acara ini untuk diproses selanjutnya. Strim boleh diperhatikan boleh digabungkan untuk mencipta strim baharu. Kaedah tatasusunan, seperti , map, reduce, dsb., digunakan untuk mengendalikan strim. filter

Nilai boleh dipancarkan kepada pelanggan seperti berikut.

import { of, Observable } from "rxjs"; 
const emitter : Observable<string> = of("Sam", "Ray", "Thomas");

Pelanggan

Pelanggan yang boleh diperhatikan adalah lebih seperti iterator tatasusunan. Mereka menggelung melalui strim Boleh Diperhati yang terhasil, menjadikannya mungkin untuk mengubah atau memproses setiap aliran.

Coretan berikut menunjukkan cara melanggan strim Boleh Diperhatikan.

emitter.subscribe((value: string) => {
  console.log(`Name: ${value}`)
})

Pengaturcaraan reaktif mempunyai beberapa kaedah langganan terbina dalam seperti

dan emit kaedah peta yang membolehkan kami mendengar setiap nilai strim Boleh Diperhatikan dan melaksanakan operasi padanya mengikut perjanjian keperluan kami dengan. flatMap

Standard untuk Sistem Reaktif

Sistem Node.js reaktif sepenuhnya harus memenuhi piawaian berikut.

Seni bina responsif

Sistem reaktif harus mempunyai pengalaman pengguna yang baik dan memberikan respons tepat pada masanya kepada interaksi pengguna.

Seni Bina Berdaya tahan

Seni bina berdaya tahan, jika dilaksanakan dengan betul, akan membolehkan sistem bertindak balas kepada ralat tanpa mengganggu keseluruhan sistem.

Seni bina ini memastikan setiap nod mempunyai replika. Jika nod induk gagal, terdapat beberapa jenis sandaran pada nod lain yang tersedia.

Skalabiliti

Sistem seharusnya dapat mengendalikan beban yang berbeza, yang berkaitan dengan keupayaannya untuk mengecil apabila infrastruktur memerlukan sedikit atau tiada sumber Skala, dan apabila infrastruktur memerlukan lebih banyak sumber, ia boleh ditingkatkan untuk menyediakan strategi pengurusan kos yang berkesan.

Selain itu, sistem juga seharusnya dapat mengendalikan beban titik dalam masa.

Mengapa anda perlu mempertimbangkan pengaturcaraan reaktif dengan Node.js?

Sekarang kita telah membincangkan secara ringkas asas pengaturcaraan reaktif, adalah penting juga untuk memahami sebab untuk mempertimbangkan pendekatan reaktif untuk pengaturcaraan dengan Node.js.

Skalabiliti

Menulis kod reaktif berfungsi menjadikannya lebih mudah untuk mengurus asas kod dan meningkatkan kebolehskalaan projek.

功能实现

对于需要定期修改功能或增加新功能的项目来说，编写功能性反应式代码使得新功能更容易被添加到现有项目中。

与时间相关的错综复杂的问题

在对外部API进行异步请求时，我们确实会遇到一些时间限制的约束。这些限制可以用反应式编程方法有效地处理。

减少代码的冗长性

实施反应式编程范式将极大地减少实现特定功能所需的代码量。

引入协调和它的好处/权衡

在反应式编程诞生之前，用Node.js构建微服务需要协调所有服务互动的协调器模式。

协调器模式的一个典型用例是在电子商务应用中拥有微服务，这些微服务按顺序处理以下任务：从购物车中获取客户订单，计算总金额，生成账单，在成功付款后，更新产品库存并创建一个订单ID，并向卖家提供Pending 。

虽然这提供了一个系统的方法来处理应用程序的逻辑流程，但依赖关系紧密耦合的一个主要缺点会破坏整个系统。例如，如果前面的服务出现故障，那么所有的依赖服务都不会被执行。

在Node.js中何时使用反应式编程方法

反应式编程不是一个万能的方法，但它在一些特定的情况下是非常合适的。

• 当需要将应用流分散到可管理的微服务中时，反应式编程模式是非常合适的。
• 当需要在有限的时间内将应用交付给生产时
• 当前面的一个依赖性的临时关闭会导致整个系统的崩溃时
• 当有很多异步的代码块，而等待的结果可能被延迟时，反应式编程也是非常合适的。

Node.js中的反应式编程的弊端

虽然功能化的反应式编程方法减少了协调器模式遇到的缺点，但它不能取代协调器模式，因为它有自己的缺点。

• 分解应用流程并分布在所有服务中所产生的冗余代码块
• 为了构建反应式服务，需要对流和事件循环有一个全面的了解

Node.js中流行的反应式编程库

RxJS

这是JavaScript中最流行的反应式编程库之一，被积极维护。

在写这篇文章的时候，RxJS正在从v7过渡到v8，它在上周有超过2700万次的下载。这次过渡的特点是重写了库的性能，更好的模块化，更好的可调试的调用堆栈，以及向后的兼容性。

下面是一个快速的RxJS使用例子。

import { range } from "rxjs";
import { map, filter } from "rxjs/operators";

range(1, 200)
  .pipe(
    filter(result => result % 2 === 1),
    map(result => result * 2 )
  )
  .subscribe(result => console.log(result));

Reactor.js

Reactor.js是另一个用于反应式编程的JavaScript库。虽然与Bacon.js和Rxjs相比，它还不是很流行，但它以轻量而闻名。使用Reactor.js在复杂的数据模型中保持一致性要容易得多，因为它能自动跟踪反应式变量，并在任何反应式变量的值发生变化时重新触发观察者。
使用Reactor.js，不需要手动设置订阅/监听器，因为依赖关系会自动为你设置。

下面是一个Reactor.js使用的快速例子。

const reactor = new Reactor({ name: "Doe" });

observe(() => {
  console.log("My name is ", reactor.name);
}); // prints "My name is Doe"

reactor.name = "John "; // prints "My name is John"

Reactor是基于与Bacon.js和Knockout.js相同的反应式原理。

其他用于反应式编程的JavaScript库包括。

• Flyd
• Bacon.js
• Knockout.js
• Kefir
• 大多数

总结

在这篇文章中，我们探讨了反应式编程，它的好处，以及何时最适合我们的Node.js项目。此外，我们还讨论了协调、其好处/利弊以及用于Node.js中反应式编程的JavaScript库。

希望你能发现这篇文章的信息量和帮助。

更多node相关知识，请访问：nodejs 教程！

Atas ialah kandungan terperinci Terokai cara menggunakan pengaturcaraan reaktif dalam Node? Analisis Kelebihan dan Kekurangan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!