库包的代码位于 lib 目录中， 在其他包中可以访问这里面的代码。
在 lib 目录下可以创建任意的目录结构。
通常情况下都把实现代码放到 lib/src 目录中。
位于 lib/src 下面的代码被认为是私有的；
其他包不应该直接导入 src/... 里面的代码。
要分享 lib/src 下的 API，你可以在 lib 目录下 创建一个文件，
在这个文件中导入 lib/src 中的代码。

最简单的库包的 目录结构

![最简单的库包的 目录结构](../../../images/simple-lib2-81ebdc20fdb53d3abbc4364956141eb0f6f8f275d1636064fc3e1db959b93c1a.png)

shelf 库的目录结构

![shelf 库的目录结构](../../../images/shelf-02e5fd43b660fcef7dbe6a883c40159e0379c8ee2088288ca60ed7dc8781bafd.png)

在 lib 和 web 库中如何导入 lib/src/foo/a.dart

![在 lib 和 web 库中如何导入 lib/src/foo/a.dart ](../../../images/import-lib-rules-fa353f6fddc6e69fe19da41bffff4f6ec7b561eeead24840bacce032759b8473.png)


dart.md

Go 代码必须放在工作空间内。它其实就是一个目录，其中包含三个子目录：

- src 目录包含 Go 的源文件，它们被组织成包（每个目录都对应一个包），
- pkg 目录包含包对象，
- bin 目录包含可执行命令。

go 工具用于构建源码包，并将其生成的二进制文件安装到 pkg 和 bin 目录中。
src 子目录通常包会含多种版本控制的代码仓库（例如 Git 或 Mercurial）， 以此来跟踪一个或多个源码包的开发。

```sh
# 此工作空间包含三个代码库（goauth2、streak 和 todo），
# 两个命令（streak 和 todo） 以及两个库（oauth 和 task）。
bin/
  streak                         # 可执行命令
  todo                           # 可执行命令
pkg/
  linux_amd64/
    code.google.com/p/goauth2/
      oauth.a                # 包对象
    github.com/nf/todo/
      task.a                 # 包对象
src/
  code.google.com/p/goauth2/
    .hg/                       # mercurial 代码库元数据
    oauth/
      oauth.go               # 包源码
      oauth_test.go          # 测试源码
  github.com/nf/
    streak/
      .git/                      # git 代码库元数据
      oauth.go               # 命令源码
      streak.go              # 命令源码
    todo/
      .git/                      # git 代码库元数据
      task/
        task.go            # 包源码
      todo.go                # 命令源码
```

```go
// hello.go
package main
import (
  "fmt"
  "github.com/user/stringutil"
)
func main() {
  fmt.Printf(stringutil.Reverse("!oG ,olleH"))
}

// reverse.go
// stringutil 包含有用于处理字符串的工具函数。
package stringutil
// Reverse 将其实参字符串以符文为单位左右反转。
func Reverse(s string) string {
  r := []rune(s)
  for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
    r[i], r[j] = r[j], r[i]
  }
  return string(r)
}
```

```sh
# 你的第一个程序
bin/
  hello                 # 可执行命令
pkg/
  linux_amd64/          # 这里会反映出你的操作系统和架构
    github.com/user/
      stringutil.a  # 包对象
src/
  github.com/user/
    hello/
      hello.go      # 命令源码
    stringutil/
      reverse.go       # 包源码


# 创建目录
mkdir $GOPATH/src/github.com/user/hello

# 用 go build 命令来测试该包
# 它会将包的对象放到工作空间的 pkg 目录中
# 这不会产生输出文件。想要输出的话，必须使用 go install 命令
go build github.com/user/stringutil
# 若你在该包的源码目录中，只需执行
go build

# 用 go 工具构建并安装此程序
# 此命令会构建 hello 命令，产生一个可执行的二进制文件。
# 接着它会将该二进制文件作为 hello（在 Windows 下则为 hello.exe）安装到工作空间的 bin 目录中。
# go 工具只有在发生错误时才会打印输出
go install github.com/user/hello
# 或者
cd $GOPATH/src/github.com/user/hello
go install

# 现在，你可以在命令行下输入它的完整路径来运行它了：
$GOPATH/bin/hello
# 若你已经将 $GOPATH/bin 添加到 PATH 中了
hello
```

```sh
bin/
    hello                          # command executable
    outyet                         # command executable
src/
    github.com/golang/example/
        .git/                      # Git repository metadata
  hello/
      hello.go               # command source
  outyet/
      main.go                # command source
      main_test.go           # test source
  stringutil/
      reverse.go             # package source
      reverse_test.go        # test source
    golang.org/x/image/
        .git/                      # Git repository metadata
  bmp/
      reader.go              # package source
      writer.go              # package source
    ... (many more repositories and packages omitted) ...
```


go.md

常见包结构

```sh
├── root
│   ├── src
│   ├── lib
│   ├── dist
│   ├── node_modules
│   ├── package.json
```


js.md

```sh
sound/                          Top-level package
      __init__.py               Initialize the sound package
      formats/                  Subpackage for file format conversions
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  Subpackage for sound effects
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  Subpackage for filters
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...
```

```python
# 包的用户可以从包中导入单个模块，例如:
import sound.effects.echo
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

# 导入子模块的另一种方法是
from sound.effects import echo
echo.echofilter(input, output, delay=0.7, atten=4)

# 另一种形式是直接导入所需的函数或变量:
from sound.effects.echo import echofilter
echofilter(input, output, delay=0.7, atten=4)

# 文件 sound/effects/__init__.py 可以包含以下代码:
__all__ = ["echo", "surround", "reverse"]
# 当用户写
from sound.effects import *
# 意味着 from sound.effects import * 将导入 sound 包的三个命名子模块
```


python.md

Cargo 推荐的目录结构

- `Cargo.toml` 和 `Cargo.lock` 保存在 `package` 根目录下
- 源代码放在 `src` 目录下
- 默认的 `lib` 包根是 `src/lib.rs`
- 默认的二进制包根是 `src/main.rs`
- 其它二进制包根放在 `src/bin/` 目录下
  - 为了使得 cargo 编译或运行这个二进制可执行文件而不是默认或其他二进制可执行文件，
  - 我们只需给 cargo 增加一个参数 `--bin my_other_bin`
- 基准测试 `benchmark` 放在 `benches` 目录下
- 示例代码放在 `examples` 目录下
- 集成测试代码放在 `tests` 目录下

```
.
├── Cargo.lock
├── Cargo.toml
├── src/
│   ├── lib.rs
│   ├── main.rs
│   └── bin/
│       ├── named-executable.rs
│       ├── another-executable.rs
│       └── multi-file-executable/
│           ├── main.rs
│           └── some_module.rs
├── benches/
│   ├── large-input.rs
│   └── multi-file-bench/
│       ├── main.rs
│       └── bench_module.rs
├── examples/
│   ├── simple.rs
│   └── multi-file-example/
│       ├── main.rs
│       └── ex_module.rs
└── tests/
    ├── some-integration-tests.rs
    └── multi-file-test/
        ├── main.rs
        └── test_module.rs
```

## mod

### 单文件内

```rust
fn function() {
    println!("called `function()`");
}
mod cool {
    pub fn function() {
        println!("called `cool::function()`");
    }
}
mod my {
    fn function() {
        println!("called `my::function()`");
    }
    mod cool {
        pub fn function() {
            println!("called `my::cool::function()`");
        }
    }
    pub fn indirect_call() {
        // 让我们从这个作用域中访问所有名为 `function` 的函数！
        print!("called `my::indirect_call()`, that\n> ");
        // `self` 关键字表示当前的模块作用域——在这个例子是 `my`。
        // 调用 `self::function()` 和直接调用 `function()` 都得到相同的结果，
        // 因为他们表示相同的函数。
        self::function();
        function();
        // 我们也可以使用 `self` 来访问 `my` 内部的另一个模块：
        self::cool::function();
        // `super` 关键字表示父作用域（在 `my` 模块外面）。
        super::function();
        // 这将在 *crate* 作用域内绑定 `cool::function` 。
        // 在这个例子中，crate 作用域是最外面的作用域。
        {
            use crate::cool::function as root_function;
            root_function();
        }
    }
}

fn main() {
    my::indirect_call();
}
```

### 文件分层

```sh
.
|-- my
|   |-- inaccessible.rs
|   |-- mod.rs
|   `-- nested.rs
`-- split.rs
```

```rust
// split.rs
// 此声明将会查找名为 `my.rs` 或 `my/mod.rs` 的文件，并将该文件的内容放到
// 此作用域中一个名为 `my` 的模块里面。
mod my;
fn function() {
    println!("called `function()`");
}
fn main() {
    my::function();
    function();
    my::indirect_access();
    my::nested::function();
}
```

```rust
// my/mod.rs
// 类似地，`mod inaccessible` 和 `mod nested` 将找到 `nested.rs` 和
// `inaccessible.rs` 文件，并在它们放到各自的模块中。
mod inaccessible;
pub mod nested;
pub fn function() {
    println!("called `my::function()`");
}
fn private_function() {
    println!("called `my::private_function()`");
}
pub fn indirect_access() {
    print!("called `my::indirect_access()`, that\n> ");
    private_function();
}
```

```rust
// my/nested.rs
pub fn function() {
    println!("called `my::nested::function()`");
}
#[allow(dead_code)]
fn private_function() {
    println!("called `my::nested::private_function()`");
}
```

```rust
// my/inaccessible.rs
#[allow(dead_code)]
pub fn public_function() {
    println!("called `my::inaccessible::public_function()`");
}
```


项目结构