作者：京東科技 楊拓

一、倉頡介紹

倉頡是一種通用編程語言，適用于各種應用開發，兼顧開發效率和運行性能，其優勢如下：

1、高效編程：語法簡明高效，支持多種范式編程。如插值字符串、主構造函數、Flow 表達式、match、if-let、while-let 和重導出等，減少冗余書寫，提升開發效率。

2、輕量運行時庫：標準庫中除 core 包外（libcangjie-std-core < 1MB），其他包都可以按需鏈接加載。

3、輕量用戶線程：倉頡使用用戶態線程模型，每個線程都是輕量級的執行實體，擁有獨立的執行上下文并且共享內存。創建線程內存開銷僅 8KB，切換線程不進入內核態，線程棧支持動態擴縮容，耗時納秒級。

4、輕量對象：每對象僅額外消耗一個機器字長記錄類型信息；不需要計數字段；GC 使用轉發表而非轉發指針。

5、類型安全：作為靜態強類型語言，倉頡通過編譯時類型檢查識別錯誤，降低運行時風險，且具備強大的類型推斷能力，減少類型標注工作。

二、快速環境配置

1、下載

在鴻蒙開發者網站找到下載中心，可以看到DevEco倉頡插件，下載到本地。

最新版下載鏈接如下：點擊此處下載最新版?

2、安裝

打開DevEco Studio，進入設置，在plugin標簽下選擇從本地磁盤安裝插件，安裝后重啟IDE。

3、創建

操作與創建ArkTs工程一致。

三、特性介紹

1、Flow 表達式

Flow流表示對輸入進行流式處理后得到輸出，在倉頡中流操作符有兩種：表示數據流向的中綴操作符 |> 和表示函數組合的中綴操作符 ~> 。

1.1、|>

表示對輸入數據做一系列的處理，可以使用 |> 來簡化。

語法形式就是e1 |> e2，其中 e2 是函數類型的表達式，e1 的類型是 e2 的參數類型的子類型.

示例1:
let gen: Array = []
gen |> forEach{a: Int64 => println("${a}")}

示例2:
func split(words: Array, separator: Rune): Array {
    words |> map { text =>
        text.split(String(separator), removeEmpty: true)
    } |> flatten |> collectArray
}

//示例3: 處理 Unicode 字符串
func split_unicode(text: String, sep: String) {
    let indices = ArrayList()
    text.runes() |> enumerate |> fold(false) { state, e =>
        let current = !sep.contains(e[1].toString())
        if (state != current) { indices.append(e[0]) }
        current
    } |> { valid: Bool => if (valid) { indices.append(text.size) } }

    let runes = text.toRuneArray()
    let result = ArrayList()
    for (i in 0..indices.size:2) {
        result.append(String(runes[indices[i]..indices[i + 1]]))
    }
    return result
}

1.2、~>

當兩個單參函數進行組合時可以使用~>。

//示例：
func f(x: Int64): Float64 {
    Float64(x)
}
func g(x: Float64): Float64 {
    x
}
//等價于{ x: Int64 => g(f(x)) }，會先對f求值，然后再對g求值，最后才會進行函數的組合
var fg = f ~> g 

建議以上兩個流操作符不要用于帶默認值的命名參數，因為配置了默認值的命名參數必須給出命名實參才能用

2、變長參數

變長參數是各個語言都有的一種功能，但是在倉頡中當形參最后一個非命名參數是 Array 類型時，就可以作為變長參數使用，不需要特殊的語法形式

func sum(arr: Array) {
    var total = 0
    for (x in arr) {
        total += x
    }
    return total
}

main() {
    println(sum())
    println(sum(1, 2, 3))
}

3、擴展

倉頡擴展提供了對類和接口進行擴展的操作，不需要使用繼承或者裝飾器模式，就可以給類添加額外的屬性和方法。這種場景的優勢在于不需要破壞被擴展類型的封裝性，就可以添加額外的功能。

可以添加的功能包括：

?添加成員函數

?添加操作符重載函數

?添加成員屬性

?實現接口

//示例1：為整型擴展兩個屬性
extend Int64 {
    public prop r: Index {
        get() { Index.Row(this) }
    }
    public prop c: Index {
        get() { Index.Col(this) }
    }
}
//調用
2.r

//示例2：擴展靜態方法
extend Expression {
    static func fromTokens(tokens: List): Result {
        match (expressionFunc(tokens).map {t => t[0]}) {
            case Some(e) => Ok(e)
            case None => Err("Invalid Expression!")
        }
    }
}
//調用
Expression.fromTokens

4、if-let和while-let

倉頡中的條件控制和循環控制基本和ArkTs一致，除了將switch換為match外無區別，但是多了if-let和while-let兩個特性表達式。

4.1、if-let

if-let 表達式首先會對條件中 <- 右側的表達式進行求值，如果此值能匹配 <- 左側的模式，則執行 if 分支，否則執行 else 分支。

main() {
    let result = Option.Some(2023)

    if (let Some(value) 

	

	倉頡沒有null判空，所以提供了option（T）來判空，它里面的取值就是some（v）和none兩種情況None為空，表示沒有賦值。some表示有賦值

	4.2、while-let

	while-let 表達式同if-let一樣，也是先會對條件中 <- 右側的表達式進行求值，如果此值能匹配 <- 左側的模式，則執行循環體，然后重復執行此過程。如果模式匹配失敗，則結束循環。

	
  public static func fromJson(r: JsonReader): FunctionCall {
    var temp_name: String = "";
    var temp_arguments: String = "";
    while (let Some(v) 
          r.startObject();
          while(r.peek() != EndObject) {
              let n = r.readName()
              match (n) {
                  case "name" => temp_name = r.readValue();
                  case "arguments" => temp_arguments = r.readValue();
                  case unkow => println("unkow key ${unkow}");
              }
          }
          r.endObject();
          break;
        case _ => throw Exception("can't deserialize for FunctionCall");
      }
    }
    return FunctionCall(temp_name, temp_arguments);
  }


	

	5、線程

	倉頡中創建一個線程非常簡單，只需要使用 spawn{} 即可開啟一個新的線程，{}里面就是在新線程中執行的代碼，并且可以使用Future獲取線程執行結果。

	
import std.sync.*
import std.time.*

//開啟一個線程
let future = spawn { task() }

//執行內容
func task(): Int64 {
    for (_ in 0..M) {
        .....
    }
    return n
}

//使用fut.get()可以等待線程執行完成獲取線程執行結果
future.get()


	

	5.1、同步-原子操作

	倉頡同樣也提供了多種同步機制來確保數據的安全，例如原子操作、互斥鎖和條件變量等

	原子操作方面倉頡提供整數類型、AtomicBool 類型和AtomicReference引用類型的原子操作來保證同步操作。

	
let num = AtomicInt64(0);
let list = ArrayList>();
func testAtomic() {
    for (i in 0..100) {
        let fut = spawn {
            sleep(Duration.millisecond)
            num.fetchAdd(1)
        }
        list.append(fut)
    }

    for (f in list) {
        f.get()
    }

    let result = num.load()
    AppLog.info("result = ${result}")//輸出100
}


	

	5.2、同步-可重入互斥鎖 ReentrantMutex

	可重入互斥鎖可以保證在任意時刻最多只有一個線程執行區塊的代碼，當一個線程嘗試獲取被其他線程持有的鎖會被阻塞，直到別的線程釋放鎖才可以執行區塊代碼。使用ReentrantMutex需要注意以下兩點：

	1.在訪問共享數據之前，必須嘗試獲取鎖。

	2.處理完共享數據后，必須進行解鎖，以便其他線程可以獲得鎖。

	
import std.sync.*
import std.time.*
import std.collection.*

var num: Int64 = 0;
let list = ArrayList>();
let lock = ReentrantMutex()

func task() {
    sleep(Duration.millisecond)
    lock.lock()
    num++
    lock.unlock()
}

func testMutex() {
    let list = ArrayList>()

    for (i in 0..100) {
        let fut = spawn {task()}
        list.append(fut)
    }

    for (f in list) {
        f.get()
    }

    AppLog.info("result = ${num}") //輸出100
}


	

	在日常使用中需要手動unlock相當不方便，而且也有可能在異常情況下鎖無法釋放的問題，為了解決這些問題，倉頡又提供一個 synchronized 關鍵字，搭配 ReentrantMutex 一起使用。

	具體使用方式就是在 synchronized 上加一個 ReentrantMutex 對象即可，然后將同步代碼寫在synchronized{}中。一個線程在進入 synchronized 修飾的代碼塊之前，會自動獲取 ReentrantMutex 實例對應的鎖，如果無法獲取鎖，則當前線程被阻塞；而線程在退出 synchronized 修飾的代碼塊之前，會自動釋放該 ReentrantMutex 實例的鎖。

	
import std.sync.*
import std.time.*
import std.collection.*

var num: Int64 = 0;
let list = ArrayList>();
let lock = ReentrantMutex()

func task() {
    sleep(Duration.millisecond)
    //        lock.lock()
    //跟上面的示例一樣，省去了加，釋放鎖的操作
    synchronized(lock) {
        num++
    }
    //        lock.unlock()
}

func testMutex() {
    let list = ArrayList>()

    for (i in 0..100) {
        let fut = spawn {task()}
        list.append(fut)
    }

    for (f in list) {
        f.get()
    }

    AppLog.info("result = ${num}") //輸出100
}


	

	四、和ArkTs互操作

	現在一般的場景是在已有ArkTs庫中使用倉頡，所以可以將倉頡代碼封裝為ArkTs庫，提供給外部使用。

	原理就是互操作宏解析被注解修飾的倉頡代碼，會自動生成ArkTs聲明文件和互操作層代碼。

	使用步驟：

	1.在cj文件中，針對 class、interface 和函數，使用 @Interop[ArkTS] 進行修飾，被修飾的對象是希望被 ArkTS 調用的。

	2.在 DevEco Studio 中的倉頡文件或者 module 名稱右鍵選擇“Generate Cangjie-ArkTS Interop API”，會在 cangjie 目錄下生成 ark_interop_api 的聲明文件。

	3.ArkTS 側添加依賴并 import ark_interop_api 即可使用。

	倉頡代碼：

	
import ohos.ark_interop.*
import ohos.ark_interop_macro.*

@Interop[ArkTS]
public func sub(a: Int64, b: Int64): Int64 {
    return a - b
}

@Interop[ArkTS]
public class CjDemo {
    public let name: String

    @Interop[ArkTS, Invisible]
    public var id: Float64 = 1.0

    public init(str: String) {
        name = str
    }

    public func add(a: Int64, b: Int64): Int64 {
        return a + b
    }

    public func foo(): Float64 {
        return 1.0
    }
}


	

	生成的代碼：

	
export declare class CjDemo {
    name: string
    add(a: number, b: number): number
    foo(): number
}

export declare interface CustomLib {
    sub(a: number, b: number): number
    CjDemo: {new (str: string): CjDemo}
}


	

	使用：

	
let cjLib : CustomLib = requireCJLib("libohos_app_cangjie_entry.so") as CustomLib
console.log("result" + cjLib.sub(2, 1))

let class1: CjDemo = new cjLib.CjDemo("arkts call")
console.log("result " + class1.add(5,1))


	

	五、后續規劃

	鴻蒙應用開發官方目前提供兩種編程語言供選擇：ArkTs和倉頡。從當前趨勢來看，這兩種語言是并行發展的，尚不存在某一方被替代的情況，因此對當前的開發工作沒有影響，倉頡可以作為技術儲備加以學習和掌握。

	在開發初期，我們全部使用了ArkTs。然而在實際開發過程中，我們發現了一些痛點：

	某些ArkTs的官方API存在性能問題，使得我們在進行性能優化時某些關鍵點較依賴系統發版。

	ArkTs提供了TaskPool和Worker兩種線程調用方式，但編寫過程較為繁瑣，線程間的數據傳遞存在限制且有性能損耗。

	我們計劃利用倉頡的優勢來解決這些問題，以打造更為健壯的鴻蒙版京東金融應用。


	審核編輯 黃宇