仓颉编程语言中的包管理

在仓颉编程语言中，随着项目规模的扩大，合理管理和组织代码显得尤为重要。为此，仓颉引入了包和模块的概念，以便于代码的分组和复用，从而提升项目的开发和维护效率。

包的概述

在仓颉中，包（package）是编译的最小单元。通过将不同功能模块的代码划分到不同的包中，我们能够实现更为清晰的代码组织和功能隔离。每个包可以独立输出编译产物，例如：AST 文件、静态库文件或动态库文件。此外，包之间的命名空间独立管理，避免命名冲突，使代码更具可读性和可维护性。

一个包可以包含多个源文件，但同一包中的文件必须具有相同的包声明，并且在同一个包的命名空间中，除了函数重载外，其他顶层定义或声明不允许同名。

模块与包的关系

模块 是若干包的集合，是开发者发布代码的最小单元。一个模块中只能有一个主程序入口 main，并且它必须位于模块的根目录下。模块入口的 main 函数可以不带参数，也可以带有 Array<String> 类型的参数，返回类型则为整数类型或 Unit 类型。

通过模块的结构化管理，可以使得代码更加模块化，方便开发者分发和复用代码。同时，模块内的包可以通过相互调用，组合实现更加复杂的功能。

包的声明

在仓颉编程语言中，包的声明是项目组织的基础。每个源文件的包声明必须位于文件的首行，并且必须使用 package 关键字。包名是由根包（root package）到当前包的路径组成，以小数点 . 分隔。例如：

package pkg1         // 声明根包为 pkg1
package pkg1.sub1    // 声明根包 pkg1 的子包 sub1

包名必须是合法的标识符，并且所有源文件的包声明必须保持一致。如果某个文件没有遵循这一规则，将导致编译错误。例如：

// file 1: 正确的包声明
package test
// 文件中的其他声明...

// file 2: 错误的包声明位置
let a = 1   // Error: 包声明必须出现在文件的首行
package test
// 文件中的其他声明...

包名与目录结构的映射

仓颉语言中，包名通常反映当前源文件相对于项目源码根目录的路径。例如，如果项目的源码位于 src/directory_0/directory_1 下，而根包名为 pkg，则包的声明应为：

package pkg.directory_0.directory_1

需要注意以下几点：

1. 包声明必须与文件路径一致：包所在的文件夹名称必须与包名匹配，源码根目录通常命名为 src，其下的文件可选择省略包声明，编译器将其默认指定为 default 包。
2. 避免命名冲突：包声明不得与同一命名空间中的顶层声明（类、函数等）同名。否则会引发命名冲突。例如：

// a.cj
package a
public class B {  // 错误，子包 a.B 与类 B 重名
    public static func f() {}
}

// b.cj
package a.B
public func f {}

此时，当尝试导入 a.B 时，编译器会产生模糊的命名冲突提示：

// main.cj
import a.B  // 使用 'a.B' 时出现歧义

main() {
    a.B.f()  // 错误
    return 0
}

包的示例

假设你的项目目录结构如下：

src
`-- directory_0
    |-- directory_1
    |    |-- a.cj
    |    `-- b.cj
    `-- c.cj
`-- main.cj

对应的包声明可以这样写：

• 在 a.cj 和 b.cj 文件中，包声明应对应路径 directory_0/directory_1：

package default.directory_0.directory_1

• 在 c.cj 文件中，包声明应对应路径 directory_0：

package default.directory_0

• 在 main.cj 文件中，因为它位于模块的根目录下，包声明可以省略：

main() {
    return 0
}

包的使用与导入

在仓颉编程语言中，包的导入是通过 import 语句实现的。导入包后，包内的所有公开定义的类、函数、常量等都可以在当前文件中使用。包的导入方式十分灵活，支持按需导入、整体导入以及别名导入。

单个成员导入

当只需要使用包中的某个具体成员时，可以通过指定导入特定的函数或类。例如：

import pkg1.sub1.Foo  // 只导入 Foo 类

main() {
    Foo f = new Foo()
    f.doSomething()
}

这种方式只会导入 Foo 类，其他未导入的成员无法访问。

整体导入

如果需要使用包中的所有公开成员，可以采用整体导入的方式：

import pkg1.sub1.*  // 导入 pkg1.sub1 包中的所有公开成员

main() {
    Foo f = new Foo()
    Bar b = new Bar()
    f.doSomething()
    b.doSomethingElse()
}

在这个例子中，包 pkg1.sub1 中所有公开的类 Foo 和 Bar 都被导入，开发者可以直接使用它们。

别名导入

在项目中，如果不同包中的成员名称出现冲突，可以使用别名导入来避免命名冲突。通过为包起一个别名，可以在使用时通过别名访问包内的成员。例如：

import pkg1.sub1.Foo as Foo1  // 为 Foo 类取别名 Foo1
import pkg2.sub2.Foo as Foo2  // 为另一个 Foo 类取别名 Foo2

main() {
    Foo1 f1 = new Foo1()
    Foo2 f2 = new Foo2()
    f1.doSomething()
    f2.doSomethingElse()
}

这种方式能够有效避免不同包中类或函数名称冲突，确保代码的可读性和可维护性。

包的可见性与访问控制

仓颉编程语言通过访问控制关键字来定义包中成员的可见性。主要的访问控制关键字包括 public、private 和 protected。它们决定了包中成员的访问权限：

• public：公开的成员可以被其他包直接访问。
• private：私有的成员只能在当前包或类中访问。
• protected：受保护的成员只能在当前包和子包中访问。

例如：

// 文件 pkg1/sub1/Foo.cj
package pkg1.sub1

public class Foo {
    private let secret = 42

    public func getSecret() {
        return this.secret
    }
}

// 文件 main.cj
import pkg1.sub1.Foo

main() {
    Foo f = new Foo()
    f.getSecret()  // 可以访问公开方法
    // f.secret  // Error: 无法直接访问私有成员
}

通过这些访问控制机制，开发者可以明确指定哪些部分的代码对外部可见，哪些部分只在包或类内部使用，从而更好地控制代码的封装性和安全性。

包的编译与输出

仓颉编程语言在编译时会根据每个包生成不同的产物。编译的产物可以包括：

• AST 文件：抽象语法树文件，是编译过程中生成的中间文件，便于后续优化或代码分析。
• 静态库文件：静态链接库，通常以 .a 或 .lib 作为文件后缀，在编译时与其他库静态链接。
• 动态库文件：动态链接库，通常以 .so 或 .dll 作为文件后缀，允许程序在运行时动态加载。

每个包在编译时都可以根据需求选择输出哪些类型的文件，从而适应不同的开发场景。

总结

在仓颉编程语言中，包和模块是代码组织和管理的核心概念。以下是主要要点的总结：

1. 包的概念：

   • 包是编译的最小单元，用于组织和管理源代码。
   • 每个包可以输出不同的编译产物，如 AST 文件、静态库和动态库。
   • 包有自己的命名空间，避免命名冲突。

2. 包的声明：

   • 使用 package 关键字声明包，包名应反映源文件相对 src 目录的路径。
   • 包声明必须出现在文件的首行，并且同一包中的所有文件必须一致。
   • 包声明不能与同一命名空间中的顶层声明同名，避免命名冲突。

3. 模块的概念：

   • 模块是若干包的集合，是发布的最小单元。
   • 模块的主程序入口 main 必须位于模块根目录下，且 main 函数可以带参数 Array<String>，返回类型为整数类型或 Unit 类型。

4. 包的使用与导入：

   • 包可以通过 import 语句导入，包括单个成员导入、整体导入和别名导入。
   • 导入方式可以有效管理包成员的使用和避免命名冲突。

5. 包的可见性与访问控制：

   • 通过 public、private 和 protected 关键字控制包成员的可见性。
   • public 成员对外公开，private 成员仅对包内部可见，protected 成员在包和子包中可见。

6. 包的编译与输出：

   • 编译时，包可以生成 AST 文件、静态库文件和动态库文件。
   • 根据需求选择不同的输出类型以适应开发和部署的场景。