仓颉语言与ArkTS互操作

最新推荐文章于 2024-07-25 20:17:04 发布
最新推荐文章于 2024-07-25 20:17:04 发布
阅读量1.5k 收藏 25
点赞数 25
分类专栏： HarmonyOS # 仓颉编程语言 文章标签： harmonyos
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43588481/article/details/139884747
版权

在 OpenHarmony 系统上，ArkTS 具备完整广泛的生态，为复用 ArkTS 生态，仓颉支持与 ArkTS 高效跨语言互通。

仓颉-ArkTS 互操作基于仓颉 CFFI 能力，通过调用 ArkTS 运行时接口，为用户提供库级别的 ArkTS 互操作能力。

使用场景：

  1. 在 ArkTS 应用开发仓颉模块：把用户仓颉代码封装成为 ArkTS 模块，能够被 ArkTS 代码加载和调用。
  2. 在仓颉应用里使用 ArkTS 存量库：在仓颉代码里创建新的 ArkTS 运行时，并加载和执行 ArkTS 的字节码。

互操作库的主要组成和功能：

  1. JSValue: 统一的 ArkTS 数据类型，在跨语言调用中做传参，对 ArkTS 类型做判断和做数据转换。
  2. JSContext: 一个 ArkTS 互操作上下文，用户创建 ArkTS 数据，辅助把 JSValue 转换为仓颉数据。
  3. JSCallInfo: 一次 ArkTS 函数调用的参数集合，包含所有的入参和 this 指针。
  4. JSRuntime: 一个由仓颉创建的 ArkTS 运行时。

一、在 ArkTS 应用里开发仓颉模块

开发仓颉互操作模块：

1.【仓颉侧】导入互操作库。

import ohos.ark_interop.*
  1. 【仓颉侧】定义要导出的函数，可被 ArkTS 调用的仓颉函数的类型是固定的：(JSContext, JSCallInfo)->JSValue。
func addNumber(context: JSContext, callInfo: JSCallInfo): JSValue {
    // 从 JSCallInfo 获取参数列表
    let arg0: JSValue = callInfo[0]
    let arg1: JSValue = callInfo[1]

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

    // 实际仓颉函数行为
    let value = a + b

    // 把结果转换为 JSValue
    let result: JSValue = context.number(value).toJSValue()

    // 返回 JSValue
    return result
}
  1. 【仓颉侧】注册要导出的函数。

// 类名没有影响

class Main {
    // 定义静态构造函数（也可用全局变量和静态变量的初始化表达式触发）
    static init() {
        // 注册键值对
        JSModule.registerModule {context, exports =>
            exports["addNumber"] = context.function(addNumber).toJSValue()
        }
    }
}

4.【ArkTS 侧】导入 ark_interop_loader，这是一个在 ohos-sdk 中提供的 napi 模块，作为仓颉运行时的启动器和仓颉模块的加载器。

import {requireCJLib} from "libark_interop_loader.so"

5.【ArkTS 侧】定义仓颉库导出的接口。

interface CangjieLib {
    // 定义的仓颉互操作函数，名称与仓颉侧注册名称一致。一般先定义 ArkTS 函数声明，在实现仓颉函数时根据声明来解析参数和返回。
    addNumber(a: number, b: number): number;
}

6.【ArkTS 侧】导入和调用仓颉库。

// 导入仓颉库，仓颉模块默认编译产物是 libentry_default.so，用户可以在 cjpm.toml 中修改配置。
const cjLib = requireCJLib("libentry_default.so") as CangjieLib;
// 调用仓颉接口
let result = cjLib.addNumber(1, 2);
console.log(`1 + 2 = ${result}`);

二、在仓颉应用里使用 ArkTS 模块

ArkTS 模块的编译产物主要有两种：

  1. C 代码（+ArkTS）编译成 so。
  2. 纯 ArkTS 代码编译成 abc。

2.1 加载 ArkTS so 模块

ArkTS so 模块根据部署方式的不同，分为以下几种：

  1. 随系统发布，在镜像的/system/lib64/module目录下。
  2. 随应用（hap）发布，在应用的/libs/arm64-v8a目录下，安装后在设备上的全局路径（通过hdc shell观察到的路径）：/data/app/el1/bundle/public/${bundleName}/libs/arm64、沙箱路径（运行时可访问路径）：/data/storage/el1/bundle/libs/arm64。
    随动态库（hsp）发布。
  3. 这里主要介绍怎么加载随系统发布的 so 模块，这些 so 在 OpenHarmony 的官方文档里会有开发文档。

接下来以相册管理模块作为示例，详细的介绍加载流程。

  1. 查看 ArkTS 文档，其导入模块的范本如下。
import photoAccessHelper from '@ohos.file.photoAccessHelper';
  1. 创建 ArkTS 运行时，准备互操作上下文。
import ohos.ark_interop.*

func tryLoadArkTSSo() {
    // 创建新的 ArkTS 运行时
    let runtime = JSRuntime()
    // 获取互操作上下文
    let context = runtime.mainContext
    ...
}
  1. 根据 ArkTS 文档里模块导入名称，推导仓颉的模块导入参数。
ArkTS 导入名仓颉导入参数说明
@ohos.file.photoAccessHelper(“file.photoAccessHelper”)以 @ohos 开头，那么参数只需要去掉 “@ohos.”。
@hms.core.push.pushService(“core.push.pushService”, prefix: “hms”)以非 @ohos 开头，那么参数去掉 “@xxx.”，并把 xxx 作为第二个参数。
  1. 导入 ArkTS 模块。
func tryLoadArkTSSo() {
    ...
    let module = context.requireSystemNativeModule("file.photoAccessHelper")
}

模块导入进来是一个 JSValue，接下来可以按照操作 ArkTS 数据的方法去操作模块。

三、在仓颉里操作 ArkTS 数据

从 ArkTS 传过来的参数，其原始类型是JSValue，这是一个匿名类型的数据，首先需要知晓其类型。

  • 通过JSValue.typeof()获取其类型枚举JSType。
  • 通过其他途径（包括但不限于阅读 ArkTS 源码、参考文档以及开发者口述）知晓其类型，然后通过类型校验接口来验证，比如判断是否是 number 类型JSValue.isNumber()。

当知道其类型之后，再把JSValue转换为对应的仓颉类型或 ArkTS 引用。

  • 转换为仓颉类型，比如一个 ArkTS string 转换为仓颉 String，JSValue.toString(JSContext)。
  • 转换为 ArkTS 引用，比如一个 ArkTS string 转换为 JSString，JSValue.asString(JSContext)。

通过仓颉数据来构造 ArkTS 数据，是通过 JSContext 的方法类构造 ArkTS 数据。

一个应用进程可以存在多个 ArkTS 运行时，而 ArkTS 运行时之间的数据是不通用的，任何 ArkTS 数据都归属于一个特定的运行时，因此创建 ArkTS 数据接口是从运行时的角度出发。

以number举例，创建一个number的方式是JSContext.number(Float64)。

ArkTS 主要数据类型对应到仓颉类型的映射如下：

ArkTS 类型仓颉类型安全引用typeof 类型
undefined-JSUndefinedJSType.UNDEFINED
null-JSNullJSType.NULL
booleanBoolJSBooleanJSType.BOOL
numberFloat64JSNumberJSType.NUMBER
stringStringJSStringJSType.STRING
object-JSObjectJSType.OBJECT
Array-JSArrayJSType.OBJECT
bigintBigIntJSBigIntJSType.BIGINT
function-JSFunctionJSType.FUNCTION
symbol-JSSymbolJSType.SYMBOL

安全引用的安全体现在两个方面：

  • 类型安全，特定类型的接口只能从安全引用里访问，总是需要先做显式的类型转换再访问。
  • 生命周期安全，对于由 ArkTS 来分配和回收的对象，安全引用能保障这些对象的生命周期。

3.1 操作 ArkTS 对象

从一个互操作函数的实现举例，该函数在 ArkTS 的声明是：addByObject(args: {a: number; b: number}): number。

func addByObject(context: JSContext, callInfo: JSCallInfo): JSValue {
    // 获取首个参数
    let arg0 = callInfo[0]
    // 校验参数0是否是对象，否则返回undefined
    if (!arg0.isObject()) {
        return context.undefined().toJSValue()
    }
    // 把参数0转换为JSObject
    let obj = arg0.asObject(context)
    // 从JSObject获取属性
    let argA = obj["a"]
    let argB = obj["b"]
    // 把JSValue转换为Float64
    let a = argA.toNumber()
    let b = argB.toNumber()

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

除了可以从对象上读取属性外，还可以对属性赋值或创建新属性，操作方式为 JSObject[key] = value，其中 key 可以是仓颉 String 、JSString 或 JSSymbol，value 是 JSValue 。

  • 说明

通过 JSObject[key] = value 定义属性时，该属性可写、可枚举、可配置。

更多参见JavaScript 标准内置对象。

对属性赋值在以下几种场景会失败，失败之后没有异常或日志：

1.目标对象是 sealed 对象，由 Object.seal() 接口创建的对象具有不可修改的特性，无法创建新的属性和修改原有属性。
2. 目标属性的 writable 是 false ，由 Object.defineProperty(object, key, {writable: false, value: xxx}) 定义属性时，可以指定属性是否可写。

对于一个未知对象，可以枚举出该对象的可枚举属性：

func handleUnknownObject(context: JSContext, target: JSObject): Unit {
    // 枚举对象的可枚举属性
    let keys = target.keys()
    println("target keys: ${keys}")
}

创建一个新的 ArkTS 对象，可以通过 JSContext.object() 来创建。

对于 ArkTS 运行时，有一个特殊的对象，该对象是 ArkTS 全局对象，在任何 ArkTS 代码里都可以直接访问该对象下的属性，在仓颉侧可以通过 JSContext.global 来访问它。

3.2 调用 ArkTS 函数

拿到一个 ArkTS 函数后，可以在仓颉里直接调用，这里以一个互操作函数举例：addByCallback(a: number, b: number, callback: (result: number)=>void): void。

func addByCallback(context: JSContext, callInfo: JSCallInfo): JSValue {
    // 获取参数，并转换为Float64
    let a = callInfo[0].toNumber()
    let b = callInfo[1].toNumber()
    // 把第3个参数转换为JSFunction
    let callback = callInfo[2].asFunction(context)
    // 计算结果
    let result = a + b
    // 从仓颉Float64创建ArkTS number
    let retJSValue = context.number(result).toJSValue()
    // 调用回调函数
    callback.call(retJSValue)
}

这个用例里的函数是不带 this 指针的，针对需要 this 指针的方法调用，可以通过命名参数 thisArg 来指定。

func doSth(context: JSContext, callInfo: JSCallInfo): JSValue {
    let callback = callInfo[0].asFunction(context)
    let thisArg = callInfo[1]

    callback.call(thisArg: thisArg)
}

在 ArkTS 代码里，可以通过 对象.方法(…) 来进行调用，这时会隐式传递 this 指针。

class Someone {
    id: number = 0
    doSth(): void {
        console.log(`someone ${this.id} have done something`)
    }
}


let target = new Someone()

// 这里会隐式传递this指针，调用正常
target.doSth()

let doSth = target.doSth;
// 这里没有传递this指针，会出现异常`can't read property of undefined`
doSth.call()

在仓颉里，对应的写法如下：

func doSth(context: JSContext, callInfo: JSCallInfo): JSValue {
    let object = callInfo[0].asObject(context)
    // 会隐式传递this指针，调用正常
    object.callMethod("doSth")

    let doSth = object["doSth"].asFunction(context)
    // 未传递this指针，会出现异常`can't read property of undefined`
    doSth.call()
    // 显式传递this指针，调用正常
    doSth.call(thisArg: object.toJSValue())
}

四、在 ArkTS 里操作仓颉对象

这里用例展示的是把仓颉对象分享到 ArkTS 运行时，使用 ArkTS 运行时的内存管理机制来控制仓颉对象的生命周期，并通过相关的互操作接口来访问该对象。

// 定义共享类
class Data <: SharedObject {
    Data(
        // 定义2个属性
        let id: Int64,
        let name: String
    ) {}

    static init() {
        // 注册导出到ark的函数
        JSModule.registerFunc("createData", createData)
        JSModule.registerFunc("setDataId", setDataId)
        JSModule.registerFunc("getDataId", getDataId)
    }

    // 创建共享对象
    static func createData(context: JSContext, _: JSCallInfo): JSValue {
        // 创建仓颉对象
        let data = Data(1, "abc")
        // 创建js对仓颉对象的引用
        let jsExternal = context.external(data)
        // 返回js对仓颉对象的引用
        return jsExternal.toJSValue()
    }

    // 设置对象的id
    static func setDataId(context: JSContext, callInfo: JSCallInfo): JSValue {
        // 读取参数
        let arg0 = callInfo[0]
        let arg1 = callInfo[1]

        // 把参数0转换为js对仓颉对象的引用
        let jsExternal = arg0.asExternal(context)
        // 获取仓颉对象
        let data: Data = jsExternal.cast<Data>().getOrThrow()
        // 把参数1转换为Float64
        let value = arg1.toNumber()

        // 仓颉对象修改属性
        data.id = Int64(value)

        // 返回undefined
        let result = context.undefined().toJSValue()
        return result
    }

    // 获取对象的id
    static func getDataId(context: JSContext, callInfo: JSCallInfo): JSValue {
        let arg0 = callInfo[0]

        let jsExternal = arg0.asExternal(context)

        let data: Data = jsExternal.cast<Data>().getOrThrow()

        let result = context.number(Float64(data.id)).toJSValue()
        return result
    }
}

import {requireCJLib} from "libark_interop_loader.so"
// 定义导出符号
interface CustomLib {
    createData(): undefined
    setDataId(data: undefined, value: number): void
    getDataId(data: undefined): number
}

// 加载自定义库
const cjLib = requireCJLib("libentry_default.so") as CustomLib

// 创建共享对象
let data = cjLib.createData()
// 操作对象属性
cjLib.setDataId(data, 3)
let id = cjLib.getDataId(data)

console.log("id is " + id)

JSExternal 对象在 ArkTS 里的类型会被识别为 undefined ，直接使用它来作为参数很容易被传递错误的参数。在使用前一个用例的仓颉库时：

...
// 创建共享对象
let data = cjLib.createData()
// 操作对象属性
cjLib.setDataId(undefined, 3) // 错误的参数，应该传递的是仓颉引用，但是编译器能通过编译
let id = cjLib.getDataId(data)
...

4.1 把仓颉对象的引用挂在 JSObject 上传递到 ArkTS

在实际开发接口时，可以把 JSExternal 对象绑定到一个 JSObject 对象上，把 JSExternal 的数据隐藏起来，以此来提高接口的安全性。

下面通过一个例子来展示：

// 定义共享类
class Data <: SharedObject {
    Data(
        // 定义2个属性
        var id: Int64,
        let name: String
    ) {}

    static init() {
        // 注册导出到ark的函数
        JSModule.registerFunc("createData", createData)
    }

    // 创建共享对象
    static func createData(context: JSContext, _: JSCallInfo): JSValue {
        let data = Data(1, "abc")
        let jsExternal = context.external(data)

        // 创建空JSObject
        let object = context.object()
        // 把js对仓颉对象的引用挂在JSObject的隐藏属性上
        object.attachCJObject(jsExternal)

        // 为js对象增加2个方法
        object["setId"] = context.function(setDataId).toJSValue()
        object["getId"] = context.function(getDataId).toJSValue()

        return object.toJSValue()
    }

    // 设置对象的id
    static func setDataId(context: JSContext, callInfo: JSCallInfo): JSValue {
        // 获取this指针
        let thisArg = callInfo.thisArg
        let arg0 = callInfo[0]

        // 把this指针转换为JSObject
        let thisObject = thisArg.asObject(context)
        // 从JSObject上获取隐藏属性
        let jsExternal = thisObject.getAttachInfo().getOrThrow()
        // 从js对仓颉对象的引用上获取仓颉对象
        let data = jsExternal.cast<Data>().getOrThrow()
        // 把参数0转换为Float64
        let value = arg0.toNumber()

        // 修改仓颉对象的属性
        data.id = Int64(value)

        let result = context.undefined()
        return result.toJSValue()
    }

    // 获取对象的id
    static func getDataId(context: JSContext, callInfo: JSCallInfo): JSValue {
        let thisArg = callInfo.thisArg
        let thisObject = thisArg.asObject(context)
        let jsExternal = thisObject.getAttachInfo().getOrThrow()
        let data = jsExternal.cast<Data>().getOrThrow()

        let result = context.number(Float64(data.id)).toJSValue()
        return result
    }
}

import {requireCJLib} from "libark_interop_loader.so"
// 定义导出符号
interface Data {
    setId(value: number): void
    getId(): number
}

interface CustomLib {
    createData(): Data
}

// 加载自定义库
const cjLib = requireCJLib("libentry_default.so") as CustomLib

// 创建共享对象
let data = cjLib.createData()
// 操作对象属性
data.setId(3)
let id = data.getId()

console.log("id is " + id)

4.2 为仓颉共享对象创建 JSClass

把所有的对象操作方法直接挂在对象上，一方面占用内存比较大，另一方面创建对象的开销比较大。对于追求性能的场景，可以定义一个 JSClass 来加速对象创建和减小内存占用。

// 定义共享类
class Data <: SharedObject {
    Data(
        // 定义2个属性
        var id: Int64,
        let name: String
    ) {}

    static init() {
        // 注册导出到ark的类
        JSModule.registerClass("Data") { context =>
            // 创建JSClass
            let clazz = context.clazz(jsConstructor)
            // 增加方法
            clazz.addMethod(context.string("setId"), context.function(setDataId))
            clazz.addMethod(context.string("getId"), context.function(getDataId))

            return clazz
        }
    }

    // js构造函数
    static func jsConstructor(context: JSContext, callInfo: JSCallInfo): JSValue {
        // 获取this指针
        let thisArg = callInfo.thisArg
        // 转换为JSObject
        let thisObject = thisArg.asObject(context)
        // 创建创建对象
        let data = Data(1, "abc")
        // 创建js对仓颉对象的引用
        let jsExternal = context.external(data)
        // 设置JSObject属性
        thisObject.attachCJObject(jsExternal)
        return thisObject.toJSValue()
    }

    // 设置对象的id
    static func setDataId(context: JSContext, callInfo: JSCallInfo): JSValue {
        // 获取this指针
        let thisArg = callInfo.thisArg
        // 把this指针转换为JSObject
        let thisObject = thisArg.asObject(context)
        // 从JSObject上获取隐藏属性
        let jsExternal = thisObject.getAttachInfo().getOrThrow()
        // 从js对仓颉对象的引用上获取仓颉对象
        let data = jsExternal.cast<Data>().getOrThrow()

        let arg0 = callInfo[0]
        // 把参数0转换为Float64
        let value = arg0.toNumber()

        // 修改仓颉对象的属性
        data.id = Int64(value)

        let result = context.undefined()
        return result.toJSValue()
    }

    // 获取对象的id
    static func getDataId(context: JSContext, callInfo: JSCallInfo): JSValue {
        let thisArg = callInfo.thisArg
        let thisObject = thisArg.asObject(context)
        let jsExternal = thisObject.getAttachInfo().getOrThrow()
        let data = jsExternal.cast<Data>().getOrThrow()

        let result = context.number(Float64(data.id)).toJSValue()
        return result
    }
}

import {requireCJLib} from "libark_interop_loader.so"
// 定义Data的接口
interface Data {
    setId(value: number): void
    getId(): number
}

interface CustomLib {
    // 定义Data的构造函数（JSClass）
    Data: {new (): Data}
}

// 加载自定义库
const cjLib  = requireCJLib("libentry_default.so") as CustomLib

// 创建共享对象
let data = new cjLib.Data()
// 操作对象属性
data.setId(3)
let id = data.getId()

console.log("id is " + id)

五、ArkTS 互操作和仓颉多线程

ArkTS 是单线程执行的虚拟机，在运行时上没有对并发做任何的容错；而仓颉在语法上支持内存共享的多线程。

如果在互操作的场景不加限制的使用多线程，可能会导致无法预期的错误，因此需要一些规范和指引来保证程序正常执行：

  1. ArkTS 代码以及大部分互操作接口只能在 ArkTS 线程上执行，否则会抛出仓颉异常。
  2. 在进入其他线程前，需要把所有依赖的 ArkTS 数据转换为仓颉数据。
  3. 在其他线程如果想要使用 ArkTS 接口，需要通过 context.postJSTask 切换到 ArkTS 线程来执行。

下面通过一个用例来展示具体做法，该用例是互操作函数，该函数的功能是对两个数字相加，并调用回调来返回相加数。

import {requireCJLib} from "libark_interop_loader.so"
// 定义导出的接口
interface CustomLib {
    addNumberAsync(a: number, b: number, callback: (result: number)=>void): void
}
// 导入仓颉库
const cjLib = requireCJLib("libentry_default.so") as CangjieLib;
// 调用仓颉函数
cjLib.addNumberAsync(1, 2, (result)=> {
    console.log("1 + 2 = " + result)
})

// 类名没有影响
class Main {
    // 定义静态构造函数
    static init() {
        // 注册键值对
        JSModule.registerFunc("addNumberAsync", addNumberAsync)
    }
}

func addNumberAsync(context: JSContext, callInfo: JSCallInfo): JSValue {
    // 从JSCallInfo获取参数列表
    let arg0: JSValue = callInfo[0]
    let arg1: JSValue = callInfo[1]
    let arg2: JSValue = callInfo[2]
    // 把JSValue转换为仓颉类型
    let a: Float64 = arg0.toNumber()
    let b: Float64 = arg1.toNumber()
    let callback = arg2.asFunction(context)
    // 新建仓颉线程
    spawn {
        // 实际仓颉函数行为
        let value = a + b
        // 发起异步回调
        context.postJSTask {
            // 创建result
            let result = context.number(value)
            // 调用js回调
            callback.call(result)
        }
    }

    // 返回 void
    return context.undefined()
}

在 ArkTS 存在着 Promise，这是对回调机制的一种封装，配合 async 、 await 的语法让回调机制变成同步调用的形式。对于上一个用例，使用 Promise 的形式来定义接口和访问：

// 接口定义
func addNumberAsync(context: JSContext, callInfo: JSCallInfo): JSValue {
    // 参数转换为仓颉类型
    let a = callInfo[0].toNumber()
    let b = callInfo[1].toNumber()
    // 创建PromiseCapability对象
    let promise = context.promiseCapability()
    // 创建新线程
    spawn {
        // 在新线程执行仓颉逻辑
        let result = a + b
        // 切换到ArkTS线程
        context.postJSTask {
            // 在ArkTS线程执行resolve
            promise.resolve(context.number(result).toJSValue())
        }
    }
    // 返回Promise
    promise.toJSValue()
}

// ArkTS 调用
import {requireCJLib} from "libark_interop_loader.so"
// 定义导出的接口
interface CustomLib {
    addNumberAsync(a: number, b: number): Promise<number>
}

async function main() {
    // 导入仓颉库
    const cjLib = requireCJLib("libentry_default.so") as CangjieLib;
    // 调用仓颉函数
    let result = await cjLib.addNumberAsync(1, 2)
    console.log("1 + 2 = " + result)
}

main()
小菜鸟学开发
关注
  • 25
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
华为的开发语言有2种，分别是ArkTS和仓颉，他们的区别是什么？
橙-极纪元-cplvfx-JJY.Cheng
06-25 3116
总的来说，仓颉和 ArkTS 共同发展，在鸿蒙生态中形成优势互补。未来开发者可以根据业务场景需要，对新增业务部分，根据具体场景选择使用仓颉编程语言或 ArkTS 进行增量开发。
华为仓颉编程语言正式发布！相比Java、Go、Swift优势在哪？附入门教程~
爱编程的鱼的博客
06-26 2817
在2024年6月21日举行的华为开发者大会上，华为公司不仅对外宣布了其新一代鸿蒙操作系统HarmonyOS NEXT，还正式发布了他们自主研发的编程语言，名为。我们一起看看仓颉编程语言的定位及其优势所在，以及它的入门教程💪仓颉编程语言在开发中力求在安全性、易用性和性能之间找到最佳平衡点。面对无法完美兼顾所有目标的挑战，仓颉选择了一条中间道路，既不是性能至上的系统编程语言，也非开发效率优先的动态脚本语言。它被设计为一种静态类型的语言，具备自动内存管理，专为应用开发而优化。
鸿蒙系统扫盲（七）：勘误补充总结，收个尾
memoryjs的专栏
01-30 1813
这是笔者鸿蒙扫盲系列的最后一篇了，准备对过去的六篇扫盲系列文章，错误的地方做一些勘误，并且补充更新一些朋友们感兴趣的知识，最后收个尾。
HarmonyOS Next，你真的足够了解它么？_harmonyos next 开发语言
2401_83947105的博客
04-09 1093
一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
华为鸿蒙（HarmonyOS）操作系统不是Android换皮，程序员的机会来了！！
Androiddddd的博客
01-18 912
在今日下午的鸿蒙生态千帆启航仪式上，华为终端云总裁朱勇刚称：鸿蒙生态将进入第二阶段，期望携手更多开发者，加速千行百业的应用鸿蒙化。余承东表示，华为鸿蒙不是安卓换皮，有自己的底座和生态才是真操作系统。目前的诸多操作系统大部分都是来自于美国，但鸿蒙系统是来自中国的操作系统，鸿蒙操作系统经历十年磨砺，一次次蝶变，今天已经运行在丰富的全场景设备上。华为持续向下扎到根，鸿蒙星河版有核心技术，有全栈能力，有底座，有生态，才是真正的操作系统。
仓颉开发入门初体验
Sebdhsk的博客
06-28 1190
在刚刚召开的华为开发者大会（HDC 2024）上，华为内部研发已久的国产自主编程语言仓颉终于正式对外官宣！当前在鸿蒙原生应用的开发中，支持声明式 UI 和一次开发、多端部署的 ArkTS 语言已经被广泛使用。仓颉语言作为面向未来的下一代编程语言，当前已经完成设计与实现并启动了开发者预览，未来将与 ArkTS 共同发展，为鸿蒙原生应用开发者提供极致高效的开发体验。同时，仓颉当前在尝试支持AI Native原生智能应用开发、DSL KIT、Actor和分布式编程等。
一文读懂，什么是仓颉编程语言？
06-23
仓颉编程语言：一文读懂，什么是仓颉编程语言？ 仓颉编程语言：一文读懂，什么是仓颉编程语言？ 仓颉编程语言：一文读懂，什么是仓颉编程语言？ 仓颉编程语言：一文读懂，什么是仓颉编程语言？ 仓颉编程语言：一文读...
什么是仓颉编程语言，它的特点是什么？
06-23
仓颉编程语言：什么是仓颉编程语言，它的特点是什么？ 仓颉编程语言：什么是仓颉编程语言，它的特点是什么？ 仓颉编程语言：什么是仓颉编程语言，它的特点是什么？ 仓颉编程语言：什么是仓颉编程语言，它的特点是...
华为在 2024 年 6 月 21 日仓颉编程语言介绍
06-25
华为在 2024 年 6 月 21 日的华为开发者大会上，华为终端 BG 软件部总裁龚体正式官宣了华为自研仓颉编程语言，并发布了 HarmonyOS NEXT 仓颉语言开发者预览版。 仓颉编程语言的名字来自 “仓颉造字”。 仓颉（约...
仓颉编程语言点简介及实际案例及案例详解
06-22
仓颉编程语言仓颉编程语言点简介及实际案例及案例详解仓颉编程语言点简介及实际案例及案例详解仓颉编程语言点简介及实际案例及案例详解仓颉编程语言点简介及实际案例及案例详解仓颉编程语言点简介及实际案例及案例...
仓颉输入法
03-08
中国台湾使用的输入法， 日常电脑上使用非常方便。
华为自研编程语言“仓颉”来了！鸿蒙应用开发新语言，性能优于 Java、Go、Swift
IT界那些事儿
06-22 3092
在今天刚刚召开的华为开发者大会（HDC 2024）上，华为内部研发已久的国产自主编程语言仓颉终于正式对外官宣！随着万物互联以及智能时代的到来，软件的形态将发生巨大的变化。一方面，移动应用和移动互联网领域仍然强力驱动人机交互、设备协同、智能化、安全性等方向的创新，另一方面人工智能也同样驱动软件朝智能化、端边云协同等方向演进。新技术、新场景下应用软件的开发对编程语言提出了新的诉求和挑战。
HarmonyOS Next，你真的足够了解它么？
shudaoshanQAQ的博客
01-30 2225
在鸿蒙生态中，目前有3套形式不同的操作系统，分别是OpenHarmony、HarmonyOS、HarmonyOS Next。
2024年HarmonyOS鸿蒙最新HarmonyOS Next，你真的足够了解它么？_harmonyos next 开发语言，2024HarmonyOS鸿蒙高级面试题汇总解答
2401_84850485的博客
05-14 731
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以戳这里获取一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！一个人可以走的很快，但一群人才能走的更远！
鸿蒙界面开发
qq_46025779的博客
07-23 2074
界面开发界面开发-布局思路属性方法字体颜色文字溢出省略号、行高Image图片组件输入框与按钮综合实训设计资源-svg图标欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入MarkdownText-to-HTML。
HarmonyOS应用开发者高级认证，Next版本发布后最新题库 - 多选题序号4
Gusha_的博客
07-23 1298
HarmonyOS应用开发者高级认证最新题库，编写于2024年7月19日，Next版本发布之后
HarmonyOS和OpenHarmony区别联系
Jason_Lee155的博客
07-23 628
刚开始接触鸿蒙开发的时候经常看到HarmonyOS和OpenHarmony频繁的出现在文章和文档之中，那么这两个名词分别是什么意思，他们之间又有什么联系呢？
【HarmonyOS】应用推送使用个推SDK如何实现？
最新发布
我的小窝
07-25 796
鸿蒙应用如何使用个推SDK实现推送功能？
cjk 仓颉 输入法 数据库
07-29
CJK仓颉输入法数据库是指为仓颉输入法提供收录和管理汉字字符及其相应输入码的数据库。仓颉输入法是一种用于输入中文字符的输入法，它采用了古代汉字字形和笔画的组合规则来生成每个汉字的输入码。输入码是指在键盘上输入的一组字符以唤出对应的汉字。 CJK是指"Chinese, Japanese, Korean" 的缩写，表示支持中日韩三国语言的输入法系统。因为中文输入码的设计能够应用于这三个语言，所以CJK仓颉输入法数据库也用于日语和韩语的输入。 仓颉输入法数据库包含了大量的汉字和其对应的输入码数据。这些数据可以根据仓颉输入法的规则和要求进行生成和维护。数据库中的每个汉字都对应一个输入码，通过输入码的组合方式可以准确地输入出所需的汉字。数据库的管理者会不断收录和更新汉字及其输入码，确保数据库的完整性和实用性。 仓颉输入法数据库的作用非常重要。它是仓颉输入法正常运作的基础，决定了仓颉输入法用户能够输入哪些汉字。数据库中的数据还会随着时间的推移不断增加和完善，以适应新的汉字的加入和使用需求的变化。 总之，CJK仓颉输入法数据库是一个为仓颉输入法提供汉字和输入码数据的数据库，对于保证仓颉输入法的准确性和实用性起到了重要作用。通过合理的管理和维护，该数据库能够为用户提供全面且准确的中文输入服务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小菜鸟学开发

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值