仓颉开发语言概述

仓颉（Cangjie）是一种专为 OpenHarmony 设计的轻量级开发语言，旨在与 ArkTS（Ark TypeScript）实现无缝互操作。本文将介绍仓颉语言的基本结构，并结合代码示例深入探讨其在开发互操作模块中的应用。

仓颉与 ArkTS 的互操作

仓颉与 ArkTS 的互操作是通过仓颉模块导出函数给 ArkTS 调用的形式来实现的。仓颉侧负责实现核心逻辑，而 ArkTS 通过定义接口调用仓颉的功能模块。下面将逐步介绍如何使用仓颉开发与 ArkTS 的互操作模块。

仓颉导出函数与 ArkTS 调用

首先，开发者需要在仓颉中定义要导出的函数，这些函数的类型是固定的，格式为 (JSContext, JSCallInfo) -> JSValue。

代码示例：定义仓颉导出函数

import ohos.ark_interop.*

// 定义仓颉导出函数，供 ArkTS 调用
func addNumber(context: JSContext, callInfo: JSCallInfo): JSValue {
    // 从 JSCallInfo 中获取参数
    let arg0: JSValue = callInfo[0]
    let arg1: JSValue = callInfo[1]

    // 转换为仓颉类型
    let a: Float64 = arg0.toNumber()
    let b: Float64 = arg1.toNumber()

    // 计算结果
    let value = a + b

    // 转换并返回 JSValue
    let result: JSValue = context.number(value).toJSValue()
    return result
}

在该示例中，addNumber 函数接受两个数字参数，并返回它们的和。JSContext 提供了与 ArkTS 的交互环境，JSCallInfo 则包含 ArkTS 传递的参数。

注册仓颉导出函数

仓颉中的函数需要注册后才能被 ArkTS 调用。使用 JSModule.registerModule 注册。

class Main {
    static init() {
        JSModule.registerModule { context, exports =>
            exports["addNumber"] = context.function(addNumber).toJSValue()
        }
    }
}

ArkTS 调用仓颉函数

在 ArkTS 侧，需要导入仓颉库并调用导出的函数。

ArkTS 侧代码示例

import { requireCJLib } from "libark_interop_loader.so"

interface CangjieLib {
    addNumber(a: number, b: number): number;
}

const cjLib = requireCJLib("libentry_default.so") as CangjieLib;
let result = cjLib.addNumber(1, 2);
console.log(`1 + 2 = ${result}`);

该代码展示了如何从 ArkTS 调用仓颉模块中的 addNumber 函数，并输出计算结果。

加载 ArkTS 模块

仓颉不仅可以被 ArkTS 调用，还可以从 ArkTS 加载模块。例如，我们可以加载 ArkTS 提供的相册管理模块。

代码示例：加载 ArkTS 模块

import ohos.ark_interop.*

func tryLoadArkTSSo() {
    // 创建 ArkTS 运行时
    let runtime = JSRuntime()
    let context = runtime.mainContext

    // 加载系统模块
    let module = context.requireSystemNativeModule("file.photoAccessHelper")
}

在上述代码中，我们创建了一个 ArkTS 运行时，并加载了相册管理模块（file.photoAccessHelper）。

操作 ArkTS 数据

仓颉可以操作 ArkTS 传递的对象和数据。仓颉的 JSValue 是一种通用类型，可以通过 JSValue.typeof() 来判断其实际类型。

代码示例：操作 ArkTS 数据

func addByObject(context: JSContext, callInfo: JSCallInfo): JSValue {
    let arg0 = callInfo[0]
    
    if (!arg0.isObject()) {
        return context.undefined().toJSValue()
    }

    let obj = arg0.asObject(context)
    let argA = obj["a"]
    let argB = obj["b"]

    let a = argA.toNumber()
    let b = argB.toNumber()
    
    let result = a + b
    return context.number(result).toJSValue()
}

该函数接收一个 ArkTS 对象作为参数，并从对象中提取属性 a 和 b，计算它们的和。

调用 ArkTS 函数

仓颉可以直接调用 ArkTS 函数，甚至支持传递回调函数。

代码示例：调用 ArkTS 回调函数

func addByCallback(context: JSContext, callInfo: JSCallInfo): JSValue {
    let a = callInfo[0].toNumber()
    let b = callInfo[1].toNumber()
    let callback = callInfo[2].asFunction(context)

    let result = a + b
    let retJSValue = context.number(result).toJSValue()

    callback.call(retJSValue)
}

在该示例中，仓颉计算了 a 和 b 的和，并通过回调函数将结果传递给 ArkTS。

仓颉与 ArkTS 的深度集成

通过仓颉与 ArkTS 的互操作性，开发者能够灵活地利用两种语言的优势，构建更为高效的应用模块。仓颉提供了直接操作 ArkTS 数据和模块的能力，而 ArkTS 则可以轻松地调用仓颉的核心功能。

仓颉中的全局对象

在仓颉中，可以访问 ArkTS 的全局对象，并通过它来调用全局属性和方法。

代码示例：操作全局对象

func accessGlobal(context: JSContext) {
    let globalObject = context.global
    let console = globalObject["console"].asObject(context)
    let log = console["log"].asFunction(context)
    
    log.call(context.string("Hello from Cangjie").toJSValue())
}

在该代码中，我们通过全局对象访问 ArkTS 的 console 对象，并调用其 log 方法进行日志输出。