因此，我与电子和我有一个NAPI文件，我有我的后端代码。在我的界面上，当我点击某个按钮时，一个函数被触发，它从NAPI调用该函数（电子是NAPI和我的javascript文件之间的桥梁），当NAPI中的“SimpleFunction”被调用时，我有另一个函数，名为“SendToElectron”，我希望它向电子发送一些东西，而不是从SimpleFunction返回一个值。（现在可能没有意义，因为我使用了一个简单的模板来描述问题，但我需要它来编写我的原始代码）。我试着用napi回调来做，但没有成功（因为我可能没有正确使用它们，如果你有回调的话，我也想用回调来解决），我没有主意了，我不知道该怎么办。
scripts.js（我在前端调用函数）

async function ClickButtonEvent(currentID)
{
  data = await api.SimpleFunction(parseInt(currentID));
}

main.js（我的主电子文件）

const { app, BrowserWindow, Menu, ipcMain, dialog } = require('electron');
const path = require('path');
const getPcapData = require('./NAPI/build/Release/operations');

function createWindow() {
  const win = new BrowserWindow({
    width: 1920,
    height: 1080,
    minWidth: 500,
    minHeight: 500,
    maxWidth: 1920,
    maxHeight: 1080,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
    },
  });

  win.loadFile('src/HTML/index.html');
}

app.whenReady().then(() => {
  createWindow();

  ipcMain.handle('SimpleFunction', async (event, index) => {
    const result = await getPcapData.SimpleFunction(index);

    return result;
  });
});

app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') app.quit();
});

preload.js（渲染器）

const { contextBridge, ipcRenderer } = require('electron');

contextBridge.exposeInMainWorld('api', {

  SimpleFunction: async (index) => {
    return await ipcRenderer.invoke('SimpleFunction', index);
  }
});

operations.cc(my napi文件）

#include <node_api.h>
#include <iostream>

#define NAPI_CALL(env, call)                                      \
  do                                                              \
  {                                                               \
    napi_status status = (call);                                  \
    if (status != napi_ok)                                        \
    {                                                             \
      const napi_extended_error_info *error_info = NULL;          \
      napi_get_last_error_info((env), &error_info);               \
      bool is_pending;                                            \
      napi_is_exception_pending((env), &is_pending);              \
      if (!is_pending)                                            \
      {                                                           \
        const char *message = (error_info->error_message == NULL) \
                                  ? "empty error message"         \
                                  : error_info->error_message;    \
        napi_throw_error((env), NULL, message);                   \
        return NULL;                                              \
      }                                                           \
    }                                                             \
  } while (0)

void SendToElectron(int index) {

// send something to electron

}

napi_value SimpleFunction(napi_env env, napi_callback_info info) {
  // Send a message to Electron
    size_t argc = 1;
    napi_value args[1];
    int index=0;

    // Get the values of the arguments passed to the function
    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));

    // Convert the values to C++ integers
    NAPI_CALL(env, napi_get_value_int32(env, args[0], &index));

    SendToElectron(index);

  return nullptr;
}

napi_value init(napi_env env, napi_value exports) {
  napi_value simpleFunction;
  napi_create_function(env, nullptr, 0, SimpleFunction, nullptr, &simpleFunction);

  napi_set_named_property(env, exports, "SimpleFunction", simpleFunction);

  return exports;
}

NAPI_MODULE(NODE_GYP_MODULE_NAME, init);