华为仓颉|新一代高性能编程语言_仓颉hello world

1. 前言

华为推出了自研编程语言——仓颉（Cangjie），这是我国完全自主研发的计算机语言，值得自豪。小编经过两天的漫长等待后，终于通过审核，拿到了仓颉编译工具。现在华哥就给大家来开箱体验下。

2. 快速上手

开发环境：Debian GNU/Linux 11 (bullseye)

编译工具：cjc（Cangjie Compiler: 0.51.4）

Hello World 示例

让我们从经典的Hello World程序开始，这是学习任何新语言的第一步。在仓颉中，编写一个Hello World程序非常简单：

// the first cangjie program
main() {
    println("Hello, World!")
}
1
2
3
4

保存并编译，编译后执行程序：

# cjc ./hello.cj -o hello
# ./hello
Hello, World!
1
2
3

代码解读

• main() { ... }: 这定义了一个名为main的函数，它是程序的入口点，这与 C/C++/Go 语言很相似。在编译并执行程序之后，系统自动从 main 开始执行花括号中的代码。
• print("Hello, World!"): 这一行代码使用了print函数，打印输出了字符串"Hello, World!"到控制台。
• 以“//”开头的内容表示注释，它是对代码的说明和对程序的解释，不参与程序编译。用“/…/”则可以实现多行注释。

点评：main方法比其他语言更加简洁，感觉已经做到最简了。

3. 基本数据类型介绍

仓颉目前的基本数据类型，包括：整数类型、浮点类型、布尔类型、字符类型、字符串类型、Unit 类型、元组类型、区间类型、Nothing 类型。

整数类型

整数类型分为有符号（signed）整数类型和无符号（unsigned）整数类型。
有符号整数类型包括 Int8、Int16、Int32、Int64 和 IntNative，分别对应编码长度为 8-bit、16-bit、32-bit、64-bit 和平台相关大小的有符号整数值的类型。
无符号整数类型包括 UInt8、UInt16、UInt32、UInt64 和 UIntNative，分别表示编码长度为 8-bit、16-bit、32-bit、64-bit 和平台相关大小的无符号整数值的类型。

var x = 100i8  // x is 100 with type Int8
var y = 0x10u64 // y is 16 with type UInt64
var z = 0o432i32  // z is 282 with type Int32
1
2
3

i8为Int8的简写，u64代表UInt64，i32代表Int32，其它类推。

点评：这种整数类型定义更像GO的语法

浮点类型

浮点类型包括 Float16、 Float32 和 Float64

let a: Float32 = 3.14
let b: Float32 = 2e3
let c: Float32 = 2.4e-1
1
2
3

点评：跟Go一样，有点感叹仓颉是集各家语言之优点。

布尔类型

布尔类型使用 Bool 表示，用来表示逻辑中的真和假。布尔类型只有两个字面量：true 和 false。

let a: Bool = true
let b: Bool = false
1
2

字符类型

字符类型使用 Char 表示，可以表示 Unicode 字符集中的所有字符。

let a: Char = 'a'
let newLine: Char = '\n'
main() {
    let he: Char = '\u{4f60}'
    let llo: Char = '\u{597d}'
    print(he)
    print(llo)
}
1
2
3
4
5
6
7
8

字符串类型

字符串类型使用 String 表示，用于表达文本数据，由一串 Unicode 字符组合而成。支持字符串字面量跨越多行。

let s2 = "Hello Cangjie Lang"
let s2 = """
    Hello,
    Cangjie Lang"""
1
2
3
4

点评：支持多行文本，也很像GO

值类型数组 VArray

仓颉编程语言引入了值类型数组 VArray<T, $N>，其中T表示该值类型数组的元素类型，$N 是一个固定的语法，通过 $ 加上一个数值字面量表示这个值类型数组的长度。

var a: VArray<Int64, $3> = [1, 2, 3]
let i = a[1] // i is 2
a[2] = 4 // a is [1, 2, 4]
let s = a.size // s is 3
1
2
3
4

点评：跟数组很像，但又有区别，支持泛型精准控制

元组类型

元组（Tuple）可以将多个不同的类型组合在一起，成为一个新的类型。元组类型使用 (T1, T2, …, TN) 表示，其中 T1 到 TN 可以是任意类型，不同类型间使用逗号（,）连接。

main() {
    var pi = (3.14, "PI")
    println(pi[0])
    println(pi[1])
}
1
2
3
4
5

编译并执行上述代码，输出结果为：

3.140000
PI
1
2

点评：哈哈，元组这不是python的结构么，跟java的枚举很像，但java语法太啰唆，这种元组结构有点小清新。

区间类型

区间类型用于表示拥有固定步长的序列，区间类型是一个泛型，使用 Range 表示。区间字面量有两种形式：“左闭右开”区间“和“左闭右闭”区间，格式分别为：start…end : step，start…=end : step。

let n = 10
let r1 = 0..10 : 1   // r1 contains 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
let r2 = 0..=n : 1   // r2 contains 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
1
2
3

点评：区间类型放在泛型中，也许有它的用武之地吧

Nothing 类型

Nothing 是一种特殊的类型，它不包含任何值，并且 Nothing 类型是所有类型的子类型。
break、continue、return 和 throw 表达式的类型是 Nothing，程序执行到这些表达式时，它们之后的代码将不会被执行。其中 break、continue 只能在循环体中使用，return 只能在函数体中使用。

点评：官方对这种结构，描述得不是很清楚，只是强调目前编译器还不允许在使用类型的地方显式地使用 Nothing 类型，慢慢学习吧。

4. 仓颉编程特性分析

模式匹配

模式匹配使代码更加简洁和易读。以下是一个使用模式匹配的示例：

main() {
    let x = 0
    match (x) {
        case 1 => let r1 = "x = 1"
                  print(r1)
        case 0 => let r2 = "x = 0" // Matched.
                  print(r2)
        case _ => let r3 = "x != 1 and x != 0"
                  print(r3)
    }
}
1
2
3
4
5
6
7
8
9
10
11

编译并执行上述代码，输出结果为：

x = 0
1

点评：感觉是对case when结构的优化和灵活化

高阶函数

仓颉支持高阶函数，使得函数可以作为参数传递和返回值，甚至变量类型。

函数类型作为参数类型

示例：函数名为 printAdd，其类型是 ((Int64, Int64) -> Int64, Int64, Int64) -> Unit，表示该函数有三个参数，参数类型分别为函数类型 (Int64, Int64) -> Int64 和两个 Int64，返回类型为 Unit。

func printAdd(add: (Int64, Int64) -> Int64, a: Int64, b: Int64): Unit {
    println(add(a, b))
}
1
2
3

函数类型作为返回类型

如下示例中，函数名为 returnAdd，其类型是 () -> (Int64, Int64) -> Int64，表示该函数无参数，返回类型为函数类型 (Int64, Int64) -> Int64。注意，-> 是右结合的。

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

func returnAdd(): (Int64, Int64) -> Int64 {
    add
}

main() {
    var a = returnAdd()
    println(a(1,2))
}
1
2
3
4
5
6
7
8
9
10
11
12

函数类型作为变量类型

函数名本身也是表达式，它的类型为对应的函数类型。

func add(p1: Int64, p2: Int64): Int64 {
    p1 + p2
}

let f: (Int64, Int64) -> Int64 = add
1
2
3
4
5

点评：学习javascript函数的灵活式，因为灵活性才有无限多可能呀。

并发编程

当开发者希望并发执行某一段代码时，只需创建一个仓颉线程即可。要创建一个新的仓颉线程，可以使用关键字 spawn 并传递一个无形参的 lambda 表达式，该 lambda 表达式即为在新线程中执行的代码。

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

main(): Int64 {
    spawn { =>
        println("New thread before sleeping")
        sleep(100 * Duration.millisecond) // sleep for 100ms.
        println("New thread after sleeping")
    }

    println("Main thread")

    return 0
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

注意：在上面的例子中，新线程会在主线程结束时一起停止，无论这个新线程是否已完成运行。上方示例的输出每次可能略有不同，有可能会输出类似如下的内容：

New thread before sleeping
Main thread
1
2

点评：比java创建线程语法简洁多了，是否能做到GO语言的并发性能，拭目以待吧。

5. 优缺点分析

优点

1. 高性能：仓颉编译器优化技术和并行处理能力，让他在高性能计算和大数据处理方面表现出色。
2. 高安全性：强类型系统和自动内存管理，减少了内存泄漏和空指针引用等问题。
3. 易学易用：语法设计简洁易懂，降低了开发者的学习门槛，集合了多种语言的优点。
4. 良好兼容性：支持与其他主流编程语言的互操作，适用于多平台开发。

缺点

1. 生态尚未完善：作为新兴语言，仓颉的生态系统还在建设中，开发者资源和第三方库相对较少。

2. 学习曲线：尽管语法设计简洁，但对于完全陌生于新语言的开发者，仍需一定的学习时间和适应期。仓颉未来成长之路还很长，这点也算不上缺点。

3. 社区支持：目前仓颉的社区支持相对有限，开发者在遇到问题时，可能需要更多的时间寻求帮助和解决方案。

6、与其他语言运行速度对比

仓颉语言通过其高效编译器优化和并行计算能力，在运行速度上与其他主流编程语言相比具有明显优势。以下是与常见编程语言的运行速度对比：

• 与Python的对比：在科学计算和数据处理领域，Python因其灵活性和易用性而广受欢迎。由于其解释执行的特性，Python在处理大规模数据和复杂计算时性能较低。相比之下，仓颉的编译执行和优化技术使其在相同任务上可以显著提高执行速度。

• 与Java的对比：Java是一种广泛应用于企业级应用和大型系统的语言，其虚拟机（JVM）优化技术确保了良好的跨平台性能。然而，仓颉通过更为高效的编译器优化和并行计算支持，可以在一些高性能计算和大数据处理场景中展现出更好的执行效率。

• 与C++的对比：C++以其近乎原生的执行速度和优秀的性能优化而著称，尤其在需要最大化硬件资源利用的应用中表现出色。虽然仓颉与C++相比可能稍逊一筹，但其在安全性和易用性方面的优势，以及足够的执行效率，使其成为一种值得开发者考虑的替代选择。

7. 总结

华为仓颉编程语言作为一款新兴的高性能编程语言，在语法设计、性能优化、安全性和兼容性方面都展现了其独特的优势。虽然目前在生态系统和社区支持方面还有待完善，但随着技术的发展和社区的壮大，仓颉有望在未来成为主流编程语言之一。最后希望仓颉越来越好，祝愿华为越来越强！