Menú
Cangjie programming language code generation and analysis expert. Use this when users need to write or analyze Cangjie code.
Instalar con Codex o Claude Copia este prompt, pégalo en Codex, Claude u otro asistente, y deja que revise la página de la skill y la instale por ti.
Basado en la clasificación ocupacional SOC
| name | cangjie-lang |
| description | Cangjie programming language code generation and analysis expert. Use this when users need to write or analyze Cangjie code. |
.cjcj（Cangjie）main()// 单行注释
/*
* 多行注释
*/
/**
* 文档注释
*/
main() {
// 代码主体
let a: Int64 = 20
var b: Int64 = 12
println("${a}${b}")
}
修饰符 变量名: 变量类型 = 初始值
let - 不可变变量（只能赋值一次，初始化后不可修改）var - 可变变量（可以被多次赋值）⚠️ 易错点1：let 不支持变量遮蔽（shadowing），不能在同一作用域内重新定义同名变量。
| 修饰符 | 范围 | 默认值 |
|---|---|---|
private | class定义内可见 | ❌ |
public | 模块内外均可见 | ❌ |
protected | 当前模块及当前类的子类可见 | ❌ |
internal | 仅当前包及子包内可见 | ✅ 默认 |
static - 影响成员变量的存储和引用方式main() {
let a: Int64 = 20 // 不可变变量
var b: Int64 = 12 // 可变变量
b = 23 // 可以修改var变量
println("${a}${b}")
}
示例参考：examples/01_variable_declaration.cj
有符号整数：Int8、Int16、Int32、Int64、IntNative
无符号整数：UInt8、UInt16、UInt32、UInt64、UIntNative
浮点类型：Float16、Float32、Float64
布尔类型：true、false
Rune 表示，可以表示 Unicode 字符集中的所有字符UInt32(e) - 获取 Unicode scalar valueRune(num) - 值必须在有效 Unicode 范围内
[0x0000, 0xD7FF] 或 [0xE000, 0x10FFFF]⚠️ 易错点2：Rune 转整数时需确保在有效 Unicode 范围内，否则会编译错误或运行时抛异常。
let slash: Rune = r'\\'
let newLine: Rune = r'\n'
let tab: Rune = r'\t'
let he: Rune = r'\u{4f60}' // 你
let llo: Rune = r'\u{597d}' // 好
仓颉支持三种字符串字面量：
1. 单行字符串字面量
内容定义在一对单引号或双引号内，只能写在同一行：
let s1: String = ""
let s2 = 'Hello Cangjie Lang'
let s3 = "\"Hello Cangjie Lang\""
let s4 = 'Hello Cangjie Lang\n' // \n 是转义字符，表示换行
2. 多行字符串字面量
开头结尾需各存在三个双引号（"""）或三个单引号（'''），内容从开头的三个引号换行后的第一行开始：
// 三个双引号
let s1: String = """
""" // 空字符串（换行后才开始）
// 三个单引号
let s2: String = '''
Hello,
Cangjie Lang'''
3. 多行原始字符串字面量
以一个或多个井号（#）和一个单引号或双引号开头，转义规则不适用，不支持插值：
let s1: String = #""# // 空字符串
let s2 = ##'#'\n'## // \n 不是换行符，是 \ 和 n 两个字符
let s3 = ###"
Hello,
Cangjie
Lang"### // 保留换行和缩进
⚠️ 易错点4：在多行原始字符串字面量中，转义字符（如 \n、\t）不会被转义，字面量中的内容会维持原样。
⚠️ 易错点5：多行原始字符串字面量不支持插值，不要使用 ${} 语法。
⚠️ 易错点3：插值字符串中使用 ${} 表达式
let fruit = "apples"
let count = 10
let s = "There are ${count * count} ${fruit}"
适用范围：插值字符串仅适用于单行字符串字面量和多行字符串字面量，不适用于多行原始字符串字面量。
(T1, T2, ..., TN)(Int64, Float64)、(Int64, Float64, String)tuple[0]、tuple[1]var tuple = (true, false)
println(tuple[0])
Array<T> // T 是元素类型，可以是任意类型
Range<T>（泛型）start、end、stepstart 和 end 类型相同（T）step 类型是 Int64step 值不能等于 0()示例参考：examples/02_basic_types.cj
⚠️ 易错点5：条件表达式的括号不能省略，这是与很多语言的差异。
if (条件) { // ✅ 必须有括号
分支 1
} else {
分支 2
}
基本形式：
if (条件) {
分支 1
} else {
分支 2
}
if 作为表达式（返回值）：
let a = 10
let result = if (a > 5) {
"greater than 5"
} else {
"5 or less"
}
// result = "greater than 5"
模式匹配（let pattern）：
let a = Some(3)
let d = Some(1)
if (let Some(e) <- a && let Some(f) <- d) { // 两个模式都匹配
println("${e} ${f}") // 输出: 3 1
}
while (条件) {
循环体
}
// do-while 形式
do {
循环体
} while (条件)
for (迭代变量 in 序列) {
循环体
}
元组遍历：
let array = [(1, 2), (3, 4), (5, 6)]
for ((x, y) in array) {
println("${x}, ${y}")
}
区间遍历：
main() {
var sum = 0
for (i in 1..=100) { // 1 到 100（包含）
sum += i
}
println(sum)
}
break、continuegoto示例参考：examples/03_control_flow.cj
语法：(参数类型) -> 返回类型
() 括起，多个参数用 , 分隔-> 连接func add(a: Int64, b: Int64): Int64 {
return a + b
}
type FnType = (Int64) -> Unit
func display(a: Int64): Unit {
println(a)
}
// 命名参数
func name(name!:String)
// 命名参数还可以设置默认值
func name(name!:String = "小王")
⚠️ 易错点8：函数参数默认是 let 定义的不可变变量
// a 和 b 默认是 let 不可变的（不能显式写 let 或 var）
func add(a: Int64, b: Int64): Int64 {
return a + b
}
⚠️ 重要：
let 或 var 修饰符（包括顶层函数、class成员方法、struct成员方法等所有函数）let 不可变的如果需要修改参数值，应该使用局部变量：
func modify(a: Int64): Int64 {
var result = a
result = result + 1 // 修改局部变量
return result
}
func add(a: Int64, b: Int64): Int64 {
a + b // 最后一个表达式自动作为返回值
}
func returnAdd(): (Int64, Int64) -> Int64 {
add // 可以直接返回函数
}
语法：
{ p1: T1, ..., pn: Tn => expressions | declarations }
示例：
// 完整类型声明
let f1 = { a: Int64, b: Int64 => a + b }
// 无参 Lambda
var display = { =>
println("Hello")
println("World")
}
// 类型推断
var sum1: (Int64, Int64) -> Int64 = { a, b => a + b }
var sum2: (Int64, Int64) -> Int64 = { a: Int64, b => a + b }
// Lambda 作为参数
func f(a1: (Int64) -> Int64): Int64 {
a1(1)
}
main(): Int64 {
f({ a2 => a2 + 10 }) // 参数类型推断
}
Lambda 立即调用：
⚠️ 易错点9：Lambda 表达式可以立即调用
let r2 = { => 123 }() // r2 = 123，立即执行
var g = { x: Int64 => println("x = ${x}") }
g(2) // 调用 Lambda
示例参考：examples/04_functions.cj
enum 开头| 分隔| 是可选的enum RGBColor {
| Red(UInt8) | Green(UInt8) | Blue(UInt8)
}
CC(p1, p2, ..., pn)示例参考：examples/05_enum.cj
基本语法：
⚠️ 重要：case 后的语句不需要 {} 括号，多行语句直接换行即可
match (待匹配值) {
case 模式1 => 处理1
case 模式2 => 处理2
case _ => 默认处理 // 通配符
}
多行语句：直接换行，不需要 {}
match (value) {
case 1 => println("one")
case 2 => println("two")
println("second number") // ✅ 多行直接换行
case _ => println("other")
}
示例：
main() {
let x = 0
match (x) {
case 1 => print("x = 1")
case 0 => print("x = 0") // 匹配
case 2 | 3 | 4 => print("other") // 多值匹配
case _ => print("其他")
}
}
支持：整数字面量、浮点数字面量、字符字面量、布尔字面量、字符串字面量、Unit 字面量
⚠️ 易错点10：不支持字符串插值
使用 _ 表示，匹配任意值，通常作为最后一个 case
使用标识符，匹配并绑定值
main() {
let x = -10
let y = match (x) {
case 0 => "zero"
case n => "x is not zero and x = ${n}" // n 绑定匹配的值
}
println(y)
}
用于匹配元组值
main() {
let tv = ("Alice", 24)
let s = match (tv) {
case ("Bob", age) => "Bob is ${age} years old"
case ("Alice", age) => "Alice is ${age} years old" // age 是绑定模式
case (name, 100) => "${name} is 100 years old"
case (_, _) => "someone"
}
println(s)
}
判断运行时类型是否是某个类型的子类型
main() {
var d = Derived()
var r = match (d) {
case b: Base => b // b 是类型模式，匹配 Base 类型
case _ => 0
}
println("r = ${r}")
}
用于匹配 enum 类型的实例
enum TimeUnit {
| Year(UInt64)
| Month(UInt64)
}
main() {
let x = Year(2)
let s = match (x) {
case Year(n) => "x has ${n * 12} months" // 匹配
case TimeUnit.Month(n) => "x has ${n} months" // TimeUnit.Month 是完整路径
}
println(s)
}
⚠️ 重要：Tuple 模式和 enum 模式可以嵌套任意模式
enum TimeUnit {
| Year(UInt64)
| Month(UInt64)
}
enum Command {
| SetTimeUnit(TimeUnit)
| GetTimeUnit
| Quit
}
main() {
let command = (SetTimeUnit(Year(2022)), SetTimeUnit(Year(2024)))
match (command) {
case (SetTimeUnit(Year(year)), _) => println("Set year ${year}")
case (_, SetTimeUnit(Month(month))) => println("Set month ${month}")
case _ => ()
}
}
在 case 的模式之后，可以使用 where 子句添加额外的条件判断（称为 pattern guard）。
语法：case 模式 where 条件 => 处理
⚠️ 重要：使用 where 关键字，不是 if
示例：
enum RGBColor {
| Red(Int16)
| Green(Int16)
| Blue(Int16)
}
main() {
let c = RGBColor.Green(-100)
let cs = match (c) {
case Red(r) where r < 0 => "Red = 0"
case Red(r) => "Red = ${r}"
case Green(g) where g < 0 => "Green = 0" // 匹配（因为 -100 < 0）
case Green(g) => "Green = ${g}"
case Blue(b) where b < 0 => "Blue = 0"
case Blue(b) => "Blue = ${b}"
}
println(cs) // 输出：Green = 0
}
注意事项：
where 后的条件表达式必须是 Bool 类型if，应该使用 where错误示例：
match (value) {
case n if n > 0 => println("positive") // ❌ 编译错误：不是 if
case _ => println("other")
}
正确写法：
match (value) {
case n where n > 0 => println("positive") // ✅ 使用 where
case _ => println("other")
}
示例参考：examples/06_pattern_matching.cj
enum Option<T> {
| Some(T) // 有值
| None // 无值
}
当需要表示某个类型可能有值，也可能没有值的时候使用。
??let optA: Option<Int64> = Option<Int64>.Some(42)
let a: Int64 = optA ?? 0 // 如果 optA 是 None，则使用默认值 0
let optA: Option<Int64> = Option<Int64>.Some(42)
if (optA.isSome()) {
println("有值")
}
if (optA.isNone()) {
println("无值")
}
let optA: Option<Int64> = Option<Int64>.Some(42)
if (let Option<Int64>.Some(a) <- optA) {
println("值是: ${a}")
} else {
println("无值")
}
func getValue(): Option<Int64> {
// ... 一些逻辑
return Option<Int64>.None
}
func process(): Int64 {
let optA = getValue()
let a = optA ?? return 0 // 如果是 None，直接返回 0
// 继续处理 a
a + 1
}
func getValue(): Option<Int64> {
return Option<Int64>.None
}
func processOrThrow(): Int64 {
let optA = getValue()
let a = optA ?? throw Exception("值不存在")
// 继续处理 a
a
}
let optA: Option<Int64> = Option<Int64>.Some(42)
let result = match (optA) {
case Option<Int64>.Some(value) => "值是: ${value}"
case Option<Int64>.None => "无值"
}
示例参考：examples/07_option_type.cj
class ClassName {
// 成员变量
// 成员属性
// 静态初始化器
// 构造函数
// 成员函数
// 操作符函数
}
class Rectangle {
let width: Int64
let height: Int64
public init(width: Int64, height: Int64) {
this.width = width
this.height = height
}
public func area() {
width * height
}
}
let rec = Rectangle(10, 20)
let l = rec.height // l = 20
对于 class 的成员（变量、属性、构造函数、函数）：
| 修饰符 | 含义 | 默认 |
|---|---|---|
private | class 定义内可见 | ❌ |
internal | 当前包及子包（含子包的子包）内可见 | ✅ 默认 |
protected | 当前模块及当前类的子类可见 | ❌ |
public | 模块内外均可见 | ❌ |
⚠️ 易错点11：成员的默认访问修饰符是 internal，不是 private 或 public。
示例参考：examples/08_class.cj
@Test - 应用于顶级函数或类，转换为单元测试类@TestCase - 标记测试类内的函数为测试用例@Fail - 标记测试失败@Assert(leftExpr, rightExpr) // 判断相等
@Assert(condition: Bool) // 判断条件
@Expect(leftExpr, rightExpr) // 判断相等
@Expect(condition: Bool) // 判断条件
@Test
class LexerTest {
@TestCase
func test() {
let a = 1
// 方式一：手动判断
if (a != 1) {
@Fail("a is not 1")
}
// 方式二：Assert 条件
@Assert(a != 1)
// 方式三：Assert 相等
@Assert(a, 1)
}
}
示例参考：examples/09_unit_test.cj
// 抛出异常
throw Exception("错误信息")
// 捕获异常
try {
// 可能抛出异常的代码
} catch (e: ExceptionType) {
// 处理异常
}
示例参考：examples/10_error_handling.cj
main() {
// 条件判断（必须有括号）
if (条件) {
// ...
} else {
// ...
}
// 循环
while (条件) { }
do { } while (条件)
for (变量 in 序列) { }
// 模式匹配
match (值) {
case 模式 => 处理
case _ => 默认
}
}
| 类型 | 后缀 |
|---|---|
| 整数 | Int8, Int16, Int32, Int64, IntNative |
| 无符号整数 | UInt8, UInt16, UInt32, UInt64, UIntNative |
| 浮点 | Float16, Float32, Float64 |
| 字符 | Rune |
| 字符串 | String |
| 元组 | (T1, T2, ...) |
| 数组 | Array<T> |
| 区间 | Range<T> |
| 函数 | (T1, T2) -> Rt |
示例参考：examples/11_quick_reference.cj
仓颉提供了多种集合类型，适用于不同的使用场景：
1. Array - 固定大小数组
let arr: Array<String> = ["A", "B", "C"]main() {
// 创建 Array
let arr: Array<String> = ["A", "B", "C"]
// 访问元素（使用下标）
println(arr[0]) // 输出: A
// 修改元素
arr[0] = "X"
println(arr[0]) // 输出: X
// 获取大小
println(arr.size) // 输出: 3
}
2. ArrayList - 动态数组
import std.collection.ArrayList
main() {
// 创建 ArrayList
let list = ArrayList<Int64>()
// 添加元素（使用 add 方法）
list.add(1, at: 0) // 在位置 0 添加 1
list.add(2, at: 1) // 在位置 1 添加 2
// 或使用 add 添加整个数组
let arr = [3, 4, 5]
list.add(all: arr) // list: [1, 2, 3, 4, 5]
// 访问元素（使用 get 方法，返回 Option）
let value = list.get(0)
match (value) {
case Option<Int64>.Some(v) => println("First: ${v}")
case Option<Int64>.None => println("Not found")
}
// 或使用下标访问
println(list[0]) // 输出: 1
// 修改元素
list[0] = 10
// 删除元素
list.remove(at: 0) // 移除第一个元素
// 获取大小
println(list.size)
}
3. HashSet - 哈希集合
import std.collection.HashSet
main() {
// 创建 HashSet
let set = HashSet<Int64>()
// 添加元素
set.add(1)
set.add(2)
set.add(3)
set.add(1) // 重复元素不会被添加
// 检查是否包含
if (set.contains(2)) {
println("包含 2")
}
// 获取大小
println(set.size) // 输出: 3
// 删除元素
set.remove(2)
}
4. HashMap - 哈希映射
let map: HashMap<String, Int> = HashMap(("A", 1), ("B", 2)) 或 HashMap([("A", 1), ("B", 2)])import std.collection.HashMap
main() {
// 创建 HashMap（使用字面量）
let map: HashMap<String, Int64> = HashMap(
("A", 1),
("B", 2),
("C", 3)
)
// 或者使用方括号
let map2: HashMap<String, Int64> = HashMap([
("A", 1),
("B", 2),
("C", 3)
])
// 或者空 HashMap
let emptyMap = HashMap<String, Int64>()
// 添加元素（使用 add 方法）
emptyMap.add("D", 4)
// 访问元素（使用 get 方法，返回 Option）
let value = map.get("A")
match (value) {
case Option<Int64>.Some(v) => println("A = ${v}")
case Option<Int64>.None => println("Not found")
}
// 或使用下标访问
println(map["A"]) // 输出: 1
// 修改元素
map["A"] = 10
// 检查是否包含键
if (map.contains("B")) {
println("包含键 B")
}
// 删除元素
map.remove("C")
// 获取大小
println(map.size)
}
添加元素：
add(element, at: index) 或 add(all: array)add(element)add(key, value) 或 map[key] = value访问元素：
array[index] 或 array.get(index)list[index] 或 list.get(index)（返回 Option）map[key] 或 map.get(key)（返回 Option）修改元素：
[] 下标方式修改删除元素：
remove(at: index)remove(element)remove(key)其他常用方法：
size - 获取元素个数（属性）clear() - 清空所有元素（ArrayList, HashSet, HashMap）contains(element) - 检查是否包含（HashSet, HashMap）get(index) - 获取元素（ArrayList, HashMap，返回 Option）示例参考：examples/12_collections.cj
仓颉使用包（package）来组织代码，提供模块化和命名空间管理。
基本语法：
package package.name
目录结构与包声明对应：
src
└── directory_0
├── directory_1
│ ├── a.cj // package demo.directory_0.directory_1
│ └── b.cj // package demo.directory_0.directory_1
└── c.cj // package demo.directory_0
└── main.cj // package demo
示例：
// a.cj
package demo.directory_0.directory_1
public func funcA() {
println("Function A")
}
// b.cj
package demo.directory_0.directory_1
public func funcB() {
println("Function B")
}
// c.cj
package demo.directory_0
public func funcC() {
println("Function C")
}
// main.cj
package demo
import demo.directory_0.directory_1.{funcA, funcB}
import demo.directory_0.funcC
main() {
funcA() // 调用 demo.directory_0.directory_1.funcA
funcB() // 调用 demo.directory_0.directory_1.funcB
funcC() // 调用 demo.directory_0.funcC
}
基本语法：
package currentPackage
import std.math.* // 导入 std.math 的所有内容
import package1.foo // 导入 package1.foo
import {package1.foo, package2.bar, package1.MyClass} // 导入多个
使用示例：
package demo
import std.math.*
import package1.helper
import {package1.MyClass, package2.Utils}
main() {
// 直接使用导入的方法和类型
let result = pow(2, 3) // std.math.pow
helper() // package1.helper
let obj = MyClass() // package1.MyClass
Utils.doSomething() // package2.Utils
}
1. 导入所有（通配符）：
import std.math.*
// 可以直接使用 std.math 中的所有内容
let value = sqrt(16)
2. 导入特定项：
import std.math.pi
// 只能使用 pi
println(pi)
3. 导入多个项：
import {std.math.sin, std.math.cos}
// 可以使用 sin 和 cos
4. 重命名导入：
import std.math as math
let value = math.sqrt(16)
示例：
package demo.math
// 默认为 internal，仅 demo.math 及其子包可见
func internalFunc() {
println("internal")
}
// public，任何地方都可访问
public func publicFunc() {
println("public")
}
// private，仅当前文件可见
private func privateFunc() {
println("private")
}
示例参考：examples/13_package_import.cj
需求识别：
生成步骤：
templates/ 目录）示例模板：
// templates/basic/variable_declaration.cj.template
{{MODIFIER}} {{VARIABLE_NAME}}: {{TYPE}} = {{INIT_VALUE}}
需求识别：
生成步骤：
var 修饰（默认let）需求识别：
生成步骤：
break/continue（不支持标签，易错点6/7）需求识别：
生成步骤：
internal（易错点11）需求识别：
生成步骤：
需求识别：
生成步骤：
@Test 和 @TestCase 宏分析步骤：
检查项：
${}⚠️分析步骤：
重点检测：
分析步骤：
优化项：
⚠️ let 不支持变量遮蔽
⚠️ 函数参数默认是 let 不可变的
var 显式声明可变参数⚠️ 成员变量默认访问修饰符是 internal
private⚠️ 所有条件表达式必须有括号
if x > 0 { }if (x > 0) { }⚠️ 不支持 goto
⚠️ break/continue 不支持标签跳转
break outerLoop;⚠️ Rune 转整数需确保在有效 Unicode 范围
Rune(0xD800) （代理区字符）[0x0000, 0xD7FF] 或 [0xE000, 0x10FFFF]⚠️ 原始字符串字面量中转义字符不会被转义
##"\n"## 会产生换行符"\\n" 或理解原始字符串特性⚠️ match 表达式的 case 按顺序匹配
_ 放在最后⚠️ 常量模式不支持字符串插值
"Hello ${name}"${} 而非 {}
"Hello {name}""Hello ${name}"{ => 123 }() 是合法语法，立即执行Lambda() 进行其他操作（如算术运算）⚠️ 元组至少需要两个元素
⚠️ 区间类型的 step 不能等于 0
Range(1, 10, 0)⚠️ enum 至少存在一个有名字的构造器
⚠️ match 表达式的 case 不需要 {} 括号
case 1 => { println("1") }case 1 => println("1")⚠️ Option 类型用于表示可能有值或无值
⚠️ Duration 和 sleep 在 std.core 里不需导入
共39个示例，按难度和语法模块分类：
基础示例（01-15）：
中级示例（16-27）：
高级示例（28-39）：
按场景组织：
basic/：
functions/：
control_flow/：
data_structures/：
testing/：
生成代码时必须确保：
${}分析代码时必须提供：
优先级：
触发条件：
当前可用的MCP工具：
search_documents - 搜索仓颉文档
get_document_content - 获取文档内容
list_documents - 列出文档
get_document_overview - 获取文档总览
# 查询lambda相关文档
search_documents(query="lambda closure")
# 获取某个文档的特定章节
get_document_content(
doc_id="manual_source_zh_cn_functions",
section="lambda"
)
# 浏览标准库结构
list_documents(category="libs", subcategory="std")
let、var、if、else、while、do、for、match、case、func、class、enum、init、return、package、import、public、private、protected、internal、static
std.core - 核心类型和函数std.io - 输入输出std.collection - 集合类型std.time - 时间和日期欢迎贡献新的示例、模板和改进建议！
贡献方式：
质量要求：
MIT License
结束
文档维护：仓颉语言社区 最后更新：2025-01-07 版本：v1.0.0