Nix函数库详解：常用内置函数实战

Nix函数库详解：常用内置函数实战

【免费下载链接】nix Nix, the purely functional package manager 项目地址: https://gitcode.com/gh_mirrors/ni/nix

引言

Nix作为一款纯函数式的包管理器（Package Manager），其强大之处很大程度上源于其丰富的内置函数库（Built-in Functions）。这些函数为Nix表达式（Nix Expression）提供了基础的操作能力，涵盖了数据处理、文件操作、系统交互等多个方面。本文将深入探讨Nix中最常用的内置函数，通过大量实战案例和详细解析，帮助读者掌握这些函数的用法，提升Nix表达式的编写效率和质量。

读完本文后，你将能够：

• 熟练运用Nix常用内置函数处理各种数据类型
• 理解函数的底层实现逻辑和适用场景
• 掌握函数组合和高级应用技巧
• 解决实际开发中遇到的常见问题

数据处理函数

1. builtins.map

builtins.map函数用于对列表中的每个元素应用指定的函数，并返回一个新的列表。它是函数式编程中非常基础且常用的函数。

函数签名：

builtins.map :: (a -> b) -> [a] -> [b]

参数说明：

• 第一个参数：一个函数，该函数接受一个类型为a的参数，返回类型为b的结果
• 第二个参数：一个类型为a的元素组成的列表
• 返回值：一个类型为b的元素组成的列表，其中每个元素都是将第一个参数函数应用于输入列表对应元素的结果

实战案例：

# 将列表中的每个数字加1
let
  numbers = [1 2 3 4 5];
  increment = x: x + 1;
  result = builtins.map increment numbers;
in
  result  # 结果为 [2 3 4 5 6]

在实际项目中，builtins.map常与其他函数结合使用，例如在docker.nix文件中：

outputs = [ ${lib.concatStringsSep " " (builtins.map (x: "\"${x}\"") outputs)} ];

这段代码使用builtins.map将输出列表中的每个元素用双引号包裹，然后使用lib.concatStringsSep将它们连接成一个字符串。

高级应用：

# 嵌套使用map处理二维列表
let
  matrix = [[1, 2], [3, 4], [5, 6]];
  double = x: x * 2;
  doubleMatrix = builtins.map (row: builtins.map double row) matrix;
in
  doubleMatrix  # 结果为 [[2, 4], [6, 8], [10, 12]]

2. builtins.filter

builtins.filter函数用于从列表中筛选出满足指定条件的元素。

函数签名：

builtins.filter :: (a -> Bool) -> [a] -> [a]

参数说明：

• 第一个参数：一个谓词函数，接受一个类型为a的参数，返回一个布尔值
• 第二个参数：一个类型为a的元素组成的列表
• 返回值：一个新的列表，只包含谓词函数返回true的元素

实战案例：

# 筛选出列表中的偶数
let
  numbers = [1 2 3 4 5 6];
  isEven = x: x % 2 == 0;
  evenNumbers = builtins.filter isEven numbers;
in
  evenNumbers  # 结果为 [2 4 6]

应用场景： 在处理配置文件或数据筛选时非常有用，例如从系统列表中筛选出特定架构的系统。

3. builtins.foldl'

builtins.foldl'是一个左折叠函数，用于将二元函数应用于累加器和列表中的每个元素，从左到右遍历，最终得到一个累加结果。

函数签名：

builtins.foldl' :: (a -> b -> a) -> a -> [b] -> a

参数说明：

• 第一个参数：一个二元函数，接受累加器（类型为a）和列表元素（类型为b），返回新的累加器值（类型为a）
• 第二个参数：初始累加器值（类型为a）
• 第三个参数：一个类型为b的元素组成的列表
• 返回值：最终的累加器值（类型为a）

实战案例：

# 计算列表中所有元素的和
let
  numbers = [1 2 3 4 5];
  sum = builtins.foldl' (acc: x: acc + x) 0 numbers;
in
  sum  # 结果为 15

在docker.nix文件中，builtins.foldl'被用于构建复杂的配置结构：

builtins.foldl' (
  acc: output:
  acc // {
    # 复杂的配置逻辑
  }
) {} outputs

高级应用：

# 实现列表反转
let
  reverseList = list: builtins.foldl' (acc: x: [x] ++ acc) [] list;
  numbers = [1 2 3 4 5];
in
  reverseList numbers  # 结果为 [5 4 3 2 1]

4. builtins.mapAttrs

builtins.mapAttrs函数用于对属性集（Attribute Set）中的每个键值对应用指定的函数，并返回一个新的属性集。

函数签名：

builtins.mapAttrs :: (String -> a -> b) -> { String : a } -> { String : b }

参数说明：

• 第一个参数：一个二元函数，接受键（字符串类型）和值（类型为a），返回转换后的值（类型为b）
• 第二个参数：一个键为字符串、值为类型a的属性集
• 返回值：一个新的属性集，键与输入属性集相同，值为应用函数后的结果（类型为b）

实战案例：

# 将属性集中的所有数值加10
let
  data = { a = 1; b = 2; c = 3; };
  add10ToValue = key: value: value + 10;
  result = builtins.mapAttrs add10ToValue data;
in
  result  # 结果为 { a = 11; b = 12; c = 13; }

在tests/installer/default.nix中，builtins.mapAttrs用于处理测试用例：

builtins.mapAttrs (imageName: image: {
  ${image.system} = builtins.mapAttrs (testName: test: makeTest imageName testName) installScripts;
})

这段代码嵌套使用了builtins.mapAttrs，先遍历镜像，再为每个镜像遍历测试脚本，创建对应的测试用例。

应用技巧： 当需要同时处理键和值时非常有用，例如重命名键或根据键对值进行不同处理。

文件系统操作函数

1. builtins.readFile

builtins.readFile函数用于读取指定路径文件的内容，并以字符串形式返回。

函数签名：

builtins.readFile :: Path -> String

参数说明：

• 参数：文件路径（Path类型）
• 返回值：文件内容（字符串类型）

实战案例：

# 读取版本文件内容
let
  version = builtins.readFile ./VERSION;
in
  "当前版本: ${version}"

在default.nix中，builtins.readFile用于读取flake锁文件：

lock = builtins.fromJSON (builtins.readFile ./flake.lock);

这里先读取flake.lock文件的内容，然后使用builtins.fromJSON将JSON字符串解析为Nix属性集。

注意事项：

• 路径可以是相对路径或绝对路径
• 如果文件不存在，Nix求值会失败
• 读取的是构建时的文件内容，而不是运行时的

2. builtins.path

builtins.path函数用于引用文件系统中的路径，并返回一个路径对象，该对象会被Nix视为输入依赖。

函数签名：

builtins.path :: { path : Path, name ? String, filter ? Path -> Bool } -> Path

参数说明：

• path：必需，指定要引用的文件系统路径
• name：可选，指定存储路径中的名称部分
• filter：可选，一个函数，用于过滤路径中的文件
• 返回值：Nix存储中的路径

实战案例：

# 引用项目中的资源目录
let
  assets = builtins.path {
    path = ./assets;
    filter = path: baseNameOf path != ".DS_Store";  # 排除macOS系统文件
  };
in
  derivation {
    # ...
    buildInputs = [assets];
    # ...
  }

在docker.nix中，builtins.path用于包含Docker构建上下文：

builtins.path {
  path = ./.;
  filter = path: baseNameOf path != "docker.nix";  # 排除自身
}

应用场景：

• 在derivation中包含源代码或资源文件
• 创建不包含构建产物的纯净源代码路径
• 选择性地包含或排除目录中的文件

3. builtins.readDir

builtins.readDir函数用于读取指定目录的内容，并返回一个属性集，其中键是文件名，值是文件类型。

函数签名：

builtins.readDir :: Path -> { String : String }

参数说明：

• 参数：目录路径（Path类型）
• 返回值：属性集，键是文件名，值是文件类型（"directory"、"regular"、"symlink"等）

实战案例：

# 列出目录中的所有子目录
let
  dirContents = builtins.readDir ./src;
  subdirs = builtins.attrNames (builtins.filterAttrs (name: type: type == "directory") dirContents);
in
  subdirs

在tests/nixos/fetch-git/default.nix中，builtins.readDir用于动态发现测试用例：

(lib.attrNames (builtins.readDir ./test-cases));

这段代码读取test-cases目录的内容，并返回所有子项的名称列表，用于自动发现和运行测试用例。

应用场景：

• 动态发现项目中的模块或插件
• 根据目录内容自动生成配置
• 批量处理目录中的文件

系统交互函数

1. builtins.currentSystem

builtins.currentSystem函数返回当前系统的标识符，通常格式为架构-操作系统。

函数签名：

builtins.currentSystem :: String

返回值： 当前系统的标识符字符串，例如x86_64-linux、aarch64-darwin等。

实战案例：

# 根据当前系统选择不同的配置
let
  config = if builtins.currentSystem == "x86_64-linux" then
    import ./configs/linux.nix
  else if builtins.currentSystem == "aarch64-darwin" then
    import ./configs/darwin.nix
  else
    import ./configs/default.nix;
in
  config

在ci/gha/tests/default.nix中，builtins.currentSystem用于设置默认系统：

system ? builtins.currentSystem,

这里将当前系统作为默认参数值，允许在需要时覆盖。

常见系统标识符：

• x86_64-linux：64位x86架构的Linux系统
• aarch64-linux：64位ARM架构的Linux系统
• x86_64-darwin：64位x86架构的macOS系统
• aarch64-darwin：64位ARM架构的macOS系统（Apple Silicon）

2. builtins.derivation

builtins.derivation函数是Nix中最核心的函数之一，用于创建派生（Derivation），即描述如何构建软件包的配方。

函数签名：

builtins.derivation :: { name : String, system : String, builder : String, args : [String], ... } -> Path

参数说明：

• name：派生的名称
• system：构建该派生的目标系统
• builder：构建器程序的路径（通常是shell）
• args：传递给构建器的命令行参数
• 其他参数：环境变量或其他构建时参数
• 返回值：派生的输出路径

实战案例：

# 创建一个简单的派生，生成hello.txt文件
let
  helloDerivation = builtins.derivation {
    name = "hello";
    system = builtins.currentSystem;
    builder = "${builtins.storePath /nix/store/bash}/bin/bash";
    args = [./builder.sh];
    message = "Hello, Nix!";
    outputHashAlgo = "sha256";
    outputHash = "00000000000000000000000000000000000000000000000000000";
  };
in
  helloDerivation

对应的builder.sh：

#!/bin/bash
echo "$message" > "$out/hello.txt"

在tests/nixos/ca-fd-leak/default.nix中，builtins.derivation用于创建测试用的派生：

builtins.derivation {
  name = "test-drv";
  system = builtins.currentSystem;
  builder = "${pkgs.bash}/bin/bash";
  args = ["-c" "echo hello, world > $out"];
  outputHash = builtins.hashString "sha256" "hello, world\n";
  outputHashAlgo = "sha256";
}

注意事项：

• builtins.derivation是创建派生的底层函数，通常我们会使用stdenv.mkDerivation等高层封装
• 需要指定outputHash和outputHashAlgo来确保可重现性
• 所有传递给派生的属性都会成为构建环境中的环境变量

高级函数与技巧

1. 函数组合

Nix的内置函数可以像乐高积木一样组合使用，创造出强大的功能。

实战案例：列表处理流水线

let
  numbers = [1 2 3 4 5 6 7 8 9 10];
  
  # 筛选偶数
  isEven = x: x % 2 == 0;
  
  # 平方
  square = x: x * x;
  
  # 求和
  sum = builtins.foldl' (acc: x: acc + x) 0;
  
  # 函数组合：筛选偶数 -> 平方 -> 求和
  evenSquaresSum = sum (builtins.map square (builtins.filter isEven numbers));
in
  evenSquaresSum  # 结果为 220 (2² + 4² + 6² + 8² + 10² = 4 + 16 + 36 + 64 + 100)

应用技巧： 使用let表达式为复杂的函数组合创建中间变量，可以提高可读性：

let
  numbers = [1 2 3 4 5 6 7 8 9 10];
  
  # 中间步骤
  evenNumbers = builtins.filter (x: x % 2 == 0) numbers;
  squaredEvens = builtins.map (x: x * x) evenNumbers;
  evenSquaresSum = builtins.foldl' (acc: x: acc + x) 0 squaredEvens;
in
  evenSquaresSum

2. 处理JSON数据

Nix提供了builtins.fromJSON和builtins.toJSON函数，用于在Nix数据结构和JSON之间进行转换。

实战案例：

# 解析JSON配置文件
let
  configJson = builtins.readFile ./config.json;
  config = builtins.fromJSON configJson;
in
  {
    appName = config.app.name;
    port = config.server.port;
    features = builtins.map (f: f.name) config.features;
  }

在default.nix中，我们看到了这种模式的实际应用：

lock = builtins.fromJSON (builtins.readFile ./flake.lock);

注意事项：

• JSON对象会转换为Nix属性集
• JSON数组会转换为Nix列表
• JSON字符串会转换为Nix字符串
• 数字会转换为Nix整数或浮点数
• JSON布尔值会转换为Nix布尔值
• JSON null会转换为Nix的null值

常用内置函数速查表

函数名	功能描述	示例
builtins.map	对列表每个元素应用函数	builtins.map (x: x*2) [1 2 3] → [2 4 6]
builtins.filter	筛选列表中满足条件的元素	builtins.filter (x: x>2) [1 2 3 4] → [3 4]
builtins.foldl'	左折叠列表	builtins.foldl' (acc: x: acc+x) 0 [1 2 3] → 6
builtins.mapAttrs	对属性集键值对应用函数	builtins.mapAttrs (k: v: v+1) {a=1; b=2} → {a=2; b=3}
builtins.readFile	读取文件内容	builtins.readFile ./file.txt → 文件内容字符串
builtins.path	引用文件系统路径	builtins.path { path = ./src; } → 存储路径
builtins.readDir	读取目录内容	builtins.readDir ./dir → { "file1" = "regular"; ... }
builtins.currentSystem	获取当前系统标识	builtins.currentSystem → "x86_64-linux"
builtins.derivation	创建派生	builtins.derivation { name = "my-drv"; ... }
builtins.fromJSON	解析JSON字符串	builtins.fromJSON "{\"a\": 1}" → {a=1}
builtins.toJSON	转换为JSON字符串	builtins.toJSON {a=1} → "{\"a\":1}"
builtins.hashString	计算字符串哈希	builtins.hashString "sha256" "hello" → 哈希值
builtins.getFlake	获取flake	builtins.getFlake "github:nixos/nix"
builtins.intersectAttrs	属性集交集	builtins.intersectAttrs {a=1} {a=2; b=3} → {a=2}

结论与最佳实践

Nix的内置函数库为编写高效、简洁的Nix表达式提供了强大的基础。通过熟练掌握这些函数，你可以：

1. 更高效地处理数据结构
2. 与文件系统进行交互
3. 创建和操作派生
4. 构建复杂的配置逻辑

最佳实践：

1. 函数组合：将简单函数组合成复杂功能，提高代码复用性和可读性
2. 错误处理：使用builtins.tryEval等函数处理可能的错误情况
3. 性能考虑：对大型数据集使用builtins.foldl'而非递归，避免栈溢出
4. 代码组织：将复杂逻辑分解为小型、专注的函数
5. 文档注释：为使用复杂内置函数的代码添加注释，说明其用途和预期行为

掌握这些内置函数是成为Nix高手的关键一步。通过不断实践和探索，你将能够更优雅地解决Nix生态系统中的各种问题，编写出更加健壮和可维护的Nix表达式。

最后，鼓励你深入研究Nix官方文档中关于内置函数的完整参考，探索更多高级函数和用法，不断扩展你的Nix技能集。

【免费下载链接】nix Nix, the purely functional package manager 项目地址: https://gitcode.com/gh_mirrors/ni/nix