使用 JavaScriptCore 进行跨语言调用

使用 JavaScriptCore 进行跨语言调用时，既可以在 Native 代码中执行 JavaScript 代码，也可以在 JavaScript 中调用 Native 方法。以下是详细的实现步骤和示例。

1. 在 Native 代码中执行 JavaScript 代码

使用 JavaScriptCore 框架，可以在 Swift 或 Objective-C 代码中执行 JavaScript 代码，并获取执行结果。

示例（Swift）

步骤 1: 导入 JavaScriptCore 框架

import JavaScriptCore

步骤 2: 创建 JSContext 对象

let jsContext = JSContext()

步骤 3: 执行 JavaScript 代码

jsContext?.evaluateScript("var a = 2 + 2")
if let result = jsContext?.evaluateScript("a") {print("Result: \(result.toInt32())") // 输出: Result: 4
}

示例代码：

import JavaScriptCoreclass ViewController: UIViewController {var jsContext: JSContext!override func viewDidLoad() {super.viewDidLoad()jsContext = JSContext()// 在 JavaScript 中定义一个函数jsContext.evaluateScript("""function add(a, b) {return a + b;}""")// 在 Swift 中调用 JavaScript 函数if let addFunction = jsContext.objectForKeyedSubscript("add") {let result = addFunction.call(withArguments: [3, 4])print("Result of add function: \(result?.toInt32() ?? 0)") // 输出: Result of add function: 7}}
}

2. 在 JavaScript 中调用 Native 方法

通过 JavaScriptCore，可以将 Native 方法暴露给 JavaScript，这样就可以在 JavaScript 中调用这些方法。

示例（Swift）

步骤 1: 定义 Native 方法

let logFunction: @convention(block) (String) -> Void = { message inprint("Log from JavaScript: \(message)")
}

步骤 2: 将 Native 方法添加到 JSContext

jsContext.setObject(logFunction, forKeyedSubscript: "log" as NSString)

步骤 3: 在 JavaScript 中调用 Native 方法

jsContext.evaluateScript("""
log('Hello from JavaScript');
""")

示例代码：

import JavaScriptCoreclass ViewController: UIViewController {var jsContext: JSContext!override func viewDidLoad() {super.viewDidLoad()jsContext = JSContext()// 定义一个 Native 方法let logFunction: @convention(block) (String) -> Void = { message inprint("Log from JavaScript: \(message)")}jsContext.setObject(logFunction, forKeyedSubscript: "log" as NSString)// 在 JavaScript 中调用 Native 方法jsContext.evaluateScript("""log('Hello from JavaScript');""")}
}

3. 完整示例：双向调用

完整代码示例：

import JavaScriptCoreclass ViewController: UIViewController {var jsContext: JSContext!override func viewDidLoad() {super.viewDidLoad()jsContext = JSContext()// 定义一个 Native 方法let logFunction: @convention(block) (String) -> Void = { message inprint("Log from JavaScript: \(message)")}jsContext.setObject(logFunction, forKeyedSubscript: "log" as NSString)// 在 JavaScript 中定义一个函数jsContext.evaluateScript("""function add(a, b) {log('Adding ' + a + ' and ' + b);return a + b;}""")// 在 Swift 中调用 JavaScript 函数if let addFunction = jsContext.objectForKeyedSubscript("add") {let result = addFunction.call(withArguments: [3, 4])print("Result of add function: \(result?.toInt32() ?? 0)") // 输出: Result of add function: 7}// 在 JavaScript 中调用 Native 方法jsContext.evaluateScript("""log('Hello from JavaScript');""")}
}

小结

通过 JavaScriptCore，可以在 Native 代码中执行 JavaScript 代码，并在 JavaScript 中调用 Native 方法，实现跨语言调用。这种双向通信机制使得混合应用程序可以充分利用 JavaScript 和 Native 各自的优势，提升应用的功能性和用户体验。

异步还是同步？这是一个问题

使用 JavaScriptCore 进行跨语言调用（在 Native 代码中直接执行 JavaScript 代码，在 JavaScript 中调用 Native 方法），是异步还是同步的？

使用 JavaScriptCore 进行跨语言调用时，通常情况下调用是同步的。这意味着在 Native 代码中直接执行 JavaScript 代码时，调用会阻塞直到 JavaScript 代码执行完成，并且可以立即获取结果。同样地，在 JavaScript 中调用 Native 方法时，也是同步执行的。

详细解释

Native 代码中执行 JavaScript 代码

在 iOS 的 Swift/Objective-C 代码中，可以通过 JSContext 来执行 JavaScript 代码。调用 JSContext.evaluateScript 方法时，代码会同步执行，并且在执行完成后立即返回结果。

示例代码：

import JavaScriptCoreclass ViewController: UIViewController {var jsContext: JSContext!override func viewDidLoad() {super.viewDidLoad()jsContext = JSContext()// 在 JavaScript 中定义一个函数jsContext.evaluateScript("""function add(a, b) {return a + b;}""")// 在 Swift 中调用 JavaScript 函数if let addFunction = jsContext.objectForKeyedSubscript("add") {let result = addFunction.call(withArguments: [3, 4])print("Result of add function: \(result?.toInt32() ?? 0)")}}
}

在这个示例中，evaluateScript 和 call 方法都是同步的，执行 JavaScript 代码后立即返回结果。

JavaScript 中调用 Native 方法

通过 JavaScriptCore，可以在 JavaScript 中调用通过 JSContext 暴露的 Native 方法。这些调用同样是同步的，JavaScript 代码会等待 Native 方法执行完成，并获取结果。

示例代码：

import JavaScriptCoreclass ViewController: UIViewController {var jsContext: JSContext!override func viewDidLoad() {super.viewDidLoad()jsContext = JSContext()// 定义一个 Native 方法let logFunction: @convention(block) (String) -> Void = { message inprint("Log from JavaScript: \(message)")}jsContext.setObject(logFunction, forKeyedSubscript: "log" as NSString)// 在 JavaScript 中调用 Native 方法jsContext.evaluateScript("""log('Hello from JavaScript');""")}
}

在这个示例中，JavaScript 中调用 log 方法会同步执行，Native 代码会立即执行打印操作。

同步执行的优缺点

优点

简单直观：
- 同步调用方式更容易理解和调试，因为代码按照顺序执行，没有复杂的回调和异步逻辑。
立即获取结果：
- 调用完成后可以立即获取执行结果，无需等待异步回调，适用于需要立即处理结果的场景。

缺点

可能阻塞线程：
- 如果 JavaScript 代码或 Native 方法执行时间较长，可能会阻塞当前线程，影响应用的响应性。
影响性能：
- 在主线程上进行耗时的同步操作可能会导致 UI 卡顿和用户体验下降。

如何处理耗时操作

为了避免同步调用带来的阻塞和性能问题，可以将耗时操作放到后台线程中执行。

示例代码：

import JavaScriptCoreclass ViewController: UIViewController {var jsContext: JSContext!override func viewDidLoad() {super.viewDidLoad()jsContext = JSContext()// 定义一个耗时的 Native 方法let heavyTaskFunction: @convention(block) () -> String = {Thread.sleep(forTimeInterval: 2) // 模拟耗时操作return "Heavy task completed"}jsContext.setObject(heavyTaskFunction, forKeyedSubscript: "heavyTask" as NSString)// 在后台线程中执行 JavaScript 代码DispatchQueue.global().async {if let result = self.jsContext.evaluateScript("heavyTask()") {print("Result of heavy task: \(result.toString() ?? "")")}}}
}