## 引用自定义库

```c++
// File foo.c

#include <stdio.h>
#include "bar.h"

int main(void) {
  printf("%d\n", add(2, 3));  // 5!
}
```

```c++
// File bar.h
#ifndef BAR_H
  #define BAR_H
  int add(int, int);
#endif
```

```c++
// File bar.c
#include "bar.h"

int add(int a, int b) {
  return a + b;
}
```

```sh
gcc -o foo foo.c bar.c
```

## 分步编译

```sh
gcc -c foo.c # 生成 foo.o
gcc -c bar.c # 生成 bar.o
gcc -o foo foo.o bar.o # 链接，合并生成一个可执行文件
```

## make

```makefile
foo: foo.o bar.o
  gcc -o foo foo.o bar.o

foo.o: bar.h foo.c
  gcc -c foo.c

bar.o: bar.h bar.c
  gcc -c bar.c
```

```sh
make foo.o
make bar.o
make foo
make # 默认执行第一条编译规则
```


c.md

Dart 有两种类型的包： 应用 包 和 库 包。

最简单的库包的 目录结构：
通常情况下都把实现代码放到 `lib/src` 目录中。
位于 `lib/src` 下面的代码被认为是私有的；
其他包不应该直接导入 `src/...` 里面的代码。

要分享 lib/src 下的 API，你可以在 lib 目录下 创建一个文件，
在这个文件中导入 lib/src 中的代码。

```sh
root ------lib-----file.dart
        |--pubspec.yaml
```

- 库不仅仅提供 API， 还是一个私有单元：
  以下划线 (\_) 开头的标识符只有在库 内部可见。
  每个 Dart app 都是一个库， 即使没有使用 library 命令也是一个库
- import 必须参数为库 的 URI。
  对于内置的库，URI 使用特殊的 dart: scheme。
  对于其他的库，你可以使用文件系统路径或者 package: scheme。
  package: scheme 指定的库通过包管理器来提供， 例如 pub 工具。

```dart
import 'dart:html';
import 'dart:io';
import 'package:mylib/mylib.dart';
import 'package:utils/utils.dart';

// Specifying a library prefix（指定库前缀）
import 'package:lib1/lib1.dart';
import 'package:lib2/lib2.dart' as lib2;
// ...
Element element1 = new Element();           // Uses Element from lib1.
lib2.Element element2 = new lib2.Element(); // Uses Element from lib2.

// Importing only part of a library（导入库的一部分）
// Import only foo.
import 'package:lib1/lib1.dart' show foo;
// Import all names EXCEPT foo.
import 'package:lib2/lib2.dart' hide foo;

// Lazily loading a library（延迟载入库）
// 可以多次调用 loadLibrary() 函数。 但是该库只是载入一次
import 'package:deferred/hello.dart' deferred as hello;
greet() async {
  await hello.loadLibrary();
  hello.printGreeting();
}


import 'french.dart';
export 'french.dart' show hello;

// 引入某个库的多个对象
import 'package:flutter/material.dart' show StatefulWidget, StatelessWidget;
```


dart.md

每个源文件都是以包的声明语句开始，用来指明包的名字。
当包被导入的时候，包内的成员将通过类似 tempconv.CToF 的形式访问。
而包级别的名字，例如在一个文件声明的类型和常量，
在同一个包的其他源文件也是可以直接访问的，就好像所有代码都在一个文件一样。

Go 语言的代码通过包（package）组织，
包类似于其它语言里的库（libraries）或者模块（modules）。
一个包由位于单个目录下的一个或多个.go 源代码文件组成, 目录定义包的作用。
每个源文件都以一条 package 声明语句开始，这个例子里就是 package main,
表示该文件属于哪个包，紧跟着一系列导入（import）的包，之后是存储在这个文件里的程序语句。

在 Go 语言程序中，每个包都有一个全局唯一的导入路径。
一个导入路径代表一个目录中的一个或多个 Go 源文件。

Go 的标准库提供了 100 多个包，以支持常见功能，如输入、输出、排序以及文本处理。

main 包比较特殊。它定义了一个独立可执行的程序，而不是一个库。

此代码用圆括号组合了导入，这是“分组”形式的导入语句。
不过使用分组导入语句是更好的形式。

在 Go 中，如果一个名字以大写字母开头，那么它就是已导出的。
例如，Pizza 就是个已导出名，Pi 也同样，它导出自 math 包。
pizza 和 pi 并未以大写字母开头，所以它们是未导出的。
在导入一个包时，你只能引用其中已导出的名字。
任何“未导出”的名字在该包外均无法访问。

言外之意，

- 大写字母开头的变量会导出给其他包使用，
- 小写字母开头的变量为包内私有，不会导出

- Go 源文件中的第一个语句必须是 `package 名称`
- 这里的 名称 即为导入该包时使用的默认名称。 （一个包中的所有文件都必须使用相同的 名称。）
- Go 的约定是包名为导入路径的最后一个元素：作为 “crypto/rot13” 导入的包应命名为 rot13。
- 可执行命令必须使用 `package main`。
- 链接成单个二进制文件的所有包，其包名无需是唯一的，只有导入路径（它们的完整文件名） 才是唯一的。

在 `src/pkg/encoding/base64` 中的包应作为 `encoding/base64` 导入，

```go
import (
  "fmt"
  "math"
)
// 等同于
import "fmt"
import "math"

// 别名操作
import(
  f "fmt"
)

// math包内的Pi即为导出的
func main() {
  fmt.Println(math.Pi)
}
```

```sh
# 若你在包的导入路径中包含了代码仓库的URL，go get 就会自动地获取、 构建并安装它：
$ go get github.com/golang/example/hello
$ $GOPATH/bin/hello
Hello, Go examples!

# 在执行完上面的go get 命令后，工作空间的目录树看起来应该是这样的：
bin/
    hello                           # command executable
src/
    github.com/golang/example/
        .git/                       # Git repository metadata
        hello/
            hello.go                # command source
        stringutil/
            reverse.go              # package source
            reverse_test.go         # test source
    github.com/user/
        hello/
            hello.go                # command source
        stringutil/
            reverse.go              # package source
            reverse_test.go         # test source
```


go.md

- 一个 Node.js 文件就是一个模块
- 包是在模块基础上更深一步的抽象，使用 npm 来解决包的发布和获取，
  `package.json`必须在包的顶层目录下

```js
import { stat, exists, readFile } from "fs";
import _, { each, forEach } from "lodash";
// 整体加载的写法
import * as circle from "./circle";

// profile.js
export var firstName = "Michael";
export var lastName = "Jackson";
export var year = 1958;

// profile.js
var firstName = "Michael";
var lastName = "Jackson";
var year = 1958;
export { firstName, lastName, year };

// export-default.js
export default function() {
  console.log("foo");
}
// import-default.js
import customName from "./export-default";
customName(); // 'foo'

export { foo, bar } from "my_module";
// 可以简单理解为
import { foo, bar } from "my_module";
export { foo, bar };
```


js.md

- `module`：一个文件就是一个模块
- `package`：包是一个包含 `__init__.py` 文件的目录
  包是一种通过用“带点号的模块名”来构造 Python 模块命名空间的方法。
- `lib`：库是完成一定功能的代码集合，在 python 中是包和模块的形式

当一个名为 spam 的模块被导入的时候，
解释器首先寻找具有该名称的内置模块。
如果没有找到，然后解释器从 `sys.path` 变量给出的目录列表里寻找名为 `spam.py` 的文件。
`sys.path` 初始有这些目录地址:

- 包含输入脚本的目录（或者未指定文件时的当前目录）。
- PYTHONPATH （一个包含目录名称的列表，它和 shell 变量 PATH 有一样的语法）。
- 取决于安装的默认设置

```python
# fibo.py
def fib(n):    # write Fibonacci series up to n
  a, b = 0, 1
  while a < n:
    print(a, end=' ')
    a, b = b, a+b
  print()
def fib2(n):   # return Fibonacci series up to n
  result = []
  a, b = 0, 1
  while a < n:
    result.append(a)
    a, b = b, a+b
  return result

#
import fibo
fibo.fib(1000)
#
from fibo import fib, fib2
fib(1000)
#
from fibo import *
fib(1000)
#
import fibo as fib
fib.fib(500)
#
from fibo import fib as fibonacci
fibonacci(500)

# 以脚本的方式执行模块
# python fibo.py <arguments>
if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))

# 子包参考
from . import echo
from .. import formats
from ..filters import equalizer
```


python.md

- 包（Packages）： Cargo 的一个功能，它允许你构建、测试和分享 crate。
  - 包（package） 是提供一系列功能的一个或者多个 crate。
  - 一个包会包含有一个 Cargo.toml 文件，阐述如何去构建这些 crate。
    - 一个包中至多 只能 包含一个库 crate(library crate)；
    - 包中可以包含任意多个二进制 crate(binary crate)；
    - 包中至少包含一个 crate，无论是库的还是二进制的。
- Crates ：一个模块的树形结构，它形成了库或二进制项目。
  - Cargo 遵循的一个约定：
    - `src/main.rs` 就是一个与包同名的二进制 crate 的 crate 根。
    - `src/lib.rs`，则包带有与其同名的库 crate，且 `src/lib.rs` 是 crate 根
    - 如果一个包同时含有 `src/main.rs` 和 `src/lib.rs`，则它有两个 crate：一个库和一个二进制项，且名字都与包相同。
    - 通过将文件放在 `src/bin` 目录下，一个包可以拥有多个二进制 crate：每个 `src/bin` 下的文件都会被编译成一个独立的二进制 crate。
- 模块（Modules）和 use： 允许你控制作用域和路径的私有性。
  - 模块 让我们可以将一个 crate 中的代码进行分组，以提高可读性与重用性。
  - 模块还可以控制项的 私有性，即项是可以被外部代码使用的（public）
- 路径（path）：一个命名例如结构体、函数或模块等项的方式

```sh
# 创建一个新的名为 restaurant 的库
cargo new --lib restaurant
```

```sh
# 模块树
crate
 └── front_of_house
     ├── hosting
     │   ├── add_to_waitlist
     │   └── seat_at_table
     └── serving
         ├── take_order
         ├── serve_order
         └── take_payment
```

```rust
// src/lib.rs
#![allow(unused)]
fn main() {
    mod front_of_house {
        mod hosting { // 模块嵌套
            fn add_to_waitlist() {}

            fn seat_at_table() {}
        }

        mod serving {
            fn take_order() {}

            fn server_order() {}

            fn take_payment() {}
        }
    }
}
```

## crate

- crate（中文有 “包，包装箱” 之意）是 Rust 的编译单元。
  - 当调用 `rustc some_file.rs` 时，`some_file.rs` 被当作 crate 文件。
  - 如果 `some_file.rs` 里面含有 `mod` 声明，那么模块文件的内容将在编译之前被插入 crate 文件的相应声明处。
  - 换句话说，模块不会单独被编译，只有 crate 才会被编译。
  - crate 可以编译成二进制可执行文件（binary）或库文件（library）。

## 库（library）

- 默认情况 下，rustc 将从 crate 产生二进制可执行文件。
- 这种行为可以通过 rustc 的选项 `--crate-type` 重载。

```sh
# 编译一个库
rustc --crate-type=lib rary.rs # 生成 library.rlib
# library.rlib 是已编译好的库的路径，这里假设它在同一目录下：

# 链接一个已编译好的库，并编译成可执行文件
rustc executable.rs --extern rary=library.rlib --edition=2018 && ./executable
```

```rust
// rary.rs
pub fn public_function() {
    println!("called rary's `public_function()`");
}
fn private_function() {
    println!("called rary's `private_function()`");
}
pub fn indirect_access() {
    print!("called rary's `indirect_access()`, that\n> ");

    private_function();
}
```

```rust
// executable.rs
// extern crate rary; // 在 Rust 2015 版或更早版本需要这个导入语句
fn main() {
    rary::public_function();
    // 报错！ `private_function` 是私有的
    //rary::private_function();
    rary::indirect_access();
}
```

## 模块路径的两种形式

- 绝对路径（absolute path）从 crate 根部开始，以 crate 名或者字面量 crate 开头。
- 相对路径（relative path）从当前模块开始，以 self、super 或当前模块的标识符开头。

```rust
mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

pub fn eat_at_restaurant() {
    // Absolute path
    crate::front_of_house::hosting::add_to_waitlist();

    // Relative path
    front_of_house::hosting::add_to_waitlist();
}
```

### 使用 super 起始的相对路径

```rust
fn serve_order() {}
mod back_of_house {
    fn fix_incorrect_order() {
        cook_order();
        super::serve_order();
    }
    fn cook_order() {}
}
```

## 创建公有的结构体和枚举

```rust
mod back_of_house {
    // 如果我们在一个结构体定义的前面使用了 pub ，
    // 这个结构体会变成公有的，但是这个结构体的字段仍然是私有的。
    pub struct Breakfast {
        pub toast: String,
        seasonal_fruit: String,
    }

    impl Breakfast {
        // 想当于静态方法
        pub fn summer(toast: &str) -> Breakfast {
            Breakfast {
                toast: String::from(toast),
                seasonal_fruit: String::from("peaches"),
            }
        }
    }
}

pub fn eat_at_restaurant() {
    // Order a breakfast in the summer with Rye toast
    let mut meal = back_of_house::Breakfast::summer("Rye");
    // Change our mind about what bread we'd like
    meal.toast = String::from("Wheat"); // 公有字段
    println!("I'd like {} toast please", meal.toast);

    // The next line won't compile if we uncomment it; we're not allowed
    // to see or modify the seasonal fruit that comes with the meal
    // meal.seasonal_fruit = String::from("blueberries"); // 私有字段
}
```

```rust
mod back_of_house {
    // 如果我们将枚举设为公有，则它的所有成员都将变为公有。
    pub enum Appetizer {
        Soup,
        Salad,
    }
}

pub fn eat_at_restaurant() {
    let order1 = back_of_house::Appetizer::Soup;
    let order2 = back_of_house::Appetizer::Salad;
}
```

## 使用 use 关键字将名称引入作用域

```rust
mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

use crate::front_of_house::hosting::add_to_waitlist;

pub fn eat_at_restaurant() {
    add_to_waitlist();
    add_to_waitlist();
    add_to_waitlist();
}
fn main() {}
```

```rust
#![allow(unused)]
fn main() {
    use std::fmt::Result;
    use std::io::Result as IoResult;

    fn function1() -> Result {
        // --snip--
        Ok(())
    }

    fn function2() -> IoResult<()> {
        // --snip--
        Ok(())
    }
}
```

```rust
mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

// 使用 pub use 重导出名称
pub use crate::front_of_house::hosting; // 引入并导出

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
    hosting::add_to_waitlist();
    hosting::add_to_waitlist();
}
fn main() {}
```

## 使用 as 关键字提供新的名称

```rust
use std::fmt::Result;
use std::io::Result as IoResult;

fn function1() -> Result {
    // --snip--
}

fn function2() -> IoResult<()> {
    // --snip--
}
```

## 使用外部包

```toml
[dependencies]
rand = "0.8.3"
```

```rust
use rand::Rng;
fn main() {
    let secret_number = rand::thread_rng().gen_range(1..101);
}
```

```rust
use std::cmp::Ordering;
use std::io;

// 与上面写法相同
use std::{cmp::Ordering, io};


use std::io;
use std::io::Write;

// 与上面写法相同
use std::io::{self, Write};

// 将一个路径下 所有 公有项引入作用域
use std::collections::*;
```

## 将模块分割进不同文件

```rust
// src/lib.rs

// 在 mod front_of_house 后使用分号，而不是代码块，
// 这将告诉 Rust 在另一个与模块同名的文件中加载模块的内容。
mod front_of_house;

pub use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
    hosting::add_to_waitlist();
    hosting::add_to_waitlist();
}
```

```rust
// src/front_of_house.rs

// pub mod hosting {
//     pub fn add_to_waitlist() {}
// }

// 继续重构，将 hosting 模块也提取到其自己的文件中
pub mod hosting;
```

```rust
// src/front_of_house/hosting.rs
pub fn add_to_waitlist() {}
```

## 使用 pub use 导出合适的公有 API

```rust
// src/lib.rs
//! # Art
//!
//! A library for modeling artistic concepts.

pub mod kinds {
    /// The primary colors according to the RYB color model.
    pub enum PrimaryColor {
        Red,
        Yellow,
        Blue,
    }

    /// The secondary colors according to the RYB color model.
    pub enum SecondaryColor {
        Orange,
        Green,
        Purple,
    }
}

pub mod utils {
    use crate::kinds::*;

    /// Combines two primary colors in equal amounts to create
    /// a secondary color.
    pub fn mix(c1: PrimaryColor, c2: PrimaryColor) -> SecondaryColor {
        // --snip--
    }
}
```

```rust
// src/main.rs
use art::kinds::PrimaryColor; // 全路径
use art::utils::mix;

fn main() {
    let red = PrimaryColor::Red;
    let yellow = PrimaryColor::Yellow;
    mix(red, yellow);
}
```

使用 pub use 语句导出

```rust
// src/lib.rs
//! # Art
//!
//! A library for modeling artistic concepts.

pub use self::kinds::PrimaryColor;
pub use self::kinds::SecondaryColor;
pub use self::utils::mix;

pub mod kinds {
    // --snip--
}

pub mod utils {
    // --snip--
}
```

```rust
// src/main.rs
use art::PrimaryColor; // 导出后路径变短
use art::mix;

fn main() {
    // --snip--
}
```

## 工作空间

### 创建工作空间

```sh
mkdir add
cd add
cargo new adder
cargo new add-one --lib

# 构建整个工作空间
cargo build
```

- 这个 `Cargo.toml` 文件配置了整个工作空间。
- 它不会包含 `[package]` 或其他我们在 `Cargo.toml` 中见过的元信息。
- 相反，它以 `[workspace]` 部分作为开始，并通过指定 `adder` 的路径来为工作空间增加成员
- 工作空间只在根目录有一个`Cargo.lock`，而不是在每一个 `crate` 目录都有 `Cargo.lock`。
  - 这确保了所有的 `crate` 都使用完全相同版本的依赖。
- `adder` 并没有自己的 `target` 目录
- 即使进入 `adder` 目录运行 `cargo build`，构建结果也位于 `add/target` 而不是 `add/adder/target`
- 如果你选择向 `crates.io` 发布工作空间中的 `crate`，每一个工作空间中的 `crate` 需要单独发布。
  - 必须进入每一个 crate 的目录并运行 `cargo publish` 来发布工作空间中的每一个 crate。

```toml
# Cargo.toml
[workspace]
members = [
    "adder",
    "add-one",
]
```

```sh
├── Cargo.lock
├── Cargo.toml
├── add-one
│   ├── Cargo.toml
│   └── src
│       └── lib.rs
├── adder
│   ├── Cargo.toml
│   └── src
│       └── main.rs
└── target
```

### 调用工作空间的 create

```rust
// add-one/src/lib.rs
pub fn add_one(x: i32) -> i32 {
    x + 1
}
```

```toml
# adder/Cargo.toml
[dependencies]
add-one = { path = "../add-one" }
```

```rust
// adder/src/main.rs
use add_one;
fn main() {
    let num = 10;
    println!("Hello, world! {} plus one is {}!", num, add_one::add_one(num));
}
```

### 依赖外部 crate

```toml
# add-one/Cargo.toml
[dependencies]
rand = "0.5.5"
```

## 使用 cargo install 从 Crates.io 安装二进制文件

`cargo install` 的二进制文件都安装到 Rust 安装根目录的 `bin` 文件夹中。
如果你使用 `rustup.rs` 安装的 Rust 且没有自定义任何配置，这将是`$HOME/.cargo/bin`

```sh
cargo install ripgrep
```


库/包/模块

了解更多