c 怎么调用js代码

C语言如何调用JavaScript代码：通过嵌入浏览器控件、使用Web框架、调用Web服务、嵌入JavaScript引擎、利用Node.js模块

嵌入JavaScript引擎：这种方法通过嵌入一个JavaScript引擎（如V8或Duktape）到C程序中，以便在C代码中运行JavaScript代码。V8是Google开发的高效JavaScript引擎，而Duktape则是一个轻量级的嵌入式JavaScript引擎。通过这种方式，C程序可以直接调用JavaScript代码，并且可以在需要时与JavaScript进行数据交换。

一、嵌入浏览器控件

嵌入浏览器控件是一种直接且简单的方法，可以让C程序在一个嵌入的浏览器中运行JavaScript代码。常见的浏览器控件包括微软的WebBrowser控件和开源的CEF（Chromium Embedded Framework）。

1. WebBrowser控件

WebBrowser控件是Windows平台下的一个COM组件，允许应用程序嵌入Internet Explorer浏览器。通过这种方式，C程序可以加载HTML页面并执行其中的JavaScript代码。

#include <windows.h>
#include <exdisp.h>
#include <mshtml.h>
// 初始化COM库
CoInitialize(NULL);
// 创建WebBrowser控件
IWebBrowser2* pWebBrowser;
CoCreateInstance(CLSID_WebBrowser, NULL, CLSCTX_INPROC_SERVER, IID_IWebBrowser2, (void)&pWebBrowser);
// 加载HTML页面
BSTR bstrURL = SysAllocString(L"https://example.com");
pWebBrowser->Navigate(bstrURL, NULL, NULL, NULL, NULL);
// 执行JavaScript代码
IHTMLDocument2* pDoc;
pWebBrowser->get_Document((IDispatch)&pDoc);
IHTMLWindow2* pWindow;
pDoc->get_parentWindow(&pWindow);
BSTR bstrScript = SysAllocString(L"alert('Hello from C!')");
VARIANT vResult;
pWindow->execScript(bstrScript, NULL, &vResult);
// 释放资源
SysFreeString(bstrURL);
SysFreeString(bstrScript);
pWindow->Release();
pDoc->Release();
pWebBrowser->Release();
CoUninitialize();

2. Chromium Embedded Framework (CEF)

CEF是一个开源项目，允许开发者将Chromium浏览器嵌入到应用程序中。CEF提供了丰富的API，可以让C程序与JavaScript代码进行交互。

#include "include/cef_app.h"
#include "include/cef_client.h"
// 初始化CEF
CefMainArgs main_args(hInstance);
CefRefPtr<CefApp> app;
CefInitialize(main_args, CefSettings(), app, NULL);
// 创建浏览器窗口
CefWindowInfo window_info;
window_info.SetAsPopup(NULL, "CEF Browser");
CefBrowserSettings browser_settings;
CefRefPtr<CefBrowser> browser = CefBrowserHost::CreateBrowserSync(window_info, new MyClientHandler(), "https://example.com", browser_settings, NULL, NULL);
// 执行JavaScript代码
browser->GetMainFrame()->ExecuteJavaScript("alert('Hello from C!')", browser->GetMainFrame()->GetURL(), 0);
// 运行消息循环
CefRunMessageLoop();
// 关闭CEF
CefShutdown();

二、使用Web框架

使用Web框架是另一种方法，通过将C程序转变为一个Web服务，从而允许JavaScript代码在浏览器中运行，并与C程序进行交互。常见的Web框架包括libmicrohttpd和CivetWeb。

1. libmicrohttpd

libmicrohttpd是一个轻量级的HTTP服务器库，可以让C程序快速实现一个Web服务器，并处理HTTP请求。

#include <microhttpd.h>
// 处理HTTP请求
int answer_to_connection(void* cls, struct MHD_Connection* connection, const char* url, const char* method, const char* version, const char* upload_data, size_t* upload_data_size, void con_cls) {
    const char* page = "<html><body><script>alert('Hello from C!');</script></body></html>";
    struct MHD_Response* response = MHD_create_response_from_buffer(strlen(page), (void*)page, MHD_RESPMEM_PERSISTENT);
    int ret = MHD_queue_response(connection, MHD_HTTP_OK, response);
    MHD_destroy_response(response);
    return ret;
}
// 启动Web服务器
struct MHD_Daemon* daemon = MHD_start_daemon(MHD_USE_SELECT_INTERNALLY, 8080, NULL, NULL, &answer_to_connection, NULL, MHD_OPTION_END);
if (NULL == daemon) return 1;
// 等待用户输入
getchar();
// 停止Web服务器
MHD_stop_daemon(daemon);

2. CivetWeb

CivetWeb是一个嵌入式C/C++ Web服务器库，支持HTTP和WebSocket协议。

#include "civetweb.h"
// 处理HTTP请求
int request_handler(struct mg_connection* conn, void* cbdata) {
    mg_printf(conn, "HTTP/1.1 200 OKrnContent-Type: text/htmlrnrn");
    mg_printf(conn, "<html><body><script>alert('Hello from C!');</script></body></html>");
    return 200;
}
// 启动Web服务器
const char* options[] = {"document_root", ".", "listening_ports", "8080", NULL};
struct mg_callbacks callbacks;
memset(&callbacks, 0, sizeof(callbacks));
struct mg_context* ctx = mg_start(&callbacks, NULL, options);
mg_set_request_handler(ctx, "/", request_handler, NULL);
// 等待用户输入
getchar();
// 停止Web服务器
mg_stop(ctx);

三、调用Web服务

通过调用Web服务，C程序可以与远程服务器上的JavaScript代码进行交互。这种方法允许C程序发送HTTP请求，并处理服务器返回的响应。

1. 使用libcurl

libcurl是一个支持HTTP、FTP、SMTP等协议的开源库，允许C程序发送HTTP请求，并接收服务器响应。

#include <curl/curl.h>
// 回调函数，用于处理服务器响应
size_t write_callback(void* contents, size_t size, size_t nmemb, void* userp) {
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}
// 发送HTTP请求
CURL* curl = curl_easy_init();
if (curl) {
    std::string readBuffer;
    curl_easy_setopt(curl, CURLOPT_URL, "https://example.com/api");
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
    curl_easy_perform(curl);
    curl_easy_cleanup(curl);
    // 处理服务器响应
    printf("Response: %sn", readBuffer.c_str());
}

四、嵌入JavaScript引擎

通过嵌入JavaScript引擎，C程序可以直接执行JavaScript代码，并进行数据交换。常见的JavaScript引擎包括V8和Duktape。

1. 使用V8引擎

V8是Google开发的高效JavaScript引擎，可以嵌入到C/C++程序中。

#include <v8.h>
// 初始化V8引擎
v8::V8::InitializeICUDefaultLocation(argv[0]);
v8::V8::InitializeExternalStartupData(argv[0]);
std::unique_ptr<v8::Platform> platform = v8::platform::NewDefaultPlatform();
v8::V8::InitializePlatform(platform.get());
v8::V8::Initialize();
// 创建一个新的Isolate实例
v8::Isolate::CreateParams create_params;
create_params.array_buffer_allocator = v8::ArrayBuffer::Allocator::NewDefaultAllocator();
v8::Isolate* isolate = v8::Isolate::New(create_params);
// 进入Isolate作用域
{
    v8::Isolate::Scope isolate_scope(isolate);
    // 创建一个新的上下文
    v8::HandleScope handle_scope(isolate);
    v8::Local<v8::Context> context = v8::Context::New(isolate);
    // 进入上下文作用域
    v8::Context::Scope context_scope(context);
    // 执行JavaScript代码
    const char* js_code = "function add(a, b) { return a + b; } add(1, 2)";
    v8::Local<v8::String> source = v8::String::NewFromUtf8(isolate, js_code, v8::NewStringType::kNormal).ToLocalChecked();
    v8::Local<v8::Script> script = v8::Script::Compile(context, source).ToLocalChecked();
    v8::Local<v8::Value> result = script->Run(context).ToLocalChecked();
    // 输出结果
    v8::String::Utf8Value utf8(isolate, result);
    printf("Result: %sn", *utf8);
}
// 释放资源
isolate->Dispose();
v8::V8::Dispose();
v8::V8::ShutdownPlatform();
delete create_params.array_buffer_allocator;

2. 使用Duktape引擎

Duktape是一个轻量级的嵌入式JavaScript引擎，适用于资源受限的环境。

#include "duktape.h"
// 创建一个Duktape上下文
duk_context* ctx = duk_create_heap_default();
// 执行JavaScript代码
duk_eval_string(ctx, "function add(a, b) { return a + b; } add(1, 2)");
printf("Result: %dn", (int)duk_get_int(ctx, -1));
// 释放资源
duk_destroy_heap(ctx);

五、利用Node.js模块

通过调用Node.js模块，C程序可以利用Node.js的丰富生态系统，并与JavaScript代码进行交互。

1. 使用napi

Node.js提供了N-API（Node.js API），允许C/C++代码与Node.js进行交互。

#include <node_api.h>
// 定义一个简单的C函数
napi_value Add(napi_env env, napi_callback_info info) {
    size_t argc = 2;
    napi_value args[2];
    napi_get_cb_info(env, info, &argc, args, NULL, NULL);
    double value0;
    double value1;
    napi_get_value_double(env, args[0], &value0);
    napi_get_value_double(env, args[1], &value1);
    napi_value sum;
    napi_create_double(env, value0 + value1, &sum);
    return sum;
}
// 初始化模块
napi_value Init(napi_env env, napi_value exports) {
    napi_property_descriptor desc = {"add", 0, Add, 0, 0, 0, napi_default, 0};
    napi_define_properties(env, exports, 1, &desc);
    return exports;
}
NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)

2. 使用node-addon-api

node-addon-api是一个基于N-API的C++封装，提供了更高层次的API。

#include <napi.h>
// 定义一个简单的C++函数
Napi::Value Add(const Napi::CallbackInfo& info) {
    Napi::Env env = info.Env();
    double value0 = info[0].As<Napi::Number>().DoubleValue();
    double value1 = info[1].As<Napi::Number>().DoubleValue();
    return Napi::Number::New(env, value0 + value1);
}
// 初始化模块
Napi::Object Init(Napi::Env env, Napi::Object exports) {
    exports.Set(Napi::String::New(env, "add"), Napi::Function::New(env, Add));
    return exports;
}
NODE_API_MODULE(addon, Init)

通过以上五种方法，可以在C程序中调用JavaScript代码，每种方法都有其适用的场景和优缺点。选择合适的方法，可以有效地解决C与JavaScript代码交互的问题，提高程序的灵活性和功能性。