c 怎么调用js方法调用方法调用方法调用方法

通过C语言调用JavaScript方法可以通过以下几种方式实现：使用嵌入式JavaScript引擎如V8或SpiderMonkey、通过WebAssembly、使用Node.js的C++扩展、通过浏览器插件。以下将详细介绍如何通过嵌入式JavaScript引擎调用JavaScript方法。

一、嵌入式JavaScript引擎

嵌入式JavaScript引擎如V8和SpiderMonkey允许你在C/C++代码中嵌入和执行JavaScript代码。V8是Google Chrome的JavaScript引擎，而SpiderMonkey是Mozilla Firefox的JavaScript引擎。它们提供了C++ API，可以方便地在C/C++代码中调用JavaScript方法。下面以V8为例，详细介绍如何实现这一过程。

一、V8引擎

1、安装V8引擎

在使用V8引擎之前，需要先安装它。你可以通过以下步骤在Linux系统上安装V8引擎：

sudo apt-get update sudo apt-get install -y libv8-dev

对于其他操作系统，可以参考V8的官方文档进行安装。

2、初始化V8引擎

在C++代码中初始化V8引擎需要执行以下步骤：

#include <v8.h>
using namespace v8;
int main(int argc, char* argv[]) {
    // 初始化 V8.
    V8::InitializeICUDefaultLocation(argv[0]);
    V8::InitializeExternalStartupData(argv[0]);
    std::unique_ptr<Platform> platform = platform::NewDefaultPlatform();
    V8::InitializePlatform(platform.get());
    V8::Initialize();
    // 创建一个新的 Isolate 和一个栈空间分配器.
    Isolate::CreateParams create_params;
    create_params.array_buffer_allocator = ArrayBuffer::Allocator::NewDefaultAllocator();
    Isolate* isolate = Isolate::New(create_params);
    {
        // 进入 Isolate 的上下文.
        Isolate::Scope isolate_scope(isolate);
        // 创建一个堆栈-分配的句柄范围.
        HandleScope handle_scope(isolate);
        // 创建一个新的上下文.
        Local<Context> context = Context::New(isolate);
        // 进入上下文范围.
        Context::Scope context_scope(context);
        // 编写 JavaScript 代码.
        Local<String> source =
            String::NewFromUtf8Literal(isolate, "'Hello' + ', World!'");
        // 编译 JavaScript 代码.
        Local<Script> script = Script::Compile(context, source).ToLocalChecked();
        // 运行 JavaScript 代码.
        Local<Value> result = script->Run(context).ToLocalChecked();
        // 将结果转换为字符串并打印.
        String::Utf8Value utf8(isolate, result);
        printf("%sn", *utf8);
    }
    // 销毁 Isolate 和释放相关资源.
    isolate->Dispose();
    V8::Dispose();
    V8::ShutdownPlatform();
    delete create_params.array_buffer_allocator;
    return 0;
}

3、调用JavaScript方法

在上面的代码中，我们已经展示了如何在C++代码中执行JavaScript代码。接下来，我们将展示如何在C++代码中调用JavaScript方法。

#include <v8.h>
using namespace v8;
int main(int argc, char* argv[]) {
    // 初始化 V8.
    V8::InitializeICUDefaultLocation(argv[0]);
    V8::InitializeExternalStartupData(argv[0]);
    std::unique_ptr<Platform> platform = platform::NewDefaultPlatform();
    V8::InitializePlatform(platform.get());
    V8::Initialize();
    // 创建一个新的 Isolate 和一个栈空间分配器.
    Isolate::CreateParams create_params;
    create_params.array_buffer_allocator = ArrayBuffer::Allocator::NewDefaultAllocator();
    Isolate* isolate = Isolate::New(create_params);
    {
        // 进入 Isolate 的上下文.
        Isolate::Scope isolate_scope(isolate);
        // 创建一个堆栈-分配的句柄范围.
        HandleScope handle_scope(isolate);
        // 创建一个新的上下文.
        Local<Context> context = Context::New(isolate);
        // 进入上下文范围.
        Context::Scope context_scope(context);
        // 编写 JavaScript 方法.
        Local<String> source = String::NewFromUtf8Literal(isolate, "function add(a, b) { return a + b; }");
        // 编译 JavaScript 代码.
        Local<Script> script = Script::Compile(context, source).ToLocalChecked();
        // 运行 JavaScript 代码.
        script->Run(context).ToLocalChecked();
        // 获取全局对象.
        Local<Object> global = context->Global();
        // 获取 JavaScript 方法.
        Local<Value> add_value = global->Get(context, String::NewFromUtf8Literal(isolate, "add")).ToLocalChecked();
        // 检查是否为函数.
        if (add_value->IsFunction()) {
            Local<Function> add_function = Local<Function>::Cast(add_value);
            // 设置参数.
            Local<Value> args[2] = { Number::New(isolate, 2), Number::New(isolate, 3) };
            // 调用 JavaScript 方法.
            Local<Value> result = add_function->Call(context, global, 2, args).ToLocalChecked();
            // 将结果转换为数字并打印.
            double result_value = result->NumberValue(context).FromJust();
            printf("Result: %fn", result_value);
        }
    }
    // 销毁 Isolate 和释放相关资源.
    isolate->Dispose();
    V8::Dispose();
    V8::ShutdownPlatform();
    delete create_params.array_buffer_allocator;
    return 0;
}

二、WebAssembly

WebAssembly (Wasm) 是一种可移植的、体积小、加载快并且兼容Web的二进制指令格式。通过WebAssembly，可以将C/C++代码编译为WebAssembly模块，然后在JavaScript中调用这些模块。以下是详细步骤：

1、安装Emscripten SDK

Emscripten是一个将C/C++代码编译为WebAssembly的工具链。你可以通过以下步骤安装Emscripten SDK：

git clone https://github.com/emscripten-core/emsdk.git cd emsdk ./emsdk install latest ./emsdk activate latest source ./emsdk_env.sh

2、编写C/C++代码

编写一个简单的C/C++函数，并将其导出为WebAssembly模块：

#include <emscripten.h>
extern "C" {
    EMSCRIPTEN_KEEPALIVE
    int add(int a, int b) {
        return a + b;
    }
}

3、编译为WebAssembly模块

使用Emscripten将C/C++代码编译为WebAssembly模块：

emcc add.cpp -O3 -s WASM=1 -s EXPORTED_FUNCTIONS="['_add']" -o add.js

4、在JavaScript中调用WebAssembly模块

在HTML文件中引入生成的JavaScript文件，并调用WebAssembly模块：

<!DOCTYPE html>
<html>
<head>
    <title>WebAssembly Example</title>
    <script src="add.js"></script>
</head>
<body>
    <script>
        Module.onRuntimeInitialized = function() {
            var result = Module._add(2, 3);
            console.log('Result:', result);
        };
    </script>
</body>
</html>

通过上述步骤，你可以在JavaScript中调用由C/C++代码生成的WebAssembly模块。

三、Node.js的C++扩展

Node.js允许开发者编写C++扩展，以便在JavaScript中调用C++代码。下面是详细步骤：

1、安装Node.js和npm

确保你已经安装了Node.js和npm。

2、初始化Node.js项目

在项目目录中运行以下命令：

npm init -y npm install --save nan

3、编写C++扩展

创建一个名为addon.cpp的文件，并编写C++扩展代码：

#include <nan.h>
void Add(const Nan::FunctionCallbackInfo<v8::Value>& info) {
    double a = info[0]->NumberValue(Nan::GetCurrentContext()).FromJust();
    double b = info[1]->NumberValue(Nan::GetCurrentContext()).FromJust();
    double result = a + b;
    info.GetReturnValue().Set(result);
}
NAN_MODULE_INIT(Initialize) {
    NAN_EXPORT(target, Add);
}
NODE_MODULE(addon, Initialize)

4、编写binding.gyp文件

在项目目录中创建一个名为binding.gyp的文件，并添加以下内容：

{
  "targets": [
    {
      "target_name": "addon",
      "sources": [ "addon.cpp" ]
    }
  ]
}

5、编译C++扩展

运行以下命令编译C++扩展：

npx node-gyp configure npx node-gyp build

6、在JavaScript中调用C++扩展

创建一个名为index.js的文件，并编写以下代码：

const addon = require('./build/Release/addon');
const result = addon.Add(2, 3);
console.log('Result:', result);

通过上述步骤，你可以在Node.js中调用C++扩展。

四、浏览器插件

浏览器插件如Chrome扩展和Firefox附加组件允许你在JavaScript中调用本地代码。以下是详细步骤：

1、编写本地代码

编写一个简单的本地代码，例如C++代码：

#include <iostream>
extern "C" {
    __declspec(dllexport) int add(int a, int b) {
        return a + b;
    }
}

2、编译本地代码

将本地代码编译为动态链接库（DLL）或共享对象（SO）：

g++ -shared -o add.so add.cpp

3、编写浏览器插件

编写一个简单的Chrome扩展，使用Native Messaging API与本地代码进行通信：

{
  "name": "com.example.native",
  "description": "Native Messaging Example",
  "path": "add.so",
  "type": "stdio",
  "allowed_origins": [
    "chrome-extension://<extension-id>/"
  ]
}

在Chrome扩展的背景脚本中调用本地代码：

chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
    if (message.type === 'add') {
        const port = chrome.runtime.connectNative('com.example.native');
        port.postMessage({ a: message.a, b: message.b });
        port.onMessage.addListener(response => {
            sendResponse({ result: response.result });
        });
        return true;
    }
});

4、在JavaScript中调用浏览器插件

在JavaScript代码中调用Chrome扩展：

chrome.runtime.sendMessage({ type: 'add', a: 2, b: 3 }, response => {
    console.log('Result:', response.result);
});

通过上述步骤，你可以在JavaScript中调用本地代码。

结论

通过上述几种方式，你可以在C/C++代码中调用JavaScript方法，包括使用嵌入式JavaScript引擎如V8或SpiderMonkey、通过WebAssembly、使用Node.js的C++扩展以及通过浏览器插件。每种方式都有其优点和缺点，具体选择哪种方式取决于你的具体需求和应用场景。