仓颉语言 -- 包

最新推荐文章于 2024-09-29 19:32:26 发布
最新推荐文章于 2024-09-29 19:32:26 发布
阅读量988 收藏 28
点赞数 16
分类专栏： 仓颉语言 文章标签： 仓颉语言 仓颉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chinus_yan/article/details/140474644
版权

1、包的概述

随着项目规模的不断扩大，仅在一个超大文件中管理源代码会变得十分困难。这时可以将源代码根据功能进行分组，并将不同功能的代码分开管理，每组独立管理的代码会生成一个输出文件。在使用时，通过导入对应的输出文件使用相应的功能，或者通过不同功能的交互与组合实现更加复杂的特性，使得项目管理更加高效。

在仓颉编程语言中，包是编译的最小单元，每个包可以单独输出 AST 文件、静态库文件、动态库文件等产物。每个包有自己的名字空间，在同一个包内不允许有同名的顶层定义或声明（函数重载除外）。一个包中可以包含多个源文件。

模块是若干包的集合，是第三方开发者发布的最小单元。一个模块的程序入口只能在其根目录下，它的顶层最多只能有一个作为程序入口的 main ，该 main 没有参数或参数类型为 Array<String>，返回类型为整数类型或 Unit 类型。

2、包的声明

在仓颉编程语言中，包声明以关键字 package 开头，后接 root 包至当前包由 . 分隔路径上所有包的包名。包名必须是合法标识符。例如：

package pkg1      // root 包 pkg1
package pkg1.sub1 // root 包 pkg1 的子包 sub1

包声明必须在源文件的非空非注释的首行，且同一个包中的不同源文件的包声明必须保持一致。

// file 1
// Comments are accepted
package test
// declarations...

// file 2
let a = 1 // Error, package declaration must appear first in a file
package test
// declarations...

仓颉的包名需反映当前源文件相对于项目源码根目录 src 的路径，并将其中的路径分隔符替换为小数点。例如包的源代码位于 src/directory_0/directory_1 下，root 包名 为 pkg 则其源代码中的包声明应为 package pkg.directory_0.directory_1。

需要注意的是：

  • 包所在的文件夹名必须与包名一致。
  • 源码根目录默认名为 src。
  • 源码根目录下的包可以没有包声明，此时编译器将默认为其指定包名 default。
    假设源代码目录结构如下：
// The directory structure is as follows:
src
`-- directory_0
    |-- directory_1
    |    |-- a.cj
    |    `-- b.cj
    `-- c.cj
`-- main.cj

则 a.cj、b.cj、c.cj、main.cj 中的包声明可以为:

// a.cj
// in file a.cj, the declared package name must correspond to relative path directory_0/directory_1.

package default.directory_0.directory_1

// b.cj
// in file b.cj, the declared package name must correspond to relative path directory_0/directory_1.

package default.directory_0.directory_1

// c.cj
// in file c.cj, the declared package name must correspond to relative path directory_0.

package default.directory_0

// main.cj
// file main.cj is in the module root directory and may omit package declaration.

main() {
    return 0
}

另外，包声明不能引起命名冲突：子包不能和当前包的顶层声明同名。

以下是一些错误示例：

// a.cj
package a
public class B { // Error, 'B' is conflicted with sub-package 'a.B'
    public static func f() {}
}

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

// main.cj
import a.B // ambiguous use of 'a.B'

main() {
    a.B.f()
    return 0
}

3、顶层声明的可见性

仓颉中，可以使用访问修饰符来控制对类型、变量、函数等顶层声明的可见性。仓颉有 4 种访问修饰符：private、internal、protected、public，在修饰顶层元素时不同访问修饰符的语义如下。

  • private 表示仅当前文件内可见。不同的文件无法访问这类成员。
  • internal 表示仅当前包及子包（包括子包的子包）内可见。同一个包内可以不导入就访问这类成员，当前包的子包（包括子包的子包）内可以通过导入来访问这类成员。
  • protected 表示仅当前模块内可见。同一个包的文件可以不导入就访问这类成员，不同包但是在同一个模块内的其它包可以通过导入访问这些成员，不同模块的包无法访问这些成员。
  • public 表示模块内外均可见。同一个包的文件可以不导入就访问这类成员，其它包可以通过导入访问这些成员。

在这里插入图片描述
不同顶层声明支持的访问修饰符和默认修饰符（默认修饰符是指在省略情况下的修饰符语义，这些默认修饰符也允许显式写出）规定如下：

  • pacakge 支持使用 internal、protected、public，默认修饰符为 public。
  • import 支持使用全部访问修饰符，默认修饰符为 private。
  • 其他顶层声明支持使用全部访问修饰符，默认修饰符为 internal。

仓颉的访问级别排序为 public > protected > internal > private。一个声明的访问修饰符不得高于该声明中用到的类型的访问修饰符的级别，参考如下示例：

  • 函数声明中的参数与返回值
// a.cj
package a
class C {}
public func f1(a1: C) // Error, public declaration f1 cannot use internal type C.
{
    return 0
}
public func f2(a1: Int8): C // Error, public declaration f2 cannot use internal type C.
{
    return C()
}
public func f3 (a1: Int8) // Error, public declaration f3 cannot use internal type C.
{
    return C()
}
  • 变量声明
// a.cj
package a
class C {}
public let v1: C = C() // Error, public declaration v1 cannot use internal type C.
public let v2 = C() // Error, public declaration v2 cannot use internal type C.
  • 类声明中继承的类
// a.cj
package a
open class C1 {}
public class C2 <: C1 {} // Error, public declaration C2 cannot use internal type C1.
  • 类型实现的接口
// a.cj
package a
interface I {}
public enum E <: I { A } // Error, public declaration uses internal types.
  • 泛型类型的类型实参
// a.cj
package a
public class C1<T> {}
class C2 {}
public let v1 = C1<C2>() // Error, public declaration v1 cannot use internal type C2.
  • where 约束中的类型上界
// a.cj
package a
interface I {}
public class B<T> where T <: I {}  // Error, public declaration B cannot use internal type I.

值得注意的是：

  • public 修饰的声明在其初始化表达式或者函数体里面可以使用本包可见的任意类型，包括 public 修饰的类型和没有 public 修饰的类型。
// a.cj
package a
class C1 {}
func f1(a1: C1)
{
  return 0
}
public func f2(a1: Int8) // Ok.
{
  var v1 = C1()
  return 0
}
public let v1 = f1(C1()) // Ok.
public class C2 // Ok.
{
  var v2 = C1()
}
  • public 修饰的顶层声明能使用匿名函数，或者任意顶层函数，包括 public 修饰的类型和没有 public 修饰的顶层函数。
public var t1: () -> Unit = { => } // Ok.
func f1(): Unit {}
public let t2 = f1 // Ok.

public func f2() // Ok.
{
  return f1
}
  • 内置类型诸如 Rune、Int64 等也都默认是 public 的。
var num = 5
public var t3 = num // Ok.

4、包的导入

4.1 使用 import 语句导入其它包中的声明或定义

在仓颉编程语言中，可以通过 import fullPackageName.itemName 的语法导入其他包中的一个顶层声明或定义，fullPackageName 为完整路径包名，itemName 为声明的名字。导入语句在源文件中的位置必须在包声明之后，其他声明或定义之前。例如：

package a
import std.math.*
import package1.foo
import {package1.foo, package2.bar}

如果要导入的多个 itemName 同属于一个 fullPackageName，可以使用 import fullPackageName.{itemName[, itemName]*} 语法，例如：

import package1.{foo, bar, fuzz}

这等价于：

import package1.foo
import package1.bar
import package1.fuzz

除了通过 import fullPackagename.itemName 语法导入一个特定的顶层声明或定义外，还可以使用 import packageName.* 语法将 packageName 包中所有可见的顶层声明或定义全部导入。例如：

import package1.*
import {package1.*, package2.*}

需要注意：

  • import 可以被 private、internal、protected、public 访问修饰符修饰。不写访问修饰符的 import 等价于 private import。
  • 导入的成员的作用域级别低于当前包声明的成员。
  • 当已导出的包的模块名或者包名被篡改，使其与导出时指定的模块名或包名不一致，在导入时会报错。
  • 只允许导入当前文件可见的顶层声明或定义，导入不可见的声明或定义将会在导入处报错。
  • 禁止通过 import 导入当前源文件所在包的声明或定义。
  • 禁止包间的循环依赖导入，如果包之间存在循环依赖，编译器会报错。
    示例如下：
// pkga/a.cj
package pkga    // Error, packages pkga pkgb are in circular dependencies.
import pkgb.*

class C {}
public struct R {}

// pkgb/b.cj
package pkgb

import pkga.*

// pkgc/c1.cj
package pkgc

import pkga.C // Error, 'C' is not accessible in package 'pkga'.
import pkga.R // OK, R is an external top-level declaration of package pkga.
import pkgc.f1 // Error, package 'pkgc' should not import itself.

public func f1() {}

// pkgc/c2.cj
package pkgc

func f2() {
    /* OK, the imported declaration is visible to all source files of the same package
     * and accessing import declaration by its name is supported.
     */
    R()

    // OK, accessing imported declaration by fully qualified name is supported.
    pkga.R()

    // OK, the declaration of current package can be accessed directly.
    f1()

    // OK, accessing declaration of current package by fully qualified name is supported.
    pkgc.f1()
}

在仓颉编程语言中，导入的声明或定义如果和当前包中的顶层声明或定义重名且不构成函数重载，则导入的声明和定义会被遮盖；导入的声明或定义如果和当前包中的顶层声明或定义重名且构成函数重载，函数调用时将会根据函数重载的规则进行函数决议。

// pkga/a.cj
package pkga

public struct R {}            // R1
public func f(a: Int32) {}    // f1
public func f(a: Bool) {} // f2

// pkgb/b.cj
package pkgb
import pkga.*

func f(a: Int32) {}         // f3
struct R {}                 // R2

func bar() {
    R()     // OK, R2 shadows R1.
    f(1)    // OK, invoke f3 in current package.
    f(true) // OK, invoke f2 in the imported package
}

4.2 隐式导入 core 包

诸如 String、Range 等类型能直接使用，并不是因为这些类型是内置类型，而是因为编译器会自动为源码隐式的导入 core 包中所有的 public 修饰的声明。

4.3 使用 import as 对导入的名字重命名

不同包的名字空间是分隔的，因此在不同的包之间可能存在同名的顶层声明。在导入不同包的同名顶层声明时，我们支持使用 import packageName.name as newName 的方式进行重命名来避免冲突。没有名字冲突的情况下仍然可以通过import as来重命名导入的内容。import as 具有如下规则：

  • 使用 import as 对导入的声明进行重命名后，当前包只能使用重命名后的新名字，原名无法使用。

  • 如果重命名后的名字与当前包顶层作用域的其它名字存在冲突，且这些名字对应的声明均为函数类型，则参与函数重载，否则报重定义的错误。

  • 支持 import pkg as newPkgName 的形式对包名进行重命名，以解决不同模块中同名包的命名冲突问题。

// a.cj
package p1
public func f1() {}

// d.cj
package p2
public func f3() {}

// b.cj
package p1
public func f2() {}

// c.cj
package pkgc
public func f1() {}

// main.cj
import p1 as A
import p1 as B
import p2.f3 as f  // OK
import pkgc.f1 as a
import pkgc.f1 as b // OK

func f(a: Int32) {}

main() {
    A.f1()  // OK, package name conflict is resolved by renaming package name.
    B.f2()  // OK, package name conflict is resolved by renaming package name.
    p1.f1() // Error, the original package name cannot be used.
    a()     // Ok.
    b()     // Ok.
    pkgc.f1()    // Error, the original name cannot be used.
}
  • 如果没有对导入的存在冲突的名字进行重命名，在 import 语句处不报错；在使用处，会因为无法导入唯一的名字而报错。这种情况可以通过 import as 定义别名或者 import fullPackageName 导入包作为命名空间。
// a.cj
package p1
public class C {}

// b.cj
package p2
public class C {}

// main1.cj
package pkga
import p1.C
import p2.C

main() {
    let _ = C() // Error
}

// main2.cj
package pkgb
import p1.C as C1
import p2.C as C2

main() {
    let _ = C1() // ok
    let _ = C2() // ok
}

// main3.cj
package pkgc
import p1
import p2

main() {
    let _ = p1.C() // ok
    let _ = p2.C() // ok
}

4.4 重导出一个导入的名字

在功能繁多的大型项目的开发过程中，这样的场景是非常常见的：包 p2 大量地使用从包 p1 中导入的声明，当包 p3 导入包 p2 并使用其中的功能时，p1 中的声明同样需要对包 p3 可见。如果要求包 p3 自行导入 p2 中使用到的 p1 中的声明，这个过程将过于繁琐。因此希望能够在 p2 被导入时一并导入 p2 使用到的 p1 中的声明。

在仓颉编程语言中，import 可以被 private、internal、protected、public 访问修饰符修饰。其中，被 public、protected 或者 internal 修饰的 import 可以把导入的成员重导出（如果这些导入的成员没有因为名称冲突或者被遮盖导致在本包中不可用）。其它包可以根据可见性直接导入并使用本包中用重导出的内容，无需从原包中导入这些内容。

  • private import 表示导入的内容仅当前文件内可访问，private 是 import 的默认修饰符，不写访问修饰符的 import 等价于 private import。
  • internal import 表示导入的内容在当前包及其子包（包括子包的子包）均可访问。非当前包访问需要显式 import。
  • protected import 表示导入的内容在当前 module 内都可访问。非当前包访问需要显式 import。
  • public import 表示导入的内容外部都可访问。非当前包访问需要显式 import。

在下面的例子中，b 是 a 的子包，在 a 中通过 public import 重导出了 b 中定义的函数 f。

package a

public let x = 0
public import a.b.f

internal package a.b

public func f() { 0 }

import a.f  // ok
let _ = f() // ok

需要注意的是，包不可以被重导出：如果被 import 导入的是包，那么该 import 不允许被 public、protected 或者 internal 修饰。

public import a.b // Error, cannot re-export package

5、程序入口

仓颉程序入口为 main，源文件根目录下的包的顶层最多只能有一个 main。

如果模块采用生成可执行文件的编译方式，编译器只在源文件根目录下的顶层查找 main。如果没有找到，编译器将会报错；如果找到 main，编译器会进一步对其参数和返回值类型进行检查。需要注意的是，main 不可被访问修饰符修饰，当一个包被导入时，包中定义的 main 不会被导入。

作为程序入口的 main 可以没有参数或参数类型为 Array<String>，返回值类型为 Unit 或整数类型。

没有参数的 main：

// main.cj
main(): Int64 { // Ok.
    return 0
}

参数类型为 Array<String> 的 main：

// main.cj
main(args: Array<String>): Unit { // Ok.
    for (arg in args) {
        println(arg)
    }
}

使用 cjc main.cj 编译完成后，通过命令行执行：./main Hello, World，将会得到如下输出：

Hello,
World

以下是一些错误示例：

// main.cj
main(): String { // Error, return type of 'main' is not 'Integer' or 'Unit'.
    return ""
}

// main.cj
main(args: Array<Int8>): Int64 { // Error, 'main' cannot be defined with parameter whose type is not Array<String>.
    return 0
}

// main.cj
main(args: Array<Int8>): Int64 { // Error, 'main' cannot be defined with parameter whose type is not Array<String>.
    return 0
}
chinusyan
关注
专栏目录
仓颉编程语言-函数指南【定义函数、调用函数、函数类型】
一键难忘的博客
07-22 4111
仓颉编程语言是一种功能强大的通用编程语言，其设计旨在提升开发效率，同时保持高性能和良好的编程体验。在仓颉编程语言中，函数的定义使用func关键字，后跟函数名、参数列表、可选的返回值类型以及函数体。func 函数名(参数列表): 返回值类型 {函数体函数式编程为仓颉编程语言提供了强大的功能，使得开发人员能够以更加简洁、高效的方式处理复杂的编程任务。通过函数式编程的优势，如简洁性、不变性、函数组合、递归和惰性计算，编程人员能够编写出更为优雅和高效的代码，提升程序的可读性和可维护性。
鸿蒙HarmonyOS应用开发 | 在仓颉编程语言中高效管理和组织包与模块
一键难忘的博客
09-13 2632
在仓颉中，包（package）是编译的最小单元。通过将不同功能模块的代码划分到不同的包中，我们能够实现更为清晰的代码组织和功能隔离。每个包可以独立输出编译产物，例如：AST 文件、静态库文件或动态库文件。此外，包之间的命名空间独立管理，避免命名冲突，使代码更具可读性和可维护性。一个包可以包含多个源文件，但同一包中的文件必须具有相同的包声明，并且在同一个包的命名空间中，除了函数重载外，其他顶层定义或声明不允许同名。在仓颉编程语言中，包和模块是代码组织和管理的核心概念。包的概念。
仓颉编程入门 -- 包的导入
几许的博客
08-16 793
在仓颉编程语言中，当你需要利用其他包中的顶层声明或定义时，可以通过import语句来实现。此语句遵循import fullPackageName.itemName的格式，其中fullPackageName代表需要引用的包的完整路径名，而itemName则指定了你希望从该包中导入的具体声明或定义的名字。重要的是，import语句在源文件中的位置有着明确的要求：它必须出现在包声明（如果存在的话）之后，同时位于任何其他的声明或定义之前。
仓颉编程语言：基本概念
啥也不会的云计算小白
06-24 1840
在以上程序中，if 表达式作为变量定义的初值使用，由于变量 bit 没有被标注类型、需要从初值中推导，所以 if 表达式的类型取为两个分支代码块类型的最小公共父类型，根据前文对“代码块”的介绍，可知两个分支代码块类型都是 Int8，所以 if 表达式的类型被确定为 Int8，其值为所执行分支即 else 分支代码块的值，所以变量 bit 的类型为 Int8、值为 1。在仓颉程序中，由一对大括号“{}”包围起来的一组表达式，被称为“代码块”，它将作为程序的一个顺序执行流，其中的表达式将按编码顺序依次执行。
仓颉编程语言：HTTP 编程
Androidbye的博客
08-22 406
HTTP 作为一种通用的应用层协议，通过请求-响应的机制实现数据传输，客户端发送请求，服务端返回响应。
总是提示"FROM 子语句语法错误"
独孤码农de博客
09-18 1905
在使用ACCESS数据库建表的时候切记:不要使用user,password...等比较敏感的关键字来做表名...否则使用select 语句的时候就会报语法错误 
鸿蒙仓颉语言【在工程中使用Redis仓颉语言客户端】
鸿蒙的技术博客
07-22 438
引入编译好的静态库依赖和通过源码方式引入依赖，任意选取一种方式即可。参考"1.1 通过源码方式引入Redis客户端依赖"。更新依赖，运行cjpm update会自动下载依赖redis_sdk项目到~/.cjpm目录下。编译Redis仓颉语言客户端请参考：[用户手册]例如Windows X64平台执行。例如Linux X64平台执行。
仓颉编程语言 -- 编写一个windows窗口
最新发布
10-06
仓颉编程语言是一种基于图形和自然符号的编程环境，它通过直观的符号和拖放操作，使得初学者可以更容易地理解并编写程序。然而，由于仓颉并不是专门针对Windows窗口应用设计的语言，我们通常会使用像Python、Visual ...
仓颉编程语言详解：高效、安全、灵活的全场景开发利器【仓颉语言接口指南大全】
一键难忘的博客
07-29 3711
仓颉编程语言是一种面向全场景应用开发的通用编程语言，致力于兼顾开发效率和运行性能，同时提供良好的编程体验。语法简明高效：仓颉编程语言提供了一系列简明高效的语法，旨在减少冗余书写、提升开发效率。例如，插值字符串、主构造函数、Flow 表达式、match、if-let、while-let 和重导出等语法，让开发者可以用较少的编码表达相关逻辑。多范式编程：支持函数式、命令式和面向对象等多范式编程。
鸿蒙HarmonyOS应用开发 | 探索鸿蒙仓颉语言：开启高效开发新纪元
一键难忘的博客
09-29 2381
仓颉语言是专为鸿蒙操作系统设计的编程语言，它融合了现代编程语言的先进特性，同时又充分考虑了鸿蒙生态的需求。仓颉语言具有简洁的语法、高效的执行效率和强大的类型系统，使得开发者能够更加轻松地开发出高质量的应用程序。
嵌入式系统中C/C++有仓颉语言对比分析
嵌入式技术开发
06-24 681
很多朋友也问我 “要不要入行鸿蒙？” 其实我很难给一个明确的答案，毕竟我也没有充分的调研数据，也不敢随意劝大家入行。“新” 意味着机遇，同样也意味着风险。在你有条件承担风险时，选择拥抱 “新” 没有任何问题，但在没有风险承担能力时，我的建议还是先学好一门主流的编程语言、开发框架、打好计算机基础，然后你再去学新出的编程语言就非常容易了。我还是很看好华为的，也期待国内的操作系统和计算机生态可以更强大。
Cangjie5 开源项目教程
gitblog_00459的博客
08-21 278
Cangjie5 开源项目教程 Cangjie5倉頡五代補完計劃项目地址:https://gitcode.com/gh_mirrors/ca/Cangjie5 项目介绍 Cangjie5 是一个基于仓颉输入法第五代编码的开源项目，旨在提供一个高效、准确的中文输入解决方案。该项目不仅支持传统的仓颉输入法，还引入了现代化的技术改进，使得输入更加流畅和用户友好。Cangjie5 项目的主要特点包括： ...
【仓颉三方库】 网络组件——hyperion
danqiufenghao的博客
08-08 432
Hyperion: 一个支持自定义编解码器的TCP通信框架Redis仓颉语言客户端SDK： redis-sdk 项目使用了该TCP框架，并实现了RESP2、RESP3协议的编解码。 ActiveMQ仓颉语言客户端SDK：acitvemq4cj项目使用了该TCP框架。工程目录结构 1.1 编译步骤 清理工程，在工程根目录下运行： 编译工程，在工程根目录下运行： 编译的静态库位于： 在工程根目录下运行： 编译服务端示例程序，在samples/echo_server目录下运行： 启动服务端，在sample
HarmonyOS NEXT仓颉编程语言开发环境搭建（安装DevEco Studio Cangjie Plugin）
老卫的技术站
09-04 2385
DevEco Studio Cangjie Plugin配套DevEco Studio发布，该插件提供了仓颉编程语言在HarmonyOS Next应用开发的开发套件，包括代码编辑、编译构建、代码调试等能力。Mac (X86)Mac (ARM)下载中心 | 华为开发者联盟-HarmonyOS开发者官网，共建鸿蒙生态下载完成之后，会得到一个devecostudio-cangjie-plugin-windows-5.0.3.700.zip插件装包。
仓颉编程语言：函数
啥也不会的云计算小白
06-26 1496
仓颉使用关键字 func 来表示函数定义的开始，func 之后依次是函数名、参数列表、可选的函数返回值类型、函数体。其中，函数名可以是任意的合法标识符，参数列表定义在一对圆括号内（多个参数间使用逗号分隔），参数列表和函数返回值类型（如果存在）之间使用冒号分隔，函数体定义在一对花括号内。上例中定义了一个名为 add 的函数，其参数列表由两个 Int64 类型的参数 a 和 b 组成，函数返回值类型为 Int64，函数体中将 a 和 b 相加并返回。
仓颉编程入门
09-20 699
仓颉SDK入门，环境配置，代码编写，编译和运行。
仓颉编程语言：cjpm 介绍
Androidbye的博客
08-25 297
CJPM（Cangjie Package Manager） 是仓颉语言的官方包管理工具，用来管理、维护仓颉项目的模块系统，并且提供更简易统一的编译入口，支持自定义编译命令。
【仓颉三方库】 网络组件——DownLoad4cj
danqiufenghao的博客
08-08 180
可靠、灵活、快速和强大的下载引擎。提供同步下载,异步下载,暂停任务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值