使用 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 代码会立即执行打印操作。

同步执行的优缺点

优点

1. 简单直观：

   • 同步调用方式更容易理解和调试，因为代码按照顺序执行，没有复杂的回调和异步逻辑。

2. 立即获取结果：

   • 调用完成后可以立即获取执行结果，无需等待异步回调，适用于需要立即处理结果的场景。

缺点

1. 可能阻塞线程：

   • 如果 JavaScript 代码或 Native 方法执行时间较长，可能会阻塞当前线程，影响应用的响应性。

2. 影响性能：

   • 在主线程上进行耗时的同步操作可能会导致 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() ?? "")")}}}
}

在这个示例中，耗时操作被放到后台线程中执行，避免了阻塞主线程，确保了应用的响应性。

小结

使用 JavaScriptCore 进行跨语言调用时，调用通常是同步的。这种同步调用方式简单直观，可以立即获取结果，但可能会导致线程阻塞和性能问题。为了避免这些问题，可以将耗时操作放到后台线程中执行，确保应用的响应性和用户体验。