From 0beb01625b63a465273c525489eec7e29c6c090a Mon Sep 17 00:00:00 2001 From: ryan4yin Date: Sun, 30 Jun 2024 15:38:06 +0000 Subject: [PATCH] =?UTF-8?q?Deploying=20to=20gh-pages=20from=20@=20NixOS-CN?= =?UTF-8?q?/nixos-cn.github.io@112224ac58dcc1c720638a52ea9a14ac4d3fdcdf=20?= =?UTF-8?q?=F0=9F=9A=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- 404.html | 8 +-- ....html-aJVSI8g5.js => 404.html-7q9hhSdq.js} | 2 +- ...naryAndSourceDistribution.html-16kgxc39.js | 2 - ...naryAndSourceDistribution.html-C-rtSMVZ.js | 2 + ...PvFv.js => Configuration.html-CE9jQ0tW.js} | 31 ++++++----- ...IsTheBlueprintOfTheSystem.html-Dttpxv9Y.js | 1 - ...IsTheBlueprintOfTheSystem.html-djsOJ9Vw.js | 1 + ...nalProgrammingShapesNixOS.html-DZ_IJvjM.js | 8 --- ...nalProgrammingShapesNixOS.html-rr2UlYus.js | 8 +++ ...ath-dependentProgramsWork.html-D2834t8G.js | 1 + ...ath-dependentProgramsWork.html-NhUUpgrU.js | 1 - assets/Intro.html-CEuRkNVT.js | 52 +++++++++++++++++++ assets/Intro.html-CsM-htdy.js | 52 ------------------- ...l-BZkwlMGp.js => Manuals.html-DFp7igCI.js} | 4 +- ...vk50dn3.js => Networking.html-D__jtwiK.js} | 4 +- ...urityIsOurUltimatePursuit.html-BDKKUkcr.js | 21 -------- ...urityIsOurUltimatePursuit.html-BJhNv_7j.js | 21 ++++++++ ...QSVs.js => QuickOverview.html-BSo4J38r.js} | 38 ++++++-------- ...t-NWjACjSk.js => SearchResult-B0cgczV8.js} | 2 +- ...B9GmW8h7.js => Subsystem.html-DSYLh798.js} | 28 +++++----- ...kj3.js => VirtualMachine.html-dR4GRz3A.js} | 16 +++--- assets/WSL2.html-B1QMWOGS.js | 7 +++ assets/WSL2.html-DbTShrQz.js | 7 --- assets/{app-KtH3BPxJ.js => app-BNkVxcYY.js} | 6 +-- assets/{arc-D7LfjWVZ.js => arc-CCBbLdcJ.js} | 2 +- ...c.js => blockDiagram-91b80b7a-BBC8OS1A.js} | 2 +- ...z_Mb.js => c4Diagram-b2a90758-Dz5AbReI.js} | 2 +- assets/channel-BjR0DzJB.js | 1 + assets/channel-CMv_FdPr.js | 1 - ...X.js => classDiagram-30eddba6-DcDvhOEg.js} | 2 +- ...s => classDiagram-v2-f2df5561-DE0A-Qsz.js} | 2 +- assets/clone-B3jXRIgC.js | 1 + assets/clone-DrDNZrmS.js | 1 - ...aQ4.js => createText-6b48ae7d-Be8-ICh4.js} | 2 +- ...ChNpa6jL.js => edges-d32062c0-DkG77r1N.js} | 2 +- ...K3-h.js => erDiagram-47591fe2-Dtou2gIg.js} | 2 +- ...7OMLol-.js => flowDb-4b19a42f-DF52bLNY.js} | 2 +- ...1g.js => flowDiagram-5540d9b9-DjBuNiGm.js} | 2 +- assets/flowDiagram-v2-3b53844e-BlTVTKH-.js | 1 + assets/flowDiagram-v2-3b53844e-BnHmn6Fa.js | 1 - ...chart-elk-definition-5fe447d6-BWURyEbg.js} | 2 +- ...k.js => ganttDiagram-9a3bba1f-BAvoVKG2.js} | 2 +- ...s => gitGraphDiagram-96e6b4ee-B-6IwZat.js} | 2 +- .../{graph-CZFZ88P_.js => graph-pHMMkIoI.js} | 2 +- ...l-DaODvwP8.js => haskell.html-IMJVSTSk.js} | 22 ++++---- ...BHnHNBwf.js => index-fc10efb0-DKnwFV05.js} | 2 +- ...tml-DhOr4nTI.js => index.html-BNRX3zGk.js} | 2 +- ...tml-CO3Zoej-.js => index.html-Bld3147c.js} | 2 +- ...tml-BdmV7lSx.js => index.html-ByMTKhkr.js} | 2 +- ...tml-DFZDy7w2.js => index.html-C7513JJK.js} | 2 +- ...tml-GGNRB_Os.js => index.html-CXqct-2E.js} | 2 +- ...tml-w6XYUv6Q.js => index.html-CykiMO0-.js} | 2 +- ...tml-DxGqHslQ.js => index.html-csQfK4x4.js} | 2 +- ...tml-BRNxgYFz.js => index.html-dT3bJ4l8.js} | 2 +- ...tml-vIVcD392.js => index.html-lh8H6DTQ.js} | 2 +- ...rH.js => infoDiagram-bcd20f53-X0KKOLmJ.js} | 2 +- ...tml-_G6iOctj.js => intro.html-B3Nq0b0F.js} | 6 +-- ...js => journeyDiagram-4fe6b3dc-Dspy-Y2l.js} | 2 +- ...{layout-T75UZZYO.js => layout-DeUj-ndh.js} | 2 +- assets/{line-Ca8uDOHw.js => line-D1cnbi83.js} | 2 +- ...{linear-arRLiK9s.js => linear-xwrFJpfU.js} | 2 +- ...e-C6L20Gds.js => mermaid.core-rZKkN201.js} | 8 +-- ...> mindmap-definition-f354de21-DculK-cN.js} | 2 +- ...K26.js => pieDiagram-79897490-fnwJYhyN.js} | 2 +- ...s => quadrantDiagram-62f64e94-C0C2SzAa.js} | 2 +- ...> requirementDiagram-05bf5f74-ClfIqA2N.js} | 2 +- ....js => sankeyDiagram-97764748-CYWvZqaT.js} | 2 +- ...s => sequenceDiagram-acc0e65c-icDQEXj_.js} | 2 +- ...d.js => stateDiagram-0ff1cf1a-B5rd5gQE.js} | 2 +- ...s => stateDiagram-v2-9a9d610d-Ck662So0.js} | 2 +- ...Zfgmxks.js => styles-3ed67cfa-DZEsZfiw.js} | 2 +- ...PYNbVDd.js => styles-991ebdfc-Ct9JCjtI.js} | 2 +- ...8LpHG_B.js => styles-d20c7d72-cvUR8323.js} | 2 +- ....js => svgDrawCommon-5ccd53ef-CdrfbuOv.js} | 2 +- ... timeline-definition-fea2a41d-BWECdlaH.js} | 2 +- ...js => xychartDiagram-ab372869-BqOEqsRf.js} | 2 +- index.html | 8 +-- manual/Configuration.html | 38 +++++++------- manual/Intro.html | 26 +++++----- manual/index.html | 6 +-- search-pro.worker.js | 2 +- sitemap.xml | 2 +- .../concept/BinaryAndSourceDistribution.html | 12 ++--- ...onfigurationIsTheBlueprintOfTheSystem.html | 10 ++-- .../HowFunctionalProgrammingShapesNixOS.html | 12 ++--- .../HowToMakePath-dependentProgramsWork.html | 10 ++-- .../concept/PurityIsOurUltimatePursuit.html | 16 +++--- tutorials/concept/index.html | 6 +-- tutorials/env/dev/haskell.html | 30 +++++------ tutorials/env/dev/index.html | 6 +-- tutorials/env/index.html | 6 +-- tutorials/index.html | 6 +-- tutorials/installation/Networking.html | 10 ++-- tutorials/installation/Subsystem.html | 36 ++++++------- tutorials/installation/VirtualMachine.html | 24 ++++----- tutorials/installation/WSL2.html | 14 ++--- tutorials/installation/index.html | 6 +-- tutorials/lang/Manuals.html | 12 ++--- tutorials/lang/QuickOverview.html | 44 +++++++--------- tutorials/lang/index.html | 6 +-- tutorials/module-system/index.html | 6 +-- tutorials/module-system/intro.html | 10 ++-- 102 files changed, 403 insertions(+), 412 deletions(-) rename assets/{404.html-aJVSI8g5.js => 404.html-7q9hhSdq.js} (94%) delete mode 100644 assets/BinaryAndSourceDistribution.html-16kgxc39.js create mode 100644 assets/BinaryAndSourceDistribution.html-C-rtSMVZ.js rename assets/{Configuration.html-C5G2PvFv.js => Configuration.html-CE9jQ0tW.js} (57%) delete mode 100644 assets/ConfigurationIsTheBlueprintOfTheSystem.html-Dttpxv9Y.js create mode 100644 assets/ConfigurationIsTheBlueprintOfTheSystem.html-djsOJ9Vw.js delete mode 100644 assets/HowFunctionalProgrammingShapesNixOS.html-DZ_IJvjM.js create mode 100644 assets/HowFunctionalProgrammingShapesNixOS.html-rr2UlYus.js create mode 100644 assets/HowToMakePath-dependentProgramsWork.html-D2834t8G.js delete mode 100644 assets/HowToMakePath-dependentProgramsWork.html-NhUUpgrU.js create mode 100644 assets/Intro.html-CEuRkNVT.js delete mode 100644 assets/Intro.html-CsM-htdy.js rename assets/{Manuals.html-BZkwlMGp.js => Manuals.html-DFp7igCI.js} (83%) rename assets/{Networking.html-xvk50dn3.js => Networking.html-D__jtwiK.js} (64%) delete mode 100644 assets/PurityIsOurUltimatePursuit.html-BDKKUkcr.js create mode 100644 assets/PurityIsOurUltimatePursuit.html-BJhNv_7j.js rename assets/{QuickOverview.html-BnfFQSVs.js => QuickOverview.html-BSo4J38r.js} (74%) rename assets/{SearchResult-NWjACjSk.js => SearchResult-B0cgczV8.js} (97%) rename assets/{Subsystem.html-B9GmW8h7.js => Subsystem.html-DSYLh798.js} (72%) rename assets/{VirtualMachine.html-UPKXfkj3.js => VirtualMachine.html-dR4GRz3A.js} (69%) create mode 100644 assets/WSL2.html-B1QMWOGS.js delete mode 100644 assets/WSL2.html-DbTShrQz.js rename assets/{app-KtH3BPxJ.js => app-BNkVxcYY.js} (98%) rename assets/{arc-D7LfjWVZ.js => arc-CCBbLdcJ.js} (96%) rename assets/{blockDiagram-91b80b7a-C6pI6ZUc.js => blockDiagram-91b80b7a-BBC8OS1A.js} (98%) rename assets/{c4Diagram-b2a90758-BwJ_z_Mb.js => c4Diagram-b2a90758-Dz5AbReI.js} (99%) create mode 100644 assets/channel-BjR0DzJB.js delete mode 100644 assets/channel-CMv_FdPr.js rename assets/{classDiagram-30eddba6-vYGySLZX.js => classDiagram-30eddba6-DcDvhOEg.js} (97%) rename assets/{classDiagram-v2-f2df5561-Cu8jWsiF.js => classDiagram-v2-f2df5561-DE0A-Qsz.js} (92%) create mode 100644 assets/clone-B3jXRIgC.js delete mode 100644 assets/clone-DrDNZrmS.js rename assets/{createText-6b48ae7d-GnsCfaQ4.js => createText-6b48ae7d-Be8-ICh4.js} (99%) rename assets/{edges-d32062c0-ChNpa6jL.js => edges-d32062c0-DkG77r1N.js} (99%) rename assets/{erDiagram-47591fe2-BbKXK3-h.js => erDiagram-47591fe2-Dtou2gIg.js} (99%) rename assets/{flowDb-4b19a42f-B7OMLol-.js => flowDb-4b19a42f-DF52bLNY.js} (99%) rename assets/{flowDiagram-5540d9b9-DkF9cC1g.js => flowDiagram-5540d9b9-DjBuNiGm.js} (97%) create mode 100644 assets/flowDiagram-v2-3b53844e-BlTVTKH-.js delete mode 100644 assets/flowDiagram-v2-3b53844e-BnHmn6Fa.js rename assets/{flowchart-elk-definition-5fe447d6-F5Y8qNy0.js => flowchart-elk-definition-5fe447d6-BWURyEbg.js} (99%) rename assets/{ganttDiagram-9a3bba1f-C1hkcUvk.js => ganttDiagram-9a3bba1f-BAvoVKG2.js} (99%) rename assets/{gitGraphDiagram-96e6b4ee-CvWjsn_w.js => gitGraphDiagram-96e6b4ee-B-6IwZat.js} (99%) rename assets/{graph-CZFZ88P_.js => graph-pHMMkIoI.js} (99%) rename assets/{haskell.html-DaODvwP8.js => haskell.html-IMJVSTSk.js} (68%) rename assets/{index-fc10efb0-BHnHNBwf.js => index-fc10efb0-DKnwFV05.js} (96%) rename assets/{index.html-DhOr4nTI.js => index.html-BNRX3zGk.js} (93%) rename assets/{index.html-CO3Zoej-.js => index.html-Bld3147c.js} (83%) rename assets/{index.html-BdmV7lSx.js => index.html-ByMTKhkr.js} (93%) rename assets/{index.html-DFZDy7w2.js => index.html-C7513JJK.js} (94%) rename assets/{index.html-GGNRB_Os.js => index.html-CXqct-2E.js} (93%) rename assets/{index.html-w6XYUv6Q.js => index.html-CykiMO0-.js} (93%) rename assets/{index.html-DxGqHslQ.js => index.html-csQfK4x4.js} (94%) rename assets/{index.html-BRNxgYFz.js => index.html-dT3bJ4l8.js} (93%) rename assets/{index.html-vIVcD392.js => index.html-lh8H6DTQ.js} (93%) rename assets/{infoDiagram-bcd20f53-A9wMI7rH.js => infoDiagram-bcd20f53-X0KKOLmJ.js} (98%) rename assets/{intro.html-_G6iOctj.js => intro.html-B3Nq0b0F.js} (68%) rename assets/{journeyDiagram-4fe6b3dc-BGKev6fL.js => journeyDiagram-4fe6b3dc-Dspy-Y2l.js} (98%) rename assets/{layout-T75UZZYO.js => layout-DeUj-ndh.js} (99%) rename assets/{line-Ca8uDOHw.js => line-D1cnbi83.js} (93%) rename assets/{linear-arRLiK9s.js => linear-xwrFJpfU.js} (99%) rename assets/{mermaid.core-C6L20Gds.js => mermaid.core-rZKkN201.js} (98%) rename assets/{mindmap-definition-f354de21-DhiAvLxS.js => mindmap-definition-f354de21-DculK-cN.js} (99%) rename assets/{pieDiagram-79897490-QkapWK26.js => pieDiagram-79897490-fnwJYhyN.js} (98%) rename assets/{quadrantDiagram-62f64e94-ClG9tsmb.js => quadrantDiagram-62f64e94-C0C2SzAa.js} (99%) rename assets/{requirementDiagram-05bf5f74-Jq4qUw68.js => requirementDiagram-05bf5f74-ClfIqA2N.js} (98%) rename assets/{sankeyDiagram-97764748-LZzRLiKc.js => sankeyDiagram-97764748-CYWvZqaT.js} (99%) rename assets/{sequenceDiagram-acc0e65c-1ltbI8a1.js => sequenceDiagram-acc0e65c-icDQEXj_.js} (99%) rename assets/{stateDiagram-0ff1cf1a-aWNHknpd.js => stateDiagram-0ff1cf1a-B5rd5gQE.js} (97%) rename assets/{stateDiagram-v2-9a9d610d-qAu6-oBP.js => stateDiagram-v2-9a9d610d-Ck662So0.js} (90%) rename assets/{styles-3ed67cfa-PZfgmxks.js => styles-3ed67cfa-DZEsZfiw.js} (98%) rename assets/{styles-991ebdfc-DPYNbVDd.js => styles-991ebdfc-Ct9JCjtI.js} (99%) rename assets/{styles-d20c7d72-I8LpHG_B.js => styles-d20c7d72-cvUR8323.js} (99%) rename assets/{svgDrawCommon-5ccd53ef-CGhu7SjD.js => svgDrawCommon-5ccd53ef-CdrfbuOv.js} (95%) rename assets/{timeline-definition-fea2a41d-LOqIv7kL.js => timeline-definition-fea2a41d-BWECdlaH.js} (99%) rename assets/{xychartDiagram-ab372869-YEof7nF5.js => xychartDiagram-ab372869-BqOEqsRf.js} (99%) diff --git a/404.html b/404.html index 59d25c2..7443a12 100644 --- a/404.html +++ b/404.html @@ -30,11 +30,11 @@ NixOS 中文 - - + + -
跳至主要內容

404

页面不存在

看起来你访问了一个失效的链接

+ - + diff --git a/assets/404.html-aJVSI8g5.js b/assets/404.html-7q9hhSdq.js similarity index 94% rename from assets/404.html-aJVSI8g5.js rename to assets/404.html-7q9hhSdq.js index c935fac..76be418 100644 --- a/assets/404.html-aJVSI8g5.js +++ b/assets/404.html-7q9hhSdq.js @@ -1 +1 @@ -import{_ as t}from"./plugin-vue_export-helper-DlAUqK2U.js";import{o as e,c as o,a as n}from"./app-KtH3BPxJ.js";const r={},a=n("p",null,"404 Not Found",-1),c=[a];function p(i,s){return e(),o("div",null,c)}const d=t(r,[["render",p],["__file","404.html.vue"]]),u=JSON.parse('{"path":"/404.html","title":"","lang":"zh-CN","frontmatter":{"layout":"NotFound","description":"404 Not Found","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/404.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:description","content":"404 Not Found"}],["meta",{"property":"og:type","content":"website"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"WebPage\\",\\"name\\":\\"\\",\\"description\\":\\"404 Not Found\\"}"]]},"headers":[],"git":{},"readingTime":{"minutes":0.01,"words":3},"filePathRelative":null,"autoDesc":true,"excerpt":"

404 Not Found

\\n"}');export{d as comp,u as data}; +import{_ as t}from"./plugin-vue_export-helper-DlAUqK2U.js";import{o as e,c as o,a as n}from"./app-BNkVxcYY.js";const r={},a=n("p",null,"404 Not Found",-1),c=[a];function p(i,s){return e(),o("div",null,c)}const d=t(r,[["render",p],["__file","404.html.vue"]]),u=JSON.parse('{"path":"/404.html","title":"","lang":"zh-CN","frontmatter":{"layout":"NotFound","description":"404 Not Found","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/404.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:description","content":"404 Not Found"}],["meta",{"property":"og:type","content":"website"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"WebPage\\",\\"name\\":\\"\\",\\"description\\":\\"404 Not Found\\"}"]]},"headers":[],"git":{},"readingTime":{"minutes":0.01,"words":3},"filePathRelative":null,"autoDesc":true,"excerpt":"

404 Not Found

\\n"}');export{d as comp,u as data}; diff --git a/assets/BinaryAndSourceDistribution.html-16kgxc39.js b/assets/BinaryAndSourceDistribution.html-16kgxc39.js deleted file mode 100644 index 074f5e7..0000000 --- a/assets/BinaryAndSourceDistribution.html-16kgxc39.js +++ /dev/null @@ -1,2 +0,0 @@ -import{_ as c}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as n,o as s,c as p,a as e,b as t,d as i,e as a}from"./app-KtH3BPxJ.js";const l="/images/Concept/Apt.svg",d="/images/Concept/Portage.svg",g="/images/Concept/HashPath.svg",m={},u=a('

二进制分发与源码分发

二进制分发从字面意思上就很容易理解，软件包仓库开放预编译的二进制包，并供包管理器下载并部署到目标主机。

源码分发则是从各处拉取源码，下载编译，再部署到目标主机。看起来只是将编译步骤挪到了本地进行而已，但却给了软件包部署更多灵活性。

以 Debian 作为二进制分发的例子

Debian 是 GNU/Linux 世界中采用二进制分发的优秀发行版之一，APT 则是它最流行的包管理器之一。

APT包管理器
APT包管理器

为了从远程获取预编译的二进制包，APT 需要从三个地方读取源列表：

  • /etc/apt/sources.list
  • /etc/apt/sources.list.d/*.list
  • /etc/apt/sources.list.d/*.source

然后访问源列表里面的 URL ，获取软件包的元数据（名称，版本，依赖信息等）。这些元数据通常被存储在 /var/lib/apt/lists/。

只要有元数据的协助，APT 很快就能推算出你要下载的包依赖哪些其他的包，并从软件包仓库开始下载需要的一揽子软件包。这些包被缓存到 /var/cache/apt/archives/。

Deb 包里面只会包含二进制文件，以及控制这些二进制文件该释放至何处的描述文件。假如你想对这个软件包搞点个性化定制，自己再克隆源码，修改源码，编译和打包一条龙。你不能从官方包仓库的软件包直接衍生变体。

不同的打包方式带来了 Linux 软件包生态的分裂。你从 Debian 系发行版和 RHEL 系发行版就能观察到 “血脉兼容” 的现象。

',12),h={class:"hint-container tip"},b=e("p",{class:"hint-container-title"},"提示",-1),x={href:"https://github.com/FabioLolix/LinuxTimeline",target:"_blank",rel:"noopener noreferrer"},_=e("h2",{id:"以-gentoo-作为源码分发的例子",tabindex:"-1"},[e("a",{class:"header-anchor",href:"#以-gentoo-作为源码分发的例子"},[e("span",null,"以 Gentoo 作为源码分发的例子")])],-1),f=e("p",null,[t("Gentoo 似乎是另一个极端。它的包管理器叫做 Portage，它从官方的软件仓库获取的是 ebuild 文件，而这些文件会被缓存到 "),e("code",null,"/var/db/repos/gentoo/"),t(" 下。")],-1),y=e("p",null,"你可以将 ebuild 理解为一种构建软件的脚本。它包含了一些函数和变量，用来指定软件包的元数据、依赖关系、源码地址、编译选项、安装步骤等信息。Portage 会根据 ebuild 中的指令来下载、编译和安装软件包。",-1),v=e("figure",null,[e("img",{src:d,alt:"Portage 包管理器",tabindex:"0",loading:"lazy"}),e("figcaption",null,"Portage 包管理器")],-1),N={href:"https://gitweb.gentoo.org/repo/gentoo.git/tree/app-editors/neovim/neovim-9999.ebuild",target:"_blank",rel:"noopener noreferrer"},P=a(`

获取到源码以后，Portage 开始了繁忙的编译流程。它需要读取一些编译变量，而它们在 /etc/portage/make.conf 这个配置文件里。 其中包括全局的 USE 标志、编译选项、镜像源、许可证等。这些变量可以控制 Portage 的功能和性能，也可以根据用户的需求进行优化和定制。

每一台 Gentoo 主机都可能有不同的编译选项，因此编译出来的产物也不一致，它们已经是一种变体了。

另外，许多人喜欢 Gentoo 的原因就是可以更极致地压榨运行性能。但是频繁的编译是相当耗费时间的。后面 Gentoo 又支持了分布式编译，可以让你的其他电脑分担工作量，不过依然是饮鸠止渴。

Nix 之道

Nix 是 NixOS 的包管理器，它是跨平台的，可以在 Linux 平台和 Darwin 平台使用。

二进制分发可以保持包的一致性，使本应正常依赖的包可以正常工作（不过需要包管理器控制版本）；源码分发可以保持包的灵活性，可以自由拓展软件功能，衍生软件变体。有什么办法可以鱼与熊掌兼得呢？

Nix 则使用一种函数式语言来描述软件包及其依赖关系，每个软件包都被视为一个纯函数的输出，这个输出是 /nix/store/ 下一个带有哈希值的目录。

我明白上面的说法对许多人来说太过抽象，所以我又准备了例子。

/nix/store/ 下的哈希路径是根据软件包的表达式（描述打包的 Nix 文件）和构建过程（参与构建的参数）来计算出来的。每个软件包都有一个唯一的标识符，它由一个哈希值和一个包名组成，例如：

/nix/store/7wzgkjk6l9ng015wnx7dbzq73v4yr97g-nyancat-1.5.2
-

其中，7wzgkjk6l9ng015wnx7dbzq73v4yr97g 是一个 160 位的 SHA-256 哈希值，它是根据软件包的表达式和构建过程的所有输入参数计算出来的。这些输入参数包括：

  • 源码或二进制文件的 URL 和哈希值
  • 版本号和包名
  • 依赖关系和构建工具
  • 编译命令和参数
  • 补丁和修改
  • 元数据和测试

这些输入参数都会被转换成一个 Nix 语言的表达式，然后被序列化成一个字符串，再用 SHA-256 算法计算出一个哈希值。这个哈希值可以保证软件包的一致性和可复现性，因为只要输入参数不变，就会得到相同的哈希值和相同的软件包。

纯函数：唯一的输入有确定的唯一的输出，函数求值不依赖外部也不影响外部
纯函数：唯一的输入有确定的唯一的输出，函数求值不依赖外部也不影响外部

而哈希路径下的文件夹存放着软件包的所有文件，包括可执行文件、库文件、配置文件、文档文件等。这些文件都存放在 /nix/store/ 目录下，而不是在系统的其他目录下，例如 /usr/bin/ 或 /bin/ 等。这样每个软件包之间都是隔离的，管理也是异常方便。

',15),k=e("p",null,"即使是这样，还是没有解决编译时间久的问题。于是社区提供了许多缓存构建主机，包管理器会优先从上面下载已有的构建结果。除非访问完了缓存主机列表也没找到需要的二进制缓存，才会自己拉取源码构建。",-1);function A(D,T){const o=n("ExternalLinkIcon"),r=n("Mermaid");return s(),p("div",null,[u,e("div",h,[b,e("p",null,[t("还存在一个 "),e("a",x,[t("Linux 时间线项目"),i(o)]),t("，你可以看到宏观的 Linux 衍生历史。")])]),_,f,y,v,e("p",null,[t("为了让这个解释更生动点，我在"),e("a",N,[t("这里"),i(o)]),t("超链接了一个 ebuild 文件，你可以试图理解其中内容。")]),P,i(r,{id:"mermaid-142",code:"eJyNjzsKwkAURftZxdTCNJYprNyFWKQQEbTRYK2ioPgL+EUHtVAR8Y9oyPjZzLyZZBdGg0Jsku7BPe9wLyEEaSktnVCwmC5E7WHTgjiW5KgMjQp6pyinqVoimlKTWTVD8mGEMI6F4piQCBbDPehLoCtBN0APsB2+70kZmClZR0yow/oyH5Nd0LmxtnZPe7DjZsN6jqF6kbeOg3ODCWoqmBtN9zmQ9GOFW092v8z1JFnbJZ15HljBP7NvEXd4vQbtvjB1OSty1oL52fV5WwZzcaNu3e9/+a/RCzRrAOM=",title:"eJx7Nn/ps859L+c0PNvY9HxWy9OeVgB6Twxx"}),k])}const z=c(m,[["render",A],["__file","BinaryAndSourceDistribution.html.vue"]]),B=JSON.parse('{"path":"/tutorials/concept/BinaryAndSourceDistribution.html","title":"二进制分发与源码分发","lang":"zh-CN","frontmatter":{"description":"二进制分发与源码分发 二进制分发从字面意思上就很容易理解，软件包仓库开放预编译的二进制包，并供包管理器下载并部署到目标主机。 源码分发则是从各处拉取源码，下载编译，再部署到目标主机。看起来只是将编译步骤挪到了本地进行而已，但却给了软件包部署更多灵活性。 以 Debian 作为二进制分发的例子 Debian 是 GNU/Linux 世界中采用二进制分发的...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/concept/BinaryAndSourceDistribution.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"二进制分发与源码分发"}],["meta",{"property":"og:description","content":"二进制分发与源码分发 二进制分发从字面意思上就很容易理解，软件包仓库开放预编译的二进制包，并供包管理器下载并部署到目标主机。 源码分发则是从各处拉取源码，下载编译，再部署到目标主机。看起来只是将编译步骤挪到了本地进行而已，但却给了软件包部署更多灵活性。 以 Debian 作为二进制分发的例子 Debian 是 GNU/Linux 世界中采用二进制分发的..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:image","content":"https://nixos-cn.github.io/images/Concept/Apt.svg"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2023-10-14T04:45:25.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2023-10-14T04:45:25.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"二进制分发与源码分发\\",\\"image\\":[\\"https://nixos-cn.github.io/images/Concept/Apt.svg\\",\\"https://nixos-cn.github.io/images/Concept/Portage.svg\\",\\"https://nixos-cn.github.io/images/Concept/HashPath.svg\\"],\\"dateModified\\":\\"2023-10-14T04:45:25.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"以 Debian 作为二进制分发的例子","slug":"以-debian-作为二进制分发的例子","link":"#以-debian-作为二进制分发的例子","children":[]},{"level":2,"title":"以 Gentoo 作为源码分发的例子","slug":"以-gentoo-作为源码分发的例子","link":"#以-gentoo-作为源码分发的例子","children":[]},{"level":2,"title":"Nix 之道","slug":"nix-之道","link":"#nix-之道","children":[]}],"git":{"createdTime":1696961467000,"updatedTime":1697258725000,"contributors":[{"name":"OpenTritium","email":"tritium404@hotmail.com","commits":3}]},"readingTime":{"minutes":5.47,"words":1642},"filePathRelative":"tutorials/concept/BinaryAndSourceDistribution.md","localizedDate":"2023年10月10日","autoDesc":true,"excerpt":"\\n

二进制分发从字面意思上就很容易理解，软件包仓库开放预编译的二进制包，并供包管理器下载并部署到目标主机。

\\n

源码分发则是从各处拉取源码，下载编译，再部署到目标主机。看起来只是将编译步骤挪到了本地进行而已，但却给了软件包部署更多灵活性。

\\n

以 Debian 作为二进制分发的例子

\\n

Debian 是 GNU/Linux 世界中采用二进制分发的优秀发行版之一，APT 则是它最流行的包管理器之一。

\\n
\\"APT包管理器\\"
APT包管理器
"}');export{z as comp,B as data}; diff --git a/assets/BinaryAndSourceDistribution.html-C-rtSMVZ.js b/assets/BinaryAndSourceDistribution.html-C-rtSMVZ.js new file mode 100644 index 0000000..3811c27 --- /dev/null +++ b/assets/BinaryAndSourceDistribution.html-C-rtSMVZ.js @@ -0,0 +1,2 @@ +import{_ as c}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as n,o as s,c as p,a as e,b as t,d as i,e as a}from"./app-BNkVxcYY.js";const l="/images/Concept/Apt.svg",d="/images/Concept/Portage.svg",g="/images/Concept/HashPath.svg",m={},u=a('

二进制分发与源码分发

二进制分发从字面意思上就很容易理解，软件包仓库开放预编译的二进制包，并供包管理器下载并部署到目标主机。

源码分发则是从各处拉取源码，下载编译，再部署到目标主机。看起来只是将编译步骤挪到了本地进行而已，但却给了软件包部署更多灵活性。

以 Debian 作为二进制分发的例子

Debian 是 GNU/Linux 世界中采用二进制分发的优秀发行版之一，APT 则是它最流行的包管理器之一。

APT包管理器
APT包管理器

为了从远程获取预编译的二进制包，APT 需要从三个地方读取源列表：

  • /etc/apt/sources.list
  • /etc/apt/sources.list.d/*.list
  • /etc/apt/sources.list.d/*.source

然后访问源列表里面的 URL ，获取软件包的元数据（名称，版本，依赖信息等）。这些元数据通常被存储在 /var/lib/apt/lists/。

只要有元数据的协助，APT 很快就能推算出你要下载的包依赖哪些其他的包，并从软件包仓库开始下载需要的一揽子软件包。这些包被缓存到 /var/cache/apt/archives/。

Deb 包里面只会包含二进制文件，以及控制这些二进制文件该释放至何处的描述文件。假如你想对这个软件包搞点个性化定制，自己再克隆源码，修改源码，编译和打包一条龙。你不能从官方包仓库的软件包直接衍生变体。

不同的打包方式带来了 Linux 软件包生态的分裂。你从 Debian 系发行版和 RHEL 系发行版就能观察到 “血脉兼容” 的现象。

',12),h={href:"https://github.com/FabioLolix/LinuxTimeline",target:"_blank",rel:"noopener noreferrer"},b=e("h2",{id:"以-gentoo-作为源码分发的例子",tabindex:"-1"},[e("a",{class:"header-anchor",href:"#以-gentoo-作为源码分发的例子"},[e("span",null,"以 Gentoo 作为源码分发的例子")])],-1),x=e("p",null,[t("Gentoo 似乎是另一个极端。它的包管理器叫做 Portage，它从官方的软件仓库获取的是 ebuild 文件，而这些文件会被缓存到 "),e("code",null,"/var/db/repos/gentoo/"),t(" 下。")],-1),_=e("p",null,"你可以将 ebuild 理解为一种构建软件的脚本。它包含了一些函数和变量，用来指定软件包的元数据、依赖关系、源码地址、编译选项、安装步骤等信息。Portage 会根据 ebuild 中的指令来下载、编译和安装软件包。",-1),y=e("figure",null,[e("img",{src:d,alt:"Portage 包管理器",tabindex:"0",loading:"lazy"}),e("figcaption",null,"Portage 包管理器")],-1),f={href:"https://gitweb.gentoo.org/repo/gentoo.git/tree/app-editors/neovim/neovim-9999.ebuild",target:"_blank",rel:"noopener noreferrer"},v=a(`

获取到源码以后，Portage 开始了繁忙的编译流程。它需要读取一些编译变量，而它们在 /etc/portage/make.conf 这个配置文件里。 其中包括全局的 USE 标志、编译选项、镜像源、许可证等。这些变量可以控制 Portage 的功能和性能，也可以根据用户的需求进行优化和定制。

每一台 Gentoo 主机都可能有不同的编译选项，因此编译出来的产物也不一致，它们已经是一种变体了。

另外，许多人喜欢 Gentoo 的原因就是可以更极致地压榨运行性能。但是频繁的编译是相当耗费时间的。后面 Gentoo 又支持了分布式编译，可以让你的其他电脑分担工作量，不过依然是饮鸠止渴。

Nix 之道

Nix 是 NixOS 的包管理器，它是跨平台的，可以在 Linux 平台和 Darwin 平台使用。

二进制分发可以保持包的一致性，使本应正常依赖的包可以正常工作（不过需要包管理器控制版本）；源码分发可以保持包的灵活性，可以自由拓展软件功能，衍生软件变体。有什么办法可以鱼与熊掌兼得呢？

Nix 则使用一种函数式语言来描述软件包及其依赖关系，每个软件包都被视为一个纯函数的输出，这个输出是 /nix/store/ 下一个带有哈希值的目录。

我明白上面的说法对许多人来说太过抽象，所以我又准备了例子。

/nix/store/ 下的哈希路径是根据软件包的表达式（描述打包的 Nix 文件）和构建过程（参与构建的参数）来计算出来的。每个软件包都有一个唯一的标识符，它由一个哈希值和一个包名组成，例如：

/nix/store/7wzgkjk6l9ng015wnx7dbzq73v4yr97g-nyancat-1.5.2
+

其中，7wzgkjk6l9ng015wnx7dbzq73v4yr97g 是一个 160 位的 SHA-256 哈希值，它是根据软件包的表达式和构建过程的所有输入参数计算出来的。这些输入参数包括：

  • 源码或二进制文件的 URL 和哈希值
  • 版本号和包名
  • 依赖关系和构建工具
  • 编译命令和参数
  • 补丁和修改
  • 元数据和测试

这些输入参数都会被转换成一个 Nix 语言的表达式，然后被序列化成一个字符串，再用 SHA-256 算法计算出一个哈希值。这个哈希值可以保证软件包的一致性和可复现性，因为只要输入参数不变，就会得到相同的哈希值和相同的软件包。

纯函数：唯一的输入有确定的唯一的输出，函数求值不依赖外部也不影响外部
纯函数：唯一的输入有确定的唯一的输出，函数求值不依赖外部也不影响外部

而哈希路径下的文件夹存放着软件包的所有文件，包括可执行文件、库文件、配置文件、文档文件等。这些文件都存放在 /nix/store/ 目录下，而不是在系统的其他目录下，例如 /usr/bin/ 或 /bin/ 等。这样每个软件包之间都是隔离的，管理也是异常方便。

',15),N=e("p",null,"即使是这样，还是没有解决编译时间久的问题。于是社区提供了许多缓存构建主机，包管理器会优先从上面下载已有的构建结果。除非访问完了缓存主机列表也没找到需要的二进制缓存，才会自己拉取源码构建。",-1);function P(k,A){const o=n("ExternalLinkIcon"),r=n("Mermaid");return s(),p("div",null,[u,e("p",null,[t("::: tip还存在一个 "),e("a",h,[t("Linux 时间线项目"),i(o)]),t("，你可以看到宏观的 Linux 衍生历史。:::")]),b,x,_,y,e("p",null,[t("为了让这个解释更生动点，我在"),e("a",f,[t("这里"),i(o)]),t("超链接了一个 ebuild 文件，你可以试图理解其中内容。")]),v,i(r,{id:"mermaid-140",code:"eJyNjzsKwkAURftZxdTCNJYprNyFWKQQEbTRYK2ioPgL+EUHtVAR8Y9oyPjZzLyZZBdGg0Jsku7BPe9wLyEEaSktnVCwmC5E7WHTgjiW5KgMjQp6pyinqVoimlKTWTVD8mGEMI6F4piQCBbDPehLoCtBN0APsB2+70kZmClZR0yow/oyH5Nd0LmxtnZPe7DjZsN6jqF6kbeOg3ODCWoqmBtN9zmQ9GOFW092v8z1JFnbJZ15HljBP7NvEXd4vQbtvjB1OSty1oL52fV5WwZzcaNu3e9/+a/RCzRrAOM=",title:"eJx7Nn/ps859L+c0PNvY9HxWy9OeVgB6Twxx"}),N])}const L=c(m,[["render",P],["__file","BinaryAndSourceDistribution.html.vue"]]),C=JSON.parse('{"path":"/tutorials/concept/BinaryAndSourceDistribution.html","title":"二进制分发与源码分发","lang":"zh-CN","frontmatter":{"description":"二进制分发与源码分发 二进制分发从字面意思上就很容易理解，软件包仓库开放预编译的二进制包，并供包管理器下载并部署到目标主机。 源码分发则是从各处拉取源码，下载编译，再部署到目标主机。看起来只是将编译步骤挪到了本地进行而已，但却给了软件包部署更多灵活性。 以 Debian 作为二进制分发的例子 Debian 是 GNU/Linux 世界中采用二进制分发的...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/concept/BinaryAndSourceDistribution.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"二进制分发与源码分发"}],["meta",{"property":"og:description","content":"二进制分发与源码分发 二进制分发从字面意思上就很容易理解，软件包仓库开放预编译的二进制包，并供包管理器下载并部署到目标主机。 源码分发则是从各处拉取源码，下载编译，再部署到目标主机。看起来只是将编译步骤挪到了本地进行而已，但却给了软件包部署更多灵活性。 以 Debian 作为二进制分发的例子 Debian 是 GNU/Linux 世界中采用二进制分发的..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:image","content":"https://nixos-cn.github.io/images/Concept/Apt.svg"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2024-06-30T15:34:48.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2024-06-30T15:34:48.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"二进制分发与源码分发\\",\\"image\\":[\\"https://nixos-cn.github.io/images/Concept/Apt.svg\\",\\"https://nixos-cn.github.io/images/Concept/Portage.svg\\",\\"https://nixos-cn.github.io/images/Concept/HashPath.svg\\"],\\"dateModified\\":\\"2024-06-30T15:34:48.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"以 Debian 作为二进制分发的例子","slug":"以-debian-作为二进制分发的例子","link":"#以-debian-作为二进制分发的例子","children":[]},{"level":2,"title":"以 Gentoo 作为源码分发的例子","slug":"以-gentoo-作为源码分发的例子","link":"#以-gentoo-作为源码分发的例子","children":[]},{"level":2,"title":"Nix 之道","slug":"nix-之道","link":"#nix-之道","children":[]}],"git":{"createdTime":1696961467000,"updatedTime":1719761688000,"contributors":[{"name":"OpenTritium","email":"tritium404@hotmail.com","commits":3},{"name":"Ryan Yin","email":"xiaoyin_c@qq.com","commits":1}]},"readingTime":{"minutes":5.47,"words":1642},"filePathRelative":"tutorials/concept/BinaryAndSourceDistribution.md","localizedDate":"2023年10月10日","autoDesc":true,"excerpt":"\\n

二进制分发从字面意思上就很容易理解，软件包仓库开放预编译的二进制包，并供包管理器下载并部署到目标主机。

\\n

源码分发则是从各处拉取源码，下载编译，再部署到目标主机。看起来只是将编译步骤挪到了本地进行而已，但却给了软件包部署更多灵活性。

\\n

以 Debian 作为二进制分发的例子

\\n

Debian 是 GNU/Linux 世界中采用二进制分发的优秀发行版之一，APT 则是它最流行的包管理器之一。

\\n
\\"APT包管理器\\"
APT包管理器
"}');export{L as comp,C as data}; diff --git a/assets/Configuration.html-C5G2PvFv.js b/assets/Configuration.html-CE9jQ0tW.js similarity index 57% rename from assets/Configuration.html-C5G2PvFv.js rename to assets/Configuration.html-CE9jQ0tW.js index 65d0d47..720b2d0 100644 --- a/assets/Configuration.html-C5G2PvFv.js +++ b/assets/Configuration.html-CE9jQ0tW.js @@ -1,31 +1,30 @@ -import{_ as p}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as i,o,c,a,b as n,d as t,e as s}from"./app-KtH3BPxJ.js";const l={},d=s(`

NixOS 配置

内容施工中

本节内容正在修缮中，当前内容可能已经过时，仅供参考。

包管理

这一节我们会讨论如何为你的系统添加额外的包。NixOS 包管理的方式有两种：

  • 配置文件声明。你可以在配置文件为系统或用户声明需要安装的包，每次你重新生成系统，NixOS 都会确保本地包含了你指定的这些包。这是持久的。

  • 非持久环境。使用 nix-env 管理软件包安装，升级与卸载。这种方式允许不同软件仓库频道版本的包共存。这也是非 root 用户唯一安装软件包的方式。

声明式包管理

在 configuration.nix 中， 提供用于声明系统环境包含的包的 environment.systemPackages 数组：

environment.systemPackages = [ pkgs.firefox ];  # 将来源于 pkgs(Nixpkgs) 的包安装到系统
-

配置文件并不是实时生效的 。你需要运行 sudo nixos-rebuild switch 来生成当前配置文件描述的系统。

`,9),u={class:"hint-container note"},r=a("p",{class:"hint-container-title"},"依赖配置",-1),v={href:"https://nixos.org/manual/nixos/stable/options.html",target:"_blank",rel:"noopener noreferrer"},k=s(`

你可以使用以下命令获取在线包仓库中可用的软件包的列表：

$ nix-env -qaP '*' --description
+import{_ as p}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as o,o as i,c,a as n,b as a,d as t,e as s}from"./app-BNkVxcYY.js";const l={},d=n("h1",{id:"nixos-配置",tabindex:"-1"},[n("a",{class:"header-anchor",href:"#nixos-配置"},[n("span",null,"NixOS 配置")])],-1),r={class:"hint-container warning"},u=s(`
内容施工中本节内容正在修缮中，当前内容可能已经过时，仅供参考。:::
包管理
这一节我们会讨论如何为你的系统添加额外的包。NixOS 包管理的方式有两种：
  • 配置文件声明。你可以在配置文件为系统或用户声明需要安装的包，每次你重新生成系统，NixOS 都会确保本地包含了你指定的这些包。这是持久的。
  • 非持久环境。使用 nix-env 管理软件包安装，升级与卸载。这种方式允许不同软件仓库频道版本的包共存。这也是非 root 用户唯一安装软件包的方式。
声明式包管理
在 configuration.nix 中， 提供用于声明系统环境包含的包的 environment.systemPackages 数组：
environment.systemPackages = [ pkgs.firefox ];  # 将来源于 pkgs(Nixpkgs) 的包安装到系统
+
配置文件并不是实时生效的 。你需要运行 sudo nixos-rebuild switch 来生成当前配置文件描述的系统。
`,8),k={class:"hint-container note"},v=n("p",{class:"hint-container-title"},"依赖配置对于某些包（例如依赖 D-Bus 或 systemd 服务注册的包），仅仅是安",-1),m={href:"https://nixos.org/manual/nixos/stable/options.html",target:"_blank",rel:"noopener noreferrer"},g=s(`
你可以使用以下命令获取在线包仓库中可用的软件包的列表：
$ nix-env -qaP '*' --description
 nixos.firefox   firefox-23.0   Mozilla Firefox - the browser, reloaded
 ...
-
通常会输出很多行可以获取的包的信息。第一列输出是属性名（例如nixos.firefox）。
前缀
nixos 前缀表明当前包是从 nixos 频道获取的。
如果你想卸载这个包，修改配置后重新生成系统即可。
定制软件包
一些软件包会提供一些禁用或启用功能，更改一些特性的选项。例如 Firefox 插件捆绑包（会额外提供一些诸如 Adobe Flash Player 的插件）会提供一个启用 Google Talk 的选项，如此配置便可以：
nixpkgs.config.firefox.enableGoogleTalkPlugin = true;
-
难以查询
遗憾的是，Nixpkgs 依然无法提供一种简易查询这些选项的方式。
除了高阶选项外，你还可以以几乎任意方式调整软件包，例如更改或禁用软件包的依赖项。例如，Nixpkgs 中的 Emacs 软件包默认依赖于 GTK 2。如果你想将其构建为使用 GTK 3 的软件包，可以按如下方式指定：
environment.systemPackages = [ (pkgs.emacs.override { gtk = pkgs.gtk3; }) ];
-
我们使用了 override 函数指定了用户定义的参数，意味着我们覆写了一部分原本的参数，构建的包也因此改变了。让我们来细看这个语句，gtk 默认是接受 pkgs.gtk2 参数的，我们使用 pkgs.gtk3 作输入的时候，默认参数已经失效了，于是构建出来的包是依赖 GTK 3 的了。
运算优先级
圆括号是必要的，因为在 Nix 语言中，列表构造优先级高于函数。如果不使用括号，列表将会认为它接收了两个元素。
我们还可以使用 overrideAttrs 函数做出更多定制。override 函数的机制是覆写了包输入函数的参数，而 overrideAttrs 允许覆写传递给 mkDerivation 的属性。如此你几乎能修改这个包的方方面面，甚至包括源码。如果你想覆写源码输入，可以这样做：
environment.systemPackages = [
+
通常会输出很多行可以获取的包的信息。第一列输出是属性名（例如nixos.firefox）。
`,3),x={class:"hint-container note"},h=s('
前缀 `nixos` 前缀表明当前包是从 `nixos` 频道获取的。:::
如果你想卸载这个包，修改配置后重新生成系统即可。
定制软件包
一些软件包会提供一些禁用或启用功能，更改一些特性的选项。例如 Firefox 插件捆绑包（会额外提供一些诸如 Adobe Flash Player 的插件）会提供一个启用 Google Talk 的选项，如此配置便可以：
nixpkgs.config.firefox.enableGoogleTalkPlugin = true;\n
',5),b={class:"hint-container warning"},f=s(`
难以查询遗憾的是，Nixpkgs 依然无法提供一种简易查询这些选项的方
式。:::
除了高阶选项外，你还可以以几乎任意方式调整软件包，例如更改或禁用软件包的依赖项。例如，Nixpkgs 中的 Emacs 软件包默认依赖于 GTK 2。如果你想将其构建为使用 GTK 3 的软件包，可以按如下方式指定：
environment.systemPackages = [ (pkgs.emacs.override { gtk = pkgs.gtk3; }) ];
+
我们使用了 override 函数指定了用户定义的参数，意味着我们覆写了一部分原本的参数，构建的包也因此改变了。让我们来细看这个语句，gtk 默认是接受 pkgs.gtk2 参数的，我们使用 pkgs.gtk3 作输入的时候，默认参数已经失效了，于是构建出来的包是依赖 GTK 3 的了。
`,5),_={class:"hint-container warning"},y=s(`
运算优先级圆括号是必要的，因为在 Nix 语言中，列表构造优先级高于函
数。如果不使用括号，列表将会认为它接收了两个元素。:::
我们还可以使用 overrideAttrs 函数做出更多定制。override 函数的机制是覆写了包输入函数的参数，而 overrideAttrs 允许覆写传递给 mkDerivation 的属性。如此你几乎能修改这个包的方方面面，甚至包括源码。如果你想覆写源码输入，可以这样做：
environment.systemPackages = [
   (pkgs.emacs.overrideAttrs (oldAttrs: {
     name = "emacs-25.0-pre";
     src = /path/to/my/emacs/tree;  # 你的源码目录
   }))
 ];
-
在这里，pkgs.emacs 被衍生出了一个重新调用 stdenv.mkDerivation 并替换了 name 和 src 属性的版本。然后 overrideAttrs 接收了这个衍生，成为了目前系统环境的 emacs 包。
添加自定义包
使用 Nix 语言构建
使用预构建文件
大多数可执行文件都不能在 NixOS 上直接工作，但是将依赖一起打包的容器格式就可以，常见的容器格式有 flatpaks 和 AppImages 等。
非持久包管理（Ad-Hoc 包管理）
这种方式不持久是相对于声明式包管理的。声明式包管理可以保证系统的一致性和可复制性，所以是持久的。不过 Ad-Hoc 方式非常灵活。
Ad-Hoc
这个词语的起源是拉丁语，意思是“为此”。它通常表示一种针对特定目的，问题或任务的解决方案，而不是一种可以适用于其他情况的通用解决方案。例如，一个政府为了解决一个具体问题而设立的委员会就是一个 ad-hoc 委员会。更宽松地说，它也可以意味着“自发的”，“未计划的”或“即兴的”。
在 nixos 中，Ad-Hoc 的意义是指可以在一个临时的 shell 环境中使用任何用 nix 打包的程序，而不需要永久地安装它。这样可以方便地创建和使用开发环境，而不影响系统的状态。
通过 nix-env 命令，你可以像常规发行版那样使用命令安装软件：
nix-env -iA nixos.thunderbird
-
如果以 root 权限执行此语句，软件包将会被安装到 /nix/var/nix/profiles/default，并且对所有用户可见。如果你是普通用户，软件包将会安装到 /nix/var/nix/profiles/per-user/username/profile，并且仅对当前用户可见。-A 参数指定了软件包所属的属性，如果不带属性，直接匹配 thunderbird 速度会较慢，同时也可能匹配到多个名称相同的包，产生歧义。
假设我们需要更新的包来自于系统频道，我们可以先更新系统频道，然后重新安装或更新指定包：
nix-channel --update nixos  # 更新系统频道
+
在这里，pkgs.emacs 被衍生出了一个重新调用 stdenv.mkDerivation 并替换了 name 和 src 属性的版本。然后 overrideAttrs 接收了这个衍生，成为了目前系统环境的 emacs 包。
添加自定义包
使用 Nix 语言构建
使用预构建文件
大多数可执行文件都不能在 NixOS 上直接工作，但是将依赖一起打包的容器格式就可以，常见的容器格式有 flatpaks 和 AppImages 等。
非持久包管理（Ad-Hoc 包管理）
这种方式不持久是相对于声明式包管理的。声明式包管理可以保证系统的一致性和可复制性，所以是持久的。不过 Ad-Hoc 方式非常灵活。
`,11),q={class:"hint-container tip"},w=s(`
Ad-Hoc这个词语的起源是拉丁语，意思是“为此”。它通常表示一种针对特定目的，
问题或任务的解决方案，而不是一种可以适用于其他情况的通用解决方案。例如，一个政府为了解决一个具体问题而设立的委员会就是一个 ad-hoc 委员会。更宽松地说，它也可以意味着“自发的”，“未计划的”或“即兴的”。
在 nixos 中，Ad-Hoc 的意义是指可以在一个临时的 shell 环境中使用任何用 nix 打包的程序，而不需要永久地安装它。这样可以方便地创建和使用开发环境，而不影响系统的状态。:::
通过 nix-env 命令，你可以像常规发行版那样使用命令安装软件：
nix-env -iA nixos.thunderbird
+
如果以 root 权限执行此语句，软件包将会被安装到 /nix/var/nix/profiles/default，并且对所有用户可见。如果你是普通用户，软件包将会安装到/nix/var/nix/profiles/per-user/username/profile，并且仅对当前用户可见。-A 参数指定了软件包所属的属性，如果不带属性，直接匹配 thunderbird 速度会较慢，同时也可能匹配到多个名称相同的包，产生歧义。
假设我们需要更新的包来自于系统频道，我们可以先更新系统频道，然后重新安装或更新指定包：
nix-channel --update nixos  # 更新系统频道
 nix-env -iA nixos.thunderbird  # 再次安装时，此包会被替换为最新版
 
上面的语句可以指定另外的频道，从而用不同频道的包去代替当前包。如果你想用当前包默认的来源升级包，尝试这样做：
nix-channel --update nixos
 nix-env -u thunderbird
 
如果你想升级所有包，可以这样：
nix-env -u '*'
 
但是需要注意， 它并不会升级系统配置中描述的包 ，那些包由 nixos-rebuild switch 命令管理。
如果你想更新那些包， nixos-rebuild switch --upgrade 即可，它会自动更新频道并更新系统生成。
如果你想卸载使用命令安装的包，使用以下命令：
nix-env -e thunderbird
 
此外，用户环境的状态是可以回滚的：
nix-env --rollback
-
`,38),m={href:"https://nixos.org/manual/nix/unstable/command-ref/nix-env.html",target:"_blank",rel:"noopener noreferrer"},g=s(`
用户管理
类似的，NixOS 支持声明式用户管理和命令行用户管理。
声明式用户管理
我们以下面的例子说明声明式用户管理的大致细节：
users.users.alice = {
+
`,18),N={href:"https://nixos.org/manual/nix/unstable/command-ref/nix-env.html",target:"_blank",rel:"noopener noreferrer"},A=s(`
用户管理
类似的，NixOS 支持声明式用户管理和命令行用户管理。
声明式用户管理
我们以下面的例子说明声明式用户管理的大致细节：
users.users.alice = {
   isNormalUser = true;
   home = "/home/alice";
   description = "Alice Foobar";
   extraGroups = [ "wheel" "networkmanager" ];
   openssh.authorizedKeys.keys = [ "ssh-dss AAAAB3Nza... alice@foobar" ];
 };
-
根据描述，该用户加入了 wheel 组，意味着它可以使用 sudo 命令提权，此外它还加入了 networkmanager 组，意味着该用户可以配置网络。不过这样创建出来的用户是没有初始密码的，你仍需要使用 passwd 命令为其分配密码， 每次重新生成系统的时候不会影响到密码的状态 。对于 ssh 连接，你可以指定认证密钥，只要公钥与私钥匹配就能连接。
`,6),b=a("code",null,"users.mutableUsers",-1),x=a("code",null,"False",-1),h=a("code",null,"/etc/passwd",-1),f=a("code",null,"/etc/group",-1),q={href:"https://nixos.org/manual/nixos/stable/options.html#opt-users.users._name_.hashedPassword",target:"_blank",rel:"noopener noreferrer"},y=a("code",null,"hashedPassword",-1),_=s(`
用户 uid 是自动分配的，不过你也可以自行指定：
uid = 1000;
+
根据描述，该用户加入了 wheel 组，意味着它可以使用 sudo 命令提权，此外它还加入了 networkmanager 组，意味着该用户可以配置网络。不过这样创建出来的用户是没有初始密码的，你仍需要使用 passwd 命令为其分配密码， 每次重新生成系统的时候不会影响到密码的状态 。对于 ssh 连接，你可以指定认证密钥，只要公钥与私钥匹配就能连接。
`,6),S=n("code",null,"users.mutableUsers",-1),D=n("code",null,"False",-1),O=n("code",null,"/etc/passwd",-1),T=n("code",null,"/etc/group",-1),M={href:"https://nixos.org/manual/nixos/stable/options.html#opt-users.users._name_.hashedPassword",target:"_blank",rel:"noopener noreferrer"},I=n("code",null,"hashedPassword",-1),G=s(`
用户 uid 是自动分配的，不过你也可以自行指定：
uid = 1000;
 
gid 分配也是自动的，同样可以用户定义，也是类似的方法：
users.groups.students.gid = 1000;
 
命令行式用户管理
创建一个名为 alice 的用户，-m 参数用于给该用户创建 home 目录：
useradd -m alice
 
为了让 nix 工具集可以为该用户所用，我们还需要给这个用户打开 login shell（加载用户配置的 shell）。这一步会把 ~/.nix-defexpr 链接到该用户的目录，这样该用户才能使用 nix 的一系列命令。
su - alice -c "true"
@@ -36,14 +35,14 @@ Retype new UNIX password: ***
   { device = "/dev/disk/by-label/data";
     fsType = "ext4";
   };
-
这条配置生成 /etc/fstab，系统在开机时会根据这个表文件来挂载分区。
device 不一定要根据 label 来指定，也可以通过 uuid 。
块的 UUID
你可以用下面的方法查看到这些块的 UUID：
tritium@KOVA ~> lsblk -o name,mountpoint,size,uuid
+
这条配置生成 /etc/fstab，系统在开机时会根据这个表文件来挂载分区。
device 不一定要根据 label 来指定，也可以通过 uuid 。
块的 UUID 你可以用下面的方法查看到这些块的 UUID：
tritium@KOVA ~> lsblk -o name,mountpoint,size,uuid
 NAME
     MOUNTPOINT         SIZE UUID
 sda                  363.3M
 sdb [SWAP]               2G 1159b63e-3072-4483-b374-78cd487e6460
 sdc                      1T 8108c250-d488-4724-9237-5d926569fbef
 sdd /mnt/wslg/distro     1T 8677e11d-56ab-4ecb-8dfd-8effb322493f
-
在默认情况下，所有被写在配置的分区都会被自动挂载，除非你指定了 noauto 的选项：
你也可以缺省 fsType 的值，因为它会自动检测文件系统类型。
nofail
如果 fstab 内容有误，系统会在启动时显示令人窒息的急救 Shell。为了避免这种情况，你可以在 option 里加入 nofail 来确保挂载是异步的且不会严重影响启动。
显示系统
X 窗口系统已经是上个世纪八十年代的软件了，冗余的功能拖累了它的性能，因此建议没有特殊需求的用户勇敢试水 Wayland。
X11
X 窗口系统可以提供最基础，成熟（稍微过时）的显示服务，只需要以下配置就能启用：
services.xserver.enable = true;
+
`,18),P=n("p",null,[a("在默认情况下，所有被写在配置的分区都会被自动挂载，除非你指定了 "),n("code",null,"noauto"),a(" 的选项：")],-1),U=n("p",null,[a("你也可以缺省 "),n("code",null,"fsType"),a(" 的值，因为它会自动检测文件系统类型。")],-1),L={class:"hint-container tip"},X=s(`
nofail如果 \`fstab\` 内容有误，系统会在启动时显示令人窒息的急救 Shell。为
了避免这种情况，你可以在 option 里加入 nofail 来确保挂载是异步的且不会严重影响启动。:::
显示系统
X 窗口系统已经是上个世纪八十年代的软件了，冗余的功能拖累了它的性能，因此建议没有特殊需求的用户勇敢试水 Wayland。
X11
X 窗口系统可以提供最基础，成熟（稍微过时）的显示服务，只需要以下配置就能启用：
services.xserver.enable = true;
 
它会自动检测并启用适合的 xorg 驱动，比如 mesa 和 xf86 系列驱动。当然你也可以手动指定：
services.xserver.videoDrivers = [ "r128" ];
 
通过以上配置就启用了 xf86-video-r128 驱动。
然后你应该至少启用一个桌面管理器或窗口管理器。我通常为新手和不喜欢折腾的人推荐桌面管理器，窗口管理器为装逼和喜欢效率的极客所用。
#  挑一个喜欢的吧
 services.xserver.desktopManager.plasma5.enable = true;
@@ -82,10 +81,10 @@ services.xserver.xserver.videoDrivers = [ "amdgpu" ];
 
触控板
笔记本电脑通常会带有触控板，启用配置如下：
services.xserver.libinput.enable = true;
 
这个驱动还有很多可配置的功能，例如关闭“触碰以点击”功能：
services.xserver.libinput.touchpad.tapping = false;
-
废弃的 synaptics 选项
services.xserver.synaptics 选项在 NixOS 17.09 之后的版本中被废弃。
GTK/QT 主题
所有的主题你可以去仓库里找到。如果你想让 QT 和 GTK 的主题一致一些：
qt.enable = true;
+
`,57),E={class:"hint-container note"},K=s(`
废弃的 synaptics 选项 \`services.xserver.synaptics\` 选项在 NixOS 17.09
之后的版本中被废弃。:::
GTK/QT 主题
所有的主题你可以去仓库里找到。如果你想让 QT 和 GTK 的主题一致一些：
qt.enable = true;
 qt.platformTheme = "gtk2";
 qt.style = "gtk2";
-
自定义键盘布局（XKB）
这是一个例子，在这个例子中，我们稍微改造一下美式键盘。我们先创建一个文件 us-greek，放到一个 symbols 文件夹下面，在里面描述自定义的键位：
xkb_symbols "us-greek"
+
自定义键盘布局（XKB）
这是一个例子，在这个例子中，我们稍微改造一下美式键盘。我们先创建一个文件us-greek，放到一个 symbols 文件夹下面，在里面描述自定义的键位：
xkb_symbols "us-greek"
 {
   include "us(basic)"            // 包含基础美式键盘
   include "level3(ralt_switch)"  // 配置右 alt 作为一个第三级开关
@@ -104,7 +103,7 @@ qt.style =
extraLayouts. 后的名称应该与布局名匹配。
但是你要知道，你写的 XKB 布局要是坏的，X 显示系统会崩掉的，所以强烈建议先测试再实装：
nix-shell -p xorg.xkbcomp
 setxkbmap -I/yourpath us-greek -print | xkbcomp -I/yourpath - $DISPLAY
 
你还可以从预置的 XKB 文件获取获取灵感：
echo "$(nix-build --no-out-link '<nixpkgs>' -A xorg.xkeyboardconfig)/etc/X11/xkb/"
-
更改配置以后，你需要注销再登录才能生效。 然后你键入 setxkbmap us-greek 并键入 Alt + a（可能在你的终端不会立马生效）。如果你要更改默认行为，还是配置一下 services.xserver.layout。
一个布局可以拥有除了 xkb_symbols 以外的数个其他组件，比如我们可以为一些键码绑定多媒体功能。我们可以通过使用 pkgs.xorg.xev 来找到中意的按键的码，然后再创建定义：
xkb_keycodes "media"
+
更改配置以后，你需要注销再登录才能生效。 然后你键入 setxkbmap us-greek 并键入 Alt + a（可能在你的终端不会立马生效）。如果你要更改默认行为，还是配置一下services.xserver.layout。
一个布局可以拥有除了 xkb_symbols 以外的数个其他组件，比如我们可以为一些键码绑定多媒体功能。我们可以通过使用 pkgs.xorg.xev 来找到中意的按键的码，然后再创建定义：
xkb_keycodes "media"
 {
  <volUp>   = 123;
  <volDown> = 456;
@@ -121,6 +120,6 @@ setxkbmap -I/yourpath us= /path/to/media-key;
   keycodesFile = /path/to/media-sym;
 };
-
上面的两个自定义目录用于引用上面的两个 nix 模块。
Wayland
`,99),w={href:"http://X.org",target:"_blank",rel:"noopener noreferrer"},N=s(`
X11 在设计之初就分为了服务端与窗口管理器，而一个 Wayland 混成器则类似 X 窗口管理器里内置了 服务端的功能，这样的设计让 Wayland 在本机体验上有了不少的提升。
Sway 是一个支持 Wayland 的窗口管理器，类似的软件还有 Wayfire，Hyprland 等：
programs.sway.enable = true;
+
上面的两个自定义目录用于引用上面的两个 nix 模块。
Wayland
`,24),F={href:"http://X.org",target:"_blank",rel:"noopener noreferrer"},V=s(`
X11 在设计之初就分为了服务端与窗口管理器，而一个 Wayland 混成器则类似 X 窗口管理器里内置了 服务端的功能，这样的设计让 Wayland 在本机体验上有了不少的提升。
Sway 是一个支持 Wayland 的窗口管理器，类似的软件还有 Wayfire，Hyprland 等：
programs.sway.enable = true;
 
如果你使用基于 wlroot 的窗口管理器，并且有共享屏幕或录制屏幕的需求，记得启用的 wlr 对应的 portal。
xdg.portal.wlr.enable = true;
-
与之相关的还有 services.pipewire.enable。
GPU 加速
为了能够流畅的硬件解码视频，加速图形渲染等，我们需要配置一些常见的硬件加速 API。
桌面环境
XFCE
GNOME
KDE
`,12);function A(S,D){const e=i("ExternalLinkIcon");return o(),c("div",null,[d,a("div",u,[r,a("p",null,[n("对于某些包（例如依赖 D-Bus 或 systemd 服务注册的包），仅仅是安装还是不够的，我们需要为它们对系统进行一些配置。你可以访问"),a("a",v,[n("选项列表"),t(e)]),n("来检索需要启用的 NixOS 模块。")])]),k,a("p",null,[n("你可以查阅 "),a("a",m,[n("nix-env 手册页"),t(e)]),n(" 获取更多信息。")]),g,a("p",null,[n("如果你设置 "),b,n(" 为 "),x,n(" ，"),h,n(" 与 "),f,n(" 目录的内容将与配置文件中描述的一致。例如，如果你从配置文件中删除了某位用户，然后重新生成系统，这个用户就真实消失了。同时通过命令行管理用户的方式将失效。不过你仍然可以通过设置用户的 "),a("a",q,[y,t(e)]),n(" 选项来分配密码。")]),_,a("p",null,[n("X11 其实是一种显示协议，"),a("a",w,[n("X.org"),t(e)]),n(" 才是显示服务器。Wayland 作为新生的显示服务器，非常缺乏生态，只能用某些方式才能部分兼容 X11。尽管如此，还是希望所有人能加入 Wayland 的阵营。")]),N])}const T=p(l,[["render",A],["__file","Configuration.html.vue"]]),L=JSON.parse('{"path":"/manual/Configuration.html","title":"NixOS 配置","lang":"zh-CN","frontmatter":{"description":"NixOS 配置 内容施工中 本节内容正在修缮中，当前内容可能已经过时，仅供参考。 包管理 这一节我们会讨论如何为你的系统添加额外的包。NixOS 包管理的方式有两种： 配置文件声明。你可以在配置文件为系统或用户声明需要安装的包，每次你重新生成系统，NixOS 都会确保本地包含了你指定的这些包。这是持久的。 非持久环境。使用 nix-env 管理软件包...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/manual/Configuration.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"NixOS 配置"}],["meta",{"property":"og:description","content":"NixOS 配置 内容施工中 本节内容正在修缮中，当前内容可能已经过时，仅供参考。 包管理 这一节我们会讨论如何为你的系统添加额外的包。NixOS 包管理的方式有两种： 配置文件声明。你可以在配置文件为系统或用户声明需要安装的包，每次你重新生成系统，NixOS 都会确保本地包含了你指定的这些包。这是持久的。 非持久环境。使用 nix-env 管理软件包..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2024-03-26T15:50:25.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2024-03-26T15:50:25.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"NixOS 配置\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2024-03-26T15:50:25.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"包管理","slug":"包管理","link":"#包管理","children":[{"level":3,"title":"声明式包管理","slug":"声明式包管理","link":"#声明式包管理","children":[]},{"level":3,"title":"定制软件包","slug":"定制软件包","link":"#定制软件包","children":[]},{"level":3,"title":"添加自定义包","slug":"添加自定义包","link":"#添加自定义包","children":[]},{"level":3,"title":"非持久包管理（Ad-Hoc 包管理）","slug":"非持久包管理-ad-hoc-包管理","link":"#非持久包管理-ad-hoc-包管理","children":[]}]},{"level":2,"title":"用户管理","slug":"用户管理","link":"#用户管理","children":[{"level":3,"title":"声明式用户管理","slug":"声明式用户管理","link":"#声明式用户管理","children":[]},{"level":3,"title":"命令行式用户管理","slug":"命令行式用户管理","link":"#命令行式用户管理","children":[]}]},{"level":2,"title":"文件系统","slug":"文件系统","link":"#文件系统","children":[]},{"level":2,"title":"显示系统","slug":"显示系统","link":"#显示系统","children":[{"level":3,"title":"X11","slug":"x11","link":"#x11","children":[]},{"level":3,"title":"Wayland","slug":"wayland","link":"#wayland","children":[]}]},{"level":2,"title":"GPU 加速","slug":"gpu-加速","link":"#gpu-加速","children":[]},{"level":2,"title":"桌面环境","slug":"桌面环境","link":"#桌面环境","children":[{"level":3,"title":"XFCE","slug":"xfce","link":"#xfce","children":[]},{"level":3,"title":"GNOME","slug":"gnome","link":"#gnome","children":[]},{"level":3,"title":"KDE","slug":"kde","link":"#kde","children":[]}]}],"git":{"createdTime":1711468225000,"updatedTime":1711468225000,"contributors":[{"name":"Ryan Yin","email":"xiaoyin_c@qq.com","commits":1}]},"readingTime":{"minutes":14.24,"words":4273},"filePathRelative":"manual/Configuration.md","localizedDate":"2024年3月26日","autoDesc":true,"excerpt":"\\n
\\n
内容施工中
\\n
本节内容正在修缮中，当前内容可能已经过时，仅供参考。
\\n
\\n
包管理
\\n
这一节我们会讨论如何为你的系统添加额外的包。NixOS 包管理的方式有两种：
\\n
    \\n
  • \\n
    配置文件声明。你可以在配置文件为系统或用户声明需要安装的包，每次你重新生成系统，NixOS 都会确保本地包含了你指定的这些包。这是持久的。
    \\n
    • \\n
  • \\n
    非持久环境。使用 nix-env 管理软件包安装，升级与卸载。这种方式允许不同软件仓库频道版本的包共存。这也是非 root 用户唯一安装软件包的方式。
    \\n
    • \\n
"}');export{T as comp,L as data};
+

与之相关的还有 services.pipewire.enable。

GPU 加速

为了能够流畅的硬件解码视频，加速图形渲染等，我们需要配置一些常见的硬件加速 API。

桌面环境

XFCE

GNOME

KDE

`,12);function z(B,C){const e=o("ExternalLinkIcon");return i(),c("div",null,[d,n("div",r,[u,n("div",k,[v,n("p",null,[a("装还是不够的，我们需要为它们对系统进行一些配置。你可以访问"),n("a",m,[a("选项列表"),t(e)]),a("来检索需要启用的 NixOS 模块。:::")]),g,n("div",x,[h,n("div",b,[f,n("div",_,[y,n("div",q,[w,n("p",null,[a("你可以查阅 "),n("a",N,[a("nix-env 手册页"),t(e)]),a("获取更多信息。")]),A,n("p",null,[a("如果你设置 "),S,a(" 为 "),D,a(" ，"),O,a(" 与 "),T,a(" 目录的内容将与配置文件中描述的一致。例如，如果你从配置文件中删除了某位用户，然后重新生成系统，这个用户就真实消失了。同时通过命令行管理用户的方式将失效。不过你仍然可以通过设置用户的"),n("a",M,[I,t(e)]),a(" 选项来分配密码。")]),G])])])])])]),P,U,n("div",L,[X,n("div",E,[K,n("p",null,[a("X11 其实是一种显示协议，"),n("a",F,[a("X.org"),t(e)]),a(" 才是显示服务器。Wayland 作为新生的显示服务器，非常缺乏生态，只能用某些方式才能部分兼容 X11。尽管如此，还是希望所有人能加入 Wayland 的阵营。")]),V])])])}const Z=p(l,[["render",z],["__file","Configuration.html.vue"]]),R=JSON.parse('{"path":"/manual/Configuration.html","title":"NixOS 配置","lang":"zh-CN","frontmatter":{"description":"NixOS 配置 内容施工中本节内容正在修缮中，当前内容可能已经过时，仅供参考。::: 包管理 这一节我们会讨论如何为你的系统添加额外的包。NixOS 包管理的方式有两种： 配置文件声明。你可以在配置文件为系统或用户声明需要安装的包，每次你重新生成系统，NixOS 都会确保本地包含了你指定的这些包。这是持久的。 非持久环境。使用 nix-env 管理软...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/manual/Configuration.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"NixOS 配置"}],["meta",{"property":"og:description","content":"NixOS 配置 内容施工中本节内容正在修缮中，当前内容可能已经过时，仅供参考。::: 包管理 这一节我们会讨论如何为你的系统添加额外的包。NixOS 包管理的方式有两种： 配置文件声明。你可以在配置文件为系统或用户声明需要安装的包，每次你重新生成系统，NixOS 都会确保本地包含了你指定的这些包。这是持久的。 非持久环境。使用 nix-env 管理软..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2024-06-30T15:34:48.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2024-06-30T15:34:48.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"NixOS 配置\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2024-06-30T15:34:48.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[],"git":{"createdTime":1711468225000,"updatedTime":1719761688000,"contributors":[{"name":"Ryan Yin","email":"xiaoyin_c@qq.com","commits":2}]},"readingTime":{"minutes":14.24,"words":4273},"filePathRelative":"manual/Configuration.md","localizedDate":"2024年3月26日","autoDesc":true,"excerpt":"\\n
\\n

内容施工中本节内容正在修缮中，当前内容可能已经过时，仅供参考。:::

\\n

包管理

\\n

这一节我们会讨论如何为你的系统添加额外的包。NixOS 包管理的方式有两种：

\\n
    \\n
  • \\n

    配置文件声明。你可以在配置文件为系统或用户声明需要安装的包，每次你重新生成系统，NixOS 都会确保本地包含了你指定的这些包。这是持久的。

    \\n
    • \\n
  • \\n

    非持久环境。使用 nix-env 管理软件包安装，升级与卸载。这种方式允许不同软件仓库频道版本的包共存。这也是非 root 用户唯一安装软件包的方式。

    \\n
    • \\n
\\n

声明式包管理

\\n

在 configuration.nix 中， 提供用于声明系统环境包含的包的\\nenvironment.systemPackages 数组：

\\n
environment.systemPackages = [ pkgs.firefox ];  # 将来源于 pkgs(Nixpkgs) 的包安装到系统\\n

配置文件并不是实时生效的 。你需要运行 sudo nixos-rebuild switch 来生成当前配置文件描述的系统。

\\n
\\n

依赖配置对于某些包（例如依赖 D-Bus 或 systemd 服务注册的包），仅仅是安

\\n

装还是不够的，我们需要为它们对系统进行一些配置。你可以访问选项列表来检索需要启用的\\nNixOS 模块。:::

\\n

你可以使用以下命令获取在线包仓库中可用的软件包的列表：

\\n
$ nix-env -qaP \'*\' --description\\nnixos.firefox   firefox-23.0   Mozilla Firefox - the browser, reloaded\\n...\\n

通常会输出很多行可以获取的包的信息。第一列输出是属性名（例如nixos.firefox）。

\\n
\\n

前缀 `nixos` 前缀表明当前包是从 `nixos` 频道获取的。:::

\\n

如果你想卸载这个包，修改配置后重新生成系统即可。

\\n

定制软件包

\\n

一些软件包会提供一些禁用或启用功能，更改一些特性的选项。例如 Firefox 插件捆绑包（会额外提供一些诸如 Adobe Flash Player 的插件）会提供一个启用 Google Talk 的选项，如此配置便可以：

\\n
nixpkgs.config.firefox.enableGoogleTalkPlugin = true;\\n
\\n

难以查询遗憾的是，Nixpkgs 依然无法提供一种简易查询这些选项的方

\\n

式。:::

\\n

除了高阶选项外，你还可以以几乎任意方式调整软件包，例如更改或禁用软件包的依赖项。例如，Nixpkgs 中的 Emacs 软件包默认依赖于 GTK 2。如果你想将其构建为使用 GTK 3 的软件包，可以按如下方式指定：

\\n
environment.systemPackages = [ (pkgs.emacs.override { gtk = pkgs.gtk3; }) ];\\n

我们使用了 override 函数指定了用户定义的参数，意味着我们覆写了一部分原本的参数，构建的包也因此改变了。让我们来细看这个语句，gtk 默认是接受 pkgs.gtk2 参数的，我们使用 pkgs.gtk3 作输入的时候，默认参数已经失效了，于是构建出来的包是依赖 GTK 3 的了。

\\n
\\n

运算优先级圆括号是必要的，因为在 Nix 语言中，列表构造优先级高于函

\\n

数。如果不使用括号，列表将会认为它接收了两个元素。:::

\\n

我们还可以使用 overrideAttrs 函数做出更多定制。override 函数的机制是覆写了包输入函数的参数，而 overrideAttrs 允许覆写传递给 mkDerivation 的属性。如此你几乎能修改这个包的方方面面，甚至包括源码。如果你想覆写源码输入，可以这样做：

\\n
environment.systemPackages = [\\n  (pkgs.emacs.overrideAttrs (oldAttrs: {\\n    name = \\"emacs-25.0-pre\\";\\n    src = /path/to/my/emacs/tree;  # 你的源码目录\\n  }))\\n];\\n

在这里，pkgs.emacs 被衍生出了一个重新调用 stdenv.mkDerivation 并替换了\\nname 和 src 属性的版本。然后 overrideAttrs 接收了这个衍生，成为了目前系统环境的 emacs 包。

\\n

添加自定义包

\\n

使用 Nix 语言构建

\\n

使用预构建文件

\\n

大多数可执行文件都不能在 NixOS 上直接工作，但是将依赖一起打包的容器格式就可以，常见的容器格式有 flatpaks 和 AppImages 等。

\\n

非持久包管理（Ad-Hoc 包管理）

\\n

这种方式不持久是相对于声明式包管理的。声明式包管理可以保证系统的一致性和可复制性，所以是持久的。不过 Ad-Hoc 方式非常灵活。

\\n
\\n

Ad-Hoc这个词语的起源是拉丁语，意思是“为此”。它通常表示一种针对特定目的，

\\n

问题或任务的解决方案，而不是一种可以适用于其他情况的通用解决方案。例如，一个政府为了解决一个具体问题而设立的委员会就是一个 ad-hoc 委员会。更宽松地说，它也可以意味着“自发的”，“未计划的”或“即兴的”。

\\n

在 nixos 中，Ad-Hoc 的意义是指可以在一个临时的 shell 环境中使用任何用 nix 打包的程序，而不需要永久地安装它。这样可以方便地创建和使用开发环境，而不影响系统的状态。:::

\\n

通过 nix-env 命令，你可以像常规发行版那样使用命令安装软件：

\\n
nix-env -iA nixos.thunderbird\\n

如果以 root 权限执行此语句，软件包将会被安装到 /nix/var/nix/profiles/default，并且对所有用户可见。如果你是普通用户，软件包将会安装到/nix/var/nix/profiles/per-user/username/profile，并且仅对当前用户可见。-A 参数指定了软件包所属的属性，如果不带属性，直接匹配 thunderbird 速度会较慢，同时也可能匹配到多个名称相同的包，产生歧义。

\\n

假设我们需要更新的包来自于系统频道，我们可以先更新系统频道，然后重新安装或更新指定包：

\\n
nix-channel --update nixos  # 更新系统频道\\nnix-env -iA nixos.thunderbird  # 再次安装时，此包会被替换为最新版\\n

上面的语句可以指定另外的频道，从而用不同频道的包去代替当前包。如果你想用当前包默认的来源升级包，尝试这样做：

\\n
nix-channel --update nixos\\nnix-env -u thunderbird\\n

如果你想升级所有包，可以这样：

\\n
nix-env -u \'*\'\\n

但是需要注意， 它并不会升级系统配置中描述的包 ，那些包由\\nnixos-rebuild switch 命令管理。

\\n

如果你想更新那些包， nixos-rebuild switch --upgrade 即可，它会自动更新频道并更新系统生成。

\\n

如果你想卸载使用命令安装的包，使用以下命令：

\\n
nix-env -e thunderbird\\n

此外，用户环境的状态是可以回滚的：

\\n
nix-env --rollback\\n

你可以查阅\\nnix-env 手册页获取更多信息。

\\n

用户管理

\\n

类似的，NixOS 支持声明式用户管理和命令行用户管理。

\\n

声明式用户管理

\\n

我们以下面的例子说明声明式用户管理的大致细节：

\\n
users.users.alice = {\\n  isNormalUser = true;\\n  home = \\"/home/alice\\";\\n  description = \\"Alice Foobar\\";\\n  extraGroups = [ \\"wheel\\" \\"networkmanager\\" ];\\n  openssh.authorizedKeys.keys = [ \\"ssh-dss AAAAB3Nza... alice@foobar\\" ];\\n};\\n

根据描述，该用户加入了 wheel 组，意味着它可以使用 sudo 命令提权，此外它还加入了 networkmanager 组，意味着该用户可以配置网络。不过这样创建出来的用户是没有初始密码的，你仍需要使用 passwd 命令为其分配密码， 每次重新生成系统的时候不会影响到密码的状态 。对于 ssh 连接，你可以指定认证密钥，只要公钥与私钥匹配就能连接。

\\n

如果你设置 users.mutableUsers 为 False ，/etc/passwd 与 /etc/group 目录的内容将与配置文件中描述的一致。例如，如果你从配置文件中删除了某位用户，然后重新生成系统，这个用户就真实消失了。同时通过命令行管理用户的方式将失效。不过你仍然可以通过设置用户的hashedPassword\\n选项来分配密码。

\\n

用户 uid 是自动分配的，不过你也可以自行指定：

\\n
uid = 1000;\\n

gid 分配也是自动的，同样可以用户定义，也是类似的方法：

\\n
users.groups.students.gid = 1000;\\n

命令行式用户管理

\\n

创建一个名为 alice 的用户，-m 参数用于给该用户创建 home 目录：

\\n
useradd -m alice\\n

为了让 nix 工具集可以为该用户所用，我们还需要给这个用户打开 login shell（加载用户配置的 shell）。这一步会把 ~/.nix-defexpr 链接到该用户的目录，这样该用户才能使用 nix 的一系列命令。

\\n
su - alice -c \\"true\\"\\n

我们还需要为其分配密码，才能登录：

\\n
passwd alice\\nEnter new UNIX password: ***\\nRetype new UNIX password: ***\\n

可以使用 userdel -r alice 删除该用户，-r 参数用于移除该用户的 home 目录。此外还有 usermod，groupadd, groupmod 和 groupdel 可以使用。

\\n

文件系统

\\n

你可以使用 fileSystems 来配置文件系统，然后按照挂载点配置文件系统，分区的参数等等：

\\n
fileSystems.\\"/data\\" =\\n  { device = \\"/dev/disk/by-label/data\\";\\n    fsType = \\"ext4\\";\\n  };\\n

这条配置生成 /etc/fstab，系统在开机时会根据这个表文件来挂载分区。

\\n

device 不一定要根据 label 来指定，也可以通过 uuid 。

\\n
\\n

块的 UUID 你可以用下面的方法查看到这些块的 UUID：

\\n
tritium@KOVA ~> lsblk -o name,mountpoint,size,uuid\\nNAME\\n    MOUNTPOINT         SIZE UUID\\nsda                  363.3M\\nsdb [SWAP]               2G 1159b63e-3072-4483-b374-78cd487e6460\\nsdc                      1T 8108c250-d488-4724-9237-5d926569fbef\\nsdd /mnt/wslg/distro     1T 8677e11d-56ab-4ecb-8dfd-8effb322493f\\n
\\n
\\n
\\n
\\n
\\n
\\n
"}');export{Z as comp,R as data}; diff --git a/assets/ConfigurationIsTheBlueprintOfTheSystem.html-Dttpxv9Y.js b/assets/ConfigurationIsTheBlueprintOfTheSystem.html-Dttpxv9Y.js deleted file mode 100644 index 8dae500..0000000 --- a/assets/ConfigurationIsTheBlueprintOfTheSystem.html-Dttpxv9Y.js +++ /dev/null @@ -1 +0,0 @@ -import{_ as i}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as o,o as n,c as a,d as r,e as s,a as e}from"./app-KtH3BPxJ.js";const p={},c=s('

配置是一幅描绘系统的蓝图

如果你尝试修改过 NixOS 的配置文件，你就会明白配置文件中书写的内容实际上是你希望下次生成的系统。我们相信这是广大 NixOS 新手的基本认知。

中心化的配置文件带来管理的便捷

既然是根据配置文件生成系统，我们肯定希望配置文件是集中的，而不是零零散散的 dotfiles。它最好使用统一的语法描述，而不是 XML、YAML、TOML、json 等各种格式。而 NixOS 正是使用 Nix 语言来抹平这道沟壑。

Nix 文件就是使用 Nix 语言编写的源码文件，它们可以互相导入（就像常见的脚本一样），你可以将它们当作项目一样去组织。

依赖计算

我们通常会在配置文件里自定义某个软件的选项，从而不自觉地引入了包。声明式配置带来的好处之一就是所有的包和依赖都是确定的，配置文件不再仅仅是单纯的源码，还是一个关系图。

',7),l=e("p",null,"因为配置使用了 Nix 语言，打包也使用了 Nix 语言，Nix 包管理器能够全程参与计算。我们将软件构建任务抽象成一个结点，软件构建往往会有其他依赖，若干结点构成了图，Nix 只需要保证这个关系图是有向无环的。",-1),d=e("div",{class:"hint-container tip"},[e("p",{class:"hint-container-title"},"提示"),e("p",null,"保证无环是为了让 Nix 能够有明确的构建顺序，使之能够并行构建，并且解决循环依赖的问题。")],-1),m=e("p",null,"在 NixOS 中你需要执行生成命令，才会重新计算依赖，生成新生代（新状态）。",-1);function h(x,u){const t=o("Mermaid");return n(),a("div",null,[c,r(t,{id:"mermaid-21",code:"eJxl0dFOwjAUBuB7n2Iv0BsfwESdCIoiOhVzwsVZV0pjN5quC7CnZ5zTQAm763f+tX9a7dGtsyK/yYbvHqxput0yE+Iue+CFQGfEWmGlfLvkFI0f43hlfL1Fr9JZDtqaUjLlRE8Q+goDpjaClbGq3bdB1ewj8mcw2KBQIe7AOga58aoLxsYeY+IJoLQME4IXwBB8GnkFXbsUpkP3UmK0Kdnb1W/vx5R2WijvNxeTGTiMjWcEH+cSDHPArjKBaU70GQ8VjU6TX1D2xt2mVID0KP+HOGtB+g39STj3A9XF+je9dqbFsWmJbXyeBeEf1z8AyaGFMw=="}),l,d,m])}const O=i(p,[["render",h],["__file","ConfigurationIsTheBlueprintOfTheSystem.html.vue"]]),_=JSON.parse('{"path":"/tutorials/concept/ConfigurationIsTheBlueprintOfTheSystem.html","title":"配置是一幅描绘系统的蓝图","lang":"zh-CN","frontmatter":{"description":"配置是一幅描绘系统的蓝图 如果你尝试修改过 NixOS 的配置文件，你就会明白配置文件中书写的内容实际上是你希望下次生成的系统。我们相信这是广大 NixOS 新手的基本认知。 中心化的配置文件带来管理的便捷 既然是根据配置文件生成系统，我们肯定希望配置文件是集中的，而不是零零散散的 dotfiles。它最好使用统一的语法描述，而不是 XML、YAML、...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/concept/ConfigurationIsTheBlueprintOfTheSystem.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"配置是一幅描绘系统的蓝图"}],["meta",{"property":"og:description","content":"配置是一幅描绘系统的蓝图 如果你尝试修改过 NixOS 的配置文件，你就会明白配置文件中书写的内容实际上是你希望下次生成的系统。我们相信这是广大 NixOS 新手的基本认知。 中心化的配置文件带来管理的便捷 既然是根据配置文件生成系统，我们肯定希望配置文件是集中的，而不是零零散散的 dotfiles。它最好使用统一的语法描述，而不是 XML、YAML、..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2023-10-12T02:00:17.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2023-10-12T02:00:17.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"配置是一幅描绘系统的蓝图\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2023-10-12T02:00:17.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"中心化的配置文件带来管理的便捷","slug":"中心化的配置文件带来管理的便捷","link":"#中心化的配置文件带来管理的便捷","children":[]},{"level":2,"title":"依赖计算","slug":"依赖计算","link":"#依赖计算","children":[]}],"git":{"createdTime":1697076017000,"updatedTime":1697076017000,"contributors":[{"name":"OpenTritium","email":"tritium404@hotmail.com","commits":1}]},"readingTime":{"minutes":1.76,"words":527},"filePathRelative":"tutorials/concept/ConfigurationIsTheBlueprintOfTheSystem.md","localizedDate":"2023年10月12日","autoDesc":true,"excerpt":"\\n

如果你尝试修改过 NixOS 的配置文件，你就会明白配置文件中书写的内容实际上是你希望下次生成的系统。我们相信这是广大 NixOS 新手的基本认知。

\\n

中心化的配置文件带来管理的便捷

\\n

既然是根据配置文件生成系统，我们肯定希望配置文件是集中的，而不是零零散散的 dotfiles。它最好使用统一的语法描述，而不是 XML、YAML、TOML、json 等各种格式。而 NixOS 正是使用 Nix 语言来抹平这道沟壑。

\\n

Nix 文件就是使用 Nix 语言编写的源码文件，它们可以互相导入（就像常见的脚本一样），你可以将它们当作项目一样去组织。

"}');export{O as comp,_ as data}; diff --git a/assets/ConfigurationIsTheBlueprintOfTheSystem.html-djsOJ9Vw.js b/assets/ConfigurationIsTheBlueprintOfTheSystem.html-djsOJ9Vw.js new file mode 100644 index 0000000..4b85317 --- /dev/null +++ b/assets/ConfigurationIsTheBlueprintOfTheSystem.html-djsOJ9Vw.js @@ -0,0 +1 @@ +import{_ as i}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as n,o,c as a,d as r,e as s,a as e}from"./app-BNkVxcYY.js";const p={},c=s('

配置是一幅描绘系统的蓝图

如果你尝试修改过 NixOS 的配置文件，你就会明白配置文件中书写的内容实际上是你希望下次生成的系统。我们相信这是广大 NixOS 新手的基本认知。

中心化的配置文件带来管理的便捷

既然是根据配置文件生成系统，我们肯定希望配置文件是集中的，而不是零零散散的 dotfiles。它最好使用统一的语法描述，而不是 XML、YAML、TOML、json 等各种格式。而 NixOS 正是使用 Nix 语言来抹平这道沟壑。

Nix 文件就是使用 Nix 语言编写的源码文件，它们可以互相导入（就像常见的脚本一样），你可以将它们当作项目一样去组织。

依赖计算

我们通常会在配置文件里自定义某个软件的选项，从而不自觉地引入了包。声明式配置带来的好处之一就是所有的包和依赖都是确定的，配置文件不再仅仅是单纯的源码，还是一个关系图。

',7),l=e("p",null,"因为配置使用了 Nix 语言，打包也使用了 Nix 语言，Nix 包管理器能够全程参与计算。我们将软件构建任务抽象成一个结点，软件构建往往会有其他依赖，若干结点构成了图，Nix 只需要保证这个关系图是有向无环的。",-1),m=e("div",{class:"hint-container tip"},[e("p",{class:"hint-container-title"},"保证无环是为了让 Nix 能够有明确的构建顺序，使之能够并行构建，并且解决循"),e("p",null,"环依赖的问题。:::"),e("p",null,"在 NixOS 中你需要执行生成命令，才会重新计算依赖，生成新生代（新状态）。")],-1);function d(h,x){const t=n("Mermaid");return o(),a("div",null,[c,r(t,{id:"mermaid-21",code:"eJxl0dFOwjAUBuB7n2Iv0BsfwESdCIoiOhVzwsVZV0pjN5quC7CnZ5zTQAm763f+tX9a7dGtsyK/yYbvHqxput0yE+Iue+CFQGfEWmGlfLvkFI0f43hlfL1Fr9JZDtqaUjLlRE8Q+goDpjaClbGq3bdB1ewj8mcw2KBQIe7AOga58aoLxsYeY+IJoLQME4IXwBB8GnkFXbsUpkP3UmK0Kdnb1W/vx5R2WijvNxeTGTiMjWcEH+cSDHPArjKBaU70GQ8VjU6TX1D2xt2mVID0KP+HOGtB+g39STj3A9XF+je9dqbFsWmJbXyeBeEf1z8AyaGFMw=="}),l,m])}const N=i(p,[["render",d],["__file","ConfigurationIsTheBlueprintOfTheSystem.html.vue"]]),O=JSON.parse('{"path":"/tutorials/concept/ConfigurationIsTheBlueprintOfTheSystem.html","title":"配置是一幅描绘系统的蓝图","lang":"zh-CN","frontmatter":{"description":"配置是一幅描绘系统的蓝图 如果你尝试修改过 NixOS 的配置文件，你就会明白配置文件中书写的内容实际上是你希望下次生成的系统。我们相信这是广大 NixOS 新手的基本认知。 中心化的配置文件带来管理的便捷 既然是根据配置文件生成系统，我们肯定希望配置文件是集中的，而不是零零散散的 dotfiles。它最好使用统一的语法描述，而不是 XML、YAML、...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/concept/ConfigurationIsTheBlueprintOfTheSystem.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"配置是一幅描绘系统的蓝图"}],["meta",{"property":"og:description","content":"配置是一幅描绘系统的蓝图 如果你尝试修改过 NixOS 的配置文件，你就会明白配置文件中书写的内容实际上是你希望下次生成的系统。我们相信这是广大 NixOS 新手的基本认知。 中心化的配置文件带来管理的便捷 既然是根据配置文件生成系统，我们肯定希望配置文件是集中的，而不是零零散散的 dotfiles。它最好使用统一的语法描述，而不是 XML、YAML、..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2024-06-30T15:34:48.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2024-06-30T15:34:48.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"配置是一幅描绘系统的蓝图\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2024-06-30T15:34:48.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"中心化的配置文件带来管理的便捷","slug":"中心化的配置文件带来管理的便捷","link":"#中心化的配置文件带来管理的便捷","children":[]},{"level":2,"title":"依赖计算","slug":"依赖计算","link":"#依赖计算","children":[]}],"git":{"createdTime":1697076017000,"updatedTime":1719761688000,"contributors":[{"name":"OpenTritium","email":"tritium404@hotmail.com","commits":1},{"name":"Ryan Yin","email":"xiaoyin_c@qq.com","commits":1}]},"readingTime":{"minutes":1.76,"words":527},"filePathRelative":"tutorials/concept/ConfigurationIsTheBlueprintOfTheSystem.md","localizedDate":"2023年10月12日","autoDesc":true,"excerpt":"\\n

如果你尝试修改过 NixOS 的配置文件，你就会明白配置文件中书写的内容实际上是你希望下次生成的系统。我们相信这是广大 NixOS 新手的基本认知。

\\n

中心化的配置文件带来管理的便捷

\\n

既然是根据配置文件生成系统，我们肯定希望配置文件是集中的，而不是零零散散的\\ndotfiles。它最好使用统一的语法描述，而不是 XML、YAML、TOML、json 等各种格式。而\\nNixOS 正是使用 Nix 语言来抹平这道沟壑。

\\n

Nix 文件就是使用 Nix 语言编写的源码文件，它们可以互相导入（就像常见的脚本一样），你可以将它们当作项目一样去组织。

"}');export{N as comp,O as data}; diff --git a/assets/HowFunctionalProgrammingShapesNixOS.html-DZ_IJvjM.js b/assets/HowFunctionalProgrammingShapesNixOS.html-DZ_IJvjM.js deleted file mode 100644 index 755eee8..0000000 --- a/assets/HowFunctionalProgrammingShapesNixOS.html-DZ_IJvjM.js +++ /dev/null @@ -1,8 +0,0 @@ -import{_ as n}from"./plugin-vue_export-helper-DlAUqK2U.js";import{o as t,c as i,e}from"./app-KtH3BPxJ.js";const a={},s=e(`

若干个函数凝聚成一个巨大的函数

为什么 NixOS 采用函数式的设计

NixOS 在设计之初就竭力遵照函数式的设计，函数式有什么迷人的气质吗？

  • NixOS 需要保证构建结果的可复现性：为了实现同样的输入能有同样的输出，采用纯函数式作为设计范式可以避免构建过程被无关变量干扰或不改变环境（无副作用），保持构建结果的统一也保证了可预测性。

  • 完整依赖性：当我们要构建一个包时，Nix 会首先检查这个函数的所有输入（即依赖项）是否都已经存在。如果所有的输入都存在，Nix 就会执行这个函数（即进行构建）。如果有任何一个输入不存在，Nix 就会先去构建那个输入。这就确保了每个包的构建过程都是完全独立的，只依赖于它自己的输入。这也意味着，如果我们改变了任何一个包的输入（例如更新了源代码或者更换了依赖项），Nix 就会重新构建这个包，这个包变动会让其他依赖它的包也会被重新构建。如果你的配置文件描述的依赖不完整，则无法进入下次构建。

  • 原子性升级或回滚：在函数式编程中，数据是不可变的。由于包管理操作从不覆盖 /nix/store/ 中的包，而只是在不同的路径中添加新版本，因此该操作是原子性的。所以在包升级期间，不存在包有一些文件来自旧版本、一些文件来自新版本的时间窗口的情况。

  • 多版本并存：每个包都是纯函数的输出。即使是同一软件包，只要它们的构建过程不是完全一致的，就会存储在其自己的哈希目录中，因此可以在系统中同时存在多个版本的同一软件包。这就像在函数式编程中，我们可以引用同一个函数的不同版本。

所以 NixOS 其实是一个庞大的构建系统，以用户的配置文件作为函数，Nix 包管理器则是这个函数的解释器或执行器，而函数的输出则是一个完全配置好的，可以直接使用的系统（代）。

所以，函数式的设计不只是单单体现在这个构建系统，还体现在它的打包语言 Nix 上面。

Nix 语言的语法设计

Nix语言是一种纯函数式语言，其语法设计充分体现了函数式编程的特点：

  • 不可变性：在Nix中，变量一旦被赋值，就不能更改。

  • 纯函数：Nix 语言中的函数是纯函数，也就是说，给定相同的输入，它们总是会产生相同的输出，并且没有副作用。为了不破坏函数的纯净，Nix 语言没有全局变量的设计。

  • 惰性求值：Nix 语言使用惰性求值，这意味着表达式在需要时才会被求值。可以降低开销。

  • 高阶函数：Nix 语言支持高阶函数，也就是说，函数可以接受其他函数作为参数，或者返回函数作为结果，也可以产生不同状态的闭包。

闭包是什么

如果你没有接触过任何一门编程语言，你可以将闭包粗略地理解为带状态的函数。

每一个 Nix 文件就是一个函数

Nix 源码文件是一种以 nix 为后缀的文本文件，让我们一览：

{ pkgs }:
-
-pkgs.stdenv.mkDerivation {
-  name = "my-package";
-  src = ./source;
-  buildInputs = [ pkgs.gcc ];
-}
-

几乎所有的 Nix 源码文件都是这种格式：冒号前的是输入，冒号后的是输出。整个文件是被一个大函数所包裹住的，每个 Nix 文件就是一个函数。

一切皆函数

NixOS 本身就是一个超大号的函数，这个函数由它内部的若干函数驱动。

`,16),o=[s];function p(l,r){return t(),i("div",null,o)}const u=n(a,[["render",p],["__file","HowFunctionalProgrammingShapesNixOS.html.vue"]]),x=JSON.parse('{"path":"/tutorials/concept/HowFunctionalProgrammingShapesNixOS.html","title":"若干个函数凝聚成一个巨大的函数","lang":"zh-CN","frontmatter":{"description":"若干个函数凝聚成一个巨大的函数 为什么 NixOS 采用函数式的设计 NixOS 在设计之初就竭力遵照函数式的设计，函数式有什么迷人的气质吗？ NixOS 需要保证构建结果的可复现性：为了实现同样的输入能有同样的输出，采用纯函数式作为设计范式可以避免构建过程被无关变量干扰或不改变环境（无副作用），保持构建结果的统一也保证了可预测性。 完整依赖性：当我们...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/concept/HowFunctionalProgrammingShapesNixOS.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"若干个函数凝聚成一个巨大的函数"}],["meta",{"property":"og:description","content":"若干个函数凝聚成一个巨大的函数 为什么 NixOS 采用函数式的设计 NixOS 在设计之初就竭力遵照函数式的设计，函数式有什么迷人的气质吗？ NixOS 需要保证构建结果的可复现性：为了实现同样的输入能有同样的输出，采用纯函数式作为设计范式可以避免构建过程被无关变量干扰或不改变环境（无副作用），保持构建结果的统一也保证了可预测性。 完整依赖性：当我们..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2023-10-13T19:17:57.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2023-10-13T19:17:57.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"若干个函数凝聚成一个巨大的函数\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2023-10-13T19:17:57.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"为什么 NixOS 采用函数式的设计","slug":"为什么-nixos-采用函数式的设计","link":"#为什么-nixos-采用函数式的设计","children":[]},{"level":2,"title":"Nix 语言的语法设计","slug":"nix-语言的语法设计","link":"#nix-语言的语法设计","children":[]},{"level":2,"title":"每一个 Nix 文件就是一个函数","slug":"每一个-nix-文件就是一个函数","link":"#每一个-nix-文件就是一个函数","children":[]},{"level":2,"title":"一切皆函数","slug":"一切皆函数","link":"#一切皆函数","children":[]}],"git":{"createdTime":1697111271000,"updatedTime":1697224677000,"contributors":[{"name":"OpenTritium","email":"tritium404@hotmail.com","commits":2}]},"readingTime":{"minutes":3.49,"words":1046},"filePathRelative":"tutorials/concept/HowFunctionalProgrammingShapesNixOS.md","localizedDate":"2023年10月12日","autoDesc":true,"excerpt":"\\n

为什么 NixOS 采用函数式的设计

\\n

NixOS 在设计之初就竭力遵照函数式的设计，函数式有什么迷人的气质吗？

\\n
    \\n
  • \\n

    NixOS 需要保证构建结果的可复现性：为了实现同样的输入能有同样的输出，采用纯函数式作为设计范式可以避免构建过程被无关变量干扰或不改变环境（无副作用），保持构建结果的统一也保证了可预测性。

    \\n
    • \\n
  • \\n

    完整依赖性：当我们要构建一个包时，Nix 会首先检查这个函数的所有输入（即依赖项）是否都已经存在。如果所有的输入都存在，Nix 就会执行这个函数（即进行构建）。如果有任何一个输入不存在，Nix 就会先去构建那个输入。这就确保了每个包的构建过程都是完全独立的，只依赖于它自己的输入。这也意味着，如果我们改变了任何一个包的输入（例如更新了源代码或者更换了依赖项），Nix 就会重新构建这个包，这个包变动会让其他依赖它的包也会被重新构建。如果你的配置文件描述的依赖不完整，则无法进入下次构建。

    \\n
    • \\n
  • \\n

    原子性升级或回滚：在函数式编程中，数据是不可变的。由于包管理操作从不覆盖 /nix/store/ 中的包，而只是在不同的路径中添加新版本，因此该操作是原子性的。所以在包升级期间，不存在包有一些文件来自旧版本、一些文件来自新版本的时间窗口的情况。

    \\n
    • \\n
  • \\n

    多版本并存：每个包都是纯函数的输出。即使是同一软件包，只要它们的构建过程不是完全一致的，就会存储在其自己的哈希目录中，因此可以在系统中同时存在多个版本的同一软件包。这就像在函数式编程中，我们可以引用同一个函数的不同版本。

    \\n
    • \\n
"}');export{u as comp,x as data}; diff --git a/assets/HowFunctionalProgrammingShapesNixOS.html-rr2UlYus.js b/assets/HowFunctionalProgrammingShapesNixOS.html-rr2UlYus.js new file mode 100644 index 0000000..76f5678 --- /dev/null +++ b/assets/HowFunctionalProgrammingShapesNixOS.html-rr2UlYus.js @@ -0,0 +1,8 @@ +import{_ as n}from"./plugin-vue_export-helper-DlAUqK2U.js";import{o as t,c as i,e as a}from"./app-BNkVxcYY.js";const e={},s=a(`

若干个函数凝聚成一个巨大的函数

为什么 NixOS 采用函数式的设计

NixOS 在设计之初就竭力遵照函数式的设计，函数式有什么迷人的气质吗？

  • NixOS 需要保证构建结果的可复现性：为了实现同样的输入能有同样的输出，采用纯函数式作为设计范式可以避免构建过程被无关变量干扰或不改变环境（无副作用），保持构建结果的统一也保证了可预测性。

  • 完整依赖性：当我们要构建一个包时，Nix 会首先检查这个函数的所有输入（即依赖项）是否都已经存在。如果所有的输入都存在，Nix 就会执行这个函数（即进行构建）。如果有任何一个输入不存在，Nix 就会先去构建那个输入。这就确保了每个包的构建过程都是完全独立的，只依赖于它自己的输入。这也意味着，如果我们改变了任何一个包的输入（例如更新了源代码或者更换了依赖项），Nix 就会重新构建这个包，这个包变动会让其他依赖它的包也会被重新构建。如果你的配置文件描述的依赖不完整，则无法进入下次构建。

  • 原子性升级或回滚：在函数式编程中，数据是不可变的。由于包管理操作从不覆盖 /nix/store/ 中的包，而只是在不同的路径中添加新版本，因此该操作是原子性的。所以在包升级期间，不存在包有一些文件来自旧版本、一些文件来自新版本的时间窗口的情况。

  • 多版本并存：每个包都是纯函数的输出。即使是同一软件包，只要它们的构建过程不是完全一致的，就会存储在其自己的哈希目录中，因此可以在系统中同时存在多个版本的同一软件包。这就像在函数式编程中，我们可以引用同一个函数的不同版本。

所以 NixOS 其实是一个庞大的构建系统，以用户的配置文件作为函数，Nix 包管理器则是这个函数的解释器或执行器，而函数的输出则是一个完全配置好的，可以直接使用的系统（代）。

所以，函数式的设计不只是单单体现在这个构建系统，还体现在它的打包语言 Nix 上面。

Nix 语言的语法设计

Nix语言是一种纯函数式语言，其语法设计充分体现了函数式编程的特点：

  • 不可变性：在Nix中，变量一旦被赋值，就不能更改。

  • 纯函数：Nix 语言中的函数是纯函数，也就是说，给定相同的输入，它们总是会产生相同的输出，并且没有副作用。为了不破坏函数的纯净，Nix 语言没有全局变量的设计。

  • 惰性求值：Nix 语言使用惰性求值，这意味着表达式在需要时才会被求值。可以降低开销。

  • 高阶函数：Nix 语言支持高阶函数，也就是说，函数可以接受其他函数作为参数，或者返回函数作为结果，也可以产生不同状态的闭包。

闭包是什么如果你没有接触过任何一门编程语言，你可以将闭包粗略地理解为带

状态的函数。:::

每一个 Nix 文件就是一个函数

Nix 源码文件是一种以 nix 为后缀的文本文件，让我们一览：

{ pkgs }:
+
+pkgs.stdenv.mkDerivation {
+  name = "my-package";
+  src = ./source;
+  buildInputs = [ pkgs.gcc ];
+}
+

几乎所有的 Nix 源码文件都是这种格式：冒号前的是输入，冒号后的是输出。整个文件是被一个大函数所包裹住的，每个 Nix 文件就是一个函数。

一切皆函数

NixOS 本身就是一个超大号的函数，这个函数由它内部的若干函数驱动。

`,10),o=[s];function p(r,c){return t(),i("div",null,o)}const u=n(e,[["render",p],["__file","HowFunctionalProgrammingShapesNixOS.html.vue"]]),x=JSON.parse('{"path":"/tutorials/concept/HowFunctionalProgrammingShapesNixOS.html","title":"若干个函数凝聚成一个巨大的函数","lang":"zh-CN","frontmatter":{"description":"若干个函数凝聚成一个巨大的函数 为什么 NixOS 采用函数式的设计 NixOS 在设计之初就竭力遵照函数式的设计，函数式有什么迷人的气质吗？ NixOS 需要保证构建结果的可复现性：为了实现同样的输入能有同样的输出，采用纯函数式作为设计范式可以避免构建过程被无关变量干扰或不改变环境（无副作用），保持构建结果的统一也保证了可预测性。 完整依赖性：当我们...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/concept/HowFunctionalProgrammingShapesNixOS.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"若干个函数凝聚成一个巨大的函数"}],["meta",{"property":"og:description","content":"若干个函数凝聚成一个巨大的函数 为什么 NixOS 采用函数式的设计 NixOS 在设计之初就竭力遵照函数式的设计，函数式有什么迷人的气质吗？ NixOS 需要保证构建结果的可复现性：为了实现同样的输入能有同样的输出，采用纯函数式作为设计范式可以避免构建过程被无关变量干扰或不改变环境（无副作用），保持构建结果的统一也保证了可预测性。 完整依赖性：当我们..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2024-06-30T15:34:48.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2024-06-30T15:34:48.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"若干个函数凝聚成一个巨大的函数\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2024-06-30T15:34:48.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"为什么 NixOS 采用函数式的设计","slug":"为什么-nixos-采用函数式的设计","link":"#为什么-nixos-采用函数式的设计","children":[]},{"level":2,"title":"Nix 语言的语法设计","slug":"nix-语言的语法设计","link":"#nix-语言的语法设计","children":[]}],"git":{"createdTime":1697111271000,"updatedTime":1719761688000,"contributors":[{"name":"OpenTritium","email":"tritium404@hotmail.com","commits":2},{"name":"Ryan Yin","email":"xiaoyin_c@qq.com","commits":1}]},"readingTime":{"minutes":3.49,"words":1046},"filePathRelative":"tutorials/concept/HowFunctionalProgrammingShapesNixOS.md","localizedDate":"2023年10月12日","autoDesc":true,"excerpt":"\\n

为什么 NixOS 采用函数式的设计

\\n

NixOS 在设计之初就竭力遵照函数式的设计，函数式有什么迷人的气质吗？

\\n
    \\n
  • \\n

    NixOS 需要保证构建结果的可复现性：为了实现同样的输入能有同样的输出，采用纯函数式作为设计范式可以避免构建过程被无关变量干扰或不改变环境（无副作用），保持构建结果的统一也保证了可预测性。

    \\n
    • \\n
  • \\n

    完整依赖性：当我们要构建一个包时，Nix 会首先检查这个函数的所有输入（即依赖项）是否都已经存在。如果所有的输入都存在，Nix 就会执行这个函数（即进行构建）。如果有任何一个输入不存在，Nix 就会先去构建那个输入。这就确保了每个包的构建过程都是完全独立的，只依赖于它自己的输入。这也意味着，如果我们改变了任何一个包的输入（例如更新了源代码或者更换了依赖项），Nix 就会重新构建这个包，这个包变动会让其他依赖它的包也会被重新构建。如果你的配置文件描述的依赖不完整，则无法进入下次构建。

    \\n
    • \\n
  • \\n

    原子性升级或回滚：在函数式编程中，数据是不可变的。由于包管理操作从不覆盖\\n/nix/store/ 中的包，而只是在不同的路径中添加新版本，因此该操作是原子性的。所以在包升级期间，不存在包有一些文件来自旧版本、一些文件来自新版本的时间窗口的情况。

    \\n
    • \\n
  • \\n

    多版本并存：每个包都是纯函数的输出。即使是同一软件包，只要它们的构建过程不是完全一致的，就会存储在其自己的哈希目录中，因此可以在系统中同时存在多个版本的同一软件包。这就像在函数式编程中，我们可以引用同一个函数的不同版本。

    \\n
    • \\n
"}');export{u as comp,x as data}; diff --git a/assets/HowToMakePath-dependentProgramsWork.html-D2834t8G.js b/assets/HowToMakePath-dependentProgramsWork.html-D2834t8G.js new file mode 100644 index 0000000..92eca51 --- /dev/null +++ b/assets/HowToMakePath-dependentProgramsWork.html-D2834t8G.js @@ -0,0 +1 @@ +import{_ as r}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as o,o as d,c as s,a as e,b as t,d as i,e as n}from"./app-BNkVxcYY.js";const l={},p=n('

如何让路径依赖的程序正常工作

一切皆是文件

Linux 沿用了 Unix 的“一切皆是文件”理念。所有的输入/输出设备，包括硬盘、终端、打印机等，都被抽象为文件。

而虚拟文件系统（VFS）是这种理念的一个重要实现。VFS 提供了一个抽象层，使得用户可以使用统一的接口来访问各种不同类型的文件系统。在 Linux 中，VFS 不仅用于访问真实的文件系统（如 ext4、btrfs 等），还可以用于访问各种虚拟文件系统（procfs、sysfs 等）。

当你想操作它们的时候，只需要使用统一的文件操作 API（如 open、read、write 等）。这种设计简约且易用，广受赞誉。

一种文件组织规范

我们在上面提到了 Linux 将一切抽象成文件，但是又如何组织这些文件呢？于是有了 FHS（Filesystem Hierarchy Standard）来指导统一的文件组织方式。

  • /bin 基本用户指令，无需特殊权限
  • /boot 引导文件
  • /dev 设备文件
  • /etc 系统配置
  • /home 用户家目录
  • /lib 基本共享库与内核模块
  • /media 可移动媒体的挂载点
  • /mnt 临时文件系统挂载点
  • /opt 拓展或业务软件
  • /run 运行时变量数据
  • /root 超级用户的家目录
  • /sbin 系统库
  • /srv 为系统服务准备的数据
  • /tmp 临时文件
',8),h={class:"hint-container tip"},m=e("p",{class:"hint-container-title"},"FHS我只罗列个大概，你可以前",-1),u={href:"https://refspecs.linuxfoundation.org/FHS_3.0/fhs/ch03.html",target:"_blank",rel:"noopener noreferrer"},x=e("p",null,"FHS 规范了一种单根树形的文件组织方式，让不同发行版之间的程序移植变得可行，应用程序总是能找到它们期望的库文件或可执行程序。",-1),_=e("p",null,[t("不知道你还记得吗？在上一节我们提到过 Nix 会将包文件释放在一个不重复的哈希路径里，而不是诸如 "),e("code",null,"/usr/bin"),t(" 之类的路径，这是妥妥的放弃了 FHS 了，它该如何保证那些有"),e("mark",null,"路径依赖"),t("的软件顺利运行呢？")],-1),S={class:"hint-container note"},g=n('

路径依赖“路径依赖”是指应用程序在运行时需要访问的文件或目录的具体位置。

例如，一个应用可能需要访问 /usr/lib 目录下的某个库文件，或者需要读取 /etc 目录下的配置文件。这些路径通常在应用的源代码中被硬编码，因此应用对它们有所依赖。:::

兼容办法

NixOS 会通过以下方式确保有路径依赖的软件正常运行：

  • 包装脚本（Wrapper Script）：NixOS 会为一些应用生成包装脚本。在执行它们的时候，包装脚本会很自然的将环境变量（比如 LD_LIBRARY_PATH）传递进去（新进程会继承其父进程的环境），它们就能在被安排好的环境变量里找到自己的依赖库。

    常见环境变量

    PATH 用于补充可执行程序的路径，让你在任何地方都能直接输入它们的名字以调用它们。

    LIBRARY_PATH 用于在编译链接阶段查找动态链接库（*.so）和静态链接库（*.a）。这个环境变量只在编译链接阶段起作用，对运行时的库搜索路径有影响的是下一个环境变量。

    LD_LIBRARY_PATH 用于指定动态链接器（ld）查找可执行文件运行时所依赖的动态链接库（*.so）的路径。即用于在程序运行期间查找动态链接库时，指定除标准路径 /usr/lib 之外的路径。:::

  • 构建过程中的路径替换：Nix 能接触到构建软件这一环节，自然可以对硬编码的路径进行替换。

  • 符号链接：NixOS 会将常见的目录或文件链接到存储在 /nix/store 中的相应文件。因为根目录下面的组织几乎全是链接在实现，所以根目录下面文件的组织对 NixOS 来说并不是太重要。

可切换的系统状态

在 NixOS 中还有一个代（generation）的概念，我们将不同的配置文件生成的系统状态称之为代，这些代实际上是链接不同的构建结果构成的。我们在上面就已经说过根目录的组织对 NixOS 不是非常重要，因为每次生成代（系统状态）就会新建一个根，链接不同的构建结果，也就是说，这个根是可以随时由 NixOS 根据配置重建的。

',7),f=e("p",null,"在生成代以后，NixOS 会添加新的引导条目，指向不同代的根目录，这样就能引导不同的系统状态。当然也能使用命令行工具实时切换这些状态。",-1);function N(k,F){const a=o("ExternalLinkIcon"),c=o("Mermaid");return d(),s("div",null,[p,e("div",h,[m,e("p",null,[t("往"),e("a",u,[t("这个网站"),i(a)]),t("了解更多有关信息。:::")]),x,_,e("div",S,[g,i(c,{id:"mermaid-147",code:"eJxLL0osyFAIceFSAALH6OdT5j/rmKBgEKugq2un4Br9tKdVwTEWq6QbWNIJu6Q7WNIZIukEkzTCohNdEq9OD7CkC0TSGSZpiMVYdEkUr6BLwo0FAJHsXdA="}),f])])])}const y=r(l,[["render",N],["__file","HowToMakePath-dependentProgramsWork.html.vue"]]),L=JSON.parse('{"path":"/tutorials/concept/HowToMakePath-dependentProgramsWork.html","title":"如何让路径依赖的程序正常工作","lang":"zh-CN","frontmatter":{"description":"如何让路径依赖的程序正常工作 一切皆是文件 Linux 沿用了 Unix 的“一切皆是文件”理念。所有的输入/输出设备，包括硬盘、终端、打印机等，都被抽象为文件。 而虚拟文件系统（VFS）是这种理念的一个重要实现。VFS 提供了一个抽象层，使得用户可以使用统一的接口来访问各种不同类型的文件系统。在 Linux 中，VFS 不仅用于访问真实的文件系统（如...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/concept/HowToMakePath-dependentProgramsWork.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"如何让路径依赖的程序正常工作"}],["meta",{"property":"og:description","content":"如何让路径依赖的程序正常工作 一切皆是文件 Linux 沿用了 Unix 的“一切皆是文件”理念。所有的输入/输出设备，包括硬盘、终端、打印机等，都被抽象为文件。 而虚拟文件系统（VFS）是这种理念的一个重要实现。VFS 提供了一个抽象层，使得用户可以使用统一的接口来访问各种不同类型的文件系统。在 Linux 中，VFS 不仅用于访问真实的文件系统（如..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2024-06-30T15:34:48.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2024-06-30T15:34:48.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"如何让路径依赖的程序正常工作\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2024-06-30T15:34:48.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"一切皆是文件","slug":"一切皆是文件","link":"#一切皆是文件","children":[]},{"level":2,"title":"一种文件组织规范","slug":"一种文件组织规范","link":"#一种文件组织规范","children":[]}],"git":{"createdTime":1697255304000,"updatedTime":1719761688000,"contributors":[{"name":"OpenTritium","email":"tritium404@hotmail.com","commits":1},{"name":"Ryan Yin","email":"xiaoyin_c@qq.com","commits":1}]},"readingTime":{"minutes":4.24,"words":1272},"filePathRelative":"tutorials/concept/HowToMakePath-dependentProgramsWork.md","localizedDate":"2023年10月14日","autoDesc":true,"excerpt":"\\n

一切皆是文件

\\n

Linux 沿用了 Unix 的“一切皆是文件”理念。所有的输入/输出设备，包括硬盘、终端、打印机等，都被抽象为文件。

\\n

而虚拟文件系统（VFS）是这种理念的一个重要实现。VFS 提供了一个抽象层，使得用户可以使用统一的接口来访问各种不同类型的文件系统。在 Linux 中，VFS 不仅用于访问真实的文件系统（如 ext4、btrfs 等），还可以用于访问各种虚拟文件系统（procfs、sysfs\\n等）。

\\n

当你想操作它们的时候，只需要使用统一的文件操作 API（如 open、read、write 等）。这种设计简约且易用，广受赞誉。

"}');export{y as comp,L as data}; diff --git a/assets/HowToMakePath-dependentProgramsWork.html-NhUUpgrU.js b/assets/HowToMakePath-dependentProgramsWork.html-NhUUpgrU.js deleted file mode 100644 index 10d2a73..0000000 --- a/assets/HowToMakePath-dependentProgramsWork.html-NhUUpgrU.js +++ /dev/null @@ -1 +0,0 @@ -import{_ as c}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as o,o as d,c as s,a as e,b as t,d as i,e as n}from"./app-KtH3BPxJ.js";const l={},p=n('

如何让路径依赖的程序正常工作

一切皆是文件

Linux 沿用了 Unix 的“一切皆是文件”理念。所有的输入/输出设备，包括硬盘、终端、打印机等，都被抽象为文件。

而虚拟文件系统（VFS）是这种理念的一个重要实现。VFS 提供了一个抽象层，使得用户可以使用统一的接口来访问各种不同类型的文件系统。在 Linux 中，VFS 不仅用于访问真实的文件系统（如 ext4、btrfs 等），还可以用于访问各种虚拟文件系统（procfs、sysfs 等）。

当你想操作它们的时候，只需要使用统一的文件操作 API（如 open、read、write 等）。这种设计简约且易用，广受赞誉。

一种文件组织规范

我们在上面提到了 Linux 将一切抽象成文件，但是又如何组织这些文件呢？于是有了 FHS（Filesystem Hierarchy Standard）来指导统一的文件组织方式。

  • /bin 基本用户指令，无需特殊权限
  • /boot 引导文件
  • /dev 设备文件
  • /etc 系统配置
  • /home 用户家目录
  • /lib 基本共享库与内核模块
  • /media 可移动媒体的挂载点
  • /mnt 临时文件系统挂载点
  • /opt 拓展或业务软件
  • /run 运行时变量数据
  • /root 超级用户的家目录
  • /sbin 系统库
  • /srv 为系统服务准备的数据
  • /tmp 临时文件
',8),h={class:"hint-container tip"},m=e("p",{class:"hint-container-title"},"FHS",-1),u={href:"https://refspecs.linuxfoundation.org/FHS_3.0/fhs/ch03.html",target:"_blank",rel:"noopener noreferrer"},x=n('

FHS 规范了一种单根树形的文件组织方式，让不同发行版之间的程序移植变得可行，应用程序总是能找到它们期望的库文件或可执行程序。

不知道你还记得吗？在上一节我们提到过 Nix 会将包文件释放在一个不重复的哈希路径里，而不是诸如 /usr/bin 之类的路径，这是妥妥的放弃了 FHS 了，它该如何保证那些有路径依赖的软件顺利运行呢？

路径依赖

“路径依赖”是指应用程序在运行时需要访问的文件或目录的具体位置。例如，一个应用可能需要访问 /usr/lib 目录下的某个库文件，或者需要读取 /etc 目录下的配置文件。这些路径通常在应用的源代码中被硬编码，因此应用对它们有所依赖。

兼容办法

NixOS 会通过以下方式确保有路径依赖的软件正常运行：

  • 包装脚本（Wrapper Script）：NixOS 会为一些应用生成包装脚本。在执行它们的时候，包装脚本会很自然的将环境变量（比如 LD_LIBRARY_PATH）传递进去（新进程会继承其父进程的环境），它们就能在被安排好的环境变量里找到自己的依赖库。

    常见环境变量

    PATH 用于补充可执行程序的路径，让你在任何地方都能直接输入它们的名字以调用它们。

    LIBRARY_PATH 用于在编译链接阶段查找动态链接库（*.so）和静态链接库（*.a）。这个环境变量只在编译链接阶段起作用，对运行时的库搜索路径有影响的是下一个环境变量。

    LD_LIBRARY_PATH 用于指定动态链接器（ld）查找可执行文件运行时所依赖的动态链接库（*.so）的路径。即用于在程序运行期间查找动态链接库时，指定除标准路径 /usr/lib 之外的路径。

  • 构建过程中的路径替换：Nix 能接触到构建软件这一环节，自然可以对硬编码的路径进行替换。

  • 符号链接：NixOS 会将常见的目录或文件链接到存储在 /nix/store 中的相应文件。因为根目录下面的组织几乎全是链接在实现，所以根目录下面文件的组织对 NixOS 来说并不是太重要。

可切换的系统状态

在 NixOS 中还有一个代（generation）的概念，我们将不同的配置文件生成的系统状态称之为代，这些代实际上是链接不同的构建结果构成的。我们在上面就已经说过根目录的组织对 NixOS 不是非常重要，因为每次生成代（系统状态）就会新建一个根，链接不同的构建结果，也就是说，这个根是可以随时由 NixOS 根据配置重建的。

',8),_=e("p",null,"在生成代以后，NixOS 会添加新的引导条目，指向不同代的根目录，这样就能引导不同的系统状态。当然也能使用命令行工具实时切换这些状态。",-1);function S(g,f){const r=o("ExternalLinkIcon"),a=o("Mermaid");return d(),s("div",null,[p,e("div",h,[m,e("p",null,[t("我只罗列个大概，你可以前往"),e("a",u,[t("这个网站"),i(r)]),t("了解更多有关信息。")])]),x,i(a,{id:"mermaid-149",code:"eJxLL0osyFAIceFSAALH6OdT5j/rmKBgEKugq2un4Br9tKdVwTEWq6QbWNIJu6Q7WNIZIukEkzTCohNdEq9OD7CkC0TSGSZpiMVYdEkUr6BLwo0FAJHsXdA="}),_])}const F=c(l,[["render",S],["__file","HowToMakePath-dependentProgramsWork.html.vue"]]),T=JSON.parse('{"path":"/tutorials/concept/HowToMakePath-dependentProgramsWork.html","title":"如何让路径依赖的程序正常工作","lang":"zh-CN","frontmatter":{"description":"如何让路径依赖的程序正常工作 一切皆是文件 Linux 沿用了 Unix 的“一切皆是文件”理念。所有的输入/输出设备，包括硬盘、终端、打印机等，都被抽象为文件。 而虚拟文件系统（VFS）是这种理念的一个重要实现。VFS 提供了一个抽象层，使得用户可以使用统一的接口来访问各种不同类型的文件系统。在 Linux 中，VFS 不仅用于访问真实的文件系统（如...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/concept/HowToMakePath-dependentProgramsWork.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"如何让路径依赖的程序正常工作"}],["meta",{"property":"og:description","content":"如何让路径依赖的程序正常工作 一切皆是文件 Linux 沿用了 Unix 的“一切皆是文件”理念。所有的输入/输出设备，包括硬盘、终端、打印机等，都被抽象为文件。 而虚拟文件系统（VFS）是这种理念的一个重要实现。VFS 提供了一个抽象层，使得用户可以使用统一的接口来访问各种不同类型的文件系统。在 Linux 中，VFS 不仅用于访问真实的文件系统（如..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2023-10-14T03:48:24.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2023-10-14T03:48:24.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"如何让路径依赖的程序正常工作\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2023-10-14T03:48:24.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"一切皆是文件","slug":"一切皆是文件","link":"#一切皆是文件","children":[]},{"level":2,"title":"一种文件组织规范","slug":"一种文件组织规范","link":"#一种文件组织规范","children":[]},{"level":2,"title":"兼容办法","slug":"兼容办法","link":"#兼容办法","children":[]},{"level":2,"title":"可切换的系统状态","slug":"可切换的系统状态","link":"#可切换的系统状态","children":[]}],"git":{"createdTime":1697255304000,"updatedTime":1697255304000,"contributors":[{"name":"OpenTritium","email":"tritium404@hotmail.com","commits":1}]},"readingTime":{"minutes":4.24,"words":1272},"filePathRelative":"tutorials/concept/HowToMakePath-dependentProgramsWork.md","localizedDate":"2023年10月14日","autoDesc":true,"excerpt":"\\n

一切皆是文件

\\n

Linux 沿用了 Unix 的“一切皆是文件”理念。所有的输入/输出设备，包括硬盘、终端、打印机等，都被抽象为文件。

\\n

而虚拟文件系统（VFS）是这种理念的一个重要实现。VFS 提供了一个抽象层，使得用户可以使用统一的接口来访问各种不同类型的文件系统。在 Linux 中，VFS 不仅用于访问真实的文件系统（如 ext4、btrfs 等），还可以用于访问各种虚拟文件系统（procfs、sysfs 等）。

\\n

当你想操作它们的时候，只需要使用统一的文件操作 API（如 open、read、write 等）。这种设计简约且易用，广受赞誉。

"}');export{F as comp,T as data}; diff --git a/assets/Intro.html-CEuRkNVT.js b/assets/Intro.html-CEuRkNVT.js new file mode 100644 index 0000000..5f6ef00 --- /dev/null +++ b/assets/Intro.html-CEuRkNVT.js @@ -0,0 +1,52 @@ +import{_ as t}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as o,o as l,c,a as n,b as a,d as i,e as s}from"./app-BNkVxcYY.js";const d={},p=n("h1",{id:"nixos-入门",tabindex:"-1"},[n("a",{class:"header-anchor",href:"#nixos-入门"},[n("span",null,"NixOS 入门")])],-1),r={class:"hint-container warning"},h=s(`

内容施工中本节内容正在修缮中，当前内容可能已经过时，仅供参考。:::

何谓 nix-channel

nix-channel 是一个命令行工具，用于订阅系统频道和软件频道。

命令行

nix-channel 命令行工具的使用：

nix-channel {--add url [name] | --remove name | --list | --update [names…] | --rollback [generation] }
+

看起来，这个命令行工具提供的功能有：订阅频道，退订频道，列出频道，更新频道，还能回滚“生成”。

频道是什么

上面我们演示了命令行工具的使用方式，却没有告知频道从哪里获取。

频道最直接的体现是一个形如 https://nixos.org/channels/nixos22.11 的 URL。

`,10),u={href:"https://channels.nixos.org/",target:"_blank",rel:"noopener noreferrer"},x=s(`

请你尝试访问上面的 URL。正如我们所说，这是一个频道集合，根目录下的每一个子目录就代表一个频道，官方提供了若干个频道：

2022/8/4 22:51:25               0.1 kB         nixos-21.11
+2022/8/4 22:59:10               0.1 kB         nixos-21.11-aarch64
+2022/8/2 23:24:22               0.1 kB         nixos-21.11-small
+2023/1/3 23:39:40               0.1 kB         nixos-22.05
+2023/1/3 22:43:29               0.1 kB         nixos-22.05-aarch64
+2023/1/2 04:11:11               0.1 kB         nixos-22.05-small
+2023/3/16 05:19:03              0.1 kB         nixos-22.11
+2023/3/16 22:18:18              0.1 kB         nixos-22.11-small
+2023/3/16 14:55:20              0.1 kB         nixos-unstable
+2023/3/16 21:27:06              0.1 kB         nixos-unstable-small
+2023/1/2 21:05:38               0.1 kB         nixpkgs-22.05-darwin
+2023/3/17 00:30:11              0.1 kB         nixpkgs-22.11-darwin
+2023/3/16 04:06:35              0.1 kB         nixpkgs-unstable
+

项目结构

我们以官方频道 nixpkgs-unstable 为例，查看每个频道大致的构成。它们似乎都提供了nixexprs.tar.xz，从文件名我们就了解到这是一个包含了若干 nix 文件的 tar 压缩档（Tarball）。

`,4),b={class:"hint-container tip"},v=s(`

Tarball Tarball 是 \`tar\` 文件格式的全称，不是 Nix 独有。它可以将多个文件

打包在一起。如果你想在打包的时候压缩一下，还可以使用 gzip，bzip2 等软件压缩该档案。当你对 tar 文件启用压缩以后，后缀名会变更为 tar.gz, tar.bz2 等，具体取决于你使用的压缩软件。:::

于是我们解压它，列出目录树：

├─.github
+├─doc
+├─lib
+├─maintainers
+├─nixos
+└─pkgs
+    ├─applications
+    │  ├─accessibility
+    │  │  ├─contrast
+    │  │  └─wvkbd
+    │  ├─audio
+    │  │  ├─a2jmidid
+    │  │  ├─ario
+    │  │  ├─csound
+    │  │  │  ├─csound-manual
+    │  │  │  └─csound-qt
+    ......
+
`,4),m={class:"hint-container note"},g=n("p",{class:"hint-container-title"},"仅供演示以上目录树是笔者为了方便演示而精简过的部分，实际构成肯定有差",-1),k=n("p",null,"别。:::",-1),_=n("p",null,[a("上面的每个子目录中都有一个 "),n("code",null,"default.nix"),a(" 文件，这是导入该目录时默认被求值的文件。每个包名文件夹下面的 "),n("code",null,"nix"),a(" 文件，这些文件和脚本类似，运行它们时，会从五湖四海获取源码和其他资源，再根据脚本的描述构建出相应的二进制包。")],-1),N={class:"hint-container tip"},f=n("p",{class:"hint-container-title"},"如果你还没有学习过 Nix 表达式语言，大抵是看不懂的，你可以前往",-1),O={href:"https://nixos-cn.org/guide/lang/",target:"_blank",rel:"noopener noreferrer"},S=s('

每个频道都应该提供一个名为 nixexprs 的 Tarball。其中 default.nix 既是根目录也是每一级目录的入口点。

系统频道与软件仓库频道

频道在 NixOS 中大致被分为两类：系统频道和软件仓库频道。

系统频道

系统频道可以从 URL 中直观的体现。形如 https://nixos.org/channels/nixos22.11 你很快就了解到这是一个 22.11 版本的 NixOS 的频道。

',5),w={class:"hint-container tip"},B=s(`

默认订阅的频道

NixOS 默认订阅了官方频道 nixos，即使你安装完系统什么都不做，它们也是存在的：

sudo nix-channel --list  # 列出频道
+
nixos https://nixos.org/channels/nixos22.11
+

这个频道提供了组成系统的一些驱动，设施等等。

`,5),y={class:"hint-container warning"},L=s(`

注意

这里的 nixos 与 https://nixos.org/channels/nixos22.11 并不是并列关系，前者是频道名，后面是被订阅的 URL。

当你有两个及两个以上频道的时候，你就会理解我的意思：

nixos https://nixos.org/channels/nixos22.11
+nixpkgs https://nixos.org/channels/nixpkgs-unstable
+

除非升级系统或更换镜像频道，否则不要动系统默认的 nixos 频道。:::

一些特殊的频道

  • 稳定（stable）频道。如 nixos-22.11。这些频道只能得到保守的错误修复和软件包升级。例如，频道更新可能会导致系统上的Linux内核从 4.19.34 升级到 4.19.38（一个小错误修复），但不会从 4.19.x 升级到 4.20.x（一个可能会破坏一切的重大更改）。在创建下一个稳定分支之前，通常会保持稳定的频道。
  • 不稳定（unstable）频道。这与 nixos 的主要开发分支相对应，因此可能有破坏性更新，不建议用于生产系统。
  • 小型（small）频道，如 nixos-22.11-small 或 nix-unstable-small。这些频道与上述稳定和不稳定频道相同，只是它们包含较少的二进制包。这意味着它们比常规通道更新得更快（例如，当一个关键的安全补丁被提交到 NixOS 的源代码树时），但可能有更多的包需要从源代码构建。它们主要用于服务器环境，因此包含很少的 GUI 应用程序。
`,7),T={href:"https://nixos.org/channels",target:"_blank",rel:"noopener noreferrer"},I={href:"https://nixos.org/nixos/download.html",target:"_blank",rel:"noopener noreferrer"},R=s(`

升级系统 #TODO

你可以使用以下命令获取当前的 nixos 频道

nix-channel --list | grep nixos
+

要切换到不同的NixOS通道，请执行

nix-channel --add https://nixos.org/channels/channel-name nixos
+

以 nixos 22.11 为例，命令为

nix-channel --add https://nixos.org/channels/nixos-22.11 nixos
+

使用以下命令以开始切换

nixos-rebuild switch --upgrade
+

该命令相当于 nix-channel --update nixos; nixos-rebuild switch

::: note频道的切换是以用户为单位的。当你不以 root 权限执行时，不会影响 /etc/nixos/configuration.nix 的配置 :::

::: warning在频道之间来回切换通常是安全的。唯一的例外是，一个较新的NixOS也可能有一个较低的Nix版本，这可能涉及到Nix数据库模式的升级。这是不容易撤消的，所以在这种情况下，您将无法返回到原始频道。:::

软件仓库频道

软件仓库频道不仅仅可以为 NixOS 使用，其他 Linux 发行版也可以安装 Nix 包管理器从中获取软件包，甚至 Darwin 也可以。

订阅 nixpkgs-unstable 频道

nixpkgs 仓库 nixpkgs 仓库更新非常快，所以没有稳定版。不过 darwin 是例

外，因为 Nix 包管理器不能保证实时兼容当前的 darwin 平台，所以要做版本控制。:::

sudo nix-channel --add https://nixos.org/channels/nixpkgs-unstable  # 添加频道，不过我更喜欢称它为 “订阅”
+sudo nix-channel --update  # 更新频道
+

如此，你便订阅上了官方的 nixpkgs-unstable 软件源。

推荐订阅镜像频道上文仅供教学。在下一节我们会指引大家订阅国内能正常访

问的镜像频道，键入下面的命令以退订官方的 nixpkgs-unstable 频道：

sudo nix-channel --remove nixpkgs-unstable
+
`,16),z=s(`

自定义频道名

默认情况下，频道名是截取自 URL 的最后一级：

nix-channel --add https://host/nixpkgs-unstable
+

我们列出频道名：

nixpkgs-unstable https://host/nixpkgs-unstable
+

如果我们需要手动命名频道，增加一个参数即可：

nix-channel --add https://host/nixpkgs-unstable nixpkgs
+

使用镜像频道

由于不可抗力的因素，大陆对于环大陆主机的访问显得异常艰难，所以我们需要使用国内的镜像频道来替代我们对官方频道（镜像频道通常由大学和企业公益性提供），下面列出了一些在中国可用的一些镜像频道：

  • 中国教育和科研计算机网（清华大学）https://mirrors.cernet.edu.cn/nix-channels/store
  • 中国科学技术大学 https://mirrors.ustc.edu.cn/nix-channels/store
  • 上海交通大学 https://mirror.sjtu.edu.cn/nix-channels/store
  • 北京外国语大学 https://mirrors.bfsu.edu.cn/nix-channels/store
  • 南京大学 https://mirror.nju.edu.cn/nix-channels/store
  • 中国科学院软件研究所 https://mirror.iscas.ac.cn/nix-channels/store

我们使用镜像源替代官方的系统频道和软件仓库频道：

sudo nix-channel --add https://mirrors.ustc.edu.cn/nix-channels/nixpkgs-unstable nixpkgs  # 订阅镜像仓库频道
+sudo nix-channel --add https://mirrors.ustc.edu.cn/nix-channels/nixos-22.11 nixos  # 请注意系统版本
+sudo nix-channel --list  # 列出频道
+
`,6),U={class:"hint-container note"},C=s(`

特地修改频道名是因为许多表达式都会把 nixpkgs 而不是 nixpkgs-unstable 作

输入。:::

二进制构建缓存

源码分发是指将软件的源代码打包并分发给用户（Gentoo），二进制分发则是将已编译好的二进制程序直接分发给用户（例如 Debian，RHEL）。NixOS 默认是源码分发形式，不过我们可以添加二进制缓存源来让 NixOS 从缓存主机获取已经构建好的软件包。

为 NixOS 添加二进制缓存源

只需要修改 NixOS 配置中的 substituters 即可：

nix.settings.substituters = [ "https://mirrors.ustc.edu.cn/nix-channels/store" ];
+

由于官方的二进制缓存源是默认添加的，你可以通过下面的方式只启用自己指定的二进制缓存源：

# 记得导入 lib
+nix.settings.substituters = lib.mkForce [ "https://mirrors.cernet.edu.cn/nix-channels/store" ];
+

当前可用的二进制缓存主机列表

  • 中国科研和教育计算机网 https://mirrors.cernet.edu.cn/nix-channels/store
  • 中国科技大学 https://mirrors.ustc.edu.cn/nix-channels/store
  • 上海交通大学 https://mirror.sjtu.edu.cn/nix-channels/store
  • 中国教育和科研计算机网 https://mirrors.cernet.edu.cn/nix-channels/store
  • 北京外国语大学 https://mirrors.bfsu.edu.cn/nix-channels/store
  • 南京大学 https://mirror.nju.edu.cn/nix-channels/store
  • 中国科学院软件研究所 https://mirror.iscas.ac.cn/nix-channels/store

Cachix 服务

`,12),q={href:"https://www.cachix.org/",target:"_blank",rel:"noopener noreferrer"},D=s('

Nix 生态构成简述

Nix 生态主要由 Nix 表达式语言，NixOS，Nix 包管理器，Nixpkgs，NixOps，Hydra 构成。以下只是梗概，并不需要你完全理解或记住它。

名称描述
Nix 表达式语言Nix 表达式语言是一种函数式编程语言，用于描述软件包的构建过程、依赖关系和环境变量等信息。它支持函数定义、递归、模式匹配等特性，还支持嵌套语法，可描述复杂的依赖关系和构建过程。Nix 还支持原子事务，使得所有的包和环境都是原子的，不会相互影响。Nix 表达式语言可用于定义软件包和环境，也可用于描述系统配置。它是一种强大、灵活、可重复和可扩展的语言，用于管理软件包和环境。
NixOSNixOS 是一种基于 Nix 包管理器的 Linux 发行版，具有高度可配置性、可重复性和安全性。它采用声明性配置，使用配置文件明确描述系统状态，使得配置更易于维护。NixOS 适用于需要高度可定制性的用例，如服务器和开发环境。
Nix 包管理器Nix 是跨平台的功能强大的包管理器，采用函数式编程思想描述依赖关系和多版本软件包管理，并提供一系列跨平台工具方便管理和部署。
NixOpsNixOps是基于NixOS的云部署管理工具，支持多云平台，提供简单的命令行接口，可创建、部署、升级和回滚NixOS。用户可通过编写Nix表达式自定义部署和配置，使其成为灵活、可扩展和可定制的工具。适合需要管理大型、复杂基础设施的组织。
HydraHydra 是在 NixOS 中使用的 CI/CD 系统，它可以自动构建、测试和部署软件包，并决定是否发布和部署。Hydra 可以在不同环境下测试软件包，适用于开发、测试和部署任何类型的软件。
Nixpkgsnixpkgs 是 Nix 软件包管理器的官方软件包集合，包含数以万计的软件包，并提供了构建、测试和部署工具，支持多平台和多架构，适用于开发、测试和部署各种类型的软件。
',3);function j(V,G){const e=o("ExternalLinkIcon");return l(),c("div",null,[p,n("div",r,[h,n("p",null,[a("官方提供了"),n("a",u,[a("官方频道集合"),i(e)]),a("。订阅了其中的频道以后，就会从相应的频道获取更新，大致和你使用其他发行版的软件源类似，不过我们后面会详述 NixOS 中的“频道”概念和传统发行版中“软件源”的区别。")]),x,n("div",b,[v,n("div",m,[g,k,_,n("div",N,[f,n("p",null,[n("a",O,[a("Nix 语言概览"),i(e)]),a(" 进行初步学习。:::")]),S,n("div",w,[B,n("div",y,[L,n("p",null,[a("要查看可用的频道，请转到"),n("a",T,[a("官方频道"),i(e)]),a("。（请注意，各种频道的 URI 重定向到一个包含最新版本频道的目录，还包括 ISO 映像和 VirtualBox 设备。）")]),n("p",null,[a("请注意，在发布过程中，尚未发布的频道也将出现在此处。请参阅"),n("a",I,[a("官方 Getting NixOS 页面"),i(e)]),a("以查找最新支持的稳定版本。")]),R])])])])])]),z,n("div",U,[C,n("p",null,[a("Cachix 服务是 Nix 二进制缓存服务实现的方式之一，你可以使用它在服务器构建缓存，然后连接到该服务器的主机可以分享这些缓存，从而避免了二次构建。了解详情请参阅 "),n("a",q,[a("Cachix 官网"),i(e)]),a("。")]),D])])}const Z=t(d,[["render",j],["__file","Intro.html.vue"]]),P=JSON.parse('{"path":"/manual/Intro.html","title":"NixOS 入门","lang":"zh-CN","frontmatter":{"description":"NixOS 入门 内容施工中本节内容正在修缮中，当前内容可能已经过时，仅供参考。::: 何谓 nix-channel nix-channel 是一个命令行工具，用于订阅系统频道和软件频道。 命令行 nix-channel 命令行工具的使用： 看起来，这个命令行工具提供的功能有：订阅频道，退订频道，列出频道，更新频道，还能回滚“生成”。 频道是什么 上面...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/manual/Intro.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"NixOS 入门"}],["meta",{"property":"og:description","content":"NixOS 入门 内容施工中本节内容正在修缮中，当前内容可能已经过时，仅供参考。::: 何谓 nix-channel nix-channel 是一个命令行工具，用于订阅系统频道和软件频道。 命令行 nix-channel 命令行工具的使用： 看起来，这个命令行工具提供的功能有：订阅频道，退订频道，列出频道，更新频道，还能回滚“生成”。 频道是什么 上面..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2024-06-30T15:34:48.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2024-06-30T15:34:48.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"NixOS 入门\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2024-06-30T15:34:48.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"使用镜像频道","slug":"使用镜像频道","link":"#使用镜像频道","children":[]}],"git":{"createdTime":1711468225000,"updatedTime":1719761688000,"contributors":[{"name":"Ryan Yin","email":"xiaoyin_c@qq.com","commits":2},{"name":"linglilongyi","email":"46670292+linglilongyi@users.noreply.github.com","commits":1}]},"readingTime":{"minutes":10.4,"words":3119},"filePathRelative":"manual/Intro.md","localizedDate":"2024年3月26日","autoDesc":true,"excerpt":"\\n
\\n

内容施工中本节内容正在修缮中，当前内容可能已经过时，仅供参考。:::

\\n

何谓 nix-channel

\\n

nix-channel 是一个命令行工具，用于订阅系统频道和软件频道。

\\n

命令行

\\n

nix-channel 命令行工具的使用：

\\n
nix-channel {--add url [name] | --remove name | --list | --update [names…] | --rollback [generation] }\\n

看起来，这个命令行工具提供的功能有：订阅频道，退订频道，列出频道，更新频道，还能回滚“生成”。

\\n

频道是什么

\\n

上面我们演示了命令行工具的使用方式，却没有告知频道从哪里获取。

\\n

频道最直接的体现是一个形如 https://nixos.org/channels/nixos22.11 的 URL。

\\n

官方提供了官方频道集合。订阅了其中的频道以后，就会从相应的频道获取更新，大致和你使用其他发行版的软件源类似，不过我们后面会详述\\nNixOS 中的“频道”概念和传统发行版中“软件源”的区别。

\\n

请你尝试访问上面的 URL。正如我们所说，这是一个频道集合，根目录下的每一个子目录就代表一个频道，官方提供了若干个频道：

\\n
2022/8/4 22:51:25               0.1 kB         nixos-21.11\\n2022/8/4 22:59:10               0.1 kB         nixos-21.11-aarch64\\n2022/8/2 23:24:22               0.1 kB         nixos-21.11-small\\n2023/1/3 23:39:40               0.1 kB         nixos-22.05\\n2023/1/3 22:43:29               0.1 kB         nixos-22.05-aarch64\\n2023/1/2 04:11:11               0.1 kB         nixos-22.05-small\\n2023/3/16 05:19:03              0.1 kB         nixos-22.11\\n2023/3/16 22:18:18              0.1 kB         nixos-22.11-small\\n2023/3/16 14:55:20              0.1 kB         nixos-unstable\\n2023/3/16 21:27:06              0.1 kB         nixos-unstable-small\\n2023/1/2 21:05:38               0.1 kB         nixpkgs-22.05-darwin\\n2023/3/17 00:30:11              0.1 kB         nixpkgs-22.11-darwin\\n2023/3/16 04:06:35              0.1 kB         nixpkgs-unstable\\n

项目结构

\\n

我们以官方频道 nixpkgs-unstable 为例，查看每个频道大致的构成。它们似乎都提供了nixexprs.tar.xz，从文件名我们就了解到这是一个包含了若干 nix 文件的 tar 压缩档（Tarball）。

\\n
\\n

Tarball Tarball 是 `tar` 文件格式的全称，不是 Nix 独有。它可以将多个文件

\\n

打包在一起。如果你想在打包的时候压缩一下，还可以使用 gzip，bzip2 等软件压缩该档案。当你对 tar 文件启用压缩以后，后缀名会变更为 tar.gz, tar.bz2 等，具体取决于你使用的压缩软件。:::

\\n

于是我们解压它，列出目录树：

\\n
├─.github\\n├─doc\\n├─lib\\n├─maintainers\\n├─nixos\\n└─pkgs\\n    ├─applications\\n    │  ├─accessibility\\n    │  │  ├─contrast\\n    │  │  └─wvkbd\\n    │  ├─audio\\n    │  │  ├─a2jmidid\\n    │  │  ├─ario\\n    │  │  ├─csound\\n    │  │  │  ├─csound-manual\\n    │  │  │  └─csound-qt\\n    ......\\n
\\n

仅供演示以上目录树是笔者为了方便演示而精简过的部分，实际构成肯定有差

\\n

别。:::

\\n

上面的每个子目录中都有一个 default.nix 文件，这是导入该目录时默认被求值的文件。每个包名文件夹下面的 nix 文件，这些文件和脚本类似，运行它们时，会从五湖四海获取源码和其他资源，再根据脚本的描述构建出相应的二进制包。

\\n
\\n

如果你还没有学习过 Nix 表达式语言，大抵是看不懂的，你可以前往

\\n

Nix 语言概览 进行初步学习。:::

\\n

每个频道都应该提供一个名为 nixexprs 的 Tarball。其中 default.nix 既是根目录也是每一级目录的入口点。

\\n

系统频道与软件仓库频道

\\n

频道在 NixOS 中大致被分为两类：系统频道和软件仓库频道。

\\n

系统频道

\\n

系统频道可以从 URL 中直观的体现。形如 https://nixos.org/channels/nixos22.11 你很快就了解到这是一个 22.11 版本的 NixOS 的频道。

\\n
\\n

默认订阅的频道

\\n

NixOS 默认订阅了官方频道 nixos，即使你安装完系统什么都不做，它们也是存在的：

\\n
sudo nix-channel --list  # 列出频道\\n
nixos https://nixos.org/channels/nixos22.11\\n

这个频道提供了组成系统的一些驱动，设施等等。

\\n
\\n

注意

\\n

这里的 nixos 与 https://nixos.org/channels/nixos22.11 并不是并列关系，前者是频道名，后面是被订阅的 URL。

\\n

当你有两个及两个以上频道的时候，你就会理解我的意思：

\\n
nixos https://nixos.org/channels/nixos22.11\\nnixpkgs https://nixos.org/channels/nixpkgs-unstable\\n

除非升级系统或更换镜像频道，否则不要动系统默认的 nixos 频道。:::

\\n

一些特殊的频道

\\n
    \\n
  • 稳定（stable）频道。如 nixos-22.11。这些频道只能得到保守的错误修复和软件包升级。例如，频道更新可能会导致系统上的Linux内核从 4.19.34 升级到 4.19.38（一个小错误修复），但不会从 4.19.x 升级到 4.20.x（一个可能会破坏一切的重大更改）。在创建下一个稳定分支之前，通常会保持稳定的频道。
    • \\n
  • 不稳定（unstable）频道。这与 nixos 的主要开发分支相对应，因此可能有破坏性更新，不建议用于生产系统。
    • \\n
  • 小型（small）频道，如 nixos-22.11-small 或 nix-unstable-small。这些频道与上述稳定和不稳定频道相同，只是它们包含较少的二进制包。这意味着它们比常规通道更新得更快（例如，当一个关键的安全补丁被提交到 NixOS 的源代码树时），但可能有更多的包需要从源代码构建。它们主要用于服务器环境，因此包含很少的 GUI 应用程序。
    • \\n
\\n

要查看可用的频道，请转到官方频道。（请注意，各种频道的 URI 重定向到一个包含最新版本频道的目录，还包括 ISO 映像和 VirtualBox 设备。）

\\n

请注意，在发布过程中，尚未发布的频道也将出现在此处。请参阅官方 Getting NixOS 页面以查找最新支持的稳定版本。

\\n

升级系统 #TODO

\\n

你可以使用以下命令获取当前的 nixos 频道

\\n
nix-channel --list | grep nixos\\n

要切换到不同的NixOS通道，请执行

\\n
nix-channel --add https://nixos.org/channels/channel-name nixos\\n

以 nixos 22.11 为例，命令为

\\n
nix-channel --add https://nixos.org/channels/nixos-22.11 nixos\\n

使用以下命令以开始切换

\\n
nixos-rebuild switch --upgrade\\n

该命令相当于 nix-channel --update nixos; nixos-rebuild switch

\\n

::: note频道的切换是以用户为单位的。当你不以 root 权限执行时，不会影响\\n/etc/nixos/configuration.nix 的配置 :::

\\n

::: warning在频道之间来回切换通常是安全的。唯一的例外是，一个较新的NixOS也可能有一个较低的Nix版本，这可能涉及到Nix数据库模式的升级。这是不容易撤消的，所以在这种情况下，您将无法返回到原始频道。:::

\\n

软件仓库频道

\\n

软件仓库频道不仅仅可以为 NixOS 使用，其他 Linux 发行版也可以安装 Nix 包管理器从中获取软件包，甚至 Darwin 也可以。

\\n

订阅 nixpkgs-unstable 频道

\\n
\\n

nixpkgs 仓库 nixpkgs 仓库更新非常快，所以没有稳定版。不过 darwin 是例

\\n

外，因为 Nix 包管理器不能保证实时兼容当前的 darwin 平台，所以要做版本控制。:::

\\n
sudo nix-channel --add https://nixos.org/channels/nixpkgs-unstable  # 添加频道，不过我更喜欢称它为 “订阅”\\nsudo nix-channel --update  # 更新频道\\n

如此，你便订阅上了官方的 nixpkgs-unstable 软件源。

\\n
\\n

推荐订阅镜像频道上文仅供教学。在下一节我们会指引大家订阅国内能正常访

\\n

问的镜像频道，键入下面的命令以退订官方的 nixpkgs-unstable 频道：

\\n
sudo nix-channel --remove nixpkgs-unstable\\n
\\n
\\n
\\n
\\n
\\n
\\n
\\n
"}');export{Z as comp,P as data}; diff --git a/assets/Intro.html-CsM-htdy.js b/assets/Intro.html-CsM-htdy.js deleted file mode 100644 index d0f963c..0000000 --- a/assets/Intro.html-CsM-htdy.js +++ /dev/null @@ -1,52 +0,0 @@ -import{_ as t}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as l,o as c,c as o,a,b as n,d as s,e as i}from"./app-KtH3BPxJ.js";const d={},r=i(`

NixOS 入门

内容施工中

本节内容正在修缮中，当前内容可能已经过时，仅供参考。

何谓 nix-channel

nix-channel 是一个命令行工具，用于订阅系统频道和软件频道。

命令行

nix-channel 命令行工具的使用：

nix-channel {--add url [name] | --remove name | --list | --update [names…] | --rollback [generation] }
-

看起来，这个命令行工具提供的功能有：订阅频道，退订频道，列出频道，更新频道，还能回滚“生成”。

频道是什么

上面我们演示了命令行工具的使用方式，却没有告知频道从哪里获取。

频道最直接的体现是一个形如 https://nixos.org/channels/nixos22.11 的 URL。

`,11),p={href:"https://channels.nixos.org/",target:"_blank",rel:"noopener noreferrer"},h=i(`

请你尝试访问上面的 URL。正如我们所说，这是一个频道集合，根目录下的每一个子目录就代表一个频道，官方提供了若干个频道：

2022/8/4 22:51:25               0.1 kB         nixos-21.11
-2022/8/4 22:59:10               0.1 kB         nixos-21.11-aarch64
-2022/8/2 23:24:22               0.1 kB         nixos-21.11-small
-2023/1/3 23:39:40               0.1 kB         nixos-22.05
-2023/1/3 22:43:29               0.1 kB         nixos-22.05-aarch64
-2023/1/2 04:11:11               0.1 kB         nixos-22.05-small
-2023/3/16 05:19:03              0.1 kB         nixos-22.11
-2023/3/16 22:18:18              0.1 kB         nixos-22.11-small
-2023/3/16 14:55:20              0.1 kB         nixos-unstable
-2023/3/16 21:27:06              0.1 kB         nixos-unstable-small
-2023/1/2 21:05:38               0.1 kB         nixpkgs-22.05-darwin
-2023/3/17 00:30:11              0.1 kB         nixpkgs-22.11-darwin
-2023/3/16 04:06:35              0.1 kB         nixpkgs-unstable
-

项目结构

我们以官方频道 nixpkgs-unstable 为例，查看每个频道大致的构成。它们似乎都提供了 nixexprs.tar.xz，从文件名我们就了解到这是一个包含了若干 nix 文件的 tar 压缩档（Tarball）。

Tarball

Tarball 是 tar 文件格式的全称，不是 Nix 独有。它可以将多个文件打包在一起。如果你想在打包的时候压缩一下，还可以使用 gzip，bzip2 等软件压缩该档案。当你对 tar 文件启用压缩以后，后缀名会变更为 tar.gz, tar.bz2 等，具体取决于你使用的压缩软件。

于是我们解压它，列出目录树：

├─.github
-├─doc
-├─lib
-├─maintainers
-├─nixos
-└─pkgs
-    ├─applications
-    │  ├─accessibility
-    │  │  ├─contrast
-    │  │  └─wvkbd
-    │  ├─audio
-    │  │  ├─a2jmidid
-    │  │  ├─ario
-    │  │  ├─csound
-    │  │  │  ├─csound-manual
-    │  │  │  └─csound-qt
-    ......
-

仅供演示

以上目录树是笔者为了方便演示而精简过的部分，实际构成肯定有差别。

上面的每个子目录中都有一个 default.nix 文件，这是导入该目录时默认被求值的文件。每个包名文件夹下面的 nix 文件，这些文件和脚本类似，运行它们时，会从五湖四海获取源码和其他资源，再根据脚本的描述构建出相应的二进制包。

`,9),u={class:"hint-container tip"},x=a("p",{class:"hint-container-title"},"提示",-1),v={href:"https://nixos-cn.org/guide/lang/",target:"_blank",rel:"noopener noreferrer"},m=i(`

每个频道都应该提供一个名为 nixexprs 的 Tarball。其中 default.nix 既是根目录也是每一级目录的入口点。

系统频道与软件仓库频道

频道在 NixOS 中大致被分为两类：系统频道和软件仓库频道。

系统频道

系统频道可以从 URL 中直观的体现。形如 https://nixos.org/channels/nixos22.11 你很快就了解到这是一个 22.11 版本的 NixOS 的频道。

默认订阅的频道

NixOS 默认订阅了官方频道 nixos，即使你安装完系统什么都不做，它们也是存在的：

sudo nix-channel --list  # 列出频道
-
nixos https://nixos.org/channels/nixos22.11
-

这个频道提供了组成系统的一些驱动，设施等等。

注意

这里的 nixos 与 https://nixos.org/channels/nixos22.11 并不是并列关系，前者是频道名，后面是被订阅的 URL。

当你有两个及两个以上频道的时候，你就会理解我的意思：

nixos https://nixos.org/channels/nixos22.11
-nixpkgs https://nixos.org/channels/nixpkgs-unstable
-

除非升级系统或更换镜像频道，否则不要动系统默认的 nixos 频道。

一些特殊的频道

  • 稳定（stable）频道。如 nixos-22.11。这些频道只能得到保守的错误修复和软件包升级。例如，频道更新可能会导致系统上的Linux内核从 4.19.34 升级到 4.19.38（一个小错误修复），但不会从 4.19.x 升级到 4.20.x（一个可能会破坏一切的重大更改）。在创建下一个稳定分支之前，通常会保持稳定的频道。
  • 不稳定（unstable）频道。这与 nixos 的主要开发分支相对应，因此可能有破坏性更新，不建议用于生产系统。
  • 小型（small）频道，如 nixos-22.11-small 或 nix-unstable-small。这些频道与上述稳定和不稳定频道相同，只是它们包含较少的二进制包。这意味着它们比常规通道更新得更快（例如，当一个关键的安全补丁被提交到 NixOS 的源代码树时），但可能有更多的包需要从源代码构建。它们主要用于服务器环境，因此包含很少的 GUI 应用程序。
`,8),b={href:"https://nixos.org/channels",target:"_blank",rel:"noopener noreferrer"},g={href:"https://nixos.org/nixos/download.html",target:"_blank",rel:"noopener noreferrer"},k=i(`

升级系统 #TODO

你可以使用以下命令获取当前的 nixos 频道

nix-channel --list | grep nixos
-

要切换到不同的NixOS通道，请执行

nix-channel --add https://nixos.org/channels/channel-name nixos
-

以 nixos 22.11 为例，命令为

nix-channel --add https://nixos.org/channels/nixos-22.11 nixos
-

使用以下命令以开始切换

nixos-rebuild switch --upgrade
-

该命令相当于 nix-channel --update nixos; nixos-rebuild switch

注

频道的切换是以用户为单位的。当你不以 root 权限执行时，不会影响 /etc/nixos/configuration.nix 的配置

注意

在频道之间来回切换通常是安全的。唯一的例外是，一个较新的NixOS也可能有一个较低的Nix版本，这可能涉及到Nix数据库模式的升级。这是不容易撤消的，所以在这种情况下，您将无法返回到原始频道。

软件仓库频道

软件仓库频道不仅仅可以为 NixOS 使用，其他 Linux 发行版也可以安装 Nix 包管理器从中获取软件包，甚至 Darwin 也可以。

订阅 nixpkgs-unstable 频道

nixpkgs 仓库

nixpkgs 仓库更新非常快，所以没有稳定版。不过 darwin 是例外，因为 Nix 包管理器不能保证实时兼容当前的 darwin 平台，所以要做版本控制。

sudo nix-channel --add https://nixos.org/channels/nixpkgs-unstable  # 添加频道，不过我更喜欢称它为 “订阅”
-sudo nix-channel --update  # 更新频道
-

如此，你便订阅上了官方的 nixpkgs-unstable 软件源。

推荐订阅镜像频道

上文仅供教学。在下一节我们会指引大家订阅国内能正常访问的镜像频道，键入下面的命令以退订官方的 nixpkgs-unstable 频道：

sudo nix-channel --remove nixpkgs-unstable
-

自定义频道名

默认情况下，频道名是截取自 URL 的最后一级：

nix-channel --add https://host/nixpkgs-unstable
-

我们列出频道名：

nixpkgs-unstable https://host/nixpkgs-unstable
-

如果我们需要手动命名频道，增加一个参数即可：

nix-channel --add https://host/nixpkgs-unstable nixpkgs
-

使用镜像频道

由于不可抗力的因素，大陆对于环大陆主机的访问显得异常艰难，所以我们需要使用国内的镜像频道来替代我们对官方频道（镜像频道通常由大学和企业公益性提供），下面列出了一些在中国可用的一些镜像频道：

  • 中国教育和科研计算机网（清华大学）https://mirrors.cernet.edu.cn/nix-channels/store
  • 中国科学技术大学 https://mirrors.ustc.edu.cn/nix-channels/store
  • 上海交通大学 https://mirror.sjtu.edu.cn/nix-channels/store
  • 北京外国语大学 https://mirrors.bfsu.edu.cn/nix-channels/store
  • 南京大学 https://mirror.nju.edu.cn/nix-channels/store
  • 中国科学院软件研究所 https://mirror.iscas.ac.cn/nix-channels/store

我们使用镜像源替代官方的系统频道和软件仓库频道：

sudo nix-channel --add https://mirrors.ustc.edu.cn/nix-channels/nixpkgs-unstable nixpkgs  # 订阅镜像仓库频道
-sudo nix-channel --add https://mirrors.ustc.edu.cn/nix-channels/nixos-22.11 nixos  # 请注意系统版本
-sudo nix-channel --list  # 列出频道
-

注

特地修改频道名是因为许多表达式都会把 nixpkgs 而不是 nixpkgs-unstable 作输入。

二进制构建缓存

源码分发是指将软件的源代码打包并分发给用户（Gentoo），二进制分发则是将已编译好的二进制程序直接分发给用户（例如 Debian，RHEL）。NixOS 默认是源码分发形式，不过我们可以添加二进制缓存源来让 NixOS 从缓存主机获取已经构建好的软件包。

为 NixOS 添加二进制缓存源

只需要修改 NixOS 配置中的 substituters 即可：

nix.settings.substituters = [ "https://mirrors.ustc.edu.cn/nix-channels/store" ];
-

由于官方的二进制缓存源是默认添加的，你可以通过下面的方式只启用自己指定的二进制缓存源：

# 记得导入 lib
-nix.settings.substituters = lib.mkForce [ "https://mirrors.cernet.edu.cn/nix-channels/store" ];
-

当前可用的二进制缓存主机列表

  • 中国科研和教育计算机网 https://mirrors.cernet.edu.cn/nix-channels/store
  • 中国科技大学 https://mirrors.ustc.edu.cn/nix-channels/store
  • 上海交通大学 https://mirror.sjtu.edu.cn/nix-channels/store
  • 中国教育和科研计算机网 https://mirrors.cernet.edu.cn/nix-channels/store
  • 北京外国语大学 https://mirrors.bfsu.edu.cn/nix-channels/store
  • 南京大学 https://mirror.nju.edu.cn/nix-channels/store
  • 中国科学院软件研究所 https://mirror.iscas.ac.cn/nix-channels/store

Cachix 服务

`,36),N={href:"https://www.cachix.org/",target:"_blank",rel:"noopener noreferrer"},f=i('

Nix 生态构成简述

Nix 生态主要由 Nix 表达式语言，NixOS，Nix 包管理器，Nixpkgs，NixOps，Hydra 构成。以下只是梗概，并不需要你完全理解或记住它。

名称描述
Nix 表达式语言Nix 表达式语言是一种函数式编程语言，用于描述软件包的构建过程、依赖关系和环境变量等信息。它支持函数定义、递归、模式匹配等特性，还支持嵌套语法，可描述复杂的依赖关系和构建过程。Nix 还支持原子事务，使得所有的包和环境都是原子的，不会相互影响。Nix 表达式语言可用于定义软件包和环境，也可用于描述系统配置。它是一种强大、灵活、可重复和可扩展的语言，用于管理软件包和环境。
NixOSNixOS 是一种基于 Nix 包管理器的 Linux 发行版，具有高度可配置性、可重复性和安全性。它采用声明性配置，使用配置文件明确描述系统状态，使得配置更易于维护。NixOS 适用于需要高度可定制性的用例，如服务器和开发环境。
Nix 包管理器Nix 是跨平台的功能强大的包管理器，采用函数式编程思想描述依赖关系和多版本软件包管理，并提供一系列跨平台工具方便管理和部署。
NixOpsNixOps是基于NixOS的云部署管理工具，支持多云平台，提供简单的命令行接口，可创建、部署、升级和回滚NixOS。用户可通过编写Nix表达式自定义部署和配置，使其成为灵活、可扩展和可定制的工具。适合需要管理大型、复杂基础设施的组织。
HydraHydra 是在 NixOS 中使用的 CI/CD 系统，它可以自动构建、测试和部署软件包，并决定是否发布和部署。Hydra 可以在不同环境下测试软件包，适用于开发、测试和部署任何类型的软件。
Nixpkgsnixpkgs 是 Nix 软件包管理器的官方软件包集合，包含数以万计的软件包，并提供了构建、测试和部署工具，支持多平台和多架构，适用于开发、测试和部署各种类型的软件。
',3);function _(O,S){const e=l("ExternalLinkIcon");return c(),o("div",null,[r,a("p",null,[n("官方提供了"),a("a",p,[n("官方频道集合"),s(e)]),n("。订阅了其中的频道以后，就会从相应的频道获取更新，大致和你使用其他发行版的软件源类似，不过我们后面会详述 NixOS 中的“频道”概念和传统发行版中“软件源”的区别。")]),h,a("div",u,[x,a("p",null,[n("如果你还没有学习过 Nix 表达式语言，大抵是看不懂的，你可以前往 "),a("a",v,[n("Nix 语言概览"),s(e)]),n(" 进行初步学习。")])]),m,a("p",null,[n("要查看可用的频道，请转到"),a("a",b,[n("官方频道"),s(e)]),n("。（请注意，各种频道的 URI 重定向到一个包含最新版本频道的目录，还包括 ISO 映像和 VirtualBox 设备。）")]),a("p",null,[n("请注意，在发布过程中，尚未发布的频道也将出现在此处。请参阅"),a("a",g,[n("官方 Getting NixOS 页面"),s(e)]),n("以查找最新支持的稳定版本。")]),k,a("p",null,[n("Cachix 服务是 Nix 二进制缓存服务实现的方式之一，你可以使用它在服务器构建缓存，然后连接到该服务器的主机可以分享这些缓存，从而避免了二次构建。了解详情请参阅 "),a("a",N,[n("Cachix 官网"),s(e)]),n("。")]),f])}const B=t(d,[["render",_],["__file","Intro.html.vue"]]),T=JSON.parse('{"path":"/manual/Intro.html","title":"NixOS 入门","lang":"zh-CN","frontmatter":{"description":"NixOS 入门 内容施工中 本节内容正在修缮中，当前内容可能已经过时，仅供参考。 何谓 nix-channel nix-channel 是一个命令行工具，用于订阅系统频道和软件频道。 命令行 nix-channel 命令行工具的使用： 看起来，这个命令行工具提供的功能有：订阅频道，退订频道，列出频道，更新频道，还能回滚“生成”。 频道是什么 上面我们...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/manual/Intro.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"NixOS 入门"}],["meta",{"property":"og:description","content":"NixOS 入门 内容施工中 本节内容正在修缮中，当前内容可能已经过时，仅供参考。 何谓 nix-channel nix-channel 是一个命令行工具，用于订阅系统频道和软件频道。 命令行 nix-channel 命令行工具的使用： 看起来，这个命令行工具提供的功能有：订阅频道，退订频道，列出频道，更新频道，还能回滚“生成”。 频道是什么 上面我们..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2024-04-30T08:58:38.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2024-04-30T08:58:38.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"NixOS 入门\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2024-04-30T08:58:38.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"何谓 nix-channel","slug":"何谓-nix-channel","link":"#何谓-nix-channel","children":[{"level":3,"title":"命令行","slug":"命令行","link":"#命令行","children":[]},{"level":3,"title":"频道是什么","slug":"频道是什么","link":"#频道是什么","children":[]},{"level":3,"title":"项目结构","slug":"项目结构","link":"#项目结构","children":[]}]},{"level":2,"title":"系统频道与软件仓库频道","slug":"系统频道与软件仓库频道","link":"#系统频道与软件仓库频道","children":[{"level":3,"title":"系统频道","slug":"系统频道","link":"#系统频道","children":[]},{"level":3,"title":"软件仓库频道","slug":"软件仓库频道","link":"#软件仓库频道","children":[]}]},{"level":2,"title":"使用镜像频道","slug":"使用镜像频道","link":"#使用镜像频道","children":[]},{"level":2,"title":"二进制构建缓存","slug":"二进制构建缓存","link":"#二进制构建缓存","children":[{"level":3,"title":"为 NixOS 添加二进制缓存源","slug":"为-nixos-添加二进制缓存源","link":"#为-nixos-添加二进制缓存源","children":[]},{"level":3,"title":"当前可用的二进制缓存主机列表","slug":"当前可用的二进制缓存主机列表","link":"#当前可用的二进制缓存主机列表","children":[]},{"level":3,"title":"Cachix 服务","slug":"cachix-服务","link":"#cachix-服务","children":[]}]},{"level":2,"title":"Nix 生态构成简述","slug":"nix-生态构成简述","link":"#nix-生态构成简述","children":[]}],"git":{"createdTime":1711468225000,"updatedTime":1714467518000,"contributors":[{"name":"Ryan Yin","email":"xiaoyin_c@qq.com","commits":1},{"name":"linglilongyi","email":"46670292+linglilongyi@users.noreply.github.com","commits":1}]},"readingTime":{"minutes":10.4,"words":3119},"filePathRelative":"manual/Intro.md","localizedDate":"2024年3月26日","autoDesc":true,"excerpt":"\\n
\\n

内容施工中

\\n

本节内容正在修缮中，当前内容可能已经过时，仅供参考。

\\n
\\n

何谓 nix-channel

\\n

nix-channel 是一个命令行工具，用于订阅系统频道和软件频道。

\\n

命令行

\\n

nix-channel 命令行工具的使用：

\\n
nix-channel {--add url [name] | --remove name | --list | --update [names…] | --rollback [generation] }\\n
"}');export{B as comp,T as data}; diff --git a/assets/Manuals.html-BZkwlMGp.js b/assets/Manuals.html-DFp7igCI.js similarity index 83% rename from assets/Manuals.html-BZkwlMGp.js rename to assets/Manuals.html-DFp7igCI.js index 66505c6..bf98018 100644 --- a/assets/Manuals.html-BZkwlMGp.js +++ b/assets/Manuals.html-DFp7igCI.js @@ -1,4 +1,4 @@ -import{_ as i}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as o,o as p,c as l,a as s,b as n,d as e,e as t}from"./app-KtH3BPxJ.js";const c={},r=t(`

Nix 语言进阶手册

数据类型

原始数据类型

字符串

有三种方式定义字符串。

单行字符串

与大多数编程语言的字符串一致，使用双引号闭合：

"Hello, nix!\\n"
+import{_ as i}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as o,o as p,c as l,a as s,b as n,d as e,e as t}from"./app-BNkVxcYY.js";const c={},r=t(`
Nix 语言进阶手册
数据类型
原始数据类型
字符串
有三种方式定义字符串。
单行字符串
与大多数编程语言的字符串一致，使用双引号闭合：
"Hello, nix!\\n"
 
多行字符串
多行字符串是通过两个单引号闭合的。
''
 This is the first line.
 This is the second line.
@@ -87,4 +87,4 @@ alist
   recurse = n: if n <= 0 then [] else recurse (n - 1) ++ [n];
 in
   recurse 5
-
断言
with 表达式
注释
`,8);function N(T,B){const a=o("ExternalLinkIcon");return p(),l("div",null,[r,s("p",null,[n("为了书写简便， "),s("a",d,[n("RFC 2396"),e(a)]),n(" 规定了对于 URI 可以不使用引号闭合：")]),u,s("p",null,[n("这里不展开说明函数式编程与命令式编程的区别，不了解这个的读者建议先阅读 "),s("a",k,[n("什么是函数式编程思维？- 知乎"),e(a)]),n(" 与 "),s("a",m,[n("函数式编程 - WIkipedia"),e(a)]),n(" 理清个中关系。")]),v,h,s("p",null,[n("Nix 语言自身提供了一些精简的内建函数，可通过 "),g,n(" 这种方式使用，官方文档参见 "),s("a",x,[n("Built-in Functions - Nix Manual"),e(a)]),n(".")]),s("p",null,[n("此外，官方函数库 "),s("a",b,[n("nixpkgs.lib"),e(a)]),n(" 提供了比 builtins 更丰富的功能。")]),s("p",null,[n("社区提供的 "),s("a",f,[n("Noogle Search"),e(a)]),n(" 可以相当容易地搜索上述两类函数，推荐一用。")]),q,s("ul",null,[s("li",null,[s("a",y,[n("属性集相关函数"),e(a)])]),s("li",null,[s("a",w,[n("列表相关函数"),e(a)])])]),_])}const E=i(c,[["render",N],["__file","Manuals.html.vue"]]),z=JSON.parse('{"path":"/tutorials/lang/Manuals.html","title":"Nix 语言进阶手册","lang":"zh-CN","frontmatter":{"description":"Nix 语言进阶手册 数据类型 原始数据类型 字符串 有三种方式定义字符串。 单行字符串 与大多数编程语言的字符串一致，使用双引号闭合： 多行字符串 多行字符串是通过两个单引号闭合的。 多行字符串往往会带有不同程度的缩进，会被进一步处理。也就是说对于以下字符串： 会被“智能缩进”处理，处理后的结果是： 每一行都被前移了最小缩进数个字符。 同时，假如第一...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/lang/Manuals.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"Nix 语言进阶手册"}],["meta",{"property":"og:description","content":"Nix 语言进阶手册 数据类型 原始数据类型 字符串 有三种方式定义字符串。 单行字符串 与大多数编程语言的字符串一致，使用双引号闭合： 多行字符串 多行字符串是通过两个单引号闭合的。 多行字符串往往会带有不同程度的缩进，会被进一步处理。也就是说对于以下字符串： 会被“智能缩进”处理，处理后的结果是： 每一行都被前移了最小缩进数个字符。 同时，假如第一..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2024-06-27T13:01:39.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2024-06-27T13:01:39.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"Nix 语言进阶手册\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2024-06-27T13:01:39.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"数据类型","slug":"数据类型","link":"#数据类型","children":[{"level":3,"title":"原始数据类型","slug":"原始数据类型","link":"#原始数据类型","children":[]},{"level":3,"title":"列表","slug":"列表","link":"#列表","children":[]},{"level":3,"title":"属性集","slug":"属性集","link":"#属性集","children":[]}]},{"level":2,"title":"数据构造","slug":"数据构造","link":"#数据构造","children":[{"level":3,"title":"递归属性集","slug":"递归属性集","link":"#递归属性集","children":[]},{"level":3,"title":"let 绑定","slug":"let-绑定","link":"#let-绑定","children":[]},{"level":3,"title":"继承至属性","slug":"继承至属性","link":"#继承至属性","children":[]},{"level":3,"title":"函数","slug":"函数","link":"#函数","children":[]},{"level":3,"title":"条件判断","slug":"条件判断","link":"#条件判断","children":[]},{"level":3,"title":"循环控制","slug":"循环控制","link":"#循环控制","children":[]},{"level":3,"title":"断言","slug":"断言","link":"#断言","children":[]},{"level":3,"title":"with 表达式","slug":"with-表达式","link":"#with-表达式","children":[]},{"level":3,"title":"注释","slug":"注释","link":"#注释","children":[]}]}],"git":{"createdTime":1697259560000,"updatedTime":1719493299000,"contributors":[{"name":"Tatooi Noyo","email":"98942281+TatooiNoyo@users.noreply.github.com","commits":5},{"name":"Tatooi Noyo","email":"tatooi.noyo@outlook.com","commits":5},{"name":"OpenTritium","email":"tritium404@hotmail.com","commits":4},{"name":"Ryan Yin","email":"xiaoyin_c@qq.com","commits":4}]},"readingTime":{"minutes":5.83,"words":1749},"filePathRelative":"tutorials/lang/Manuals.md","localizedDate":"2023年10月14日","autoDesc":true,"excerpt":"\\n
数据类型
\\n
原始数据类型
\\n
字符串
\\n
有三种方式定义字符串。
\\n
单行字符串
\\n
与大多数编程语言的字符串一致，使用双引号闭合：
\\n
\\"Hello, nix!\\\\n\\"\\n
多行字符串
\\n
多行字符串是通过两个单引号闭合的。
"}');export{E as comp,z as data};
+

断言

with 表达式

注释

`,8);function N(T,B){const a=o("ExternalLinkIcon");return p(),l("div",null,[r,s("p",null,[n("为了书写简便， "),s("a",d,[n("RFC 2396"),e(a)]),n(" 规定了对于 URI 可以不使用引号闭合：")]),u,s("p",null,[n("这里不展开说明函数式编程与命令式编程的区别，不了解这个的读者建议先阅读"),s("a",k,[n("什么是函数式编程思维？- 知乎"),e(a)]),n(" 与"),s("a",m,[n("函数式编程 - WIkipedia"),e(a)]),n(" 理清个中关系。")]),v,h,s("p",null,[n("Nix 语言自身提供了一些精简的内建函数，可通过 "),g,n(" 这种方式使用，官方文档参见 "),s("a",x,[n("Built-in Functions - Nix Manual"),e(a)]),n(".")]),s("p",null,[n("此外，官方函数库 "),s("a",b,[n("nixpkgs.lib"),e(a)]),n(" 提供了比 builtins 更丰富的功能。")]),s("p",null,[n("社区提供的 "),s("a",f,[n("Noogle Search"),e(a)]),n(" 可以相当容易地搜索上述两类函数，推荐一用。")]),q,s("ul",null,[s("li",null,[s("a",y,[n("属性集相关函数"),e(a)])]),s("li",null,[s("a",w,[n("列表相关函数"),e(a)])])]),_])}const E=i(c,[["render",N],["__file","Manuals.html.vue"]]),z=JSON.parse('{"path":"/tutorials/lang/Manuals.html","title":"Nix 语言进阶手册","lang":"zh-CN","frontmatter":{"description":"Nix 语言进阶手册 数据类型 原始数据类型 字符串 有三种方式定义字符串。 单行字符串 与大多数编程语言的字符串一致，使用双引号闭合： 多行字符串 多行字符串是通过两个单引号闭合的。 多行字符串往往会带有不同程度的缩进，会被进一步处理。也就是说对于以下字符串： 会被“智能缩进”处理，处理后的结果是： 每一行都被前移了最小缩进数个字符。 同时，假如第一...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/lang/Manuals.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"Nix 语言进阶手册"}],["meta",{"property":"og:description","content":"Nix 语言进阶手册 数据类型 原始数据类型 字符串 有三种方式定义字符串。 单行字符串 与大多数编程语言的字符串一致，使用双引号闭合： 多行字符串 多行字符串是通过两个单引号闭合的。 多行字符串往往会带有不同程度的缩进，会被进一步处理。也就是说对于以下字符串： 会被“智能缩进”处理，处理后的结果是： 每一行都被前移了最小缩进数个字符。 同时，假如第一..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2024-06-30T15:34:48.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2024-06-30T15:34:48.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"Nix 语言进阶手册\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2024-06-30T15:34:48.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"数据类型","slug":"数据类型","link":"#数据类型","children":[{"level":3,"title":"原始数据类型","slug":"原始数据类型","link":"#原始数据类型","children":[]},{"level":3,"title":"列表","slug":"列表","link":"#列表","children":[]},{"level":3,"title":"属性集","slug":"属性集","link":"#属性集","children":[]}]},{"level":2,"title":"数据构造","slug":"数据构造","link":"#数据构造","children":[{"level":3,"title":"递归属性集","slug":"递归属性集","link":"#递归属性集","children":[]},{"level":3,"title":"let 绑定","slug":"let-绑定","link":"#let-绑定","children":[]},{"level":3,"title":"继承至属性","slug":"继承至属性","link":"#继承至属性","children":[]},{"level":3,"title":"函数","slug":"函数","link":"#函数","children":[]},{"level":3,"title":"条件判断","slug":"条件判断","link":"#条件判断","children":[]},{"level":3,"title":"循环控制","slug":"循环控制","link":"#循环控制","children":[]},{"level":3,"title":"断言","slug":"断言","link":"#断言","children":[]},{"level":3,"title":"with 表达式","slug":"with-表达式","link":"#with-表达式","children":[]},{"level":3,"title":"注释","slug":"注释","link":"#注释","children":[]}]}],"git":{"createdTime":1697259560000,"updatedTime":1719761688000,"contributors":[{"name":"Ryan Yin","email":"xiaoyin_c@qq.com","commits":5},{"name":"Tatooi Noyo","email":"98942281+TatooiNoyo@users.noreply.github.com","commits":5},{"name":"Tatooi Noyo","email":"tatooi.noyo@outlook.com","commits":5},{"name":"OpenTritium","email":"tritium404@hotmail.com","commits":4}]},"readingTime":{"minutes":5.83,"words":1749},"filePathRelative":"tutorials/lang/Manuals.md","localizedDate":"2023年10月14日","autoDesc":true,"excerpt":"\\n

数据类型

\\n

原始数据类型

\\n

字符串

\\n

有三种方式定义字符串。

\\n
单行字符串
\\n

与大多数编程语言的字符串一致，使用双引号闭合：

\\n
\\"Hello, nix!\\\\n\\"\\n
多行字符串
\\n

多行字符串是通过两个单引号闭合的。

"}');export{E as comp,z as data}; diff --git a/assets/Networking.html-xvk50dn3.js b/assets/Networking.html-D__jtwiK.js similarity index 64% rename from assets/Networking.html-xvk50dn3.js rename to assets/Networking.html-D__jtwiK.js index e79ab94..fb3dfc1 100644 --- a/assets/Networking.html-xvk50dn3.js +++ b/assets/Networking.html-D__jtwiK.js @@ -1,4 +1,4 @@ -import{_ as t}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as i,o,c as p,a as s,b as n,d as e,e as l}from"./app-KtH3BPxJ.js";const c={},r=l(`

NixOS 的网络问题

国内用户在使用 NixOS 时会存在一些网络问题，一是 NixOS 高度依赖 GitHub 作为 channel/flake 数据源——在国内访问 GitHub 相当的慢，二是 NixOS 官方的包缓存服务器在国内访问速度较慢。

为了解决这些问题，你可以使用国内的镜像源，或者使用代理工具来加速访问。

这里我先介绍几个比较简单的配置方法。

1. 使用国内的 Nix 包缓存服务器

首先，在执行后面给出的任何 nix 相关命令时，你都可以通过 --option 选项来指定镜像源，例如：

# 使用上海交通大学的镜像源
+import{_ as t}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as i,o,c as p,a as s,b as n,d as e,e as l}from"./app-BNkVxcYY.js";const c={},r=l(`
NixOS 的网络问题
国内用户在使用 NixOS 时会存在一些网络问题，一是 NixOS 高度依赖 GitHub 作为 channel/flake 数据源——在国内访问 GitHub 相当的慢，二是 NixOS 官方的包缓存服务器在国内访问速度较慢。
为了解决这些问题，你可以使用国内的镜像源，或者使用代理工具来加速访问。
这里我先介绍几个比较简单的配置方法。
1. 使用国内的 Nix 包缓存服务器
首先，在执行后面给出的任何 nix 相关命令时，你都可以通过 --option 选项来指定镜像源，例如：
# 使用上海交通大学的镜像源
 # 官方文档: https://mirror.sjtu.edu.cn/docs/nix-channels/store
 nixos-rebuild switch --option substituters "https://mirror.sjtu.edu.cn/nix-channels/store"
 
@@ -34,4 +34,4 @@ Environment="https_proxy=socks5h://localhost:7891"
 EOF
 sudo systemctl daemon-reload
 sudo systemctl restart nix-daemon
-
但请注意，系统重启后 /run/ 目录下的内容会被清空，所以每次重启后都需要重新执行上述命令！
如果你希望永久设置代理，建议将上述命令保存为 shell 脚本，在每次启动系统时运行一下。或者也可以使用旁路网关或 TUN 等全局代理方案。
`,20),u={href:"https://nixos-and-flakes.thiscute.world/zh/nixos-with-flakes/add-custom-cache-servers",target:"_blank",rel:"noopener noreferrer"},d={class:"hint-container warning"},m=s("p",{class:"hint-container-title"},"GitHub 报 HTTP 403 错误",-1),h={href:"https://github.com/ryan4yin/nixos-and-flakes-book/issues/74",target:"_blank",rel:"noopener noreferrer"},k={href:"https://github.com/NixOS/nix/issues/6536",target:"_blank",rel:"noopener noreferrer"};function x(v,b){const a=i("ExternalLinkIcon");return o(),p("div",null,[r,s("p",null,[n("更详细的说明与其他用法介绍，请移步"),s("a",u,[n("添加自定义缓存服务器"),e(a)]),n(" ，注意这部分内容可能需要一定的 NixOS 使用经验才能理解。")]),s("div",d,[m,s("p",null,[n("注意：使用一些商用代理或公共代理时你可能会遇到 GitHub 下载时报 HTTP 403 错误（"),s("a",h,[n("nixos-and-flakes-book/issues/74"),e(a)]),n("），可尝试通过更换代理服务器或者设置 "),s("a",k,[n("access-tokens"),e(a)]),n(" 来解决。")])])])}const f=t(c,[["render",x],["__file","Networking.html.vue"]]),N=JSON.parse('{"path":"/tutorials/installation/Networking.html","title":"NixOS 的网络问题","lang":"zh-CN","frontmatter":{"description":"NixOS 的网络问题 国内用户在使用 NixOS 时会存在一些网络问题，一是 NixOS 高度依赖 GitHub 作为 channel/flake 数据源——在国内访问 GitHub 相当的慢，二是 NixOS 官方的包缓存服务器在国内访问速度较慢。 为了解决这些问题，你可以使用国内的镜像源，或者使用代理工具来加速访问。 这里我先介绍几个比较简单的配...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/installation/Networking.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"NixOS 的网络问题"}],["meta",{"property":"og:description","content":"NixOS 的网络问题 国内用户在使用 NixOS 时会存在一些网络问题，一是 NixOS 高度依赖 GitHub 作为 channel/flake 数据源——在国内访问 GitHub 相当的慢，二是 NixOS 官方的包缓存服务器在国内访问速度较慢。 为了解决这些问题，你可以使用国内的镜像源，或者使用代理工具来加速访问。 这里我先介绍几个比较简单的配..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2024-03-27T15:33:47.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2024-03-27T15:33:47.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"NixOS 的网络问题\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2024-03-27T15:33:47.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"1. 使用国内的 Nix 包缓存服务器","slug":"_1-使用国内的-nix-包缓存服务器","link":"#_1-使用国内的-nix-包缓存服务器","children":[]},{"level":2,"title":"2. 使用国内镜像地址加速 Flakes Inputs 的下载","slug":"_2-使用国内镜像地址加速-flakes-inputs-的下载","link":"#_2-使用国内镜像地址加速-flakes-inputs-的下载","children":[]},{"level":2,"title":"3. 使用代理工具加速访问 Channels 跟 Flake Inputs","slug":"_3-使用代理工具加速访问-channels-跟-flake-inputs","link":"#_3-使用代理工具加速访问-channels-跟-flake-inputs","children":[]}],"git":{"createdTime":1711467352000,"updatedTime":1711553627000,"contributors":[{"name":"Ryan Yin","email":"xiaoyin_c@qq.com","commits":2}]},"readingTime":{"minutes":2.65,"words":796},"filePathRelative":"tutorials/installation/Networking.md","localizedDate":"2024年3月26日","autoDesc":true,"excerpt":"\\n
国内用户在使用 NixOS 时会存在一些网络问题，一是 NixOS 高度依赖 GitHub 作为 channel/flake\\n数据源——在国内访问 GitHub 相当的慢，二是 NixOS 官方的包缓存服务器在国内访问速度较慢。
\\n
为了解决这些问题，你可以使用国内的镜像源，或者使用代理工具来加速访问。
\\n
这里我先介绍几个比较简单的配置方法。
\\n
1. 使用国内的 Nix 包缓存服务器
\\n
首先，在执行后面给出的任何 nix 相关命令时，你都可以通过 --option 选项来指定镜像源，例如：
"}');export{f as comp,N as data};
+

但请注意，系统重启后 /run/ 目录下的内容会被清空，所以每次重启后都需要重新执行上述命令！

如果你希望永久设置代理，建议将上述命令保存为 shell 脚本，在每次启动系统时运行一下。或者也可以使用旁路网关或 TUN 等全局代理方案。

`,20),u={href:"https://nixos-and-flakes.thiscute.world/zh/nixos-with-flakes/add-custom-cache-servers",target:"_blank",rel:"noopener noreferrer"},d={class:"hint-container warning"},m=s("p",{class:"hint-container-title"},"GitHub 报 HTTP 403 错误注意：使用一些商用代理或公共代理时你可能会遇",-1),h={href:"https://github.com/ryan4yin/nixos-and-flakes-book/issues/74",target:"_blank",rel:"noopener noreferrer"},k={href:"https://github.com/NixOS/nix/issues/6536",target:"_blank",rel:"noopener noreferrer"};function x(v,b){const a=i("ExternalLinkIcon");return o(),p("div",null,[r,s("p",null,[n("更详细的说明与其他用法介绍，请移步"),s("a",u,[n("添加自定义缓存服务器"),e(a)]),n("，注意这部分内容可能需要一定的 NixOS 使用经验才能理解。")]),s("div",d,[m,s("p",null,[n("到 GitHub 下载时报 HTTP 403 错误（"),s("a",h,[n("nixos-and-flakes-book/issues/74"),e(a)]),n("），可尝试通过更换代理服务器或者设置 "),s("a",k,[n("access-tokens"),e(a)]),n(" 来解决。:::")])])])}const f=t(c,[["render",x],["__file","Networking.html.vue"]]),N=JSON.parse('{"path":"/tutorials/installation/Networking.html","title":"NixOS 的网络问题","lang":"zh-CN","frontmatter":{"description":"NixOS 的网络问题 国内用户在使用 NixOS 时会存在一些网络问题，一是 NixOS 高度依赖 GitHub 作为 channel/flake 数据源——在国内访问 GitHub 相当的慢，二是 NixOS 官方的包缓存服务器在国内访问速度较慢。 为了解决这些问题，你可以使用国内的镜像源，或者使用代理工具来加速访问。 这里我先介绍几个比较简单的配...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/installation/Networking.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"NixOS 的网络问题"}],["meta",{"property":"og:description","content":"NixOS 的网络问题 国内用户在使用 NixOS 时会存在一些网络问题，一是 NixOS 高度依赖 GitHub 作为 channel/flake 数据源——在国内访问 GitHub 相当的慢，二是 NixOS 官方的包缓存服务器在国内访问速度较慢。 为了解决这些问题，你可以使用国内的镜像源，或者使用代理工具来加速访问。 这里我先介绍几个比较简单的配..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2024-06-30T15:34:48.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2024-06-30T15:34:48.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"NixOS 的网络问题\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2024-06-30T15:34:48.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"1. 使用国内的 Nix 包缓存服务器","slug":"_1-使用国内的-nix-包缓存服务器","link":"#_1-使用国内的-nix-包缓存服务器","children":[]},{"level":2,"title":"2. 使用国内镜像地址加速 Flakes Inputs 的下载","slug":"_2-使用国内镜像地址加速-flakes-inputs-的下载","link":"#_2-使用国内镜像地址加速-flakes-inputs-的下载","children":[]},{"level":2,"title":"3. 使用代理工具加速访问 Channels 跟 Flake Inputs","slug":"_3-使用代理工具加速访问-channels-跟-flake-inputs","link":"#_3-使用代理工具加速访问-channels-跟-flake-inputs","children":[]}],"git":{"createdTime":1711467352000,"updatedTime":1719761688000,"contributors":[{"name":"Ryan Yin","email":"xiaoyin_c@qq.com","commits":3}]},"readingTime":{"minutes":2.65,"words":796},"filePathRelative":"tutorials/installation/Networking.md","localizedDate":"2024年3月26日","autoDesc":true,"excerpt":"\\n

国内用户在使用 NixOS 时会存在一些网络问题，一是 NixOS 高度依赖 GitHub 作为\\nchannel/flake 数据源——在国内访问 GitHub 相当的慢，二是 NixOS 官方的包缓存服务器在国内访问速度较慢。

\\n

为了解决这些问题，你可以使用国内的镜像源，或者使用代理工具来加速访问。

\\n

这里我先介绍几个比较简单的配置方法。

\\n

1. 使用国内的 Nix 包缓存服务器

\\n

首先，在执行后面给出的任何 nix 相关命令时，你都可以通过 --option 选项来指定镜像源，例如：

"}');export{f as comp,N as data}; diff --git a/assets/PurityIsOurUltimatePursuit.html-BDKKUkcr.js b/assets/PurityIsOurUltimatePursuit.html-BDKKUkcr.js deleted file mode 100644 index 71865f8..0000000 --- a/assets/PurityIsOurUltimatePursuit.html-BDKKUkcr.js +++ /dev/null @@ -1,21 +0,0 @@ -import{_ as n}from"./plugin-vue_export-helper-DlAUqK2U.js";import{o as a,c as s,e}from"./app-KtH3BPxJ.js";const t={},i=e(`

纯净是我们的至高追求

整个构建系统并不是绝对纯净

我们前面一直在强调，NixOS 的生态系统有多函数式，好吧的确是有非常多的函数，但是这些函数似乎并不纯净。这些都要从整个函数机器的齿轮 —— Nix 文件说起。

为了设计一个纯净的函数，我们应该尽量地把它设计得封闭，使之隔离外部环境。但是 Nix 并不是这样，Nix 为了编译那些 Nix 文件，依然需要访问到外部世界的东西。

提示

Nix 文件可以访问任意文件（如 ~/.config/nixpkgs/config.nix）、环境变量、Git仓库、Nix搜索路径（$NIX_PATH）中的文件、命令行参数（--arg）以及系统类型（builtins.currentSystem）。

这就意味着这个函数的求值过程并不完全封闭。如果你在两台不同的机器上运行相同的 Nix 表达式，可能会得到不同的结果，因为这两台机器上的环境变量或文件系统可能是不同的。所以我们建议尽量避开任何带有路径依赖的写法。

但是这样做并不能完全解决问题，因为 Nix 文件本身就是一个路径依赖（当你使用 import 函数来引入其他 Nix 文件时，你必须指定一个相对或绝对路径）这就导致了一个问题：如果你想把你的 Nix 项目分享给别人，你必须保证他们能够找到你引用的所有文件。这就需要你把所有相关的文件都打包成一个压缩文件或者上传到一个 Git 仓库，并且告诉别人如何正确地使用它们。

这显然是很麻烦的，而且也违背了函数式编程的原则。我们希望能够用一种更简单和优雅的方式来管理和共享我们的 Nix 项目，而不需要关心它们所依赖的具体路径。

我们好像漏掉了什么细节

在前面的章节中，我们还一直试图给阅读者灌输 “NixOS” 只要靠配置文件就能复现系统的理念？但是事实果真是这样吗，让我们回溯一下：不变的函数之所以能有不变的输出，是因为有不变的输入。输入果真是一成不变的吗？

我们以最大的输入 pkgs 举例，这个输入指代的是 Nix 包管理器的软件仓库 Nixpkgs，里面有数不尽的包（Nixpkgs 是事实上最大的单体包仓库）日日夜夜在提交与修改，导致 nixpkgs 一直处于 unstable 状态。与之俱来的是 options 也经常变动，这意味着你的配置文件可能对旧版包是生效的，但是新版包的 options 变动了，现在又无效了。

你会如何解决这个由依赖版本与配置不匹配的问题呢？答案是现在很多语言的包管理（比如 Cargo，pnpm）都采用的版本锁定。本网站的就是被 pnpm 管理着依赖，你可以访问本站源代码仓库，根目录下有个叫做 pnpm-lock.yaml 的文件，里面描述了各依赖互相兼容的版本。每次更新依赖时，包管理器会在尽可能让依赖版本比较新的条件下保持最大兼容，并更新 Lock 文件。

于是我们怀着两个需求：

  • 尽量排除 Nix 文件互相引用时对本地文件系统路径的依赖
  • 控制输入的版本，从而达到输出的可预期性
  • 将 Nix 项目组织成一种易管理的形式

于是 Flakes 诞生了！

终极解决方案 Flakes

Flakes 是 Nix 2.4 版本引入的一个新特性，它可以让你用一种声明式和纯净的方式来定义和使用 Nix 项目。Flakes 使用了一种 Flake 引用的方式来代替文件系统路径，URL 等。Flake 引用大致就是下面的用法：

  • 类 URL 句法，例如 github:NixOS/nixpkgs 表示 Github 托管平台上一个叫做 NixOS 用户的 nixpkgs 仓库。这与裸 URL 不同，要是哪天 Github 域名搬家了，也不用你批量替换 URL，只需要等 Nix 更新 Flakes 引用的解析规则就成。

  • 类路径句法，比如 /absolute/path/to/the/Flakes 和 ./relative/path/to/the/Flakes。你可能就会疑惑，这不就是平时的相对路径与绝对路径写法吗，究竟“类”在哪里了呢？“类”在这种引用既可能指向一个本地文件系统路径，也可能指向一个本地 Git 仓库。如果你的 URL 指向一个本地的 Git 仓库，它就会在 flake.lock 里面记录当前仓库的 commit hash，这就保证了输入的版本是不变的。那你又问，万一我要引入的目录没有版本控制呢？那我只能说你自己人工去保证输入的这个目录的内容是不变的吧。

为了保证输入的可获取性，我们一般用网络上的仓库作为输入，因为只要有网络，我们就能获得相同的输入。而使用本地文件系统路径作为输入则不然，我们很难保证每台主机的相应文件系统路径下都有一样的文件。因此，我们的建议是更多地依赖网络上的输入，除非你有一些隐私信息，才有必要使用本地文件系统输入。

{
-  description = "A simple Flakes";
-
-  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
-
-  outputs = { self, nixpkgs }: {
-    packages.x86_64-linux.hello = 
-      with nixpkgs.legacyPackages.x86_64-linux; 
-      stdenv.mkDerivation {
-        name = "hello";
-        src = hello.src;
-        buildInputs = [ gcc ];
-        installPhase = ''
-          mkdir -p $out/bin
-          echo "Hello, world!" > $out/bin/hello
-          chmod +x $out/bin/hello
-        '';
-      };
-  };
-}
-

钉住版本

当你在 Flakes.nix 文件中指定了一个 Flakes引用（例如 github:NixOS/nixpkgs/nixos-unstable）后，Nix会在第一次运行 nix build 或其他 Nix 命令时会生成一个 flake.lock 文件。这个文件会记录下所有输入 Flakes 的具体版本（例如，Git 提交哈希）。有了版本锁，你什么时候构建，都是会根据 flake.lock 文件来确认依赖版本，使得构建结果也与之前并无二致。

如果你想更新到最新的提交，你可以运行 nix flake update 命令。这个命令会去更新输入，并重新钉住最新输入的版本

`,23),o=[i];function p(c,l){return a(),s("div",null,o)}const d=n(t,[["render",p],["__file","PurityIsOurUltimatePursuit.html.vue"]]),k=JSON.parse('{"path":"/tutorials/concept/PurityIsOurUltimatePursuit.html","title":"纯净是我们的至高追求","lang":"zh-CN","frontmatter":{"description":"纯净是我们的至高追求 整个构建系统并不是绝对纯净 我们前面一直在强调，NixOS 的生态系统有多函数式，好吧的确是有非常多的函数，但是这些函数似乎并不纯净。这些都要从整个函数机器的齿轮 —— Nix 文件说起。 为了设计一个纯净的函数，我们应该尽量地把它设计得封闭，使之隔离外部环境。但是 Nix 并不是这样，Nix 为了编译那些 Nix 文件，依然需要...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/concept/PurityIsOurUltimatePursuit.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"纯净是我们的至高追求"}],["meta",{"property":"og:description","content":"纯净是我们的至高追求 整个构建系统并不是绝对纯净 我们前面一直在强调，NixOS 的生态系统有多函数式，好吧的确是有非常多的函数，但是这些函数似乎并不纯净。这些都要从整个函数机器的齿轮 —— Nix 文件说起。 为了设计一个纯净的函数，我们应该尽量地把它设计得封闭，使之隔离外部环境。但是 Nix 并不是这样，Nix 为了编译那些 Nix 文件，依然需要..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2023-10-14T04:59:37.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2023-10-14T04:59:37.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"纯净是我们的至高追求\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2023-10-14T04:59:37.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"整个构建系统并不是绝对纯净","slug":"整个构建系统并不是绝对纯净","link":"#整个构建系统并不是绝对纯净","children":[]},{"level":2,"title":"我们好像漏掉了什么细节","slug":"我们好像漏掉了什么细节","link":"#我们好像漏掉了什么细节","children":[]},{"level":2,"title":"终极解决方案 Flakes","slug":"终极解决方案-flakes","link":"#终极解决方案-flakes","children":[]},{"level":2,"title":"钉住版本","slug":"钉住版本","link":"#钉住版本","children":[]}],"git":{"createdTime":1697224677000,"updatedTime":1697259577000,"contributors":[{"name":"OpenTritium","email":"tritium404@hotmail.com","commits":4}]},"readingTime":{"minutes":5.3,"words":1590},"filePathRelative":"tutorials/concept/PurityIsOurUltimatePursuit.md","localizedDate":"2023年10月13日","autoDesc":true,"excerpt":"\\n

整个构建系统并不是绝对纯净

\\n

我们前面一直在强调，NixOS 的生态系统有多函数式，好吧的确是有非常多的函数，但是这些函数似乎并不纯净。这些都要从整个函数机器的齿轮 —— Nix 文件说起。

\\n

为了设计一个纯净的函数，我们应该尽量地把它设计得封闭，使之隔离外部环境。但是 Nix 并不是这样，Nix 为了编译那些 Nix 文件，依然需要访问到外部世界的东西。

\\n
\\n

提示

\\n

Nix 文件可以访问任意文件（如 ~/.config/nixpkgs/config.nix）、环境变量、Git仓库、Nix搜索路径（$NIX_PATH）中的文件、命令行参数（--arg）以及系统类型（builtins.currentSystem）。

\\n
"}');export{d as comp,k as data}; diff --git a/assets/PurityIsOurUltimatePursuit.html-BJhNv_7j.js b/assets/PurityIsOurUltimatePursuit.html-BJhNv_7j.js new file mode 100644 index 0000000..c10053f --- /dev/null +++ b/assets/PurityIsOurUltimatePursuit.html-BJhNv_7j.js @@ -0,0 +1,21 @@ +import{_ as n}from"./plugin-vue_export-helper-DlAUqK2U.js";import{o as a,c as s,e as t}from"./app-BNkVxcYY.js";const e={},p=t(`

纯净是我们的至高追求

整个构建系统并不是绝对纯净

我们前面一直在强调，NixOS 的生态系统有多函数式，好吧的确是有非常多的函数，但是这些函数似乎并不纯净。这些都要从整个函数机器的齿轮 —— Nix 文件说起。

为了设计一个纯净的函数，我们应该尽量地把它设计得封闭，使之隔离外部环境。但是 Nix 并不是这样，Nix 为了编译那些 Nix 文件，依然需要访问到外部世界的东西。

Nix 文件可以访问任意文件（如 \`~/.config/nixpkgs/config.nix\`）、环境变

量、Git仓库、Nix搜索路径（$NIX_PATH）中的文件、命令行参数（--arg）以及系统类型（builtins.currentSystem）。:::

这就意味着这个函数的求值过程并不完全封闭。如果你在两台不同的机器上运行相同的 Nix 表达式，可能会得到不同的结果，因为这两台机器上的环境变量或文件系统可能是不同的。所以我们建议尽量避开任何带有路径依赖的写法。

但是这样做并不能完全解决问题，因为 Nix 文件本身就是一个路径依赖（当你使用 import 函数来引入其他 Nix 文件时，你必须指定一个相对或绝对路径）这就导致了一个问题：如果你想把你的 Nix 项目分享给别人，你必须保证他们能够找到你引用的所有文件。这就需要你把所有相关的文件都打包成一个压缩文件或者上传到一个 Git 仓库，并且告诉别人如何正确地使用它们。

这显然是很麻烦的，而且也违背了函数式编程的原则。我们希望能够用一种更简单和优雅的方式来管理和共享我们的 Nix 项目，而不需要关心它们所依赖的具体路径。

我们好像漏掉了什么细节

在前面的章节中，我们还一直试图给阅读者灌输 “NixOS” 只要靠配置文件就能复现系统的理念？但是事实果真是这样吗，让我们回溯一下：不变的函数之所以能有不变的输出，是因为有不变的输入。输入果真是一成不变的吗？

我们以最大的输入 pkgs 举例，这个输入指代的是 Nix 包管理器的软件仓库 Nixpkgs，里面有数不尽的包（Nixpkgs 是事实上最大的单体包仓库）日日夜夜在提交与修改，导致 nixpkgs 一直处于 unstable 状态。与之俱来的是 options 也经常变动，这意味着你的配置文件可能对旧版包是生效的，但是新版包的 options 变动了，现在又无效了。

你会如何解决这个由依赖版本与配置不匹配的问题呢？答案是现在很多语言的包管理（比如 Cargo，pnpm）都采用的版本锁定。本网站的就是被 pnpm 管理着依赖，你可以访问本站源代码仓库，根目录下有个叫做 pnpm-lock.yaml 的文件，里面描述了各依赖互相兼容的版本。每次更新依赖时，包管理器会在尽可能让依赖版本比较新的条件下保持最大兼容，并更新 Lock 文件。

于是我们怀着两个需求：

  • 尽量排除 Nix 文件互相引用时对本地文件系统路径的依赖
  • 控制输入的版本，从而达到输出的可预期性
  • 将 Nix 项目组织成一种易管理的形式

于是 Flakes 诞生了！

终极解决方案 Flakes

Flakes 是 Nix 2.4 版本引入的一个新特性，它可以让你用一种声明式和纯净的方式来定义和使用 Nix 项目。Flakes 使用了一种 Flake 引用的方式来代替文件系统路径，URL 等。Flake 引用大致就是下面的用法：

  • 类 URL 句法，例如 github:NixOS/nixpkgs 表示 Github 托管平台上一个叫做 NixOS 用户的 nixpkgs 仓库。这与裸 URL 不同，要是哪天 Github 域名搬家了，也不用你批量替换 URL，只需要等 Nix 更新 Flakes 引用的解析规则就成。

  • 类路径句法，比如 /absolute/path/to/the/Flakes 和./relative/path/to/the/Flakes。你可能就会疑惑，这不就是平时的相对路径与绝对路径写法吗，究竟“类”在哪里了呢？“类”在这种引用既可能指向一个本地文件系统路径，也可能指向一个本地 Git 仓库。如果你的 URL 指向一个本地的 Git 仓库，它就会在 flake.lock 里面记录当前仓库的 commit hash，这就保证了输入的版本是不变的。那你又问，万一我要引入的目录没有版本控制呢？那我只能说你自己人工去保证输入的这个目录的内容是不变的吧。

为了保证输入的可获取性，我们一般用网络上的仓库作为输入，因为只要有网络，我们就能获得相同的输入。而使用本地文件系统路径作为输入则不然，我们很难保证每台主机的相应文件系统路径下都有一样的文件。因此，我们的建议是更多地依赖网络上的输入，除非你有一些隐私信息，才有必要使用本地文件系统输入。

{
+  description = "A simple Flakes";
+
+  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+
+  outputs = { self, nixpkgs }: {
+    packages.x86_64-linux.hello =
+      with nixpkgs.legacyPackages.x86_64-linux;
+      stdenv.mkDerivation {
+        name = "hello";
+        src = hello.src;
+        buildInputs = [ gcc ];
+        installPhase = ''
+          mkdir -p $out/bin
+          echo "Hello, world!" > $out/bin/hello
+          chmod +x $out/bin/hello
+        '';
+      };
+  };
+}
+

钉住版本

当你在 Flakes.nix 文件中指定了一个 Flakes引用（例如github:NixOS/nixpkgs/nixos-unstable）后，Nix会在第一次运行 nix build 或其他 Nix 命令时会生成一个 flake.lock 文件。这个文件会记录下所有输入 Flakes 的具体版本（例如，Git 提交哈希）。有了版本锁，你什么时候构建，都是会根据 flake.lock 文件来确认依赖版本，使得构建结果也与之前并无二致。

如果你想更新到最新的提交，你可以运行 nix flake update 命令。这个命令会去更新输入，并重新钉住最新输入的版本

`,5),i=[p];function o(c,l){return a(),s("div",null,i)}const k=n(e,[["render",o],["__file","PurityIsOurUltimatePursuit.html.vue"]]),d=JSON.parse(`{"path":"/tutorials/concept/PurityIsOurUltimatePursuit.html","title":"纯净是我们的至高追求","lang":"zh-CN","frontmatter":{"description":"纯净是我们的至高追求 整个构建系统并不是绝对纯净 我们前面一直在强调，NixOS 的生态系统有多函数式，好吧的确是有非常多的函数，但是这些函数似乎并不纯净。这些都要从整个函数机器的齿轮 —— Nix 文件说起。 为了设计一个纯净的函数，我们应该尽量地把它设计得封闭，使之隔离外部环境。但是 Nix 并不是这样，Nix 为了编译那些 Nix 文件，依然需要...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/concept/PurityIsOurUltimatePursuit.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"纯净是我们的至高追求"}],["meta",{"property":"og:description","content":"纯净是我们的至高追求 整个构建系统并不是绝对纯净 我们前面一直在强调，NixOS 的生态系统有多函数式，好吧的确是有非常多的函数，但是这些函数似乎并不纯净。这些都要从整个函数机器的齿轮 —— Nix 文件说起。 为了设计一个纯净的函数，我们应该尽量地把它设计得封闭，使之隔离外部环境。但是 Nix 并不是这样，Nix 为了编译那些 Nix 文件，依然需要..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2024-06-30T15:34:48.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2024-06-30T15:34:48.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"纯净是我们的至高追求\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2024-06-30T15:34:48.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"整个构建系统并不是绝对纯净","slug":"整个构建系统并不是绝对纯净","link":"#整个构建系统并不是绝对纯净","children":[]}],"git":{"createdTime":1697224677000,"updatedTime":1719761688000,"contributors":[{"name":"OpenTritium","email":"tritium404@hotmail.com","commits":4},{"name":"Ryan Yin","email":"xiaoyin_c@qq.com","commits":1}]},"readingTime":{"minutes":5.3,"words":1590},"filePathRelative":"tutorials/concept/PurityIsOurUltimatePursuit.md","localizedDate":"2023年10月13日","autoDesc":true,"excerpt":"\\n

整个构建系统并不是绝对纯净

\\n

我们前面一直在强调，NixOS 的生态系统有多函数式，好吧的确是有非常多的函数，但是这些函数似乎并不纯净。这些都要从整个函数机器的齿轮 —— Nix 文件说起。

\\n

为了设计一个纯净的函数，我们应该尽量地把它设计得封闭，使之隔离外部环境。但是 Nix\\n并不是这样，Nix 为了编译那些 Nix 文件，依然需要访问到外部世界的东西。

\\n
\\n

Nix 文件可以访问任意文件（如 \`~/.config/nixpkgs/config.nix\`）、环境变

\\n

量、Git仓库、Nix搜索路径（$NIX_PATH）中的文件、命令行参数（--arg）以及系统类型（builtins.currentSystem）。:::

\\n

这就意味着这个函数的求值过程并不完全封闭。如果你在两台不同的机器上运行相同的 Nix\\n表达式，可能会得到不同的结果，因为这两台机器上的环境变量或文件系统可能是不同的。所以我们建议尽量避开任何带有路径依赖的写法。

\\n

但是这样做并不能完全解决问题，因为 Nix 文件本身就是一个路径依赖（当你使用 import\\n函数来引入其他 Nix 文件时，你必须指定一个相对或绝对路径）这就导致了一个问题：如果你想把你的 Nix 项目分享给别人，你必须保证他们能够找到你引用的所有文件。这就需要你把所有相关的文件都打包成一个压缩文件或者上传到一个 Git 仓库，并且告诉别人如何正确地使用它们。

\\n

这显然是很麻烦的，而且也违背了函数式编程的原则。我们希望能够用一种更简单和优雅的方式来管理和共享我们的 Nix 项目，而不需要关心它们所依赖的具体路径。

\\n

我们好像漏掉了什么细节

\\n

在前面的章节中，我们还一直试图给阅读者灌输 “NixOS” 只要靠配置文件就能复现系统的理念？但是事实果真是这样吗，让我们回溯一下：不变的函数之所以能有不变的输出，是因为有不变的输入。输入果真是一成不变的吗？

\\n

我们以最大的输入 pkgs 举例，这个输入指代的是 Nix 包管理器的软件仓库 Nixpkgs，里面有数不尽的包（Nixpkgs 是事实上最大的单体包仓库）日日夜夜在提交与修改，导致\\nnixpkgs 一直处于 unstable 状态。与之俱来的是 options 也经常变动，这意味着你的配置文件可能对旧版包是生效的，但是新版包的 options 变动了，现在又无效了。

\\n

你会如何解决这个由依赖版本与配置不匹配的问题呢？答案是现在很多语言的包管理（比如\\nCargo，pnpm）都采用的版本锁定。本网站的就是被 pnpm 管理着依赖，你可以访问本站源代码仓库，根目录下有个叫做 pnpm-lock.yaml 的文件，里面描述了各依赖互相兼容的版本。每次更新依赖时，包管理器会在尽可能让依赖版本比较新的条件下保持最大兼容，并更新 Lock 文件。

\\n

于是我们怀着两个需求：

\\n
    \\n
  • 尽量排除 Nix 文件互相引用时对本地文件系统路径的依赖
    • \\n
  • 控制输入的版本，从而达到输出的可预期性
    • \\n
  • 将 Nix 项目组织成一种易管理的形式
    • \\n
\\n

于是 Flakes 诞生了！

\\n

终极解决方案 Flakes

\\n

Flakes 是 Nix 2.4 版本引入的一个新特性，它可以让你用一种声明式和纯净的方式来定义和使用 Nix 项目。Flakes 使用了一种 Flake 引用的方式来代替文件系统路径，URL\\n等。Flake 引用大致就是下面的用法：

\\n
    \\n
  • \\n

    类 URL 句法，例如 github:NixOS/nixpkgs 表示 Github 托管平台上一个叫做\\nNixOS 用户的 nixpkgs 仓库。这与裸 URL 不同，要是哪天 Github 域名搬家了，也不用你批量替换 URL，只需要等 Nix 更新 Flakes 引用的解析规则就成。

    \\n
    • \\n
  • \\n

    类路径句法，比如 /absolute/path/to/the/Flakes 和./relative/path/to/the/Flakes。你可能就会疑惑，这不就是平时的相对路径与绝对路径写法吗，究竟“类”在哪里了呢？“类”在这种引用既可能指向一个本地文件系统路径，也可能指向一个本地 Git 仓库。如果你的 URL 指向一个本地的 Git 仓库，它就会在\\nflake.lock 里面记录当前仓库的 commit hash，这就保证了输入的版本是不变的。那你又问，万一我要引入的目录没有版本控制呢？那我只能说你自己人工去保证输入的这个目录的内容是不变的吧。

    \\n
    • \\n
\\n

为了保证输入的可获取性，我们一般用网络上的仓库作为输入，因为只要有网络，我们就能获得相同的输入。而使用本地文件系统路径作为输入则不然，我们很难保证每台主机的相应文件系统路径下都有一样的文件。因此，我们的建议是更多地依赖网络上的输入，除非你有一些隐私信息，才有必要使用本地文件系统输入。

\\n
{\\n  description = \\"A simple Flakes\\";\\n\\n  inputs.nixpkgs.url = \\"github:NixOS/nixpkgs/nixos-unstable\\";\\n\\n  outputs = { self, nixpkgs }: {\\n    packages.x86_64-linux.hello =\\n      with nixpkgs.legacyPackages.x86_64-linux;\\n      stdenv.mkDerivation {\\n        name = \\"hello\\";\\n        src = hello.src;\\n        buildInputs = [ gcc ];\\n        installPhase = ''\\n          mkdir -p $out/bin\\n          echo \\"Hello, world!\\" > $out/bin/hello\\n          chmod +x $out/bin/hello\\n        '';\\n      };\\n  };\\n}\\n

钉住版本

\\n

当你在 Flakes.nix 文件中指定了一个 Flakes引用（例如github:NixOS/nixpkgs/nixos-unstable）后，Nix会在第一次运行 nix build 或其他\\nNix 命令时会生成一个 flake.lock 文件。这个文件会记录下所有输入 Flakes 的具体版本（例如，Git 提交哈希）。有了版本锁，你什么时候构建，都是会根据 flake.lock 文件来确认依赖版本，使得构建结果也与之前并无二致。

\\n

如果你想更新到最新的提交，你可以运行 nix flake update 命令。这个命令会去更新输入，并重新钉住最新输入的版本

\\n
"}`);export{k as comp,d as data}; diff --git a/assets/QuickOverview.html-BnfFQSVs.js b/assets/QuickOverview.html-BSo4J38r.js similarity index 74% rename from assets/QuickOverview.html-BnfFQSVs.js rename to assets/QuickOverview.html-BSo4J38r.js index b2d0676..5373c30 100644 --- a/assets/QuickOverview.html-BnfFQSVs.js +++ b/assets/QuickOverview.html-BSo4J38r.js @@ -1,23 +1,23 @@ -import{_ as p}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as i,o,c as l,a as n,b as s,d as e,e as t}from"./app-KtH3BPxJ.js";const c={},d=t(`

Nix 语言快速入门

提示

Nix 语言的主要工作是描述打包过程。同时 Nix 语言也是一门强类型和动态类型的语言。

交互模式

以下交互式教程需要使用 nix repl 命令调出交互命令模式：

$ nix repl
+import{_ as p}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as i,o,c as l,a as n,b as a,d as t,e as s}from"./app-BNkVxcYY.js";const c={},r=n("h1",{id:"nix-语言快速入门",tabindex:"-1"},[n("a",{class:"header-anchor",href:"#nix-语言快速入门"},[n("span",null,"Nix 语言快速入门")])],-1),u={class:"hint-container tip"},d=s(`
Nix 语言的主要工作是**描述打包过程**。同时 Nix 语言也是一门强类型和动态
类型的语言。:::
交互模式
以下交互式教程需要使用 nix repl 命令调出交互命令模式：
$ nix repl
 Welcome to Nix 2.5.1. Type :? for help.
 
它有点像用于调试 JavaScript 的控制台或 Python 的交互模式？
nix-repl> 1 + 2  # 输入表达式
 3  # 输出结果
-
惰性求值
Nix语言的求值是惰性的，这意味着表达式不会在被绑定到变量后立即求值，而是在该值被使用时才求值。
即时计算被直接依赖的值
nix-repl> { a.b.c = 1; }
+
`,7),k={class:"hint-container tip"},v=s(`
惰性求值Nix语言的求值是惰性的，这意味着表达式不会在被绑定到变量后立即求
值，而是在该值被使用时才求值。:::
即时计算被直接依赖的值
nix-repl> { a.b.c = 1; }
 { a = { ... }; }
-
在上面的例子中，我们输入了一个匿名集合，而这个匿名集合包含 a 集合。
匿名集合
匿名集合即没有分配名称的集合，与之对立的是命名集合，例如 foo = { bar };。
a 集合中的值并没有被这个匿名集合直接依赖，自然顶级以下的集合不会被立刻求值。占位的变成了 ... 。
在下面这个例子，我们将显式声明 qux 的直接依赖：
let
+
在上面的例子中，我们输入了一个匿名集合，而这个匿名集合包含 a 集合。
`,5),m={class:"hint-container note"},b=s(`
匿名集合匿名集合即没有分配名称的集合，与之对立的是命名集合，例如
foo = { bar };。:::
a 集合中的值并没有被这个匿名集合直接依赖，自然顶级以下的集合不会被立刻求值。占位的变成了 ... 。
在下面这个例子，我们将显式声明 qux 的直接依赖：
let
   foo = { bar.qux = 1; };
   lax = foo.bar.qux;
 in
   lax  # 我们需要 lax，lax 需要 foo.bar.qux
 
我们可以输入 :p 启用详尽求值，所有表达式都将被立刻求值：
nix-repl> :p { a.b.c = 1; }
 { a = { b = { c = 1; }; }; }
-
注意
:p 参数只能在交互模式使用，输入 :q 可以退出交互模式。
文件求值
`,19),r={href:"https://nixos.org/manual/nix/stable/command-ref/nix-instantiate.html",target:"_blank",rel:"noopener noreferrer"},u=n("code",null,"nix-instantiate --eval",-1),k=n("code",null,"*.nix",-1),v=t(`
$ echo 1 + 2 > file.nix  # 该命令会往 file.nix 中写入 1 + 2
+
`,7),x={class:"hint-container warning"},g=n("p",{class:"hint-container-title"},"`:p` 参数只能在交互模式使用，输入 `:q` 可以退出交互模式。:::",-1),h=n("h2",{id:"文件求值",tabindex:"-1"},[n("a",{class:"header-anchor",href:"#文件求值"},[n("span",null,"文件求值")])],-1),y={href:"https://nixos.org/manual/nix/stable/command-ref/nix-instantiate.html",target:"_blank",rel:"noopener noreferrer"},f=n("code",null,"nix-instantiate --eval",-1),w=n("code",null,"*.nix",-1),q=s(`
$ echo 1 + 2 > file.nix  # 该命令会往 file.nix 中写入 1 + 2
 $ nix-instantiate --eval file.nix  # 文件求值
 3  # 输出结果
-
立即求值
在文件求值的情景下可以通过在命令行添加 --strict 参数来启用立即求值。
$ echo "{ a.b.c = 1; }" > file.nix
+
`,1),_={class:"hint-container tip"},N=s(`
立即求值在文件求值的情景下可以通过在命令行添加 \`--strict\` 参数来启用立即
求值。
$ echo "{ a.b.c = 1; }" > file.nix
 $ nix-instantiate --eval --strict file.nix
 { a = { b = { c = 1; }; }; }
-
echo 命令
echo 是 Linux 中最常见的命令之一，主要作用是输出文本，追加文本，返回输出。
你可以键入 help echo 来获取该命令的使用帮助。
代码风格
好的代码风格会让程序员身心愉悦，同时也增加了代码可维护性。
`,5),m={class:"hint-container info"},b=n("p",{class:"hint-container-title"},"格式化",-1),x={href:"https://github.com/kamadorueda/alejandra",target:"_blank",rel:"noopener noreferrer"},g={href:"https://kamadorueda.com/alejandra/",target:"_blank",rel:"noopener noreferrer"},h=t(`
当心空格
空格用于分隔词法标记（Lexical tokens），在一些场景是必要的，不然会无法区分关键字。
注
在许多中文资料中，混淆了 Lexical，Syntax 和 Grammar 三者的概念：
  • Lexical（词法）：是指语言中单词的意义、形态和用法等方面的规则。词法规则定义了单词的基本形态和语法功能，例如名词、动词、形容词等。同时，它还规定了一些特殊单词的用法，例如冠词、介词、连词等。
  • Syntax（句法）：是指语言中标记（Token）之间的组合方式，以及这种组合方式所遵循的规则。通俗点说，语法规定了单词应该如何排列、组合成句子，以及这些句子之间的联系方式。
  • Grammar（语法）：是指语言中的规则体系，包括了语法规则、语义规则和语用规则等。它涉及到语言的整个结构和组成方式，而不仅仅是句子的构成。
下面的两种示例是等价的：
let
+
::: ::: info echo 命令 echo 是 Linux 中最常见的命令之一，主要作用是输出文本，追加文本，返回输出。
你可以键入 help echo 来获取该命令的使用帮助。:::
代码风格
好的代码风格会让程序员身心愉悦，同时也增加了代码可维护性。
`,7),$={class:"hint-container info"},j=n("p",{class:"hint-container-title"},"格式化 [Alejandra](https://github.com/kamadorueda/alejandra) 是一个新兴",-1),S={href:"https://kamadorueda.com/alejandra/",target:"_blank",rel:"noopener noreferrer"},L=n("h2",{id:"当心空格",tabindex:"-1"},[n("a",{class:"header-anchor",href:"#当心空格"},[n("span",null,"当心空格")])],-1),A=n("p",null,"空格用于分隔词法标记（Lexical tokens），在一些场景是必要的，不然会无法区分关键字。",-1),T=n("div",{class:"hint-container note"},[n("p",{class:"hint-container-title"},"注"),n("p",null,"在许多中文资料中，混淆了 Lexical，Syntax 和 Grammar 三者的概念："),n("ul",null,[n("li",null,"Lexical（词法）：是指语言中单词的意义、形态和用法等方面的规则。词法规则定义了单词的基本形态和语法功能，例如名词、动词、形容词等。同时，它还规定了一些特殊单词的用法，例如冠词、介词、连词等。"),n("li",null,"Syntax（句法）：是指语言中标记（Token）之间的组合方式，以及这种组合方式所遵循的规则。通俗点说，语法规定了单词应该如何排列、组合成句子，以及这些句子之间的联系方式。"),n("li",null,"Grammar（语法）：是指语言中的规则体系，包括了语法规则、语义规则和语用规则等。它涉及到语言的整个结构和组成方式，而不仅仅是句子的构成。")])],-1),O=s(`
下面的两种示例是等价的：
let
   x = 1;
   y = 2;
 in
@@ -42,17 +42,13 @@ $ nix-instantiate --eval = false;
   };  # 标准 json 不支持注释
 }
-
json 样式
你可能觉得莫名的像 json，下面是 json 的示例：
{
+
json 样式你可能觉得莫名的像 json，下面是 json 的示例：
{
   "string": "hello",
   "integer": 1,
   "float": 3.141,
   "bool": true,
   "null": null,
-  "list": [
-    1,
-    "two",
-    false
-  ],
+  "list": [1, "two", false],
   "object": {
     "a": "hello",
     "b": 1,
@@ -60,25 +56,25 @@ $ nix-instantiate --eval "d": false
   }
 }
-
注意到了吗？
  • 属性不需要添加引号
  • 列表是用空格分隔的
递归属性集
当属性集内的属性需要访问该集合的另一个属性时，应当使用递归属性集：
rec {
+
注意到了吗？
  • 属性不需要添加引号
  • 列表是用空格分隔的
递归属性集
当属性集内的属性需要访问该集合的另一个属性时，应当使用递归属性集：
rec {
   one = 1;
   two = one + 1;  # 直接依赖于 one
   three = two + 1; # 直接依赖于 two，间接依赖于 one
 }
 
输出如下：
{ one = 1; three = 3; two = 2; }
-
注
元素的声明顺序并不决定元素在属性集中的排布顺序，属性集中的元素排布顺序是由求值顺序决定的，优先被求值的被放在了前面。
let 绑定
一个完整的 let 绑定有两个部分： let 绑定名称与值， in 使用名称。在 let 与 in 之间的语句中，你可以声明需要被复用的名称，并将其与值绑定。它们可以在 in 之后的表达式中发挥作用：
let
+
::: note元素的声明顺序并不决定元素在属性集中的排布顺序，属性集中的元素排布顺序是由求值顺序决定的，优先被求值的被放在了前面。:::
let 绑定
一个完整的 let 绑定有两个部分： let 绑定名称与值， in 使用名称。在 let 与 in 之间的语句中，你可以声明需要被复用的名称，并将其与值绑定。它们可以在 in 之后的表达式中发挥作用：
let
   b = a + 1;
   a = 1;
 in
   a + b
-
引用到 a 的地方有两处，它们都会将 a ＂替换＂成值来计算或赋值，类似于常量。
提示
你不需要关心名称的声明顺序，不会出现名称未定义的情况。
in 后面只能跟随一个表达式，并且 let 绑定的名称只在该表达式是有效的的，这里演示一个列表：
let
+
引用到 a 的地方有两处，它们都会将 a ＂替换＂成值来计算或赋值，类似于常量。
::: tip你不需要关心名称的声明顺序，不会出现名称未定义的情况。:::
in 后面只能跟随一个表达式，并且 let 绑定的名称只在该表达式是有效的的，这里演示一个列表：
let
   b = a + 1;
   c = a + b;
   a = 1;
 in
   [ a b c ]
 
输出的值为：
[ 1 2 3 ]
-
作用域
let 绑定是有作用域的，绑定的名称只能在作用域使用，或者说每个 let 绑定的名称只能在该表达式内使用：
{
+
作用域 **\`let\` 绑定是有作用域的，绑定的名称只能在作用域使用，或者说每
个 let 绑定的名称只能在该表达式内使用：**
{
   a = let x = 1; in x;
   b = x;
 }
@@ -152,7 +148,7 @@ $ nix-instantiate --eval }
 
inherit 同样可以在 let 表达式中使用：
let
   inherit ({ x = 1; y = 2; }) x y;
-in 
+in
   [ x y ]
 
等价于：
let
   x = { x = 1; y = 2; }.x;
@@ -187,7 +183,7 @@ $ nix-instantiate --eval ../../  # 当前目录的上级的上级目录
 ./  # 当前目录
 
检索路径
又名＂尖括号语法＂。
检索路径是通过系统变量来获取路径的语法，由一对尖括号组成：
<nixpkgs>
-
`,80),y=n("code",null,"",-1),f={href:"https://nixos.org/manual/nix/unstable/command-ref/env-common.html?highlight=nix_path#env-NIX_PATH",target:"_blank",rel:"noopener noreferrer"},w=n("code",null,"$NIX_PATH",-1),q=t(`
/nix/var/nix/profiles/per-user/root/channels/nixpkgs
+
`,77),P=n("code",null,"",-1),z={href:"https://nixos.org/manual/nix/unstable/command-ref/env-common.html?highlight=nix_path#env-NIX_PATH",target:"_blank",rel:"noopener noreferrer"},I=n("code",null,"$NIX_PATH",-1),C=s(`
/nix/var/nix/profiles/per-user/root/channels/nixpkgs
 
我们建议你避免使用检索路径来指定其它相对路径，比如下面的例子：
<nixpkgs/lib>
 
这是一种污染，因为这样指定相对路径会让配置与环境产生联系。我们的配置文件应该尽量保留纯函数式的特性，即输出只与输入有关，纯函数不应该与外界产生任何联系。
多行字符串
Nix 中被两对单引号 '' 引用的内容即为多行字符串。
''
 multi
@@ -201,7 +197,7 @@ string
     three
 ''
 
等价于：
"one\\n two\\n  three\\n"
-
字符串中的字符转义
在单行字符串中，Nix 的转义语法与许多其他语言相同，" \\ \${ 以及其他 \\n \\t 等特殊字符，都可直接使用 \\ 进行转义，比如：
"this is a \\"string\\" \\\\"  # 结果是: this is a "string" \\
+
字符串中的字符转义
在单行字符串中，Nix 的转义语法与许多其他语言相同，" \\ \${ 以及其他 \\n\\t 等特殊字符，都可直接使用 \\ 进行转义，比如：
"this is a \\"string\\" \\\\"  # 结果是: this is a "string" \\
 
但在多行字符串中，情况会有点特殊。Nix 规定在多行字符串中需要使用两个单引号 '' 来转义。
比如如下 Nix 代码会输出原始字符 \${a}，而不是做字符串插值：
let
   a = "1";
 in
@@ -288,11 +284,11 @@ args@{= {a, b, ...}@args: a + b + args.c;
 in
   f { a = 1; b = 2; c = 3; }
-
函数库
`,88),_={href:"https://nixos.org/manual/nix/stable/language/operators.html",target:"_blank",rel:"noopener noreferrer"},N=n("code",null,"+",-1),$=n("code",null,"==",-1),j=n("code",null,"&&",-1),S=n("h3",{id:"内建函数",tabindex:"-1"},[n("a",{class:"header-anchor",href:"#内建函数"},[n("span",null,"内建函数")])],-1),A=n("code",null,"",-1),O=n("code",null,"",-1),T={href:"https://nixos.org/manual/nix/stable/language/builtins.html",target:"_blank",rel:"noopener noreferrer"},L=t(`
builtins.toString()  # 通过 builtins 使用函数
+
函数库
`,88),B={href:"https://nixos.org/manual/nix/stable/language/operators.html",target:"_blank",rel:"noopener noreferrer"},J=n("code",null,"+",-1),Q=n("code",null,"==",-1),R=n("code",null,"&&",-1),D=n("h3",{id:"内建函数",tabindex:"-1"},[n("a",{class:"header-anchor",href:"#内建函数"},[n("span",null,"内建函数")])],-1),G=n("code",null,"",-1),H=n("code",null,"",-1),M={href:"https://nixos.org/manual/nix/stable/language/builtins.html",target:"_blank",rel:"noopener noreferrer"},V=s(`
builtins.toString()  # 通过 builtins 使用函数
 
导入
import 表达式以其他 Nix 文件的路径为参数，返回该 Nix 文件的求值结果。
import 的参数如果为文件夹路径，那么会返回该文件夹下的 default.nix 文件的执行结果。
如下示例中，import 会导入 ./file.nix 文件，并返回该文件的求值结果：
$ echo 1 + 2 > file.nix
 import ./file.nix
 3
 
被导入的 Nix 文件可以返回任何内容，返回值可以向上面的例子一样是数值，也可以是属性集（attribute set）、函数、列表，等等。
如下示例导入了 file.nix 文件中定义的一个函数，并使用参数调用了该函数：
$ echo "x: x + 1" > file.nix
 import ./file.nix 1
 2
-
`,9);function z(P,I){const a=i("ExternalLinkIcon");return o(),l("div",null,[d,n("p",null,[s("使用 "),n("a",r,[u,e(a)]),s(" 对 "),k,s(" 文件中存在的表达式进行求值：")]),v,n("div",m,[b,n("p",null,[n("a",x,[s("Alejandra"),e(a)]),s(" 是一个新兴的 Nix 代码格式化工具，使用 Rust 编写。你可以"),n("a",g,[s("在线尝试"),e(a)]),s("它。")])]),h,n("p",null,[s("这个时候 "),y,s(" 实际上一依赖了系统变量中一个名为 "),n("a",f,[w,e(a)]),s(" 的路径值：")]),q,n("p",null,[s("除了一些 "),n("a",_,[s("内建操作符"),e(a)]),s(" （"),N,s(", "),$,s(", "),j,s(", 等）,我们还要学习一些被视为事实标准的库。")]),S,n("p",null,[s("它们在 Nix 语言中并不是 "),A,s(" 类型，而是 "),O,s(" 元操作类型（primitive operations）。这些函数是内置在 Nix 解释器中，由 C++ 实现。查询 "),n("a",T,[s("内建函数"),e(a)]),s(" 以了解其使用方法。")]),L])}const Q=p(c,[["render",z],["__file","QuickOverview.html.vue"]]),D=JSON.parse('{"path":"/tutorials/lang/QuickOverview.html","title":"Nix 语言快速入门","lang":"zh-CN","frontmatter":{"description":"Nix 语言快速入门 提示 Nix 语言的主要工作是描述打包过程。同时 Nix 语言也是一门强类型和动态类型的语言。 交互模式 以下交互式教程需要使用 nix repl 命令调出交互命令模式： 它有点像用于调试 JavaScript 的控制台或 Python 的交互模式？ 惰性求值 Nix语言的求值是惰性的，这意味着表达式不会在被绑定到变量后立即求值，...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/lang/QuickOverview.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"Nix 语言快速入门"}],["meta",{"property":"og:description","content":"Nix 语言快速入门 提示 Nix 语言的主要工作是描述打包过程。同时 Nix 语言也是一门强类型和动态类型的语言。 交互模式 以下交互式教程需要使用 nix repl 命令调出交互命令模式： 它有点像用于调试 JavaScript 的控制台或 Python 的交互模式？ 惰性求值 Nix语言的求值是惰性的，这意味着表达式不会在被绑定到变量后立即求值，..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2024-06-02T00:17:28.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2024-06-02T00:17:28.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"Nix 语言快速入门\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2024-06-02T00:17:28.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"交互模式","slug":"交互模式","link":"#交互模式","children":[]},{"level":2,"title":"即时计算被直接依赖的值","slug":"即时计算被直接依赖的值","link":"#即时计算被直接依赖的值","children":[]},{"level":2,"title":"文件求值","slug":"文件求值","link":"#文件求值","children":[]},{"level":2,"title":"代码风格","slug":"代码风格","link":"#代码风格","children":[]},{"level":2,"title":"当心空格","slug":"当心空格","link":"#当心空格","children":[]},{"level":2,"title":"名称和值","slug":"名称和值","link":"#名称和值","children":[]},{"level":2,"title":"属性集","slug":"属性集","link":"#属性集","children":[]},{"level":2,"title":"递归属性集","slug":"递归属性集","link":"#递归属性集","children":[]},{"level":2,"title":"let 绑定","slug":"let-绑定","link":"#let-绑定","children":[]},{"level":2,"title":"属性访问","slug":"属性访问","link":"#属性访问","children":[]},{"level":2,"title":"with 表达式","slug":"with-表达式","link":"#with-表达式","children":[]},{"level":2,"title":"inherit 表达式","slug":"inherit-表达式","link":"#inherit-表达式","children":[]},{"level":2,"title":"字符串插值","slug":"字符串插值","link":"#字符串插值","children":[]},{"level":2,"title":"路径类型","slug":"路径类型","link":"#路径类型","children":[]},{"level":2,"title":"检索路径","slug":"检索路径","link":"#检索路径","children":[]},{"level":2,"title":"多行字符串","slug":"多行字符串","link":"#多行字符串","children":[]},{"level":2,"title":"字符串中的字符转义","slug":"multi-line-string-escape","link":"#multi-line-string-escape","children":[]},{"level":2,"title":"函数","slug":"函数","link":"#函数","children":[]},{"level":2,"title":"柯里化函数","slug":"柯里化函数","link":"#柯里化函数","children":[]},{"level":2,"title":"属性集参数","slug":"属性集参数","link":"#属性集参数","children":[]},{"level":2,"title":"默认参数","slug":"默认参数","link":"#默认参数","children":[]},{"level":2,"title":"额外参数","slug":"额外参数","link":"#额外参数","children":[]},{"level":2,"title":"命名参数集","slug":"命名参数集","link":"#命名参数集","children":[]},{"level":2,"title":"函数库","slug":"函数库","link":"#函数库","children":[{"level":3,"title":"内建函数","slug":"内建函数","link":"#内建函数","children":[]},{"level":3,"title":"导入","slug":"导入","link":"#导入","children":[]}]}],"git":{"createdTime":1711465427000,"updatedTime":1717287448000,"contributors":[{"name":"AmourAmer","email":"153876579+AmourAmer@users.noreply.github.com","commits":2},{"name":"Ryan Yin","email":"xiaoyin_c@qq.com","commits":1}]},"readingTime":{"minutes":13.65,"words":4095},"filePathRelative":"tutorials/lang/QuickOverview.md","localizedDate":"2024年3月26日","autoDesc":true,"excerpt":"\\n
\\n
提示
\\n
Nix 语言的主要工作是描述打包过程。同时 Nix 语言也是一门强类型和动态类型的语言。
\\n
\\n
交互模式
\\n
以下交互式教程需要使用 nix repl 命令调出交互命令模式：
\\n
$ nix repl\\nWelcome to Nix 2.5.1. Type :? for help.\\n
"}');export{Q as comp,D as data};
+
`,9);function E(Z,W){const e=i("ExternalLinkIcon");return o(),l("div",null,[r,n("div",u,[d,n("div",k,[v,n("div",m,[b,n("div",x,[g,h,n("p",null,[a("使用"),n("a",y,[f,t(e)]),a(" 对 "),w,a(" 文件中存在的表达式进行求值：")]),q,n("div",_,[N,n("div",$,[j,n("p",null,[a("的 Nix 代码格式化工具，使用 Rust 编写。你可以"),n("a",S,[a("在线尝试"),t(e)]),a("它。:::")]),L,A,T])])])])])]),O,n("p",null,[a("这个时候 "),P,a(" 实际上一依赖了系统变量中一个名为"),n("a",z,[I,t(e)]),a(" 的路径值：")]),C,n("p",null,[a("除了一些"),n("a",B,[a("内建操作符"),t(e)]),a(" （"),J,a(", "),Q,a(", "),R,a(", 等）,我们还要学习一些被视为事实标准的库。")]),D,n("p",null,[a("它们在 Nix 语言中并不是 "),G,a(" 类型，而是 "),H,a(" 元操作类型（primitive operations）。这些函数是内置在 Nix 解释器中，由 C++ 实现。查询"),n("a",M,[a("内建函数"),t(e)]),a(" 以了解其使用方法。")]),V])}const F=p(c,[["render",E],["__file","QuickOverview.html.vue"]]),K=JSON.parse('{"path":"/tutorials/lang/QuickOverview.html","title":"Nix 语言快速入门","lang":"zh-CN","frontmatter":{"description":"Nix 语言快速入门 Nix 语言的主要工作是**描述打包过程**。同时 Nix 语言也是一门强类型和动态 类型的语言。::: 交互模式 以下交互式教程需要使用 nix repl 命令调出交互命令模式： 它有点像用于调试 JavaScript 的控制台或 Python 的交互模式？ 惰性求值Nix语言的求值是惰性的，这意味着表达式不会在被绑定到变量后立...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/lang/QuickOverview.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"Nix 语言快速入门"}],["meta",{"property":"og:description","content":"Nix 语言快速入门 Nix 语言的主要工作是**描述打包过程**。同时 Nix 语言也是一门强类型和动态 类型的语言。::: 交互模式 以下交互式教程需要使用 nix repl 命令调出交互命令模式： 它有点像用于调试 JavaScript 的控制台或 Python 的交互模式？ 惰性求值Nix语言的求值是惰性的，这意味着表达式不会在被绑定到变量后立..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2024-06-30T15:34:48.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2024-06-30T15:34:48.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"Nix 语言快速入门\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2024-06-30T15:34:48.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"名称和值","slug":"名称和值","link":"#名称和值","children":[]},{"level":2,"title":"属性集","slug":"属性集","link":"#属性集","children":[]},{"level":2,"title":"递归属性集","slug":"递归属性集","link":"#递归属性集","children":[]},{"level":2,"title":"let 绑定","slug":"let-绑定","link":"#let-绑定","children":[]},{"level":2,"title":"属性访问","slug":"属性访问","link":"#属性访问","children":[]},{"level":2,"title":"with 表达式","slug":"with-表达式","link":"#with-表达式","children":[]},{"level":2,"title":"inherit 表达式","slug":"inherit-表达式","link":"#inherit-表达式","children":[]},{"level":2,"title":"字符串插值","slug":"字符串插值","link":"#字符串插值","children":[]},{"level":2,"title":"路径类型","slug":"路径类型","link":"#路径类型","children":[]},{"level":2,"title":"检索路径","slug":"检索路径","link":"#检索路径","children":[]},{"level":2,"title":"多行字符串","slug":"多行字符串","link":"#多行字符串","children":[]},{"level":2,"title":"字符串中的字符转义","slug":"multi-line-string-escape","link":"#multi-line-string-escape","children":[]},{"level":2,"title":"函数","slug":"函数","link":"#函数","children":[]},{"level":2,"title":"柯里化函数","slug":"柯里化函数","link":"#柯里化函数","children":[]},{"level":2,"title":"属性集参数","slug":"属性集参数","link":"#属性集参数","children":[]},{"level":2,"title":"默认参数","slug":"默认参数","link":"#默认参数","children":[]},{"level":2,"title":"额外参数","slug":"额外参数","link":"#额外参数","children":[]},{"level":2,"title":"命名参数集","slug":"命名参数集","link":"#命名参数集","children":[]},{"level":2,"title":"函数库","slug":"函数库","link":"#函数库","children":[{"level":3,"title":"内建函数","slug":"内建函数","link":"#内建函数","children":[]},{"level":3,"title":"导入","slug":"导入","link":"#导入","children":[]}]}],"git":{"createdTime":1711465427000,"updatedTime":1719761688000,"contributors":[{"name":"AmourAmer","email":"153876579+AmourAmer@users.noreply.github.com","commits":2},{"name":"Ryan Yin","email":"xiaoyin_c@qq.com","commits":2}]},"readingTime":{"minutes":13.65,"words":4095},"filePathRelative":"tutorials/lang/QuickOverview.md","localizedDate":"2024年3月26日","autoDesc":true,"excerpt":"\\n
\\n

Nix 语言的主要工作是**描述打包过程**。同时 Nix 语言也是一门强类型和动态

\\n

类型的语言。:::

\\n

交互模式

\\n

以下交互式教程需要使用 nix repl 命令调出交互命令模式：

\\n
$ nix repl\\nWelcome to Nix 2.5.1. Type :? for help.\\n

它有点像用于调试 JavaScript 的控制台或 Python 的交互模式？

\\n
nix-repl> 1 + 2  # 输入表达式\\n3  # 输出结果\\n
\\n

惰性求值Nix语言的求值是惰性的，这意味着表达式不会在被绑定到变量后立即求

\\n

值，而是在该值被使用时才求值。:::

\\n

即时计算被直接依赖的值

\\n
nix-repl> { a.b.c = 1; }\\n{ a = { ... }; }\\n

在上面的例子中，我们输入了一个匿名集合，而这个匿名集合包含 a 集合。

\\n
\\n

匿名集合匿名集合即没有分配名称的集合，与之对立的是命名集合，例如

\\n

foo = { bar };。:::

\\n

a 集合中的值并没有被这个匿名集合直接依赖，自然顶级以下的集合不会被立刻求值。占位的变成了 ... 。

\\n

在下面这个例子，我们将显式声明 qux 的直接依赖：

\\n
let\\n  foo = { bar.qux = 1; };\\n  lax = foo.bar.qux;\\nin\\n  lax  # 我们需要 lax，lax 需要 foo.bar.qux\\n

我们可以输入 :p 启用详尽求值，所有表达式都将被立刻求值：

\\n
nix-repl> :p { a.b.c = 1; }\\n{ a = { b = { c = 1; }; }; }\\n
\\n

`:p` 参数只能在交互模式使用，输入 `:q` 可以退出交互模式。:::

\\n

文件求值

\\n

使用nix-instantiate --eval\\n对 *.nix 文件中存在的表达式进行求值：

\\n
$ echo 1 + 2 > file.nix  # 该命令会往 file.nix 中写入 1 + 2\\n$ nix-instantiate --eval file.nix  # 文件求值\\n3  # 输出结果\\n
\\n

立即求值在文件求值的情景下可以通过在命令行添加 `--strict` 参数来启用立即

\\n

求值。

\\n
$ echo \\"{ a.b.c = 1; }\\" > file.nix\\n$ nix-instantiate --eval --strict file.nix\\n{ a = { b = { c = 1; }; }; }\\n

::: ::: info echo 命令 echo 是 Linux 中最常见的命令之一，主要作用是输出文本，追加文本，返回输出。

\\n

你可以键入 help echo 来获取该命令的使用帮助。:::

\\n

代码风格

\\n

好的代码风格会让程序员身心愉悦，同时也增加了代码可维护性。

\\n
\\n

格式化 [Alejandra](https://github.com/kamadorueda/alejandra) 是一个新兴

\\n

的 Nix 代码格式化工具，使用 Rust 编写。你可以在线尝试它。:::

\\n

当心空格

\\n

空格用于分隔词法标记（Lexical tokens），在一些场景是必要的，不然会无法区分关键字。

\\n
\\n

注

\\n

在许多中文资料中，混淆了 Lexical，Syntax 和 Grammar 三者的概念：

\\n
    \\n
  • Lexical（词法）：是指语言中单词的意义、形态和用法等方面的规则。词法规则定义了单词的基本形态和语法功能，例如名词、动词、形容词等。同时，它还规定了一些特殊单词的用法，例如冠词、介词、连词等。
    • \\n
  • Syntax（句法）：是指语言中标记（Token）之间的组合方式，以及这种组合方式所遵循的规则。通俗点说，语法规定了单词应该如何排列、组合成句子，以及这些句子之间的联系方式。
    • \\n
  • Grammar（语法）：是指语言中的规则体系，包括了语法规则、语义规则和语用规则等。它涉及到语言的整个结构和组成方式，而不仅仅是句子的构成。
    • \\n
\\n
\\n
\\n
\\n
\\n
\\n
\\n
"}');export{F as comp,K as data}; diff --git a/assets/SearchResult-NWjACjSk.js b/assets/SearchResult-B0cgczV8.js similarity index 97% rename from assets/SearchResult-NWjACjSk.js rename to assets/SearchResult-B0cgczV8.js index 9d678d6..efdb1e3 100644 --- a/assets/SearchResult-NWjACjSk.js +++ b/assets/SearchResult-B0cgczV8.js @@ -1 +1 @@ -import{u as _,f as Z,g as ee,h as B,i as te,j as ae,t as le,k as se,l as O,m as D,n as re,p as j,q as a,s as $,v as M,R as U,x as ue,y as ie,z as oe,A as ne,B as ce,C as ve,D as he,E as pe,O as de,F as ye,G as me,P as ge,H as fe,I as He,J as E}from"./app-KtH3BPxJ.js";const ke=["/","/manual/Configuration.html","/manual/Intro.html","/tutorials/concept/BinaryAndSourceDistribution.html","/tutorials/concept/ConfigurationIsTheBlueprintOfTheSystem.html","/tutorials/concept/HowFunctionalProgrammingShapesNixOS.html","/tutorials/concept/HowToMakePath-dependentProgramsWork.html","/tutorials/concept/PurityIsOurUltimatePursuit.html","/tutorials/installation/Networking.html","/tutorials/installation/Subsystem.html","/tutorials/installation/VirtualMachine.html","/tutorials/installation/WSL2.html","/tutorials/lang/Manuals.html","/tutorials/lang/QuickOverview.html","/tutorials/module-system/intro.html","/tutorials/env/dev/haskell.html","/404.html","/manual/","/tutorials/concept/","/tutorials/","/tutorials/installation/","/tutorials/lang/","/tutorials/module-system/","/tutorials/env/dev/","/tutorials/env/"],Re="SEARCH_PRO_QUERY_HISTORY",d=_(Re,[]),Se=()=>{const{queryHistoryCount:l}=E,s=l>0;return{enabled:s,queryHistory:d,addQueryHistory:r=>{s&&(d.value.length{d.value=[...d.value.slice(0,r),...d.value.slice(r+1)]}}},T=l=>ke[l.id]+("anchor"in l?`#${l.anchor}`:""),Qe="SEARCH_PRO_RESULT_HISTORY",{resultHistoryCount:L}=E,y=_(Qe,[]),we=()=>{const l=L>0;return{enabled:l,resultHistory:y,addResultHistory:s=>{if(l){const r={link:T(s),display:s.display};"header"in s&&(r.header=s.header),y.value.length{y.value=[...y.value.slice(0,s),...y.value.slice(s+1)]}}},xe=l=>{const s=ce(),r=B(),C=ve(),i=O(!1),g=he([]);return pe(()=>{const{search:R,terminate:m}=de(),S=()=>{g.value=[],i.value=!1},f=He(h=>{i.value=!0,h?R(h,r.value,s.value).then(p=>{var Q,H;return((H=(Q=s.value).searchFilter)==null?void 0:H.call(Q,p,h,r.value,C.value))??p}).then(p=>{g.value=p,i.value=!1}).catch(p=>{console.error(p),S()}):S()},E.searchDelay);j([l,r],()=>f(l.value),{immediate:!0}),ye(()=>{m()})}),{searching:i,results:g}};var Pe=Z({name:"SearchResult",props:{query:{type:String,required:!0},isFocusing:Boolean},emits:["close","updateQuery"],setup(l,{emit:s}){const r=ee(),C=B(),i=te(ae),{enabled:g,addQueryHistory:R,queryHistory:m,removeQueryHistory:S}=Se(),{enabled:f,resultHistory:h,addResultHistory:p,removeResultHistory:Q}=we(),H=g||f,P=le(l,"query"),{results:k,searching:N}=xe(P),u=se({isQuery:!0,index:0}),c=O(0),v=O(0),I=D(()=>H&&(m.value.length>0||h.value.length>0)),b=D(()=>k.value.length>0),q=D(()=>k.value[c.value]||null),V=()=>{const{isQuery:e,index:t}=u;t===0?(u.isQuery=!e,u.index=e?h.value.length-1:m.value.length-1):u.index=t-1},W=()=>{const{isQuery:e,index:t}=u;t===(e?m.value.length-1:h.value.length-1)?(u.isQuery=!e,u.index=0):u.index=t+1},Y=()=>{c.value=c.value>0?c.value-1:k.value.length-1,v.value=q.value.contents.length-1},z=()=>{c.value=c.value{v.value{v.value>0?v.value-=1:Y()},A=e=>e.map(t=>me(t)?t:a(t[0],t[1])),K=e=>{if(e.type==="customField"){const t=ge[e.index]||"$content",[o,x=""]=fe(t)?t[C.value].split("$content"):t.split("$content");return e.display.map(n=>a("div",A([o,...n,x])))}return e.display.map(t=>a("div",A(t)))},w=()=>{c.value=0,v.value=0,s("updateQuery",""),s("close")};return re("keydown",e=>{if(l.isFocusing){if(b.value){if(e.key==="ArrowUp")J();else if(e.key==="ArrowDown")G();else if(e.key==="Enter"){const t=q.value.contents[v.value];R(l.query),p(t),r.push(T(t)),w()}}else if(f){if(e.key==="ArrowUp")V();else if(e.key==="ArrowDown")W();else if(e.key==="Enter"){const{index:t}=u;u.isQuery?(s("updateQuery",m.value[t]),e.preventDefault()):(r.push(h.value[t].link),w())}}}}),j([c,v],()=>{var e;(e=document.querySelector(".search-pro-result-list-item.active .search-pro-result-item.active"))==null||e.scrollIntoView(!1)},{flush:"post"}),()=>a("div",{class:["search-pro-result-wrapper",{empty:P.value?!b.value:!I.value}],id:"search-pro-results"},P.value===""?H?I.value?[g?a("ul",{class:"search-pro-result-list"},a("li",{class:"search-pro-result-list-item"},[a("div",{class:"search-pro-result-title"},i.value.queryHistory),m.value.map((e,t)=>a("div",{class:["search-pro-result-item",{active:u.isQuery&&u.index===t}],onClick:()=>{s("updateQuery",e)}},[a($,{class:"search-pro-result-type"}),a("div",{class:"search-pro-result-content"},e),a("button",{class:"search-pro-remove-icon",innerHTML:M,onClick:o=>{o.preventDefault(),o.stopPropagation(),S(t)}})]))])):null,f?a("ul",{class:"search-pro-result-list"},a("li",{class:"search-pro-result-list-item"},[a("div",{class:"search-pro-result-title"},i.value.resultHistory),h.value.map((e,t)=>a(U,{to:e.link,class:["search-pro-result-item",{active:!u.isQuery&&u.index===t}],onClick:()=>{w()}},()=>[a($,{class:"search-pro-result-type"}),a("div",{class:"search-pro-result-content"},[e.header?a("div",{class:"content-header"},e.header):null,a("div",e.display.map(o=>A(o)).flat())]),a("button",{class:"search-pro-remove-icon",innerHTML:M,onClick:o=>{o.preventDefault(),o.stopPropagation(),Q(t)}})]))])):null]:i.value.emptyHistory:i.value.emptyResult:N.value?a(ue,{hint:i.value.searching}):b.value?a("ul",{class:"search-pro-result-list"},k.value.map(({title:e,contents:t},o)=>{const x=c.value===o;return a("li",{class:["search-pro-result-list-item",{active:x}]},[a("div",{class:"search-pro-result-title"},e||i.value.defaultTitle),t.map((n,X)=>{const F=x&&v.value===X;return a(U,{to:T(n),class:["search-pro-result-item",{active:F,"aria-selected":F}],onClick:()=>{R(l.query),p(n),w()}},()=>[n.type==="text"?null:a(n.type==="title"?ie:n.type==="heading"?oe:ne,{class:"search-pro-result-type"}),a("div",{class:"search-pro-result-content"},[n.type==="text"&&n.header?a("div",{class:"content-header"},n.header):null,a("div",K(n))])])})])})):i.value.emptyResult)}});export{Pe as default}; +import{u as _,f as Z,g as ee,h as B,i as te,j as ae,t as le,k as se,l as O,m as D,n as re,p as j,q as a,s as $,v as M,R as U,x as ue,y as ie,z as oe,A as ne,B as ce,C as ve,D as he,E as pe,O as de,F as ye,G as me,P as ge,H as fe,I as He,J as E}from"./app-BNkVxcYY.js";const ke=["/","/manual/Configuration.html","/manual/Intro.html","/tutorials/concept/BinaryAndSourceDistribution.html","/tutorials/concept/ConfigurationIsTheBlueprintOfTheSystem.html","/tutorials/concept/HowFunctionalProgrammingShapesNixOS.html","/tutorials/concept/HowToMakePath-dependentProgramsWork.html","/tutorials/concept/PurityIsOurUltimatePursuit.html","/tutorials/installation/Networking.html","/tutorials/installation/Subsystem.html","/tutorials/installation/VirtualMachine.html","/tutorials/installation/WSL2.html","/tutorials/lang/Manuals.html","/tutorials/lang/QuickOverview.html","/tutorials/module-system/intro.html","/tutorials/env/dev/haskell.html","/404.html","/manual/","/tutorials/concept/","/tutorials/","/tutorials/installation/","/tutorials/lang/","/tutorials/module-system/","/tutorials/env/dev/","/tutorials/env/"],Re="SEARCH_PRO_QUERY_HISTORY",d=_(Re,[]),Se=()=>{const{queryHistoryCount:l}=E,s=l>0;return{enabled:s,queryHistory:d,addQueryHistory:r=>{s&&(d.value.length{d.value=[...d.value.slice(0,r),...d.value.slice(r+1)]}}},T=l=>ke[l.id]+("anchor"in l?`#${l.anchor}`:""),Qe="SEARCH_PRO_RESULT_HISTORY",{resultHistoryCount:L}=E,y=_(Qe,[]),we=()=>{const l=L>0;return{enabled:l,resultHistory:y,addResultHistory:s=>{if(l){const r={link:T(s),display:s.display};"header"in s&&(r.header=s.header),y.value.length{y.value=[...y.value.slice(0,s),...y.value.slice(s+1)]}}},xe=l=>{const s=ce(),r=B(),C=ve(),i=O(!1),g=he([]);return pe(()=>{const{search:R,terminate:m}=de(),S=()=>{g.value=[],i.value=!1},f=He(h=>{i.value=!0,h?R(h,r.value,s.value).then(p=>{var Q,H;return((H=(Q=s.value).searchFilter)==null?void 0:H.call(Q,p,h,r.value,C.value))??p}).then(p=>{g.value=p,i.value=!1}).catch(p=>{console.error(p),S()}):S()},E.searchDelay);j([l,r],()=>f(l.value),{immediate:!0}),ye(()=>{m()})}),{searching:i,results:g}};var Pe=Z({name:"SearchResult",props:{query:{type:String,required:!0},isFocusing:Boolean},emits:["close","updateQuery"],setup(l,{emit:s}){const r=ee(),C=B(),i=te(ae),{enabled:g,addQueryHistory:R,queryHistory:m,removeQueryHistory:S}=Se(),{enabled:f,resultHistory:h,addResultHistory:p,removeResultHistory:Q}=we(),H=g||f,P=le(l,"query"),{results:k,searching:N}=xe(P),u=se({isQuery:!0,index:0}),c=O(0),v=O(0),I=D(()=>H&&(m.value.length>0||h.value.length>0)),b=D(()=>k.value.length>0),q=D(()=>k.value[c.value]||null),V=()=>{const{isQuery:e,index:t}=u;t===0?(u.isQuery=!e,u.index=e?h.value.length-1:m.value.length-1):u.index=t-1},W=()=>{const{isQuery:e,index:t}=u;t===(e?m.value.length-1:h.value.length-1)?(u.isQuery=!e,u.index=0):u.index=t+1},Y=()=>{c.value=c.value>0?c.value-1:k.value.length-1,v.value=q.value.contents.length-1},z=()=>{c.value=c.value{v.value{v.value>0?v.value-=1:Y()},A=e=>e.map(t=>me(t)?t:a(t[0],t[1])),K=e=>{if(e.type==="customField"){const t=ge[e.index]||"$content",[o,x=""]=fe(t)?t[C.value].split("$content"):t.split("$content");return e.display.map(n=>a("div",A([o,...n,x])))}return e.display.map(t=>a("div",A(t)))},w=()=>{c.value=0,v.value=0,s("updateQuery",""),s("close")};return re("keydown",e=>{if(l.isFocusing){if(b.value){if(e.key==="ArrowUp")J();else if(e.key==="ArrowDown")G();else if(e.key==="Enter"){const t=q.value.contents[v.value];R(l.query),p(t),r.push(T(t)),w()}}else if(f){if(e.key==="ArrowUp")V();else if(e.key==="ArrowDown")W();else if(e.key==="Enter"){const{index:t}=u;u.isQuery?(s("updateQuery",m.value[t]),e.preventDefault()):(r.push(h.value[t].link),w())}}}}),j([c,v],()=>{var e;(e=document.querySelector(".search-pro-result-list-item.active .search-pro-result-item.active"))==null||e.scrollIntoView(!1)},{flush:"post"}),()=>a("div",{class:["search-pro-result-wrapper",{empty:P.value?!b.value:!I.value}],id:"search-pro-results"},P.value===""?H?I.value?[g?a("ul",{class:"search-pro-result-list"},a("li",{class:"search-pro-result-list-item"},[a("div",{class:"search-pro-result-title"},i.value.queryHistory),m.value.map((e,t)=>a("div",{class:["search-pro-result-item",{active:u.isQuery&&u.index===t}],onClick:()=>{s("updateQuery",e)}},[a($,{class:"search-pro-result-type"}),a("div",{class:"search-pro-result-content"},e),a("button",{class:"search-pro-remove-icon",innerHTML:M,onClick:o=>{o.preventDefault(),o.stopPropagation(),S(t)}})]))])):null,f?a("ul",{class:"search-pro-result-list"},a("li",{class:"search-pro-result-list-item"},[a("div",{class:"search-pro-result-title"},i.value.resultHistory),h.value.map((e,t)=>a(U,{to:e.link,class:["search-pro-result-item",{active:!u.isQuery&&u.index===t}],onClick:()=>{w()}},()=>[a($,{class:"search-pro-result-type"}),a("div",{class:"search-pro-result-content"},[e.header?a("div",{class:"content-header"},e.header):null,a("div",e.display.map(o=>A(o)).flat())]),a("button",{class:"search-pro-remove-icon",innerHTML:M,onClick:o=>{o.preventDefault(),o.stopPropagation(),Q(t)}})]))])):null]:i.value.emptyHistory:i.value.emptyResult:N.value?a(ue,{hint:i.value.searching}):b.value?a("ul",{class:"search-pro-result-list"},k.value.map(({title:e,contents:t},o)=>{const x=c.value===o;return a("li",{class:["search-pro-result-list-item",{active:x}]},[a("div",{class:"search-pro-result-title"},e||i.value.defaultTitle),t.map((n,X)=>{const F=x&&v.value===X;return a(U,{to:T(n),class:["search-pro-result-item",{active:F,"aria-selected":F}],onClick:()=>{R(l.query),p(n),w()}},()=>[n.type==="text"?null:a(n.type==="title"?ie:n.type==="heading"?oe:ne,{class:"search-pro-result-type"}),a("div",{class:"search-pro-result-content"},[n.type==="text"&&n.header?a("div",{class:"content-header"},n.header):null,a("div",K(n))])])})])})):i.value.emptyResult)}});export{Pe as default}; diff --git a/assets/Subsystem.html-B9GmW8h7.js b/assets/Subsystem.html-DSYLh798.js similarity index 72% rename from assets/Subsystem.html-B9GmW8h7.js rename to assets/Subsystem.html-DSYLh798.js index 66612ca..c9f884c 100644 --- a/assets/Subsystem.html-B9GmW8h7.js +++ b/assets/Subsystem.html-DSYLh798.js @@ -1,26 +1,26 @@ -import{_ as d}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as l,o as r,c as u,a as n,b as s,d as i,w as a,e as o}from"./app-KtH3BPxJ.js";const m="/images/GreenHand/TurnOffWindowsFastboot.webp",v="/images/GreenHand/WindowsDiskManager.webp",k="/images/GreenHand/DisableSecureBoot.webp",b="/images/GreenHand/FirstBoot.webp",h="/images/GreenHand/TrulyMeet.webp",g={},f=o('

双系统安装

Windows 系统上的准备

本章将介绍如何在已经安装了 Windows 系统的物理机上再安装 NixOS 。

关闭快速启动

若不关闭 Windows 的快速启动，可能会导致 NixOS 掉网卡。点击 “更改当前不可用配置” 以后会出现一个 UAC 窗口，点击允许以后，再取消 “启用快速启动（推荐）” 复选框。

关闭快速启动
关闭快速启动

调整时间设置

由于 Windows 与 Linux 时间标准不同，从 Linux 切换回 Windows 会导致系统时间变更的问题。

在这里我们提供修改 Windows 设置，以让两种系统时间保持一致的的方法。

PowerShell 管理员权限运行：

Reg add HKLM\\SYSTEM\\CurrentControlSet\\Control\\TimeZoneInformation /v RealTimeIsUniversal /t REG_DWORD /d 1
-

该命令向注册表添加了字段，下次重启生效。

腾出空间

我们需要为 NixOS 的安装准备一些空间，我们推荐为 NixOS 保留的分区不少于 64GB。

你可以使用 Windows 自带的磁盘管理或 DiskGenius 等其他分区软件腾出这些空间。

Windows 磁盘管理
Windows 磁盘管理

制作引导媒介

',17),x={href:"https://www.ventoy.net/cn/download.html",target:"_blank",rel:"noopener noreferrer"},w={href:"https://nixos.org/download.html#nix-more:~:text=without%20a%20desktop.-,Minimal%20ISO%20image,-The%20minimal%20installation",target:"_blank",rel:"noopener noreferrer"},q=o('

调整 BIOS 设置

在执行以下操作时，请将电脑关机，并将启动媒介连接电脑。

关闭安全引导

在按下开机键，屏幕出现厂商品牌的时候，按住可以使你进入 BIOS 设置的按键，然后你会进入跟下图相同或类似的界面。

厂商差异

具体情况以厂商主板为准。不同厂商生产的机型进入 BIOS 设置的按键不相同，甚至界面也不会相同。对于某些厂商（比如联想，宏碁），关闭安全启动需要为主板设置管理员密码，建议完成系统安装后立刻移除主板密码，以防止密码被遗忘。

关闭安全引导
关闭安全引导

请关闭安全引导，NixOS 官方暂时不支持安全引导。这一步没有代价，安装完成后，你随时可以把安全引导再开启。

安全引导

安全引导的技术原理是用数字签名来验证软件是否可信，如果不可信就不让它运行。

调整启动顺序

UEFI 支持

UEFI 和 Legacy 是两种不同的引导方式，安装前请查阅你的主板是否支持 UEFI，或者当前系统是否以 UEFI 方式安装。对于 Windows 系统只需要使用磁盘管理或 DiskGenius 查看是否存在 ESP 分区即可。而对于 Linux，键入：

ls /sys/firmware/efi/efivars
-

若存在输出，就代表支持 UEFI。

默认情况下，BIOS 会从本地硬盘开始查找 EFI（ESP） 分区，然后启动这个分区的启动管理器，所以我们要在 BIOS 设置中找到诸如“启动顺序”选项，将 USB 拉到最高优先级。

保存后重启，不出意外就到了接下来的环节。

引导选择

你会先进入 Ventoy 的引导界面，然后使用上下按键选择你需要引导的镜像，回车确认。下图就是你即将见到的 NixOS 的引导界面：

初见引导界面
初见引导界面

正常来说选择第一项正常启动即可。如果你想引导完成后移除启动媒介，可以使用 copytoram 启动项，这样会把系统复制到内存。

屏幕工作不正常

如果在正常的内核引导下，屏幕会有闪烁，撕裂的情况发生，导致安装难以继续。那么请重启后选择 nomodeset 项引导，此项会禁用一些内核针对显卡的功能。

进入 Live CD

初遇
初遇

由于我们选择的是最小化镜像，所以是没有桌面环境的，当前在我们面前的是 tty 界面。

我们现在进入的系统是由镜像直接初始化的，系统并未被安装到硬盘上。我们需要使用现在这个已经被加载的基本系统完成 NixOS 到硬盘的部署。

网络连接

如果你有可选的有线连接，请将网线接入到电脑。

USB 热点

退而求其次，如果你手机数据流量充足，也可以使用 USB 共享网络给主机。

WiFi 连接

NixOS 默认使用 wpa_supplicant 作为无线守护程序。

sudo systemctl start wpa_supplicant  # 启动服务
+import{_ as d}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as l,o as r,c as u,a as n,b as s,d as o,w as a,e as i}from"./app-BNkVxcYY.js";const m="/images/GreenHand/TurnOffWindowsFastboot.webp",v="/images/GreenHand/WindowsDiskManager.webp",k="/images/GreenHand/DisableSecureBoot.webp",b="/images/GreenHand/FirstBoot.webp",h="/images/GreenHand/TrulyMeet.webp",g={},f=i('
双系统安装
Windows 系统上的准备
本章将介绍如何在已经安装了 Windows 系统的物理机上再安装 NixOS 。
关闭快速启动
若不关闭 Windows 的快速启动，可能会导致 NixOS 掉网卡。点击 “更改当前不可用配置” 以后会出现一个 UAC 窗口，点击允许以后，再取消 “启用快速启动（推荐）” 复选框。
关闭快速启动
关闭快速启动
调整时间设置
由于 Windows 与 Linux 时间标准不同，从 Linux 切换回 Windows 会导致系统时间变更的问题。
在这里我们提供修改 Windows 设置，以让两种系统时间保持一致的的方法。
PowerShell 管理员权限运行：
Reg add HKLM\\SYSTEM\\CurrentControlSet\\Control\\TimeZoneInformation /v RealTimeIsUniversal /t REG_DWORD /d 1
+
该命令向注册表添加了字段，下次重启生效。
腾出空间
我们需要为 NixOS 的安装准备一些空间，我们推荐为 NixOS 保留的分区不少于 64GB。
你可以使用 Windows 自带的磁盘管理或 DiskGenius 等其他分区软件腾出这些空间。
Windows 磁盘管理
Windows 磁盘管理
制作引导媒介
',17),x={href:"https://www.ventoy.net/cn/download.html",target:"_blank",rel:"noopener noreferrer"},w={href:"https://nixos.org/download.html#nix-more:~:text=without%20a%20desktop.-,Minimal%20ISO%20image,-The%20minimal%20installation",target:"_blank",rel:"noopener noreferrer"},_=n("h2",{id:"调整-bios-设置",tabindex:"-1"},[n("a",{class:"header-anchor",href:"#调整-bios-设置"},[n("span",null,"调整 BIOS 设置")])],-1),q=n("p",null,"在执行以下操作时，请将电脑关机，并将启动媒介连接电脑。",-1),y=n("h3",{id:"关闭安全引导",tabindex:"-1"},[n("a",{class:"header-anchor",href:"#关闭安全引导"},[n("span",null,"关闭安全引导")])],-1),S=n("p",null,"在按下开机键，屏幕出现厂商品牌的时候，按住可以使你进入 BIOS 设置的按键，然后你会进入跟下图相同或类似的界面。",-1),O={class:"hint-container warning"},B=n("p",{class:"hint-container-title"},"厂商差异具体情况以厂商主板为准。不同厂商生产的机型进入 BIOS 设置的按",-1),N=n("p",null,"键不相同，甚至界面也不会相同。对于某些厂商（比如联想，宏碁），关闭安全启动需要为主板设置管理员密码，建议完成系统安装后立刻移除主板密码，以防止密码被遗忘。:::",-1),M=n("figure",null,[n("img",{src:k,alt:"关闭安全引导",tabindex:"0",loading:"lazy"}),n("figcaption",null,"关闭安全引导")],-1),G=n("p",null,"请关闭安全引导，NixOS 官方暂时不支持安全引导。这一步没有代价，安装完成后，你随时可以把安全引导再开启。",-1),W={class:"hint-container tip"},T=n("p",{class:"hint-container-title"},"安全引导安全引导的技术原理是用数字签名来验证软件是否可信，如果不可信就不",-1),I=n("p",null,"让它运行。:::",-1),E=n("h3",{id:"调整启动顺序",tabindex:"-1"},[n("a",{class:"header-anchor",href:"#调整启动顺序"},[n("span",null,"调整启动顺序")])],-1),F={class:"hint-container warning"},P=i(`
UEFI 支持 UEFI 和 Legacy 是两种不同的引导方式，安装前请查阅你的主板
是否支持 UEFI，或者当前系统是否以 UEFI 方式安装。对于 Windows 系统只需要使用磁盘管理或 DiskGenius 查看是否存在 ESP 分区即可。而对于 Linux，键入：
ls /sys/firmware/efi/efivars
+
若存在输出，就代表支持 UEFI。:::
默认情况下，BIOS 会从本地硬盘开始查找 EFI（ESP） 分区，然后启动这个分区的启动管理器，所以我们要在 BIOS 设置中找到诸如“启动顺序”选项，将 USB 拉到最高优先级。
保存后重启，不出意外就到了接下来的环节。
引导选择
你会先进入 Ventoy 的引导界面，然后使用上下按键选择你需要引导的镜像，回车确认。下图就是你即将见到的 NixOS 的引导界面：
初见引导界面
初见引导界面
正常来说选择第一项正常启动即可。如果你想引导完成后移除启动媒介，可以使用 copytoram 启动项，这样会把系统复制到内存。
',10),C={class:"hint-container warning"},D=i('
屏幕工作不正常如果在正常的内核引导下，屏幕会有闪烁，撕裂的情况发生，
导致安装难以继续。那么请重启后选择 nomodeset 项引导，此项会禁用一些内核针对显卡的功能。:::
进入 Live CD
初遇
初遇
由于我们选择的是最小化镜像，所以是没有桌面环境的，当前在我们面前的是 tty 界面。
我们现在进入的系统是由镜像直接初始化的，系统并未被安装到硬盘上。我们需要使用现在这个已经被加载的基本系统完成 NixOS 到硬盘的部署。
网络连接
如果你有可选的有线连接，请将网线接入到电脑。
USB 热点
退而求其次，如果你手机数据流量充足，也可以使用 USB 共享网络给主机。
WiFi 连接
NixOS 默认使用 wpa_supplicant 作为无线守护程序。
sudo systemctl start wpa_supplicant  # 启动服务
 sudo wpa_cli  # 进入 wpa 命令行交互模式
-
然后就进入了交互模式，不同区域的 WiFi 网络认证协议也不相同。大多数情况下使用家庭网络的方式即可：
`,29),_=n("div",{class:"language-bash line-numbers-mode","data-ext":"sh","data-title":"sh"},[n("pre",{class:"language-bash"},[n("code",null,[n("span",{class:"token operator"},">"),s(` add_network
+

然后就进入了交互模式，不同区域的 WiFi 网络认证协议也不相同。大多数情况下使用家庭网络的方式即可：

`,14),A=n("div",{class:"language-bash line-numbers-mode","data-ext":"sh","data-title":"sh"},[n("pre",{class:"language-bash"},[n("code",null,[n("span",{class:"token operator"},">"),s(` add_network `),n("span",{class:"token number"},"0"),s(` `),n("span",{class:"token operator"},">"),s(" set_network "),n("span",{class:"token number"},"0"),s(" ssid "),n("span",{class:"token string"},'"WIFI SSID"'),s(` OK `),n("span",{class:"token operator"},">"),s(" set_network "),n("span",{class:"token number"},"0"),s(` key_mgmt NONE OK `),n("span",{class:"token operator"},">"),s(" enable_network "),n("span",{class:"token number"},"0"),s(` -OK -`)])]),n("div",{class:"line-numbers","aria-hidden":"true"},[n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"})])],-1),y=n("div",{class:"language-bash line-numbers-mode","data-ext":"sh","data-title":"sh"},[n("pre",{class:"language-bash"},[n("code",null,[n("span",{class:"token operator"},">"),s(` add_network +OK +`)])]),n("div",{class:"line-numbers","aria-hidden":"true"},[n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"})])],-1),z=n("div",{class:"language-bash line-numbers-mode","data-ext":"sh","data-title":"sh"},[n("pre",{class:"language-bash"},[n("code",null,[n("span",{class:"token operator"},">"),s(` add_network `),n("span",{class:"token number"},"0"),s(` `),n("span",{class:"token operator"},">"),s(" set_network "),n("span",{class:"token number"},"0"),s(" ssid "),n("span",{class:"token string"},'"你家 WIFI 的 SSID"'),s(` OK `),n("span",{class:"token operator"},">"),s(" set_network "),n("span",{class:"token number"},"0"),s(" psk "),n("span",{class:"token string"},'"WIFI 密码"'),s(` OK -`),n("span",{class:"token operator"},">"),s(" set_network "),n("span",{class:"token number"},"0"),s(` key_mgmt WPA-PSK +`),n("span",{class:"token operator"},">"),s(" set_network "),n("span",{class:"token number"},"0"),s(` key_mgmt WPA-PSK OK `),n("span",{class:"token operator"},">"),s(" enable_network "),n("span",{class:"token number"},"0"),s(` OK -`)])]),n("div",{class:"line-numbers","aria-hidden":"true"},[n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"})])],-1),S=n("div",{class:"language-bash line-numbers-mode","data-ext":"sh","data-title":"sh"},[n("pre",{class:"language-bash"},[n("code",null,[n("span",{class:"token operator"},">"),s(` add_network +`)])]),n("div",{class:"line-numbers","aria-hidden":"true"},[n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"})])],-1),U=n("div",{class:"language-bash line-numbers-mode","data-ext":"sh","data-title":"sh"},[n("pre",{class:"language-bash"},[n("code",null,[n("span",{class:"token operator"},">"),s(` add_network `),n("span",{class:"token number"},"0"),s(` `),n("span",{class:"token operator"},">"),s(" set_network "),n("span",{class:"token number"},"0"),s(" ssid "),n("span",{class:"token string"},'"eduroam"'),s(` OK @@ -32,10 +32,10 @@ OK OK `),n("span",{class:"token operator"},">"),s(" enable_network "),n("span",{class:"token number"},"0"),s(` OK -`)])]),n("div",{class:"line-numbers","aria-hidden":"true"},[n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"})])],-1),O=o(`
<3>CTRL-EVENT-CONNECTED - Connection to 32:85:ab:ef:24:5c completed [id=0 id_str=]
+`)])]),n("div",{class:"line-numbers","aria-hidden":"true"},[n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"}),n("div",{class:"line-number"})])],-1),K=i(`
<3>CTRL-EVENT-CONNECTED - Connection to 32:85:ab:ef:24:5c completed [id=0 id_str=]
 
等待出现上面的消息说明你已经连接上了，可以输入 quit 以退出交互模式。
检测网络
ping www.baidu.com -c 4  # 此项不通优先先检查域名解析服务器
 ping 119.29.29.29 -c 4  # 腾讯 DNSPod，不通请检查网络连接
-
如果收到了大多数乃至全部包，说明网络是连通的。
更换频道
使用以下命令将两个频道（系统频道和软件仓库频道）替换到镜像源频道：
不要盲目复制
在订阅系统版本时请指定系统版本，一般指定当前的最新稳定版。如果不清楚可以去官网查询或查看你的 Live CD 版本。
sudo -i
+
如果收到了大多数乃至全部包，说明网络是连通的。
更换频道
使用以下命令将两个频道（系统频道和软件仓库频道）替换到镜像源频道：
不要盲目复制在订阅系统版本时请指定系统版本，一般指定当前的最新稳定
版。如果不清楚可以去官网查询或查看你的 Live CD 版本。:::
sudo -i
 nix-channel --add https://mirrors.ustc.edu.cn/nix-channels/nixpkgs-unstable nixpkgs  # 订阅镜像仓库频道
 nix-channel --add https://mirrors.ustc.edu.cn/nix-channels/nixos-22.11 nixos  # 请注意系统版本
 nix-channel --list  # 列出频道
@@ -44,10 +44,10 @@ nixos-rebuild --option substituter
 
分区与格式化
首先，我们使用 lsblk 命令查看一手分区情况：
NAMEMAJ:MINRMSIZEROTYPEMOUNTPOINTS
loop07:00799.4M1loop/nix/.ro-store
sda8:010B0disk
sdb8:16157.7G0disk
-sdb18:17157.6G0part
--ventory254:00833M1dm/iso
-sda28:18132M0part
nvme0n1259:00476.9G0disk
-nvme0n1p1259:10256M0part
-nvme0n1p2259:2016M0part
-nvme0n1p3259:30320G0part
TYPE 列指示了分区类型还是硬盘类型。这里需要的是硬盘类型。根据接口类型和硬盘容量大小，你很快就能分辨出我电脑的唯一硬盘是 nvme0n1，sda 是我的引导 U 盘。
parted -a optimal /dev/nvme0n1  # 启用对齐，并进行分区
 
我们已经进入了交互模式。在这个模式中，所有操作都是即时生效的，所以请再三确认你的操作。你可以输入 help 查看帮助手册，然后输入 p 查看当前分区状况。
NumberStartEndSizeFile systemNameFlags
120.5KB268MB268MBfat32EFI system partitionboot, esp, no_automount
2268MB285MB16.8MBMicrosoft reserved partitionmsftres, no_automount
3286MB344GB344GBntfsBasic data partitionmsftdata
在现有的 GPT 分区表上，我们添加额外的分区。首先我们需要一个 NixOS 的主分区，用来容纳 NixOS 的根文件系统。
mkpart primary 344GB -16GiB
 
然后添加一个 SWAP 分区，它可以拓展你的内存能力以及将内存数据休眠于此。
mkpart primary linux-swap -16GiB 100%
-
分区对齐
不出意外的话，会出现一个警告：
Warnning: The resulting partition is not properly aligned for best performance: 966660784s % 2048s != 0s Ignore/Cancel?
我在这里输入了 Ignore，忽略这个警告。
在我的设备上，现有的 GPT 分区表是由 Disk Genius 生成的，出现这个警告我并不意外，我选择忽略这个警告。这个警告提示你分区没有对齐，对齐以后才能获得最佳性能。如果你想让分区重新对齐，就只能重新创建 GPT 表，再重新安装两个系统。
如果你想让你的分区对齐，可以在创建第一张分区表时使用百分比表示分区的开始和结束位置：
mkpart primary 0% 100%
+
分区对齐不出意外的话，会出现一个警告：
Warnning: The resulting partition is not properly aligned for best performance: 966660784s % 2048s != 0s Ignore/Cancel?
我在这里输入了 Ignore，忽略这个警告。
在我的设备上，现有的 GPT 分区表是由 Disk Genius 生成的，出现这个警告我并不意外，我选择忽略这个警告。这个警告提示你分区没有对齐，对齐以后才能获得最佳性能。如果你想让分区重新对齐，就只能重新创建 GPT 表，再重新安装两个系统。
如果你想让你的分区对齐，可以在创建第一张分区表时使用百分比表示分区的开始和结束位置：
mkpart primary 0% 100%
 
或者在开始的时候就使用对齐参数：
parted -a optimal /dev/nvme0n1
 
你还可以使用下面的命令检查分区是否对齐，最后一个数字是分区序号：
align-check optimal 1
-
现在的分区表应当是：
NumberStartEndSizeFile systemNameFlags
120.5KB268MB268MBfat32EFI system partitionboot, esp, no_automount
2268MB285MB16.8MBMicrosoft reserved partitionmsftres, no_automount
3286MB344GB344GBntfsBasic data partitionmsftdata
4344GB495GB151GBprimary
5495GB512GB17.2GBlinux-swap(v1)primaryswap
然后输入 quit 退出交互模式。
接下来进行格式化环节。格式化根目录：
mkfs.btrfs -L nixos /dev/nvme0n1p4
+
现在的分区表应当是：
NumberStartEndSizeFile systemNameFlags
120.5KB268MB268MBfat32EFI system partitionboot, esp, no_automount
2268MB285MB16.8MBMicrosoft reserved partitionmsftres, no_automount
3286MB344GB344GBntfsBasic data partitionmsftdata
4344GB495GB151GBprimary
5495GB512GB17.2GBlinux-swap(v1)primaryswap
然后输入 quit 退出交互模式。
接下来进行格式化环节。格式化根目录：
mkfs.btrfs -L nixos /dev/nvme0n1p4
 
再格式化交换分区：
mkswap -L swap /dev/nvme0n1p5
 
然后挂载根分区到当前的 /mnt 目录下：
mount /dev/nvme0n1p4 /mnt
 
创建几个子卷，我们今后可以对子卷进行更细粒化的管理：
btrfs subvolume create /mnt/root
@@ -62,7 +62,7 @@ btrfs subvolume create /mnt/nix
 swapon /dev/nvme0n1p5
 
编辑系统配置
我们使用以下命令生成基础配置：
nixos-generate-config --root /mnt
 
然后编辑配置：
vim /mnt/etc/nixos/configuration.nix
-
因为是基本的安装，我并没有为配置加太多花，不要改动你配置中的最后一行的版本号：
{ config, lib, pkgs, ...}:
+
因为是基本的安装，我并没有为配置加太多花，==不要改动你配置中的最后一行的版本号 ==：
{ config, lib, pkgs, ...}:
 {
     imports = [ ./hardware-configuration.nix ];
     boot.loader = {
@@ -150,4 +150,4 @@ btrfs subvolume create /mnt/nix
 passwd root  # 重置 root 密码
 useradd -m -G wheel tritium  # 添加普通用户，并加入 wheel 组
 passwd tritium  # 设置普通账户密码
-
然后关机，不出意外的话还是需要你去 BIOS 调整一下启动项，推荐把 NixOS 的启动项拉到最前面，因为在 GRUB 的界面你能选择引导至 NixOS 还是 Windows。当然有的机型可以在出现厂商 Logo 时直接按 F10（或其他按钮）来选择启动项。
最终退后三步朝电脑跪拜祈求它能正常开机，至此基本安装教程完毕。
`,52);function B(N,M){const p=l("ExternalLinkIcon"),c=l("CodeTabs");return r(),u("div",null,[f,n("p",null,[s("我们使用 "),n("a",x,[s("Ventoy"),i(p)]),s(" 制作引导媒介，Ventoy 会将引导写入媒介（驱动器），然后你可以间接选择引导你媒介中的镜像。这样的好处是刻录一次就能引导多镜像（具体请参阅 Ventoy 官网以获取使用方法）。")]),n("p",null,[s("下载"),n("a",w,[s("最简镜像"),i(p)]),s("（Minimal ISO image），我们不使用官方安装程序做演示，因为没有太多的自定义选项。下载完成后，拷贝镜像至已经安装 Ventoy 的驱动器的任意目录。")]),q,i(c,{id:"152",data:[{id:"开放网络"},{id:"家庭网络"},{id:"企业网络"}],"tab-id":"shell"},{title0:a(({value:t,isActive:e})=>[s("开放网络")]),title1:a(({value:t,isActive:e})=>[s("家庭网络")]),title2:a(({value:t,isActive:e})=>[s("企业网络")]),tab0:a(({value:t,isActive:e})=>[_]),tab1:a(({value:t,isActive:e})=>[y]),tab2:a(({value:t,isActive:e})=>[S]),_:1}),O])}const T=d(g,[["render",B],["__file","Subsystem.html.vue"]]),I=JSON.parse('{"path":"/tutorials/installation/Subsystem.html","title":"双系统安装","lang":"zh-CN","frontmatter":{"description":"双系统安装 Windows 系统上的准备 本章将介绍如何在已经安装了 Windows 系统的物理机上再安装 NixOS 。 关闭快速启动 若不关闭 Windows 的快速启动，可能会导致 NixOS 掉网卡。点击 “更改当前不可用配置” 以后会出现一个 UAC 窗口，点击允许以后，再取消 “启用快速启动（推荐）” 复选框。 关闭快速启动关闭快速启动 调...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/installation/Subsystem.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"双系统安装"}],["meta",{"property":"og:description","content":"双系统安装 Windows 系统上的准备 本章将介绍如何在已经安装了 Windows 系统的物理机上再安装 NixOS 。 关闭快速启动 若不关闭 Windows 的快速启动，可能会导致 NixOS 掉网卡。点击 “更改当前不可用配置” 以后会出现一个 UAC 窗口，点击允许以后，再取消 “启用快速启动（推荐）” 复选框。 关闭快速启动关闭快速启动 调..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:image","content":"https://nixos-cn.github.io/images/GreenHand/TurnOffWindowsFastboot.webp"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2023-11-02T01:58:54.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2023-11-02T01:58:54.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"双系统安装\\",\\"image\\":[\\"https://nixos-cn.github.io/images/GreenHand/TurnOffWindowsFastboot.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/WindowsDiskManager.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/DisableSecureBoot.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/FirstBoot.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/TrulyMeet.webp\\"],\\"dateModified\\":\\"2023-11-02T01:58:54.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"Windows 系统上的准备","slug":"windows-系统上的准备","link":"#windows-系统上的准备","children":[{"level":3,"title":"关闭快速启动","slug":"关闭快速启动","link":"#关闭快速启动","children":[]},{"level":3,"title":"调整时间设置","slug":"调整时间设置","link":"#调整时间设置","children":[]},{"level":3,"title":"腾出空间","slug":"腾出空间","link":"#腾出空间","children":[]},{"level":3,"title":"制作引导媒介","slug":"制作引导媒介","link":"#制作引导媒介","children":[]}]},{"level":2,"title":"调整 BIOS 设置","slug":"调整-bios-设置","link":"#调整-bios-设置","children":[{"level":3,"title":"关闭安全引导","slug":"关闭安全引导","link":"#关闭安全引导","children":[]},{"level":3,"title":"调整启动顺序","slug":"调整启动顺序","link":"#调整启动顺序","children":[]}]},{"level":2,"title":"引导选择","slug":"引导选择","link":"#引导选择","children":[]},{"level":2,"title":"进入 Live CD","slug":"进入-live-cd","link":"#进入-live-cd","children":[{"level":3,"title":"网络连接","slug":"网络连接","link":"#网络连接","children":[]},{"level":3,"title":"更换频道","slug":"更换频道","link":"#更换频道","children":[]},{"level":3,"title":"分区与格式化","slug":"分区与格式化","link":"#分区与格式化","children":[]},{"level":3,"title":"编辑系统配置","slug":"编辑系统配置","link":"#编辑系统配置","children":[]},{"level":3,"title":"部署系统","slug":"部署系统","link":"#部署系统","children":[]}]}],"git":{"createdTime":1696961467000,"updatedTime":1698890334000,"contributors":[{"name":"OpenTritium","email":"tritium404@hotmail.com","commits":3}]},"readingTime":{"minutes":10.35,"words":3105},"filePathRelative":"tutorials/installation/Subsystem.md","localizedDate":"2023年10月10日","autoDesc":true,"excerpt":"\\n
Windows 系统上的准备
\\n
本章将介绍如何在已经安装了 Windows 系统的物理机上再安装 NixOS 。
\\n
关闭快速启动
\\n
若不关闭 Windows 的快速启动，可能会导致 NixOS 掉网卡。点击 “更改当前不可用配置” 以后会出现一个 UAC 窗口，点击允许以后，再取消 “启用快速启动（推荐）” 复选框。
\\n
\\"关闭快速启动\\"
关闭快速启动
"}');export{T as comp,I as data};
+

然后关机，不出意外的话还是需要你去 BIOS 调整一下启动项，推荐把 NixOS 的启动项拉到最前面，因为在 GRUB 的界面你能选择引导至 NixOS 还是 Windows。当然有的机型可以在出现厂商 Logo 时直接按 F10（或其他按钮）来选择启动项。

最终退后三步朝电脑跪拜祈求它能正常开机，至此基本安装教程完毕。

`,39);function H(L,V){const p=l("ExternalLinkIcon"),c=l("CodeTabs");return r(),u("div",null,[f,n("p",null,[s("我们使用 "),n("a",x,[s("Ventoy"),o(p)]),s(" 制作引导媒介，Ventoy 会将引导写入媒介（驱动器），然后你可以间接选择引导你媒介中的镜像。这样的好处是刻录一次就能引导多镜像（具体请参阅 Ventoy 官网以获取使用方法）。")]),n("p",null,[s("下载"),n("a",w,[s("最简镜像"),o(p)]),s("（Minimal ISO image），我们不使用官方安装程序做演示，因为没有太多的自定义选项。下载完成后，拷贝镜像至已经安装 Ventoy 的驱动器的任意目录。")]),_,q,y,S,n("div",O,[B,N,M,G,n("div",W,[T,I,E,n("div",F,[P,n("div",C,[D,o(c,{id:"148",data:[{id:"开放网络"},{id:"家庭网络"},{id:"企业网络"}],"tab-id":"shell"},{title0:a(({value:t,isActive:e})=>[s("开放网络")]),title1:a(({value:t,isActive:e})=>[s("家庭网络")]),title2:a(({value:t,isActive:e})=>[s("企业网络")]),tab0:a(({value:t,isActive:e})=>[A]),tab1:a(({value:t,isActive:e})=>[z]),tab2:a(({value:t,isActive:e})=>[U]),_:1})])])])]),K])}const Y=d(g,[["render",H],["__file","Subsystem.html.vue"]]),j=JSON.parse('{"path":"/tutorials/installation/Subsystem.html","title":"双系统安装","lang":"zh-CN","frontmatter":{"description":"双系统安装 Windows 系统上的准备 本章将介绍如何在已经安装了 Windows 系统的物理机上再安装 NixOS 。 关闭快速启动 若不关闭 Windows 的快速启动，可能会导致 NixOS 掉网卡。点击 “更改当前不可用配置” 以后会出现一个 UAC 窗口，点击允许以后，再取消 “启用快速启动（推荐）” 复选框。 关闭快速启动关闭快速启动 调...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/installation/Subsystem.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"双系统安装"}],["meta",{"property":"og:description","content":"双系统安装 Windows 系统上的准备 本章将介绍如何在已经安装了 Windows 系统的物理机上再安装 NixOS 。 关闭快速启动 若不关闭 Windows 的快速启动，可能会导致 NixOS 掉网卡。点击 “更改当前不可用配置” 以后会出现一个 UAC 窗口，点击允许以后，再取消 “启用快速启动（推荐）” 复选框。 关闭快速启动关闭快速启动 调..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:image","content":"https://nixos-cn.github.io/images/GreenHand/TurnOffWindowsFastboot.webp"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2024-06-30T15:34:48.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2024-06-30T15:34:48.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"双系统安装\\",\\"image\\":[\\"https://nixos-cn.github.io/images/GreenHand/TurnOffWindowsFastboot.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/WindowsDiskManager.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/DisableSecureBoot.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/FirstBoot.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/TrulyMeet.webp\\"],\\"dateModified\\":\\"2024-06-30T15:34:48.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"Windows 系统上的准备","slug":"windows-系统上的准备","link":"#windows-系统上的准备","children":[{"level":3,"title":"关闭快速启动","slug":"关闭快速启动","link":"#关闭快速启动","children":[]},{"level":3,"title":"调整时间设置","slug":"调整时间设置","link":"#调整时间设置","children":[]},{"level":3,"title":"腾出空间","slug":"腾出空间","link":"#腾出空间","children":[]},{"level":3,"title":"制作引导媒介","slug":"制作引导媒介","link":"#制作引导媒介","children":[]}]},{"level":2,"title":"调整 BIOS 设置","slug":"调整-bios-设置","link":"#调整-bios-设置","children":[{"level":3,"title":"关闭安全引导","slug":"关闭安全引导","link":"#关闭安全引导","children":[]},{"level":3,"title":"更换频道","slug":"更换频道","link":"#更换频道","children":[]},{"level":3,"title":"编辑系统配置","slug":"编辑系统配置","link":"#编辑系统配置","children":[]},{"level":3,"title":"部署系统","slug":"部署系统","link":"#部署系统","children":[]}]}],"git":{"createdTime":1696961467000,"updatedTime":1719761688000,"contributors":[{"name":"OpenTritium","email":"tritium404@hotmail.com","commits":3},{"name":"Ryan Yin","email":"xiaoyin_c@qq.com","commits":1}]},"readingTime":{"minutes":10.35,"words":3105},"filePathRelative":"tutorials/installation/Subsystem.md","localizedDate":"2023年10月10日","autoDesc":true,"excerpt":"\\n

Windows 系统上的准备

\\n

本章将介绍如何在已经安装了 Windows 系统的物理机上再安装 NixOS 。

\\n

关闭快速启动

\\n

若不关闭 Windows 的快速启动，可能会导致 NixOS 掉网卡。点击 “更改当前不可用配置”\\n以后会出现一个 UAC 窗口，点击允许以后，再取消 “启用快速启动（推荐）” 复选框。

\\n
\\"关闭快速启动\\"
关闭快速启动
"}');export{Y as comp,j as data}; diff --git a/assets/VirtualMachine.html-UPKXfkj3.js b/assets/VirtualMachine.html-dR4GRz3A.js similarity index 69% rename from assets/VirtualMachine.html-UPKXfkj3.js rename to assets/VirtualMachine.html-dR4GRz3A.js index 1c02fe2..a835927 100644 --- a/assets/VirtualMachine.html-UPKXfkj3.js +++ b/assets/VirtualMachine.html-dR4GRz3A.js @@ -1,14 +1,14 @@ -import{_ as n}from"./plugin-vue_export-helper-DlAUqK2U.js";import{o as a,c as s,e}from"./app-KtH3BPxJ.js";const t="/images/GreenHand/EnableUefi.webp",i="/images/GreenHand/VmResAllocation.webp",p="/images/GreenHand/VmNet.webp",o="/images/GreenHand/FirstEncounterWithTty.webp",l="/images/GreenHand/Efivars.webp",c="/images/GreenHand/CheckNet.webp",r="/images/GreenHand/RebuildSystem.webp",d="/images/GreenHand/Lsblk.webp",u="/images/GreenHand/HardwareConfig.webp",m="/images/GreenHand/HelloKde.webp",v={},b=e('

虚拟机安装

无论你使用什么虚拟机安装，过程都是大同小异的。需要注意的是 HyperV 的安全启动是默认开启的，需要你手动关掉。

以下教程是基于 UEFI 的安装，所以还需要你启用 VMware 的 UEFI 选项（如果你真的使用 VMware 的话）。

启用 UEFI
启用 UEFI

创建虚拟机

虚拟机的资源大小取决于你的应用，这个教程仅为新手提供一种基本系统的安装方法，更加高阶的个性化教程会在额外的章节提及。

本文使用创建的虚拟机的内存为 8GB，硬盘为 32GB 大小。如果你的计算机资源不够，理论上是可以尝试开辟更小的资源。

资源分配
资源分配

检查虚拟网络

部分 VMWARE 用户会遇到网络无法连接到宿主机网络的问题，可能是虚拟网络未配置导致的，推荐下面的 NAT 配置：

虚拟网络
虚拟网络

如果你看到图上的按钮和文本框大多为灰色并无法修改，记得点击右下角的 UAC 蓝色盾牌以修改设置。HyperV 的虚拟交换机保持默认设置就好，一般而言没有那么容易出问题。

检查 UEFI 变量

然后假设你如愿开机进入 Live CD 了：

与 TTY 相遇
与 TTY 相遇

为了防止分区的时候遇到麻烦，还是先验证一下 UEFI 是否真正启用：

ls /sys/firmware/efi/efivars  # 列出 EFI 变量
+import{_ as n}from"./plugin-vue_export-helper-DlAUqK2U.js";import{o as a,c as s,e}from"./app-BNkVxcYY.js";const t="/images/GreenHand/EnableUefi.webp",i="/images/GreenHand/VmResAllocation.webp",p="/images/GreenHand/VmNet.webp",o="/images/GreenHand/FirstEncounterWithTty.webp",l="/images/GreenHand/Efivars.webp",c="/images/GreenHand/CheckNet.webp",r="/images/GreenHand/RebuildSystem.webp",d="/images/GreenHand/Lsblk.webp",u="/images/GreenHand/HardwareConfig.webp",m="/images/GreenHand/HelloKde.webp",v={},b=e('
虚拟机安装
无论你使用什么虚拟机安装，过程都是大同小异的。需要注意的是 HyperV 的安全启动是默认开启的，需要你手动关掉。
以下教程是基于 UEFI 的安装，所以还需要你启用 VMware 的 UEFI 选项（如果你真的使用 VMware 的话）。
启用 UEFI
启用 UEFI
创建虚拟机
虚拟机的资源大小取决于你的应用，这个教程仅为新手提供一种基本系统的安装方法，更加高阶的个性化教程会在额外的章节提及。
本文使用创建的虚拟机的内存为 8GB，硬盘为 32GB 大小。如果你的计算机资源不够，理论上是可以尝试开辟更小的资源。
资源分配
资源分配
检查虚拟网络
部分 VMWARE 用户会遇到网络无法连接到宿主机网络的问题，可能是虚拟网络未配置导致的，推荐下面的 NAT 配置：
虚拟网络
虚拟网络
如果你看到图上的按钮和文本框大多为灰色并无法修改，记得点击右下角的 UAC 蓝色盾牌以修改设置。HyperV 的虚拟交换机保持默认设置就好，一般而言没有那么容易出问题。
检查 UEFI 变量
然后假设你如愿开机进入 Live CD 了：
与 TTY 相遇
与 TTY 相遇
为了防止分区的时候遇到麻烦，还是先验证一下 UEFI 是否真正启用：
ls /sys/firmware/efi/efivars  # 列出 EFI 变量
 
EFI 变量
EFI 变量
检查网络
随便 Ping 几个主机：
ping www.baidu.com -c 4
 ping 119.29.29.29 -c 4
-
如果域名不可及而 IP 可以访问，则优先检查 DNS 服务器配置。
Ping
Ping
更换镜像频道
频道类似一种获取软件源码包的软件源。
由于未知原因大陆访问远洋主机有点困难，还是用镜像服务器吧：
注意系统版本
截至笔者截稿，NixOS 当前最新版本为 23.05，遂命令也是针对这个版本而生效的，更新的版本请注意替换命令中的系统版本号。
sudo -i
+
如果域名不可及而 IP 可以访问，则优先检查 DNS 服务器配置。
Ping
Ping
更换镜像频道
频道类似一种获取软件源码包的软件源。
由于未知原因大陆访问远洋主机有点困难，还是用镜像服务器吧：
注意系统版本截至笔者截稿，NixOS 当前最新版本为 23.05，遂命令也是针对
这个版本而生效的，更新的版本请注意替换命令中的系统版本号。:::
sudo -i
 nix-channel --add https://mirrors.ustc.edu.cn/nix-channels/nixpkgs-unstable nixpkgs  # 订阅镜像仓库频道
 nix-channel --add https://mirrors.ustc.edu.cn/nix-channels/nixos-23.05 nixos  # 请注意系统版本
 nix-channel --list  # 列出频道，这一步是确认修改没有出错
 nix-channel --update  # 更新并解包频道
 nixos-rebuild --option substituters https://mirrors.ustc.edu.cn/nix-channels/store switch --upgrade  # 临时切换二进制缓存源，并更新生成
 
不出意外就能顺利构建：
使配置生效
使配置生效
分区与格式化
查看一下我们要分区的设备：
lsblk
-
块设备
块设备
可以看出 /dev/sda 就是我们要分区的设备。
接下来进入 parted 的交互模式开始分区，请注意这些修改是实时生效的，所以不需要你操心保存的事。
单位问题
两种单位的计算方法不一致，MB 以 10 为底计算，而 MiB 以 2 为底计算，这也许能解答你对 parted 显示的硬盘时大时小的疑惑。GiB 与 GB 同理。
parted /dev/sda  # 分区该设备
+
块设备
块设备
可以看出 /dev/sda 就是我们要分区的设备。
接下来进入 parted 的交互模式开始分区，请注意这些修改是实时生效的，所以不需要你操心保存的事。
单位问题两种单位的计算方法不一致，MB 以 10 为底计算，而 MiB 以 2 为底计
算，这也许能解答你对 parted 显示的硬盘时大时小的疑惑。GiB 与 GB 同理。:::
parted /dev/sda  # 分区该设备
 mklabel gpt  # 创建 GPT 表
 mkpart ESP fat32 1MiB 256MiB  # 在 1 MiB - 256 MiB 的位置创建引导分区
 p  # 打印当前分区表
@@ -17,7 +17,7 @@ mkpart primary 256MiB -8GiB  -8GiB 100%  # 余下的 8GiB 用于创建交换分区
 p  # 确认当前分区情况
 quit  # 退出
-
保留 1 MiB
1 MiB 可以保证分区标识，也就是说，分区的起始扇区包含了分区的类型、大小、位置等信息，这些信息是操作系统识别和加载分区的重要依据，如果这些信息被破坏或覆盖，就会导致分区无法启动或者数据丢失。
以上命令创建的分区有：
  • 一个引导分区，存放内核和引导
  • 一个主分区，放置软件，用户数据
  • 一个交换分区（虚拟内存）
但是光创建分区还不够，还需要格式化他们：
mkfs.fat -F 32 /dev/sda1  # 格式化引导分区为 FAT32 格式
+
保留 1 MiB 1 MiB 可以保证分区标识，也就是说，分区的起始扇区包含了分区的
类型、大小、位置等信息，这些信息是操作系统识别和加载分区的重要依据，如果这些信息被破坏或覆盖，就会导致分区无法启动或者数据丢失。::: 以上命令创建的分区有：
  • 一个引导分区，存放内核和引导
  • 一个主分区，放置软件，用户数据
  • 一个交换分区（虚拟内存）
但是光创建分区还不够，还需要格式化他们：
mkfs.fat -F 32 /dev/sda1  # 格式化引导分区为 FAT32 格式
 mkfs.btrfs -L nixos /dev/sda2  # 格式化根分区为 Btrfs 格式
 mkswap -L swap /dev/sda3  # 设置交换分区
 mount /dev/sda2 /mnt  # 将根分区挂载到 /mnt 下
@@ -31,7 +31,7 @@ btrfs subvolume create /mnt/nix  # 创建 nix 子卷
 mount -o compress=zstd,noatime,subvol=nix /dev/sda2 /mnt/nix  # 启用透明压缩并不记录时间戳参数挂载 nix 子卷
 mount /dev/sda1 /mnt/boot  # 挂载 boot
 swapon /dev/sda3  # 启用交换分区
-
引导分区
大多数厂商的主板只认 FAT32 格式的引导分区。
Btrfs
Btrfs 是一种比较新颖的文件系统（不提还在冲击内核的 Bcachefs 的话），支持 Cow，校验，快照等特性。划分子卷是为了更好的区分管理。
我们还需要将当前状态生成配置到目标系统中：
nixos-generate-config --root /mnt
+
引导分区大多数厂商的主板只认 FAT32 格式的引导分区。:::
Btrfs Btrfs 是一种比较新颖的文件系统（不提还在冲击内核的 Bcachefs 的
话），支持 Cow，校验，快照等特性。划分子卷是为了更好的区分管理。:::
我们还需要将当前状态生成配置到目标系统中：
nixos-generate-config --root /mnt
 
我们还需要在默认配置上修改一些内容，才能完成一个粗放的安装：
vim /mnt/etc/nixos/configuration.nix
 
{ config, pkgs, ...}:
 {
@@ -53,15 +53,15 @@ btrfs subvolume create /mnt/nix  # 创建 nix 子卷
   ];
   sound.enable = true;
   hardware.pulseaudio.enable = true;
-  nix.settings.substituters = [ 
+  nix.settings.substituters = [
     "https://mirrors.cernet.edu.cn/nix-channels/store"
   ];
   system.stateVersion = "23.05";
 }
 
你肯定在安装 NixOS 之前就了解过它是一个根据配置文件生成系统的发行版，在上面的配置中我们描述了一个带 KDE 桌面的基本系统。
由于生成配置命令没有写入 Btrfs 子卷的挂载参数，我们需要自己修改另一个配置文件：
vim /mnt/etc/nixos/hardware-configuration.nix
 
挂载参数
挂载参数
加一些小参数，比如 "compress=zstd" 和 "noatime"，需要注意的是 Nix 的列表语法是用空格分隔元素的。
然后开始部署系统：
nixos-install --option substituters https://mirrors.ustc.edu.cn/nix-channels/store
-
缓存缺失
如果缓存主机缺失某些二进制缓存，带来了冗长的编译环节，可以尝试更换一个 substituter，比如 https://mirror.sjtu.edu.cn/nix-channels/store。
添加用户，tritium 是我的用户名，记得改成你自己的：
nixos-enter  # 进入部署好的系统，类似 arch 的 chroot
+
缓存缺失如果缓存主机缺失某些二进制缓存，带来了冗长的编译环节，可以尝试
更换一个 substituter，比如https://mirror.sjtu.edu.cn/nix-channels/store。:::
添加用户，tritium 是我的用户名，记得改成你自己的：
nixos-enter  # 进入部署好的系统，类似 arch 的 chroot
 passwd root  # 重置 root 密码
 useradd -m -G wheel tritium  # 添加普通用户，并加入 wheel 组
 passwd tritium  # 设置普通账户密码
-
重置 root 密码
nixos-install 有时候有毒，最后一步的设置密码不生效，所以才会有上面重置 root 密码这步。
然后重启（最好断掉虚拟机的光驱），就能看到安装好的系统了：
好久不见，KDE
好久不见，KDE
',63),k=[b];function g(h,f){return a(),s("div",null,k)}const y=n(v,[["render",g],["__file","VirtualMachine.html.vue"]]),_=JSON.parse('{"path":"/tutorials/installation/VirtualMachine.html","title":"虚拟机安装","lang":"zh-CN","frontmatter":{"description":"虚拟机安装 无论你使用什么虚拟机安装，过程都是大同小异的。需要注意的是 HyperV 的安全启动是默认开启的，需要你手动关掉。 以下教程是基于 UEFI 的安装，所以还需要你启用 VMware 的 UEFI 选项（如果你真的使用 VMware 的话）。 启用 UEFI启用 UEFI 创建虚拟机 虚拟机的资源大小取决于你的应用，这个教程仅为新手提供一种基...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/installation/VirtualMachine.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"虚拟机安装"}],["meta",{"property":"og:description","content":"虚拟机安装 无论你使用什么虚拟机安装，过程都是大同小异的。需要注意的是 HyperV 的安全启动是默认开启的，需要你手动关掉。 以下教程是基于 UEFI 的安装，所以还需要你启用 VMware 的 UEFI 选项（如果你真的使用 VMware 的话）。 启用 UEFI启用 UEFI 创建虚拟机 虚拟机的资源大小取决于你的应用，这个教程仅为新手提供一种基..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:image","content":"https://nixos-cn.github.io/images/GreenHand/EnableUefi.webp"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2023-10-10T18:11:07.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2023-10-10T18:11:07.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"虚拟机安装\\",\\"image\\":[\\"https://nixos-cn.github.io/images/GreenHand/EnableUefi.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/VmResAllocation.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/VmNet.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/FirstEncounterWithTty.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/Efivars.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/CheckNet.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/RebuildSystem.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/Lsblk.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/HardwareConfig.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/HelloKde.webp\\"],\\"dateModified\\":\\"2023-10-10T18:11:07.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"创建虚拟机","slug":"创建虚拟机","link":"#创建虚拟机","children":[]},{"level":2,"title":"检查虚拟网络","slug":"检查虚拟网络","link":"#检查虚拟网络","children":[]},{"level":2,"title":"检查 UEFI 变量","slug":"检查-uefi-变量","link":"#检查-uefi-变量","children":[]},{"level":2,"title":"检查网络","slug":"检查网络","link":"#检查网络","children":[]},{"level":2,"title":"更换镜像频道","slug":"更换镜像频道","link":"#更换镜像频道","children":[]},{"level":2,"title":"分区与格式化","slug":"分区与格式化","link":"#分区与格式化","children":[]}],"git":{"createdTime":1696961467000,"updatedTime":1696961467000,"contributors":[{"name":"OpenTritium","email":"tritium404@hotmail.com","commits":1}]},"readingTime":{"minutes":5.76,"words":1729},"filePathRelative":"tutorials/installation/VirtualMachine.md","localizedDate":"2023年10月10日","autoDesc":true,"excerpt":"\\n
无论你使用什么虚拟机安装，过程都是大同小异的。需要注意的是 HyperV 的安全启动是默认开启的，需要你手动关掉。
\\n
以下教程是基于 UEFI 的安装，所以还需要你启用 VMware 的 UEFI 选项（如果你真的使用 VMware 的话）。
\\n
\\"启用
启用 UEFI
\\n
创建虚拟机
\\n
虚拟机的资源大小取决于你的应用，这个教程仅为新手提供一种基本系统的安装方法，更加高阶的个性化教程会在额外的章节提及。
"}');export{y as comp,_ as data};
+

重置 root 密码 \`nixos-install\` 有时候有毒，最后一步的设置密码不生效，所

以才会有上面重置 root 密码这步。::: 然后重启（最好断掉虚拟机的光驱），就能看到安装好的系统了：

好久不见，KDE
好久不见，KDE
',27),k=[b];function g(h,f){return a(),s("div",null,k)}const y=n(v,[["render",g],["__file","VirtualMachine.html.vue"]]),_=JSON.parse('{"path":"/tutorials/installation/VirtualMachine.html","title":"虚拟机安装","lang":"zh-CN","frontmatter":{"description":"虚拟机安装 无论你使用什么虚拟机安装，过程都是大同小异的。需要注意的是 HyperV 的安全启动是默认开启的，需要你手动关掉。 以下教程是基于 UEFI 的安装，所以还需要你启用 VMware 的 UEFI 选项（如果你真的使用 VMware 的话）。 启用 UEFI启用 UEFI 创建虚拟机 虚拟机的资源大小取决于你的应用，这个教程仅为新手提供一种基...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/installation/VirtualMachine.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"虚拟机安装"}],["meta",{"property":"og:description","content":"虚拟机安装 无论你使用什么虚拟机安装，过程都是大同小异的。需要注意的是 HyperV 的安全启动是默认开启的，需要你手动关掉。 以下教程是基于 UEFI 的安装，所以还需要你启用 VMware 的 UEFI 选项（如果你真的使用 VMware 的话）。 启用 UEFI启用 UEFI 创建虚拟机 虚拟机的资源大小取决于你的应用，这个教程仅为新手提供一种基..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:image","content":"https://nixos-cn.github.io/images/GreenHand/EnableUefi.webp"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2024-06-30T15:34:48.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2024-06-30T15:34:48.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"虚拟机安装\\",\\"image\\":[\\"https://nixos-cn.github.io/images/GreenHand/EnableUefi.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/VmResAllocation.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/VmNet.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/FirstEncounterWithTty.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/Efivars.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/CheckNet.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/RebuildSystem.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/Lsblk.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/HardwareConfig.webp\\",\\"https://nixos-cn.github.io/images/GreenHand/HelloKde.webp\\"],\\"dateModified\\":\\"2024-06-30T15:34:48.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"创建虚拟机","slug":"创建虚拟机","link":"#创建虚拟机","children":[]},{"level":2,"title":"检查虚拟网络","slug":"检查虚拟网络","link":"#检查虚拟网络","children":[]},{"level":2,"title":"检查 UEFI 变量","slug":"检查-uefi-变量","link":"#检查-uefi-变量","children":[]},{"level":2,"title":"检查网络","slug":"检查网络","link":"#检查网络","children":[]},{"level":2,"title":"更换镜像频道","slug":"更换镜像频道","link":"#更换镜像频道","children":[]}],"git":{"createdTime":1696961467000,"updatedTime":1719761688000,"contributors":[{"name":"OpenTritium","email":"tritium404@hotmail.com","commits":1},{"name":"Ryan Yin","email":"xiaoyin_c@qq.com","commits":1}]},"readingTime":{"minutes":5.76,"words":1729},"filePathRelative":"tutorials/installation/VirtualMachine.md","localizedDate":"2023年10月10日","autoDesc":true,"excerpt":"\\n

无论你使用什么虚拟机安装，过程都是大同小异的。需要注意的是 HyperV 的安全启动是默认开启的，需要你手动关掉。

\\n

以下教程是基于 UEFI 的安装，所以还需要你启用 VMware 的 UEFI 选项（如果你真的使用\\nVMware 的话）。

\\n
\\"启用
启用 UEFI
\\n

创建虚拟机

\\n

虚拟机的资源大小取决于你的应用，这个教程仅为新手提供一种基本系统的安装方法，更加高阶的个性化教程会在额外的章节提及。

"}');export{y as comp,_ as data}; diff --git a/assets/WSL2.html-B1QMWOGS.js b/assets/WSL2.html-B1QMWOGS.js new file mode 100644 index 0000000..a42a920 --- /dev/null +++ b/assets/WSL2.html-B1QMWOGS.js @@ -0,0 +1,7 @@ +import{_ as o}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as l,o as r,c as i,a as e,b as s,d as n,e as t}from"./app-BNkVxcYY.js";const p={},c=t(`

WSL2 安装

启用 WSL 2 环境

快捷启用

对于新系统（Windows 11，Windows 10 的 2004 版本或更新的系统），使用==管理员权限 ==下的 CMD 或 Powershell 执行下面的命令即可：

wsl --install --no-distribution
+

这条命令会帮助你安装 WSL2 环境的依赖，相比逐个去启用组件是更简单快捷。

手动启用

与上面不同的是，这种方法可能适合稍旧一些的系统。

我们需要启用两个可选功能，它们分别是 “适用于 Linux 的 Windows 子系统” 和 “虚拟机平台”：

dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
+dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
+

然后重新启动计算机。

`,11),d={href:"https://wslstorestorage.blob.core.windows.net/wslblob/wsl_update_x64.msi",target:"_blank",rel:"noopener noreferrer"},h=t(`

记得设置默认版本为 2：

wsl --set-default-version 2
+
`,2),u={class:"hint-container warning"},m=e("p",{class:"hint-container-title"},"尽力支持 NixOS-WSL 对 inbox 版本的 WSL（即通过 Window 可选功能启用的",-1),w=e("p",null,"WSL）是尽力支持的，如果有条件，请更新到最新 Windows 使用 Windows 商店分发（使用第一种方法安装方式）的最新 WSL 支持。:::",-1),g=e("h2",{id:"下载根文件系统",tabindex:"-1"},[e("a",{class:"header-anchor",href:"#下载根文件系统"},[e("span",null,"下载根文件系统")])],-1),_={href:"https://github.com/nix-community/NixOS-WSL/releases",target:"_blank",rel:"noopener noreferrer"},x=e("code",null,"nixos-wsl.tar.gz",-1),v=t(`

然后决定好你要将这个文件系统导入至哪里，这里以 E:\\wslDistroStorage\\NixOS 举例，并且确认当前的工作文件夹就是你刚刚下载的根文件系统档案所在的文件夹。

wsl --import NixOS E:\\wslDistroStorage\\NixOS nixos-wsl.tar.gz --version 2
+

然后引导到 NixOS：

wsl -d NixOS
+
`,4),S={class:"hint-container tip"},b=e("p",{class:"hint-container-title"},"默认发行版可以通过 `wsl -s NixOS` 将 NixOS 设置为默认启动的发行版。:::",-1),W={href:"https://learn.microsoft.com/zh-cn/windows/wsl/troubleshooting",target:"_blank",rel:"noopener noreferrer"};function k(f,L){const a=l("ExternalLinkIcon");return r(),i("div",null,[c,e("p",null,[s("我们还需要一个完整的 Linux 内核："),e("a",d,[s("WSL 2 Linux 内核更新包"),n(a)]),s("，安装它。")]),h,e("div",u,[m,w,g,e("p",null,[s("在 "),e("a",_,[s("NixOS-WSL 项目的最新 Release 页"),n(a)]),s("中下载 "),x,s("。")]),v,e("div",S,[b,e("p",null,[s("第一次启用会稍久，但是你不够幸运的话，可能终端上会出现令人厌烦的错误码，你可以在"),e("a",W,[s("疑难解答"),n(a)]),s(" 页面找到找到你可能期待的答案。")])])])])}const O=o(p,[["render",k],["__file","WSL2.html.vue"]]),C=JSON.parse('{"path":"/tutorials/installation/WSL2.html","title":"WSL2 安装","lang":"zh-CN","frontmatter":{"description":"WSL2 安装 启用 WSL 2 环境 快捷启用 对于新系统（Windows 11，Windows 10 的 2004 版本或更新的系统），使用==管理员权限 ==下的 CMD 或 Powershell 执行下面的命令即可： 这条命令会帮助你安装 WSL2 环境的依赖，相比逐个去启用组件是更简单快捷。 手动启用 与上面不同的是，这种方法可能适合稍旧一些...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/installation/WSL2.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"WSL2 安装"}],["meta",{"property":"og:description","content":"WSL2 安装 启用 WSL 2 环境 快捷启用 对于新系统（Windows 11，Windows 10 的 2004 版本或更新的系统），使用==管理员权限 ==下的 CMD 或 Powershell 执行下面的命令即可： 这条命令会帮助你安装 WSL2 环境的依赖，相比逐个去启用组件是更简单快捷。 手动启用 与上面不同的是，这种方法可能适合稍旧一些..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2024-06-30T15:34:48.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2024-06-30T15:34:48.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"WSL2 安装\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2024-06-30T15:34:48.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"启用 WSL 2 环境","slug":"启用-wsl-2-环境","link":"#启用-wsl-2-环境","children":[]},{"level":2,"title":"快捷启用","slug":"快捷启用","link":"#快捷启用","children":[]},{"level":2,"title":"手动启用","slug":"手动启用","link":"#手动启用","children":[]}],"git":{"createdTime":1696961467000,"updatedTime":1719761688000,"contributors":[{"name":"OpenTritium","email":"tritium404@hotmail.com","commits":1},{"name":"Ryan Yin","email":"xiaoyin_c@qq.com","commits":1}]},"readingTime":{"minutes":1.59,"words":476},"filePathRelative":"tutorials/installation/WSL2.md","localizedDate":"2023年10月10日","autoDesc":true,"excerpt":"\\n

启用 WSL 2 环境

\\n

快捷启用

\\n

对于新系统（Windows 11，Windows 10 的 2004 版本或更新的系统），使用==管理员权限\\n==下的 CMD 或 Powershell 执行下面的命令即可：

\\n
wsl --install --no-distribution\\n
"}');export{O as comp,C as data}; diff --git a/assets/WSL2.html-DbTShrQz.js b/assets/WSL2.html-DbTShrQz.js deleted file mode 100644 index 0a023f7..0000000 --- a/assets/WSL2.html-DbTShrQz.js +++ /dev/null @@ -1,7 +0,0 @@ -import{_ as o}from"./plugin-vue_export-helper-DlAUqK2U.js";import{r as l,o as r,c as i,a,b as e,d as n,e as t}from"./app-KtH3BPxJ.js";const p={},c=t(`

WSL2 安装

启用 WSL 2 环境

快捷启用

对于新系统（Windows 11，Windows 10 的 2004 版本或更新的系统），使用管理员权限下的 CMD 或 Powershell 执行下面的命令即可：

wsl --install --no-distribution
-

这条命令会帮助你安装 WSL2 环境的依赖，相比逐个去启用组件是更简单快捷。

手动启用

与上面不同的是，这种方法可能适合稍旧一些的系统。

我们需要启用两个可选功能，它们分别是 “适用于 Linux 的 Windows 子系统” 和 “虚拟机平台”：

dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
-dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
-

然后重新启动计算机。

`,11),d={href:"https://wslstorestorage.blob.core.windows.net/wslblob/wsl_update_x64.msi",target:"_blank",rel:"noopener noreferrer"},h=t(`

记得设置默认版本为 2：

wsl --set-default-version 2
-

尽力支持

NixOS-WSL 对 inbox 版本的 WSL（即通过 Window 可选功能启用的 WSL）是尽力支持的，如果有条件，请更新到最新 Windows 使用 Windows 商店分发（使用第一种方法安装方式）的最新 WSL 支持。

下载根文件系统

`,4),u={href:"https://github.com/nix-community/NixOS-WSL/releases",target:"_blank",rel:"noopener noreferrer"},m=a("code",null,"nixos-wsl.tar.gz",-1),w=t(`

然后决定好你要将这个文件系统导入至哪里，这里以 E:\\wslDistroStorage\\NixOS 举例，并且确认当前的工作文件夹就是你刚刚下载的根文件系统档案所在的文件夹。

wsl --import NixOS E:\\wslDistroStorage\\NixOS nixos-wsl.tar.gz --version 2
-

然后引导到 NixOS：

wsl -d NixOS
-

默认发行版

可以通过 wsl -s NixOS 将 NixOS 设置为默认启动的发行版。

`,5),g={href:"https://learn.microsoft.com/zh-cn/windows/wsl/troubleshooting",target:"_blank",rel:"noopener noreferrer"};function v(x,S){const s=l("ExternalLinkIcon");return r(),i("div",null,[c,a("p",null,[e("我们还需要一个完整的 Linux 内核："),a("a",d,[e("WSL 2 Linux 内核更新包"),n(s)]),e("，安装它。")]),h,a("p",null,[e("在 "),a("a",u,[e("NixOS-WSL 项目的最新 Release 页"),n(s)]),e(" 中下载 "),m,e("。")]),w,a("p",null,[e("第一次启用会稍久，但是你不够幸运的话，可能终端上会出现令人厌烦的错误码，你可以在 "),a("a",g,[e("疑难解答"),n(s)]),e(" 页面找到找到你可能期待的答案。")])])}const W=o(p,[["render",v],["__file","WSL2.html.vue"]]),_=JSON.parse('{"path":"/tutorials/installation/WSL2.html","title":"WSL2 安装","lang":"zh-CN","frontmatter":{"description":"WSL2 安装 启用 WSL 2 环境 快捷启用 对于新系统（Windows 11，Windows 10 的 2004 版本或更新的系统），使用管理员权限下的 CMD 或 Powershell 执行下面的命令即可： 这条命令会帮助你安装 WSL2 环境的依赖，相比逐个去启用组件是更简单快捷。 手动启用 与上面不同的是，这种方法可能适合稍旧一些的系统。 ...","head":[["meta",{"property":"og:url","content":"https://nixos-cn.github.io/tutorials/installation/WSL2.html"}],["meta",{"property":"og:site_name","content":"NixOS 中文"}],["meta",{"property":"og:title","content":"WSL2 安装"}],["meta",{"property":"og:description","content":"WSL2 安装 启用 WSL 2 环境 快捷启用 对于新系统（Windows 11，Windows 10 的 2004 版本或更新的系统），使用管理员权限下的 CMD 或 Powershell 执行下面的命令即可： 这条命令会帮助你安装 WSL2 环境的依赖，相比逐个去启用组件是更简单快捷。 手动启用 与上面不同的是，这种方法可能适合稍旧一些的系统。 ..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"zh-CN"}],["meta",{"property":"og:updated_time","content":"2023-10-10T18:11:07.000Z"}],["meta",{"property":"article:author","content":"NixOS-CN"}],["meta",{"property":"article:modified_time","content":"2023-10-10T18:11:07.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"WSL2 安装\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2023-10-10T18:11:07.000Z\\",\\"author\\":[{\\"@type\\":\\"Person\\",\\"name\\":\\"NixOS-CN\\",\\"url\\":\\"https://github.com/nixos-cn\\"}]}"]]},"headers":[{"level":2,"title":"启用 WSL 2 环境","slug":"启用-wsl-2-环境","link":"#启用-wsl-2-环境","children":[]},{"level":2,"title":"快捷启用","slug":"快捷启用","link":"#快捷启用","children":[]},{"level":2,"title":"手动启用","slug":"手动启用","link":"#手动启用","children":[]},{"level":2,"title":"下载根文件系统","slug":"下载根文件系统","link":"#下载根文件系统","children":[]}],"git":{"createdTime":1696961467000,"updatedTime":1696961467000,"contributors":[{"name":"OpenTritium","email":"tritium404@hotmail.com","commits":1}]},"readingTime":{"minutes":1.59,"words":476},"filePathRelative":"tutorials/installation/WSL2.md","localizedDate":"2023年10月10日","autoDesc":true,"excerpt":"\\n

启用 WSL 2 环境

\\n

快捷启用

\\n

对于新系统（Windows 11，Windows 10 的 2004 版本或更新的系统），使用管理员权限下的 CMD 或 Powershell 执行下面的命令即可：

\\n
wsl --install --no-distribution\\n
"}');export{W as comp,_ as data}; diff --git a/assets/app-KtH3BPxJ.js b/assets/app-BNkVxcYY.js similarity index 98% rename from assets/app-KtH3BPxJ.js rename to assets/app-BNkVxcYY.js index b8efe14..a37a4c6 100644 --- a/assets/app-KtH3BPxJ.js +++ b/assets/app-BNkVxcYY.js @@ -1,6 +1,6 @@ function __vite__mapDeps(indexes) { if (!__vite__mapDeps.viteFileDeps) { - __vite__mapDeps.viteFileDeps = ["assets/index.html-CO3Zoej-.js","assets/plugin-vue_export-helper-DlAUqK2U.js","assets/Configuration.html-C5G2PvFv.js","assets/Intro.html-CsM-htdy.js","assets/BinaryAndSourceDistribution.html-16kgxc39.js","assets/ConfigurationIsTheBlueprintOfTheSystem.html-Dttpxv9Y.js","assets/HowFunctionalProgrammingShapesNixOS.html-DZ_IJvjM.js","assets/HowToMakePath-dependentProgramsWork.html-NhUUpgrU.js","assets/PurityIsOurUltimatePursuit.html-BDKKUkcr.js","assets/Networking.html-xvk50dn3.js","assets/Subsystem.html-B9GmW8h7.js","assets/VirtualMachine.html-UPKXfkj3.js","assets/WSL2.html-DbTShrQz.js","assets/Manuals.html-BZkwlMGp.js","assets/QuickOverview.html-BnfFQSVs.js","assets/intro.html-_G6iOctj.js","assets/haskell.html-DaODvwP8.js","assets/404.html-aJVSI8g5.js","assets/index.html-DhOr4nTI.js","assets/index.html-GGNRB_Os.js","assets/index.html-vIVcD392.js","assets/index.html-DFZDy7w2.js","assets/index.html-BdmV7lSx.js","assets/index.html-DxGqHslQ.js","assets/index.html-BRNxgYFz.js","assets/index.html-w6XYUv6Q.js"] + __vite__mapDeps.viteFileDeps = ["assets/index.html-Bld3147c.js","assets/plugin-vue_export-helper-DlAUqK2U.js","assets/Configuration.html-CE9jQ0tW.js","assets/Intro.html-CEuRkNVT.js","assets/BinaryAndSourceDistribution.html-C-rtSMVZ.js","assets/ConfigurationIsTheBlueprintOfTheSystem.html-djsOJ9Vw.js","assets/HowFunctionalProgrammingShapesNixOS.html-rr2UlYus.js","assets/HowToMakePath-dependentProgramsWork.html-D2834t8G.js","assets/PurityIsOurUltimatePursuit.html-BJhNv_7j.js","assets/Networking.html-D__jtwiK.js","assets/Subsystem.html-DSYLh798.js","assets/VirtualMachine.html-dR4GRz3A.js","assets/WSL2.html-B1QMWOGS.js","assets/Manuals.html-DFp7igCI.js","assets/QuickOverview.html-BSo4J38r.js","assets/intro.html-B3Nq0b0F.js","assets/haskell.html-IMJVSTSk.js","assets/404.html-7q9hhSdq.js","assets/index.html-BNRX3zGk.js","assets/index.html-CXqct-2E.js","assets/index.html-lh8H6DTQ.js","assets/index.html-C7513JJK.js","assets/index.html-ByMTKhkr.js","assets/index.html-csQfK4x4.js","assets/index.html-dT3bJ4l8.js","assets/index.html-CykiMO0-.js"] } return indexes.map((i) => __vite__mapDeps.viteFileDeps[i]) } @@ -20,7 +20,7 @@ function __vite__mapDeps(indexes) { * @vue/runtime-dom v3.4.21 * (c) 2018-present Yuxi (Evan) You and Vue contributors * @license MIT -**/const yd="http://www.w3.org/2000/svg",wd="http://www.w3.org/1998/Math/MathML",Dt=typeof document<"u"?document:null,Ts=Dt&&Dt.createElement("template"),_d={insert:(e,t,n)=>{t.insertBefore(e,n||null)},remove:e=>{const t=e.parentNode;t&&t.removeChild(e)},createElement:(e,t,n,r)=>{const o=t==="svg"?Dt.createElementNS(yd,e):t==="mathml"?Dt.createElementNS(wd,e):Dt.createElement(e,n?{is:n}:void 0);return e==="select"&&r&&r.multiple!=null&&o.setAttribute("multiple",r.multiple),o},createText:e=>Dt.createTextNode(e),createComment:e=>Dt.createComment(e),setText:(e,t)=>{e.nodeValue=t},setElementText:(e,t)=>{e.textContent=t},parentNode:e=>e.parentNode,nextSibling:e=>e.nextSibling,querySelector:e=>Dt.querySelector(e),setScopeId(e,t){e.setAttribute(t,"")},insertStaticContent(e,t,n,r,o,l){const s=n?n.previousSibling:t.lastChild;if(o&&(o===l||o.nextSibling))for(;t.insertBefore(o.cloneNode(!0),n),!(o===l||!(o=o.nextSibling)););else{Ts.innerHTML=r==="svg"?`${e}`:r==="mathml"?`${e}`:e;const a=Ts.content;if(r==="svg"||r==="mathml"){const i=a.firstChild;for(;i.firstChild;)a.appendChild(i.firstChild);a.removeChild(i)}t.insertBefore(a,n)}return[s?s.nextSibling:t.firstChild,n?n.previousSibling:t.lastChild]}},Rt="transition",jn="animation",In=Symbol("_vtc"),Wt=(e,{slots:t})=>f(Lf,xi(e),t);Wt.displayName="Transition";const Ei={name:String,type:String,css:{type:Boolean,default:!0},duration:[String,Number,Object],enterFromClass:String,enterActiveClass:String,enterToClass:String,appearFromClass:String,appearActiveClass:String,appearToClass:String,leaveFromClass:String,leaveActiveClass:String,leaveToClass:String},Cd=Wt.props=Ae({},ni,Ei),Jt=(e,t=[])=>{te(e)?e.forEach(n=>n(...t)):e&&e(...t)},Ls=e=>e?te(e)?e.some(t=>t.length>1):e.length>1:!1;function xi(e){const t={};for(const R in e)R in Ei||(t[R]=e[R]);if(e.css===!1)return t;const{name:n="v",type:r,duration:o,enterFromClass:l=`${n}-enter-from`,enterActiveClass:s=`${n}-enter-active`,enterToClass:a=`${n}-enter-to`,appearFromClass:i=l,appearActiveClass:c=s,appearToClass:u=a,leaveFromClass:d=`${n}-leave-from`,leaveActiveClass:p=`${n}-leave-active`,leaveToClass:h=`${n}-leave-to`}=e,g=Ed(o),_=g&&g[0],w=g&&g[1],{onBeforeEnter:y,onEnter:x,onEnterCancelled:b,onLeave:S,onLeaveCancelled:$,onBeforeAppear:E=y,onAppear:G=x,onAppearCancelled:N=b}=t,q=(R,J,Ce)=>{Mt(R,J?u:a),Mt(R,J?c:s),Ce&&Ce()},P=(R,J)=>{R._isLeaving=!1,Mt(R,d),Mt(R,h),Mt(R,p),J&&J()},z=R=>(J,Ce)=>{const be=R?G:x,W=()=>q(J,R,Ce);Jt(be,[J,W]),As(()=>{Mt(J,R?i:l),xt(J,R?u:a),Ls(be)||Is(J,r,_,W)})};return Ae(t,{onBeforeEnter(R){Jt(y,[R]),xt(R,l),xt(R,s)},onBeforeAppear(R){Jt(E,[R]),xt(R,i),xt(R,c)},onEnter:z(!1),onAppear:z(!0),onLeave(R,J){R._isLeaving=!0;const Ce=()=>P(R,J);xt(R,d),Si(),xt(R,p),As(()=>{R._isLeaving&&(Mt(R,d),xt(R,h),Ls(S)||Is(R,r,w,Ce))}),Jt(S,[R,Ce])},onEnterCancelled(R){q(R,!1),Jt(b,[R])},onAppearCancelled(R){q(R,!0),Jt(N,[R])},onLeaveCancelled(R){P(R),Jt($,[R])}})}function Ed(e){if(e==null)return null;if(Ee(e))return[ko(e.enter),ko(e.leave)];{const t=ko(e);return[t,t]}}function ko(e){return Su(e)}function xt(e,t){t.split(/\s+/).forEach(n=>n&&e.classList.add(n)),(e[In]||(e[In]=new Set)).add(t)}function Mt(e,t){t.split(/\s+/).forEach(r=>r&&e.classList.remove(r));const n=e[In];n&&(n.delete(t),n.size||(e[In]=void 0))}function As(e){requestAnimationFrame(()=>{requestAnimationFrame(e)})}let xd=0;function Is(e,t,n,r){const o=e._endId=++xd,l=()=>{o===e._endId&&r()};if(n)return setTimeout(l,n);const{type:s,timeout:a,propCount:i}=ki(e,t);if(!s)return r();const c=s+"end";let u=0;const d=()=>{e.removeEventListener(c,p),l()},p=h=>{h.target===e&&++u>=i&&d()};setTimeout(()=>{u(n[g]||"").split(", "),o=r(`${Rt}Delay`),l=r(`${Rt}Duration`),s=Ps(o,l),a=r(`${jn}Delay`),i=r(`${jn}Duration`),c=Ps(a,i);let u=null,d=0,p=0;t===Rt?s>0&&(u=Rt,d=s,p=l.length):t===jn?c>0&&(u=jn,d=c,p=i.length):(d=Math.max(s,c),u=d>0?s>c?Rt:jn:null,p=u?u===Rt?l.length:i.length:0);const h=u===Rt&&/\b(transform|all)(,|$)/.test(r(`${Rt}Property`).toString());return{type:u,timeout:d,propCount:p,hasTransform:h}}function Ps(e,t){for(;e.lengthRs(n)+Rs(e[r])))}function Rs(e){return e==="auto"?0:Number(e.slice(0,-1).replace(",","."))*1e3}function Si(){return document.body.offsetHeight}function kd(e,t,n){const r=e[In];r&&(t=(t?[t,...r]:[...r]).join(" ")),t==null?e.removeAttribute("class"):n?e.setAttribute("class",t):e.className=t}const Os=Symbol("_vod"),Sd=Symbol("_vsh"),Td=Symbol(""),Ld=/(^|;)\s*display\s*:/;function Ad(e,t,n){const r=e.style,o=$e(n);let l=!1;if(n&&!o){if(t)if($e(t))for(const s of t.split(";")){const a=s.slice(0,s.indexOf(":")).trim();n[a]==null&&Vr(r,a,"")}else for(const s in t)n[s]==null&&Vr(r,s,"");for(const s in n)s==="display"&&(l=!0),Vr(r,s,n[s])}else if(o){if(t!==n){const s=r[Td];s&&(n+=";"+s),r.cssText=n,l=Ld.test(n)}}else t&&e.removeAttribute("style");Os in e&&(e[Os]=l?r.display:"",e[Sd]&&(r.display="none"))}const Ms=/\s*!important$/;function Vr(e,t,n){if(te(n))n.forEach(r=>Vr(e,t,r));else if(n==null&&(n=""),t.startsWith("--"))e.setProperty(t,n);else{const r=Id(e,t);Ms.test(n)?e.setProperty(Mn(r),n.replace(Ms,""),"important"):e[r]=n}}const $s=["Webkit","Moz","ms"],So={};function Id(e,t){const n=So[t];if(n)return n;let r=lt(t);if(r!=="filter"&&r in e)return So[t]=r;r=mr(r);for(let o=0;o<$s.length;o++){const l=$s[o]+r;if(l in e)return So[t]=l}return t}const Ns="http://www.w3.org/1999/xlink";function Pd(e,t,n,r,o){if(r&&t.startsWith("xlink:"))n==null?e.removeAttributeNS(Ns,t.slice(6,t.length)):e.setAttributeNS(Ns,t,n);else{const l=Ru(t);n==null||l&&!Ta(n)?e.removeAttribute(t):e.setAttribute(t,l?"":n)}}function Rd(e,t,n,r,o,l,s){if(t==="innerHTML"||t==="textContent"){r&&s(r,o,l),e[t]=n??"";return}const a=e.tagName;if(t==="value"&&a!=="PROGRESS"&&!a.includes("-")){const c=a==="OPTION"?e.getAttribute("value")||"":e.value,u=n??"";(c!==u||!("_value"in e))&&(e.value=u),n==null&&e.removeAttribute(t),e._value=n;return}let i=!1;if(n===""||n==null){const c=typeof e[t];c==="boolean"?n=Ta(n):n==null&&c==="string"?(n="",i=!0):c==="number"&&(n=0,i=!0)}try{e[t]=n}catch{}i&&e.removeAttribute(t)}function Od(e,t,n,r){e.addEventListener(t,n,r)}function Md(e,t,n,r){e.removeEventListener(t,n,r)}const Hs=Symbol("_vei");function $d(e,t,n,r,o=null){const l=e[Hs]||(e[Hs]={}),s=l[t];if(r&&s)s.value=r;else{const[a,i]=Nd(t);if(r){const c=l[t]=Fd(r,o);Od(e,a,c,i)}else s&&(Md(e,a,s,i),l[t]=void 0)}}const Ds=/(?:Once|Passive|Capture)$/;function Nd(e){let t;if(Ds.test(e)){t={};let r;for(;r=e.match(Ds);)e=e.slice(0,e.length-r[0].length),t[r[0].toLowerCase()]=!0}return[e[2]===":"?e.slice(3):Mn(e.slice(2)),t]}let To=0;const Hd=Promise.resolve(),Dd=()=>To||(Hd.then(()=>To=0),To=Date.now());function Fd(e,t){const n=r=>{if(!r._vts)r._vts=Date.now();else if(r._vts<=n.attached)return;ot(jd(r,n.value),t,5,[r])};return n.value=e,n.attached=Dd(),n}function jd(e,t){if(te(t)){const n=e.stopImmediatePropagation;return e.stopImmediatePropagation=()=>{n.call(e),e._stopped=!0},t.map(r=>o=>!o._stopped&&r&&r(o))}else return t}const Fs=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&e.charCodeAt(2)>96&&e.charCodeAt(2)<123,Bd=(e,t,n,r,o,l,s,a,i)=>{const c=o==="svg";t==="class"?kd(e,r,c):t==="style"?Ad(e,n,r):vr(t)?dl(t)||$d(e,t,n,r,s):(t[0]==="."?(t=t.slice(1),!0):t[0]==="^"?(t=t.slice(1),!1):zd(e,t,r,c))?Rd(e,t,r,l,s,a,i):(t==="true-value"?e._trueValue=r:t==="false-value"&&(e._falseValue=r),Pd(e,t,r,c))};function zd(e,t,n,r){if(r)return!!(t==="innerHTML"||t==="textContent"||t in e&&Fs(t)&&ne(n));if(t==="spellcheck"||t==="draggable"||t==="translate"||t==="form"||t==="list"&&e.tagName==="INPUT"||t==="type"&&e.tagName==="TEXTAREA")return!1;if(t==="width"||t==="height"){const o=e.tagName;if(o==="IMG"||o==="VIDEO"||o==="CANVAS"||o==="SOURCE")return!1}return Fs(t)&&$e(n)?!1:t in e}const Ti=new WeakMap,Li=new WeakMap,Jr=Symbol("_moveCb"),js=Symbol("_enterCb"),Ai={name:"TransitionGroup",props:Ae({},Cd,{tag:String,moveClass:String}),setup(e,{slots:t}){const n=Nn(),r=ti();let o,l;return si(()=>{if(!o.length)return;const s=e.moveClass||`${e.name||"v"}-move`;if(!qd(o[0].el,n.vnode.el,s))return;o.forEach(Gd),o.forEach(Kd);const a=o.filter(Ud);Si(),a.forEach(i=>{const c=i.el,u=c.style;xt(c,s),u.transform=u.webkitTransform=u.transitionDuration="";const d=c[Jr]=p=>{p&&p.target!==c||(!p||/transform$/.test(p.propertyName))&&(c.removeEventListener("transitionend",d),c[Jr]=null,Mt(c,s))};c.addEventListener("transitionend",d)})}),()=>{const s=le(e),a=xi(s);let i=s.tag||Ze;o=l,l=t.default?Ll(t.default()):[];for(let c=0;cdelete e.mode;Ai.props;const Wd=Ai;function Gd(e){const t=e.el;t[Jr]&&t[Jr](),t[js]&&t[js]()}function Kd(e){Li.set(e,e.el.getBoundingClientRect())}function Ud(e){const t=Ti.get(e),n=Li.get(e),r=t.left-n.left,o=t.top-n.top;if(r||o){const l=e.el.style;return l.transform=l.webkitTransform=`translate(${r}px,${o}px)`,l.transitionDuration="0s",e}}function qd(e,t,n){const r=e.cloneNode(),o=e[In];o&&o.forEach(a=>{a.split(/\s+/).forEach(i=>i&&r.classList.remove(i))}),n.split(/\s+/).forEach(a=>a&&r.classList.add(a)),r.style.display="none";const l=t.nodeType===1?t:t.parentNode;l.appendChild(r);const{hasTransform:s}=ki(r);return l.removeChild(r),s}const Yd=Ae({patchProp:Bd},_d);let Lo,Bs=!1;function Zd(){return Lo=Bs?Lo:ed(Yd),Bs=!0,Lo}const Xd=(...e)=>{const t=Zd().createApp(...e),{mount:n}=t;return t.mount=r=>{const o=Qd(r);if(o)return n(o,!0,Jd(o))},t};function Jd(e){if(e instanceof SVGElement)return"svg";if(typeof MathMLElement=="function"&&e instanceof MathMLElement)return"mathml"}function Qd(e){return $e(e)?document.querySelector(e):e}var ep=["link","meta","script","style","noscript","template"],tp=["title","base"],np=([e,t,n])=>tp.includes(e)?e:ep.includes(e)?e==="meta"&&t.name?`${e}.${t.name}`:e==="template"&&t.id?`${e}.${t.id}`:JSON.stringify([e,Object.entries(t).map(([r,o])=>typeof o=="boolean"?o?[r,""]:null:[r,o]).filter(r=>r!=null).sort(([r],[o])=>r.localeCompare(o)),n]):null,rp=e=>{const t=new Set,n=[];return e.forEach(r=>{const o=np(r);o&&!t.has(o)&&(t.add(o),n.push(r))}),n},op=e=>e[0]==="/"?e:`/${e}`,Ii=e=>e[e.length-1]==="/"||e.endsWith(".html")?e:`${e}/`,fn=e=>/^(https?:)?\/\//.test(e),lp=/.md((\?|#).*)?$/,ar=(e,t="/")=>!!(fn(e)||e.startsWith("/")&&!e.startsWith(t)&&!lp.test(e)),Pi=e=>/^[a-z][a-z0-9+.-]*:/.test(e),Cr=e=>Object.prototype.toString.call(e)==="[object Object]",sp=e=>{const[t,...n]=e.split(/(\?|#)/);if(!t||t.endsWith("/"))return e;let r=t.replace(/(^|\/)README.md$/i,"$1index.html");return r.endsWith(".md")?r=r.substring(0,r.length-3)+".html":r.endsWith(".html")||(r=r+".html"),r.endsWith("/index.html")&&(r=r.substring(0,r.length-10)),r+n.join("")},Ol=e=>e[e.length-1]==="/"?e.slice(0,-1):e,Ri=e=>e[0]==="/"?e.slice(1):e,ap=(e,t)=>{const n=Object.keys(e).sort((r,o)=>{const l=o.split("/").length-r.split("/").length;return l!==0?l:o.length-r.length});for(const r of n)if(t.startsWith(r))return r;return"/"},ip=e=>typeof e=="function",Le=e=>typeof e=="string";const cp="modulepreload",up=function(e){return"/"+e},zs={},ce=function(t,n,r){let o=Promise.resolve();if(n&&n.length>0){const l=document.getElementsByTagName("link");o=Promise.all(n.map(s=>{if(s=up(s),s in zs)return;zs[s]=!0;const a=s.endsWith(".css"),i=a?'[rel="stylesheet"]':"";if(!!r)for(let d=l.length-1;d>=0;d--){const p=l[d];if(p.href===s&&(!a||p.rel==="stylesheet"))return}else if(document.querySelector(`link[href="${s}"]${i}`))return;const u=document.createElement("link");if(u.rel=a?"stylesheet":cp,a||(u.as="script",u.crossOrigin=""),u.href=s,document.head.appendChild(u),a)return new Promise((d,p)=>{u.addEventListener("load",d),u.addEventListener("error",()=>p(new Error(`Unable to preload CSS for ${s}`)))})}))}return o.then(()=>t()).catch(l=>{const s=new Event("vite:preloadError",{cancelable:!0});if(s.payload=l,window.dispatchEvent(s),!s.defaultPrevented)throw l})},fp=JSON.parse("{}"),dp=Object.fromEntries([["/",{loader:()=>ce(()=>import("./index.html-CO3Zoej-.js"),__vite__mapDeps([0,1])),meta:{y:"h",t:"主页",i:"home-fill"}}],["/manual/Configuration.html",{loader:()=>ce(()=>import("./Configuration.html-C5G2PvFv.js"),__vite__mapDeps([2,1])),meta:{y:"a",t:"NixOS 配置"}}],["/manual/Intro.html",{loader:()=>ce(()=>import("./Intro.html-CsM-htdy.js"),__vite__mapDeps([3,1])),meta:{y:"a",t:"NixOS 入门"}}],["/tutorials/concept/BinaryAndSourceDistribution.html",{loader:()=>ce(()=>import("./BinaryAndSourceDistribution.html-16kgxc39.js"),__vite__mapDeps([4,1])),meta:{y:"a",t:"二进制分发与源码分发"}}],["/tutorials/concept/ConfigurationIsTheBlueprintOfTheSystem.html",{loader:()=>ce(()=>import("./ConfigurationIsTheBlueprintOfTheSystem.html-Dttpxv9Y.js"),__vite__mapDeps([5,1])),meta:{y:"a",t:"配置是一幅描绘系统的蓝图"}}],["/tutorials/concept/HowFunctionalProgrammingShapesNixOS.html",{loader:()=>ce(()=>import("./HowFunctionalProgrammingShapesNixOS.html-DZ_IJvjM.js"),__vite__mapDeps([6,1])),meta:{y:"a",t:"若干个函数凝聚成一个巨大的函数"}}],["/tutorials/concept/HowToMakePath-dependentProgramsWork.html",{loader:()=>ce(()=>import("./HowToMakePath-dependentProgramsWork.html-NhUUpgrU.js"),__vite__mapDeps([7,1])),meta:{y:"a",t:"如何让路径依赖的程序正常工作"}}],["/tutorials/concept/PurityIsOurUltimatePursuit.html",{loader:()=>ce(()=>import("./PurityIsOurUltimatePursuit.html-BDKKUkcr.js"),__vite__mapDeps([8,1])),meta:{y:"a",t:"纯净是我们的至高追求"}}],["/tutorials/installation/Networking.html",{loader:()=>ce(()=>import("./Networking.html-xvk50dn3.js"),__vite__mapDeps([9,1])),meta:{y:"a",t:"NixOS 的网络问题"}}],["/tutorials/installation/Subsystem.html",{loader:()=>ce(()=>import("./Subsystem.html-B9GmW8h7.js"),__vite__mapDeps([10,1])),meta:{y:"a",t:"双系统安装"}}],["/tutorials/installation/VirtualMachine.html",{loader:()=>ce(()=>import("./VirtualMachine.html-UPKXfkj3.js"),__vite__mapDeps([11,1])),meta:{y:"a",t:"虚拟机安装"}}],["/tutorials/installation/WSL2.html",{loader:()=>ce(()=>import("./WSL2.html-DbTShrQz.js"),__vite__mapDeps([12,1])),meta:{y:"a",t:"WSL2 安装"}}],["/tutorials/lang/Manuals.html",{loader:()=>ce(()=>import("./Manuals.html-BZkwlMGp.js"),__vite__mapDeps([13,1])),meta:{y:"a",t:"Nix 语言进阶手册"}}],["/tutorials/lang/QuickOverview.html",{loader:()=>ce(()=>import("./QuickOverview.html-BnfFQSVs.js"),__vite__mapDeps([14,1])),meta:{y:"a",t:"Nix 语言快速入门"}}],["/tutorials/module-system/intro.html",{loader:()=>ce(()=>import("./intro.html-_G6iOctj.js"),__vite__mapDeps([15,1])),meta:{y:"a",t:"Nix 的模块系统"}}],["/tutorials/env/dev/haskell.html",{loader:()=>ce(()=>import("./haskell.html-DaODvwP8.js"),__vite__mapDeps([16,1])),meta:{y:"a",t:"Haskell 开发环境部署",i:"haskell",s:"Haskell"}}],["/404.html",{loader:()=>ce(()=>import("./404.html-aJVSI8g5.js"),__vite__mapDeps([17,1])),meta:{y:"p",t:""}}],["/manual/",{loader:()=>ce(()=>import("./index.html-DhOr4nTI.js"),__vite__mapDeps([18,1])),meta:{y:"p",t:"Manual"}}],["/tutorials/concept/",{loader:()=>ce(()=>import("./index.html-GGNRB_Os.js"),__vite__mapDeps([19,1])),meta:{y:"p",t:"Concept"}}],["/tutorials/",{loader:()=>ce(()=>import("./index.html-vIVcD392.js"),__vite__mapDeps([20,1])),meta:{y:"p",t:"Tutorials"}}],["/tutorials/installation/",{loader:()=>ce(()=>import("./index.html-DFZDy7w2.js"),__vite__mapDeps([21,1])),meta:{y:"p",t:"Installation"}}],["/tutorials/lang/",{loader:()=>ce(()=>import("./index.html-BdmV7lSx.js"),__vite__mapDeps([22,1])),meta:{y:"p",t:"Lang"}}],["/tutorials/module-system/",{loader:()=>ce(()=>import("./index.html-DxGqHslQ.js"),__vite__mapDeps([23,1])),meta:{y:"p",t:"Module System"}}],["/tutorials/env/dev/",{loader:()=>ce(()=>import("./index.html-BRNxgYFz.js"),__vite__mapDeps([24,1])),meta:{y:"p",t:"Dev"}}],["/tutorials/env/",{loader:()=>ce(()=>import("./index.html-w6XYUv6Q.js"),__vite__mapDeps([25,1])),meta:{y:"p",t:"Env"}}]]);/*! +**/const yd="http://www.w3.org/2000/svg",wd="http://www.w3.org/1998/Math/MathML",Dt=typeof document<"u"?document:null,Ts=Dt&&Dt.createElement("template"),_d={insert:(e,t,n)=>{t.insertBefore(e,n||null)},remove:e=>{const t=e.parentNode;t&&t.removeChild(e)},createElement:(e,t,n,r)=>{const o=t==="svg"?Dt.createElementNS(yd,e):t==="mathml"?Dt.createElementNS(wd,e):Dt.createElement(e,n?{is:n}:void 0);return e==="select"&&r&&r.multiple!=null&&o.setAttribute("multiple",r.multiple),o},createText:e=>Dt.createTextNode(e),createComment:e=>Dt.createComment(e),setText:(e,t)=>{e.nodeValue=t},setElementText:(e,t)=>{e.textContent=t},parentNode:e=>e.parentNode,nextSibling:e=>e.nextSibling,querySelector:e=>Dt.querySelector(e),setScopeId(e,t){e.setAttribute(t,"")},insertStaticContent(e,t,n,r,o,l){const s=n?n.previousSibling:t.lastChild;if(o&&(o===l||o.nextSibling))for(;t.insertBefore(o.cloneNode(!0),n),!(o===l||!(o=o.nextSibling)););else{Ts.innerHTML=r==="svg"?`${e}`:r==="mathml"?`${e}`:e;const a=Ts.content;if(r==="svg"||r==="mathml"){const i=a.firstChild;for(;i.firstChild;)a.appendChild(i.firstChild);a.removeChild(i)}t.insertBefore(a,n)}return[s?s.nextSibling:t.firstChild,n?n.previousSibling:t.lastChild]}},Rt="transition",jn="animation",In=Symbol("_vtc"),Wt=(e,{slots:t})=>f(Lf,xi(e),t);Wt.displayName="Transition";const Ei={name:String,type:String,css:{type:Boolean,default:!0},duration:[String,Number,Object],enterFromClass:String,enterActiveClass:String,enterToClass:String,appearFromClass:String,appearActiveClass:String,appearToClass:String,leaveFromClass:String,leaveActiveClass:String,leaveToClass:String},Cd=Wt.props=Ae({},ni,Ei),Jt=(e,t=[])=>{te(e)?e.forEach(n=>n(...t)):e&&e(...t)},Ls=e=>e?te(e)?e.some(t=>t.length>1):e.length>1:!1;function xi(e){const t={};for(const R in e)R in Ei||(t[R]=e[R]);if(e.css===!1)return t;const{name:n="v",type:r,duration:o,enterFromClass:l=`${n}-enter-from`,enterActiveClass:s=`${n}-enter-active`,enterToClass:a=`${n}-enter-to`,appearFromClass:i=l,appearActiveClass:c=s,appearToClass:u=a,leaveFromClass:d=`${n}-leave-from`,leaveActiveClass:p=`${n}-leave-active`,leaveToClass:h=`${n}-leave-to`}=e,g=Ed(o),_=g&&g[0],w=g&&g[1],{onBeforeEnter:y,onEnter:x,onEnterCancelled:b,onLeave:S,onLeaveCancelled:$,onBeforeAppear:E=y,onAppear:G=x,onAppearCancelled:N=b}=t,q=(R,J,Ce)=>{Mt(R,J?u:a),Mt(R,J?c:s),Ce&&Ce()},P=(R,J)=>{R._isLeaving=!1,Mt(R,d),Mt(R,h),Mt(R,p),J&&J()},z=R=>(J,Ce)=>{const be=R?G:x,W=()=>q(J,R,Ce);Jt(be,[J,W]),As(()=>{Mt(J,R?i:l),xt(J,R?u:a),Ls(be)||Is(J,r,_,W)})};return Ae(t,{onBeforeEnter(R){Jt(y,[R]),xt(R,l),xt(R,s)},onBeforeAppear(R){Jt(E,[R]),xt(R,i),xt(R,c)},onEnter:z(!1),onAppear:z(!0),onLeave(R,J){R._isLeaving=!0;const Ce=()=>P(R,J);xt(R,d),Si(),xt(R,p),As(()=>{R._isLeaving&&(Mt(R,d),xt(R,h),Ls(S)||Is(R,r,w,Ce))}),Jt(S,[R,Ce])},onEnterCancelled(R){q(R,!1),Jt(b,[R])},onAppearCancelled(R){q(R,!0),Jt(N,[R])},onLeaveCancelled(R){P(R),Jt($,[R])}})}function Ed(e){if(e==null)return null;if(Ee(e))return[ko(e.enter),ko(e.leave)];{const t=ko(e);return[t,t]}}function ko(e){return Su(e)}function xt(e,t){t.split(/\s+/).forEach(n=>n&&e.classList.add(n)),(e[In]||(e[In]=new Set)).add(t)}function Mt(e,t){t.split(/\s+/).forEach(r=>r&&e.classList.remove(r));const n=e[In];n&&(n.delete(t),n.size||(e[In]=void 0))}function As(e){requestAnimationFrame(()=>{requestAnimationFrame(e)})}let xd=0;function Is(e,t,n,r){const o=e._endId=++xd,l=()=>{o===e._endId&&r()};if(n)return setTimeout(l,n);const{type:s,timeout:a,propCount:i}=ki(e,t);if(!s)return r();const c=s+"end";let u=0;const d=()=>{e.removeEventListener(c,p),l()},p=h=>{h.target===e&&++u>=i&&d()};setTimeout(()=>{u(n[g]||"").split(", "),o=r(`${Rt}Delay`),l=r(`${Rt}Duration`),s=Ps(o,l),a=r(`${jn}Delay`),i=r(`${jn}Duration`),c=Ps(a,i);let u=null,d=0,p=0;t===Rt?s>0&&(u=Rt,d=s,p=l.length):t===jn?c>0&&(u=jn,d=c,p=i.length):(d=Math.max(s,c),u=d>0?s>c?Rt:jn:null,p=u?u===Rt?l.length:i.length:0);const h=u===Rt&&/\b(transform|all)(,|$)/.test(r(`${Rt}Property`).toString());return{type:u,timeout:d,propCount:p,hasTransform:h}}function Ps(e,t){for(;e.lengthRs(n)+Rs(e[r])))}function Rs(e){return e==="auto"?0:Number(e.slice(0,-1).replace(",","."))*1e3}function Si(){return document.body.offsetHeight}function kd(e,t,n){const r=e[In];r&&(t=(t?[t,...r]:[...r]).join(" ")),t==null?e.removeAttribute("class"):n?e.setAttribute("class",t):e.className=t}const Os=Symbol("_vod"),Sd=Symbol("_vsh"),Td=Symbol(""),Ld=/(^|;)\s*display\s*:/;function Ad(e,t,n){const r=e.style,o=$e(n);let l=!1;if(n&&!o){if(t)if($e(t))for(const s of t.split(";")){const a=s.slice(0,s.indexOf(":")).trim();n[a]==null&&Vr(r,a,"")}else for(const s in t)n[s]==null&&Vr(r,s,"");for(const s in n)s==="display"&&(l=!0),Vr(r,s,n[s])}else if(o){if(t!==n){const s=r[Td];s&&(n+=";"+s),r.cssText=n,l=Ld.test(n)}}else t&&e.removeAttribute("style");Os in e&&(e[Os]=l?r.display:"",e[Sd]&&(r.display="none"))}const Ms=/\s*!important$/;function Vr(e,t,n){if(te(n))n.forEach(r=>Vr(e,t,r));else if(n==null&&(n=""),t.startsWith("--"))e.setProperty(t,n);else{const r=Id(e,t);Ms.test(n)?e.setProperty(Mn(r),n.replace(Ms,""),"important"):e[r]=n}}const $s=["Webkit","Moz","ms"],So={};function Id(e,t){const n=So[t];if(n)return n;let r=lt(t);if(r!=="filter"&&r in e)return So[t]=r;r=mr(r);for(let o=0;o<$s.length;o++){const l=$s[o]+r;if(l in e)return So[t]=l}return t}const Ns="http://www.w3.org/1999/xlink";function Pd(e,t,n,r,o){if(r&&t.startsWith("xlink:"))n==null?e.removeAttributeNS(Ns,t.slice(6,t.length)):e.setAttributeNS(Ns,t,n);else{const l=Ru(t);n==null||l&&!Ta(n)?e.removeAttribute(t):e.setAttribute(t,l?"":n)}}function Rd(e,t,n,r,o,l,s){if(t==="innerHTML"||t==="textContent"){r&&s(r,o,l),e[t]=n??"";return}const a=e.tagName;if(t==="value"&&a!=="PROGRESS"&&!a.includes("-")){const c=a==="OPTION"?e.getAttribute("value")||"":e.value,u=n??"";(c!==u||!("_value"in e))&&(e.value=u),n==null&&e.removeAttribute(t),e._value=n;return}let i=!1;if(n===""||n==null){const c=typeof e[t];c==="boolean"?n=Ta(n):n==null&&c==="string"?(n="",i=!0):c==="number"&&(n=0,i=!0)}try{e[t]=n}catch{}i&&e.removeAttribute(t)}function Od(e,t,n,r){e.addEventListener(t,n,r)}function Md(e,t,n,r){e.removeEventListener(t,n,r)}const Hs=Symbol("_vei");function $d(e,t,n,r,o=null){const l=e[Hs]||(e[Hs]={}),s=l[t];if(r&&s)s.value=r;else{const[a,i]=Nd(t);if(r){const c=l[t]=Fd(r,o);Od(e,a,c,i)}else s&&(Md(e,a,s,i),l[t]=void 0)}}const Ds=/(?:Once|Passive|Capture)$/;function Nd(e){let t;if(Ds.test(e)){t={};let r;for(;r=e.match(Ds);)e=e.slice(0,e.length-r[0].length),t[r[0].toLowerCase()]=!0}return[e[2]===":"?e.slice(3):Mn(e.slice(2)),t]}let To=0;const Hd=Promise.resolve(),Dd=()=>To||(Hd.then(()=>To=0),To=Date.now());function Fd(e,t){const n=r=>{if(!r._vts)r._vts=Date.now();else if(r._vts<=n.attached)return;ot(jd(r,n.value),t,5,[r])};return n.value=e,n.attached=Dd(),n}function jd(e,t){if(te(t)){const n=e.stopImmediatePropagation;return e.stopImmediatePropagation=()=>{n.call(e),e._stopped=!0},t.map(r=>o=>!o._stopped&&r&&r(o))}else return t}const Fs=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&e.charCodeAt(2)>96&&e.charCodeAt(2)<123,Bd=(e,t,n,r,o,l,s,a,i)=>{const c=o==="svg";t==="class"?kd(e,r,c):t==="style"?Ad(e,n,r):vr(t)?dl(t)||$d(e,t,n,r,s):(t[0]==="."?(t=t.slice(1),!0):t[0]==="^"?(t=t.slice(1),!1):zd(e,t,r,c))?Rd(e,t,r,l,s,a,i):(t==="true-value"?e._trueValue=r:t==="false-value"&&(e._falseValue=r),Pd(e,t,r,c))};function zd(e,t,n,r){if(r)return!!(t==="innerHTML"||t==="textContent"||t in e&&Fs(t)&&ne(n));if(t==="spellcheck"||t==="draggable"||t==="translate"||t==="form"||t==="list"&&e.tagName==="INPUT"||t==="type"&&e.tagName==="TEXTAREA")return!1;if(t==="width"||t==="height"){const o=e.tagName;if(o==="IMG"||o==="VIDEO"||o==="CANVAS"||o==="SOURCE")return!1}return Fs(t)&&$e(n)?!1:t in e}const Ti=new WeakMap,Li=new WeakMap,Jr=Symbol("_moveCb"),js=Symbol("_enterCb"),Ai={name:"TransitionGroup",props:Ae({},Cd,{tag:String,moveClass:String}),setup(e,{slots:t}){const n=Nn(),r=ti();let o,l;return si(()=>{if(!o.length)return;const s=e.moveClass||`${e.name||"v"}-move`;if(!qd(o[0].el,n.vnode.el,s))return;o.forEach(Gd),o.forEach(Kd);const a=o.filter(Ud);Si(),a.forEach(i=>{const c=i.el,u=c.style;xt(c,s),u.transform=u.webkitTransform=u.transitionDuration="";const d=c[Jr]=p=>{p&&p.target!==c||(!p||/transform$/.test(p.propertyName))&&(c.removeEventListener("transitionend",d),c[Jr]=null,Mt(c,s))};c.addEventListener("transitionend",d)})}),()=>{const s=le(e),a=xi(s);let i=s.tag||Ze;o=l,l=t.default?Ll(t.default()):[];for(let c=0;cdelete e.mode;Ai.props;const Wd=Ai;function Gd(e){const t=e.el;t[Jr]&&t[Jr](),t[js]&&t[js]()}function Kd(e){Li.set(e,e.el.getBoundingClientRect())}function Ud(e){const t=Ti.get(e),n=Li.get(e),r=t.left-n.left,o=t.top-n.top;if(r||o){const l=e.el.style;return l.transform=l.webkitTransform=`translate(${r}px,${o}px)`,l.transitionDuration="0s",e}}function qd(e,t,n){const r=e.cloneNode(),o=e[In];o&&o.forEach(a=>{a.split(/\s+/).forEach(i=>i&&r.classList.remove(i))}),n.split(/\s+/).forEach(a=>a&&r.classList.add(a)),r.style.display="none";const l=t.nodeType===1?t:t.parentNode;l.appendChild(r);const{hasTransform:s}=ki(r);return l.removeChild(r),s}const Yd=Ae({patchProp:Bd},_d);let Lo,Bs=!1;function Zd(){return Lo=Bs?Lo:ed(Yd),Bs=!0,Lo}const Xd=(...e)=>{const t=Zd().createApp(...e),{mount:n}=t;return t.mount=r=>{const o=Qd(r);if(o)return n(o,!0,Jd(o))},t};function Jd(e){if(e instanceof SVGElement)return"svg";if(typeof MathMLElement=="function"&&e instanceof MathMLElement)return"mathml"}function Qd(e){return $e(e)?document.querySelector(e):e}var ep=["link","meta","script","style","noscript","template"],tp=["title","base"],np=([e,t,n])=>tp.includes(e)?e:ep.includes(e)?e==="meta"&&t.name?`${e}.${t.name}`:e==="template"&&t.id?`${e}.${t.id}`:JSON.stringify([e,Object.entries(t).map(([r,o])=>typeof o=="boolean"?o?[r,""]:null:[r,o]).filter(r=>r!=null).sort(([r],[o])=>r.localeCompare(o)),n]):null,rp=e=>{const t=new Set,n=[];return e.forEach(r=>{const o=np(r);o&&!t.has(o)&&(t.add(o),n.push(r))}),n},op=e=>e[0]==="/"?e:`/${e}`,Ii=e=>e[e.length-1]==="/"||e.endsWith(".html")?e:`${e}/`,fn=e=>/^(https?:)?\/\//.test(e),lp=/.md((\?|#).*)?$/,ar=(e,t="/")=>!!(fn(e)||e.startsWith("/")&&!e.startsWith(t)&&!lp.test(e)),Pi=e=>/^[a-z][a-z0-9+.-]*:/.test(e),Cr=e=>Object.prototype.toString.call(e)==="[object Object]",sp=e=>{const[t,...n]=e.split(/(\?|#)/);if(!t||t.endsWith("/"))return e;let r=t.replace(/(^|\/)README.md$/i,"$1index.html");return r.endsWith(".md")?r=r.substring(0,r.length-3)+".html":r.endsWith(".html")||(r=r+".html"),r.endsWith("/index.html")&&(r=r.substring(0,r.length-10)),r+n.join("")},Ol=e=>e[e.length-1]==="/"?e.slice(0,-1):e,Ri=e=>e[0]==="/"?e.slice(1):e,ap=(e,t)=>{const n=Object.keys(e).sort((r,o)=>{const l=o.split("/").length-r.split("/").length;return l!==0?l:o.length-r.length});for(const r of n)if(t.startsWith(r))return r;return"/"},ip=e=>typeof e=="function",Le=e=>typeof e=="string";const cp="modulepreload",up=function(e){return"/"+e},zs={},ce=function(t,n,r){let o=Promise.resolve();if(n&&n.length>0){const l=document.getElementsByTagName("link");o=Promise.all(n.map(s=>{if(s=up(s),s in zs)return;zs[s]=!0;const a=s.endsWith(".css"),i=a?'[rel="stylesheet"]':"";if(!!r)for(let d=l.length-1;d>=0;d--){const p=l[d];if(p.href===s&&(!a||p.rel==="stylesheet"))return}else if(document.querySelector(`link[href="${s}"]${i}`))return;const u=document.createElement("link");if(u.rel=a?"stylesheet":cp,a||(u.as="script",u.crossOrigin=""),u.href=s,document.head.appendChild(u),a)return new Promise((d,p)=>{u.addEventListener("load",d),u.addEventListener("error",()=>p(new Error(`Unable to preload CSS for ${s}`)))})}))}return o.then(()=>t()).catch(l=>{const s=new Event("vite:preloadError",{cancelable:!0});if(s.payload=l,window.dispatchEvent(s),!s.defaultPrevented)throw l})},fp=JSON.parse("{}"),dp=Object.fromEntries([["/",{loader:()=>ce(()=>import("./index.html-Bld3147c.js"),__vite__mapDeps([0,1])),meta:{y:"h",t:"主页",i:"home-fill"}}],["/manual/Configuration.html",{loader:()=>ce(()=>import("./Configuration.html-CE9jQ0tW.js"),__vite__mapDeps([2,1])),meta:{y:"a",t:"NixOS 配置"}}],["/manual/Intro.html",{loader:()=>ce(()=>import("./Intro.html-CEuRkNVT.js"),__vite__mapDeps([3,1])),meta:{y:"a",t:"NixOS 入门"}}],["/tutorials/concept/BinaryAndSourceDistribution.html",{loader:()=>ce(()=>import("./BinaryAndSourceDistribution.html-C-rtSMVZ.js"),__vite__mapDeps([4,1])),meta:{y:"a",t:"二进制分发与源码分发"}}],["/tutorials/concept/ConfigurationIsTheBlueprintOfTheSystem.html",{loader:()=>ce(()=>import("./ConfigurationIsTheBlueprintOfTheSystem.html-djsOJ9Vw.js"),__vite__mapDeps([5,1])),meta:{y:"a",t:"配置是一幅描绘系统的蓝图"}}],["/tutorials/concept/HowFunctionalProgrammingShapesNixOS.html",{loader:()=>ce(()=>import("./HowFunctionalProgrammingShapesNixOS.html-rr2UlYus.js"),__vite__mapDeps([6,1])),meta:{y:"a",t:"若干个函数凝聚成一个巨大的函数"}}],["/tutorials/concept/HowToMakePath-dependentProgramsWork.html",{loader:()=>ce(()=>import("./HowToMakePath-dependentProgramsWork.html-D2834t8G.js"),__vite__mapDeps([7,1])),meta:{y:"a",t:"如何让路径依赖的程序正常工作"}}],["/tutorials/concept/PurityIsOurUltimatePursuit.html",{loader:()=>ce(()=>import("./PurityIsOurUltimatePursuit.html-BJhNv_7j.js"),__vite__mapDeps([8,1])),meta:{y:"a",t:"纯净是我们的至高追求"}}],["/tutorials/installation/Networking.html",{loader:()=>ce(()=>import("./Networking.html-D__jtwiK.js"),__vite__mapDeps([9,1])),meta:{y:"a",t:"NixOS 的网络问题"}}],["/tutorials/installation/Subsystem.html",{loader:()=>ce(()=>import("./Subsystem.html-DSYLh798.js"),__vite__mapDeps([10,1])),meta:{y:"a",t:"双系统安装"}}],["/tutorials/installation/VirtualMachine.html",{loader:()=>ce(()=>import("./VirtualMachine.html-dR4GRz3A.js"),__vite__mapDeps([11,1])),meta:{y:"a",t:"虚拟机安装"}}],["/tutorials/installation/WSL2.html",{loader:()=>ce(()=>import("./WSL2.html-B1QMWOGS.js"),__vite__mapDeps([12,1])),meta:{y:"a",t:"WSL2 安装"}}],["/tutorials/lang/Manuals.html",{loader:()=>ce(()=>import("./Manuals.html-DFp7igCI.js"),__vite__mapDeps([13,1])),meta:{y:"a",t:"Nix 语言进阶手册"}}],["/tutorials/lang/QuickOverview.html",{loader:()=>ce(()=>import("./QuickOverview.html-BSo4J38r.js"),__vite__mapDeps([14,1])),meta:{y:"a",t:"Nix 语言快速入门"}}],["/tutorials/module-system/intro.html",{loader:()=>ce(()=>import("./intro.html-B3Nq0b0F.js"),__vite__mapDeps([15,1])),meta:{y:"a",t:"Nix 的模块系统"}}],["/tutorials/env/dev/haskell.html",{loader:()=>ce(()=>import("./haskell.html-IMJVSTSk.js"),__vite__mapDeps([16,1])),meta:{y:"a",t:"Haskell 开发环境部署",i:"haskell",s:"Haskell"}}],["/404.html",{loader:()=>ce(()=>import("./404.html-7q9hhSdq.js"),__vite__mapDeps([17,1])),meta:{y:"p",t:""}}],["/manual/",{loader:()=>ce(()=>import("./index.html-BNRX3zGk.js"),__vite__mapDeps([18,1])),meta:{y:"p",t:"Manual"}}],["/tutorials/concept/",{loader:()=>ce(()=>import("./index.html-CXqct-2E.js"),__vite__mapDeps([19,1])),meta:{y:"p",t:"Concept"}}],["/tutorials/",{loader:()=>ce(()=>import("./index.html-lh8H6DTQ.js"),__vite__mapDeps([20,1])),meta:{y:"p",t:"Tutorials"}}],["/tutorials/installation/",{loader:()=>ce(()=>import("./index.html-C7513JJK.js"),__vite__mapDeps([21,1])),meta:{y:"p",t:"Installation"}}],["/tutorials/lang/",{loader:()=>ce(()=>import("./index.html-ByMTKhkr.js"),__vite__mapDeps([22,1])),meta:{y:"p",t:"Lang"}}],["/tutorials/module-system/",{loader:()=>ce(()=>import("./index.html-csQfK4x4.js"),__vite__mapDeps([23,1])),meta:{y:"p",t:"Module System"}}],["/tutorials/env/dev/",{loader:()=>ce(()=>import("./index.html-dT3bJ4l8.js"),__vite__mapDeps([24,1])),meta:{y:"p",t:"Dev"}}],["/tutorials/env/",{loader:()=>ce(()=>import("./index.html-CykiMO0-.js"),__vite__mapDeps([25,1])),meta:{y:"p",t:"Env"}}]]);/*! * vue-router v4.3.0 * (c) 2024 Eduardo San Martin Morote * @license MIT @@ -32,4 +32,4 @@ function __vite__mapDeps(indexes) { ${r}}`)),t.appendChild(o)}},Iv=e=>{const t=pn(e),n={html:[],js:[],css:[],isLegal:!1};return["html","js","css"].forEach(r=>{const o=t.filter(l=>ga[r].types.includes(l));if(o.length){const l=o[0];n[r]=[e[l].replace(/^\n|\n$/g,""),ga[r].map[l]||l]}}),n.isLegal=(!n.html.length||n.html[1]==="none")&&(!n.js.length||n.js[1]==="none")&&(!n.css.length||n.css[1]==="none"),n},Lc=e=>e.replace(/
/g,"
").replace(/<((\S+)[^<]*?)\s+\/>/g,"<$1>"),Ac=e=>`
${Lc(e)}
`,Pv=e=>`${e.replace("export default ","const $reactApp = ").replace(/App\.__style__(\s*)=(\s*)`([\s\S]*)?`/,"")}; -ReactDOM.createRoot(document.getElementById("app")).render(React.createElement($reactApp))`,Rv=e=>e.replace(/export\s+default\s*\{(\n*[\s\S]*)\n*\}\s*;?$/u,"Vue.createApp({$1}).mount('#app')").replace(/export\s+default\s*define(Async)?Component\s*\(\s*\{(\n*[\s\S]*)\n*\}\s*\)\s*;?$/u,"Vue.createApp({$1}).mount('#app')").trim(),Ic=e=>`(function(exports){var module={};module.exports=exports;${e};return module.exports.__esModule?module.exports.default:module.exports;})({})`,Ov=(e,t)=>{const n=Gl(t),r=e.js[0]||"";return{...n,html:Lc(e.html[0]||""),js:r,css:e.css[0]||"",isLegal:e.isLegal,getScript:()=>{var o;return n.useBabel?((o=window.Babel.transform(r,{presets:["es2015"]}))==null?void 0:o.code)||"":r}}},Mv=/