Wow, my fellow front-end developers! Today, I want to share with you an incredibly useful feature - 跨组件触发请求. Are you often racking your brain trying to implement a smooth pagination list? Don't worry, I've discovered a super handy tool that has really helped me a lot! I'm so excited I could jump for joy!

alovajs - have you heard of it? It's a next-generation request tool, not just a simple HTTP client. Unlike react-query and swrjs, alovajs provides a complete solution for requests. It can not only handle basic API calls, but also optimize complex data interaction scenarios, such as the pagination list we're going to discuss today.

If you want to dive deeper into alovajs' powerful features, be sure to check out the official website https://alova.js.org. I'm sure you'll discover a whole new world of efficient data requests!

Now, let's see how alovajs makes cross-component request triggering a breeze.

In the past, if you wanted to trigger a request in one component from another component, you had to save the data to the Store and complete it by dispatching an Action. Now, you can use this middleware to eliminate the component hierarchy restriction and quickly trigger the operation functions of any request in any component.

For example, you can re-trigger the request for the sidebar menu after updating the menu data in a certain component, thereby refreshing the data. After operating on the list data, you can trigger the list update.

Features

• Delegate the operation functions of any alova use hook;
• Trigger the delegated operation functions from any position;

Usage

Basic usage

Taking vue3 as an example, the usage is the same in react and svelte.

Use actionDelegationMiddleware to delegate the operation functions of useRequest in component A.

```javascript title=Component A
import { actionDelegationMiddleware } from 'alova/client';

useRequest(queryTodo, {
// ...
middleware: actionDelegationMiddleware('actionName')
});

In any component (e.g. component B), use `accessAction` to pass in the specified delegation name to trigger the operation functions of `useRequest` in component A.



```javascript title=Component B
import { accessAction } from 'alova/client';

accessAction('actionName', delegatedActions => {
  // Call the send function in component A
  delegatedActions.send();

  // Call the abort function in component A
  delegatedActions.abort();
});

Batch trigger operation functions

In the above example, we used accessAction to trigger the operation function of a use hook, but in fact, the same delegation name will not overwrite each other, but will be saved in a set, and we can use this name to trigger their delegated functions at the same time.

```javascript title=Component C
import { actionDelegationMiddleware } from 'alova/client';

useRequest(queryTodo, {
// ...
middleware: actionDelegationMiddleware('actionName1')
});

```javascript title=Component D
import { actionDelegationMiddleware } from 'alova/client';

useRequest(queryTodo, {
  // ...
  middleware: actionDelegationMiddleware('actionName1')
});

```javascript title=Component E
import { accessAction } from 'alova/client';

// Since it will match the delegated hooks of component C and component D, the callback function will be executed twice
accessAction('actionName1', delegatedActions => {
// Call the send function in component C and component D
delegatedActions.send();

// Call the abort function in component C and component D
delegatedActions.abort();
});

Additionally, you can use regular expressions in `accessAction` to batch trigger the operation functions that meet the delegation name conditions.



```javascript title=Component F
import { actionDelegationMiddleware } from 'alova/client';

useRequest(queryTodo, {
  // ...
  middleware: actionDelegationMiddleware('prefix_name1')
});

```javascript title=Component G
import { actionDelegationMiddleware } from 'alova/client';

useRequest(queryTodo, {
// ...
middleware: actionDelegationMiddleware('prefix_name2')
});

```javascript title=Component H
import { accessAction } from 'alova/client';

// Since it will match the delegated hooks of component F and component G, the callback function will be executed twice
accessAction(/^prefix_/, delegatedActions => {
  // Call the send function in component F and component G
  delegatedActions.send();

  // Call the abort function in component F and component G
  delegatedActions.abort();
});

This feature really makes my life easier when dealing with cross-component data synchronization. No more headaches about data consistency! And the best part is, it's so easy to use. I'm surprised react-query and axios haven't come up with something like this yet.

If you're dealing with complex component interactions in your daily development, I highly recommend giving alovajs a try. This powerful tool can significantly improve your development efficiency and user experience.

What do you usually do to handle cross-component requests? Have you encountered any interesting problems or solutions? Feel free to share your experiences in the comments! Let's discuss and learn from each other. I can't wait to hear your thoughts!