如何仅克隆 Git 存储库的子目录？

您正在尝试执行的操作称为稀疏结帐，该功能已在 Git 1.7.0（2012 年 2 月）中添加。进行稀疏克隆的步骤如下：

mkdir <repo>
cd <repo>
git init
git remote add -f origin <url>

这将使用您的遥控器创建一个空存储库，并获取所有对象但不检出它们。然后做：

git config core.sparseCheckout true

现在您需要定义要实际签出的文件/文件夹。这是通过在 .git/info/sparse-checkout 中列出它们来完成的，例如：

echo "some/dir/" >> .git/info/sparse-checkout
echo "another/sub/tree" >> .git/info/sparse-checkout

最后但同样重要的是，使用远程状态更新您的空仓库：

git pull origin master

您现在将在文件系统上“签出”some/dir 和 another/sub/tree 的文件（这些路径仍然存在），并且不存在其他路径。

您可能想看看 extended tutorial，您可能应该阅读官方的 documentation for sparse checkout 和 read-tree。

作为一个函数：

function git_sparse_clone() (
  rurl="$1" localdir="$2" && shift 2

  mkdir -p "$localdir"
  cd "$localdir"

  git init
  git remote add -f origin "$rurl"

  git config core.sparseCheckout true

  # Loops over remaining args
  for i; do
    echo "$i" >> .git/info/sparse-checkout
  done

  git pull origin master
)

用法：

git_sparse_clone "http://github.com/tj/n" "./local/location" "/bin"

请注意，这仍然会从服务器下载整个存储库——只是结帐的大小减小了。目前不可能只克隆一个目录。但是，如果您不需要存储库的历史记录，您至少可以通过创建浅层克隆来节省带宽。有关如何结合浅层 clone 和稀疏结帐的信息，请参阅下面的 udondan's answer。

从 Git 2.25.0（2020 年 1 月）开始，在 Git 中添加了一个实验性 sparse-checkout 命令：

git sparse-checkout init
# same as:
# git config core.sparseCheckout true

git sparse-checkout set "A/B"
# same as:
# echo "A/B" >> .git/info/sparse-checkout

git sparse-checkout list
# same as:
# cat .git/info/sparse-checkout

---

来自 git 2.19 的git clone --filter现在可以在 GitHub 上运行（测试于 2021 年 1 月 14 日，git 2.30.0）

此选项是与远程协议的更新一起添加的，它确实可以防止从服务器下载对象。

例如，在这个最小的测试存储库中只克隆目录 d1 所需的对象：https://github.com/cirosantilli/test-git-partial-clone 我可以这样做：

git clone \
  --depth 1  \
  --filter=blob:none  \
  --sparse \
  https://github.com/cirosantilli/test-git-partial-clone \
;
cd test-git-partial-clone
git sparse-checkout set d1

这是 https://github.com/cirosantilli/test-git-partial-clone-big-small 的一个不那么简约但更现实的版本

git clone \
  --depth 1  \
  --filter=blob:none  \
  --sparse \
  https://github.com/cirosantilli/test-git-partial-clone-big-small \
;
cd test-git-partial-clone-big-small
git sparse-checkout set small

该存储库包含：

一个包含 10 个 10MB 文件的大目录

一个包含 1000 个大小为 1 字节的文件的小目录

所有内容都是伪随机的，因此不可压缩。

在我的 36.4 Mbps 互联网上克隆时间：

满：24s

部分：“瞬时”

不幸的是，还需要 sparse-checkout 部分。您也可以只下载某些更易于理解的文件：

git clone \
  --depth 1  \
  --filter=blob:none  \
  --no-checkout \
  https://github.com/cirosantilli/test-git-partial-clone \
;
cd test-git-partial-clone
git checkout master -- d1

但是由于某种原因downloads files one by one very slowly，该方法使其无法使用，除非目录中的文件很少。

分析最小存储库中的对象

克隆命令仅获得：

带有主分支尖端的单个提交对象

存储库的所有 4 个树对象：提交的顶级目录 d1、d2、master 三个目录

提交的顶级目录

d1、d2、master三个目录

然后，git sparse-checkout set 命令仅从服务器获取丢失的 blob（文件）：

d1/a

d1/b

更好的是，稍后在 GitHub 上可能会开始支持：

  --filter=blob:none \
  --filter=tree:0 \

其中 --filter=tree:0 from Git 2.20 将防止对所有树对象进行不必要的 clone 提取，并允许将其推迟到 checkout。但是在我的 2020-09-18 测试中失败了：

fatal: invalid filter-spec 'combine:blob:none+tree:0'

大概是因为 --filter=combine: 复合过滤器（在 Git 2.24 中添加，由多个 --filter 暗示）尚未实现。

我观察了哪些对象被提取：

git verify-pack -v .git/objects/pack/*.pack

正如在 How to list ALL git objects in the database? 中提到的：它并没有给我一个非常清楚的指示每个对象到底是什么，但它确实说明了每个对象的类型（commit、tree、blob），因为有在那个最小的 repo 中这么少的对象，我可以明确地推断出每个对象是什么。

git rev-list --objects --all 确实产生了带有树/blob 路径的更清晰的输出，但不幸的是，当我运行它时它会获取一些对象，这使得很难确定何时获取了什么，如果有人有更好的命令，请告诉我。

TODO 找到 GitHub 的公告，上面写着他们何时开始支持它。 2020 年 1 月 17 日的 https://github.blog/2020-01-17-bring-your-monorepo-down-to-size-with-sparse-checkout/ 已经提到 --filter blob:none。

git sparse-checkout

我认为这个命令旨在管理一个设置文件，上面写着“我只关心这些子树”，以便将来的命令只会影响这些子树。但是有点难以确定，因为当前的文档有点……稀疏;-)

它本身并不能阻止获取 blob。

如果这种理解是正确的，那么这将是对上述 git clone --filter 的一个很好的补充，因为如果您打算在部分克隆的 repo 中执行 git 操作，它将防止无意获取更多对象。

当我尝试使用 Git 2.25.1 时：

git clone \
  --depth 1 \
  --filter=blob:none \
  --no-checkout \
  https://github.com/cirosantilli/test-git-partial-clone \
;
cd test-git-partial-clone
git sparse-checkout init

它不起作用，因为 init 实际上获取了所有对象。

但是，在 Git 2.28 中，它并没有按需要获取对象。但是，如果我这样做：

git sparse-checkout set d1

d1 没有被提取和检出，即使这明确说明它应该：https://github.blog/2020-01-17-bring-your-monorepo-down-to-size-with-sparse-checkout/#sparse-checkout-and-partial-clones 带有免责声明：

请留意部分克隆功能是否会普遍可用[1]。 [1]：GitHub 仍在内部评估此功能，同时它已在少数几个存储库（包括本文中使用的示例）上启用。随着该功能的稳定和成熟，我们会及时通知您其进展情况。

所以，是的，目前很难确定，这部分归功于 GitHub 是封闭源代码的乐趣。但让我们密切关注它。

命令分解

服务器应配置：

git config --local uploadpack.allowfilter 1
git config --local uploadpack.allowanysha1inwant 1

命令分解：

--filter=blob:none 跳过所有 blob，但仍获取所有树对象

--filter=tree:0 跳过不需要的树：https://www.spinics.net/lists/git/msg342006.html

--depth 1 已经暗示了 --single-branch，另请参阅：如何在 Git 中克隆单个分支？

file://$(path) 是克服 git clone 协议恶作剧所必需的：如何用相对路径浅克隆本地 git 存储库？

--filter=combine:FILTER1+FILTER2 是一次使用多个过滤器的语法，尝试通过 --filter 出于某种原因失败：“多个过滤器规格无法组合”。这是在 Git 2.24 中添加的 e987df5fe62b8b29be4cdcdeb3704681ada2b29e “list-objects-filter：实现复合过滤器” 编辑：在 Git 2.28 上，我通过实验看到 --filter=FILTER1 --filter FILTER2 也具有相同的效果，因为 GitHub 没有实现 combine ：但截至 2020 年 9 月 18 日并抱怨致命：无效的过滤器规范“组合：blob：无+树：0”。 TODO在哪个版本推出？

--filter 的格式记录在 man git-rev-list 上。

Git 树上的文档：

https://github.com/git/git/blob/v2.19.0/Documentation/technical/partial-clone.txt

https://github.com/git/git/blob/v2.19.0/Documentation/rev-list-options.txt#L720

https://github.com/git/git/blob/v2.19.0/t/t5616-partial-clone.sh

在本地测试一下

以下脚本可重现地在本地生成 https://github.com/cirosantilli/test-git-partial-clone 存储库，执行本地克隆，并观察克隆的内容：

#!/usr/bin/env bash
set -eu

list-objects() (
  git rev-list --all --objects
  echo "master commit SHA: $(git log -1 --format="%H")"
  echo "mybranch commit SHA: $(git log -1 --format="%H")"
  git ls-tree master
  git ls-tree mybranch | grep mybranch
  git ls-tree master~ | grep root
)

# Reproducibility.
export GIT_COMMITTER_NAME='a'
export GIT_COMMITTER_EMAIL='a'
export GIT_AUTHOR_NAME='a'
export GIT_AUTHOR_EMAIL='a'
export GIT_COMMITTER_DATE='2000-01-01T00:00:00+0000'
export GIT_AUTHOR_DATE='2000-01-01T00:00:00+0000'

rm -rf server_repo local_repo
mkdir server_repo
cd server_repo

# Create repo.
git init --quiet
git config --local uploadpack.allowfilter 1
git config --local uploadpack.allowanysha1inwant 1

# First commit.
# Directories present in all branches.
mkdir d1 d2
printf 'd1/a' > ./d1/a
printf 'd1/b' > ./d1/b
printf 'd2/a' > ./d2/a
printf 'd2/b' > ./d2/b
# Present only in root.
mkdir 'root'
printf 'root' > ./root/root
git add .
git commit -m 'root' --quiet

# Second commit only on master.
git rm --quiet -r ./root
mkdir 'master'
printf 'master' > ./master/master
git add .
git commit -m 'master commit' --quiet

# Second commit only on mybranch.
git checkout -b mybranch --quiet master~
git rm --quiet -r ./root
mkdir 'mybranch'
printf 'mybranch' > ./mybranch/mybranch
git add .
git commit -m 'mybranch commit' --quiet

echo "# List and identify all objects"
list-objects
echo

# Restore master.
git checkout --quiet master
cd ..

# Clone. Don't checkout for now, only .git/ dir.
git clone --depth 1 --quiet --no-checkout --filter=blob:none "file://$(pwd)/server_repo" local_repo
cd local_repo

# List missing objects from master.
echo "# Missing objects after --no-checkout"
git rev-list --all --quiet --objects --missing=print
echo

echo "# Git checkout fails without internet"
mv ../server_repo ../server_repo.off
! git checkout master
echo

echo "# Git checkout fetches the missing directory from internet"
mv ../server_repo.off ../server_repo
git checkout master -- d1/
echo

echo "# Missing objects after checking out d1"
git rev-list --all --quiet --objects --missing=print

GitHub upstream。

Git v2.19.0 中的输出：

# List and identify all objects
c6fcdfaf2b1462f809aecdad83a186eeec00f9c1
fc5e97944480982cfc180a6d6634699921ee63ec
7251a83be9a03161acde7b71a8fda9be19f47128
62d67bce3c672fe2b9065f372726a11e57bade7e
b64bf435a3e54c5208a1b70b7bcb0fc627463a75 d1
308150e8fddde043f3dbbb8573abb6af1df96e63 d1/a
f70a17f51b7b30fec48a32e4f19ac15e261fd1a4 d1/b
84de03c312dc741d0f2a66df7b2f168d823e122a d2
0975df9b39e23c15f63db194df7f45c76528bccb d2/a
41484c13520fcbb6e7243a26fdb1fc9405c08520 d2/b
7d5230379e4652f1b1da7ed1e78e0b8253e03ba3 master
8b25206ff90e9432f6f1a8600f87a7bd695a24af master/master
ef29f15c9a7c5417944cc09711b6a9ee51b01d89
19f7a4ca4a038aff89d803f017f76d2b66063043 mybranch
1b671b190e293aa091239b8b5e8c149411d00523 mybranch/mybranch
c3760bb1a0ece87cdbaf9a563c77a45e30a4e30e
a0234da53ec608b54813b4271fbf00ba5318b99f root
93ca1422a8da0a9effc465eccbcb17e23015542d root/root
master commit SHA: fc5e97944480982cfc180a6d6634699921ee63ec
mybranch commit SHA: fc5e97944480982cfc180a6d6634699921ee63ec
040000 tree b64bf435a3e54c5208a1b70b7bcb0fc627463a75    d1
040000 tree 84de03c312dc741d0f2a66df7b2f168d823e122a    d2
040000 tree 7d5230379e4652f1b1da7ed1e78e0b8253e03ba3    master
040000 tree 19f7a4ca4a038aff89d803f017f76d2b66063043    mybranch
040000 tree a0234da53ec608b54813b4271fbf00ba5318b99f    root

# Missing objects after --no-checkout
?f70a17f51b7b30fec48a32e4f19ac15e261fd1a4
?8b25206ff90e9432f6f1a8600f87a7bd695a24af
?41484c13520fcbb6e7243a26fdb1fc9405c08520
?0975df9b39e23c15f63db194df7f45c76528bccb
?308150e8fddde043f3dbbb8573abb6af1df96e63

# Git checkout fails without internet
fatal: '/home/ciro/bak/git/test-git-web-interface/other-test-repos/partial-clone.tmp/server_repo' does not appear to be a git repository
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

# Git checkout fetches the missing directory from internet
remote: Enumerating objects: 1, done.
remote: Counting objects: 100% (1/1), done.
remote: Total 1 (delta 0), reused 0 (delta 0)
Receiving objects: 100% (1/1), 45 bytes | 45.00 KiB/s, done.
remote: Enumerating objects: 1, done.
remote: Counting objects: 100% (1/1), done.
remote: Total 1 (delta 0), reused 0 (delta 0)
Receiving objects: 100% (1/1), 45 bytes | 45.00 KiB/s, done.

# Missing objects after checking out d1
?8b25206ff90e9432f6f1a8600f87a7bd695a24af
?41484c13520fcbb6e7243a26fdb1fc9405c08520
?0975df9b39e23c15f63db194df7f45c76528bccb

结论：d1/ 之外的所有 blob 都丢失了。例如 0975df9b39e23c15f63db194df7f45c76528bccb，即 d2/b 在签出 d1/a 后不存在。

请注意，root/root 和 mybranch/mybranch 也丢失了，但 --depth 1 将其隐藏在丢失文件列表中。如果您删除 --depth 1，则它们会显示在丢失文件列表中。

我有一个梦想

这个特性可能会彻底改变 Git。

想象一下，您的企业 in a single repo 的所有代码库都没有 ugly third-party tools like repo。

想象一下 storing huge blobs directly in the repo without any ugly third party extensions。

想象一下，如果 GitHub 允许 per file / directory metadata 之类的星标和权限，那么您可以将所有个人资料存储在一个存储库中。

想象一下，如果 submodules were treated exactly like regular directories：只请求一个树形 SHA 和一个 DNS-like mechanism resolves your request，首先查看您的 local ~/.git，然后首先查看更接近的服务器（您企业的镜像/缓存）并最终在 GitHub 上。

---

编辑：从 Git 2.19 开始，这终于成为可能，如 answer 所示。

考虑支持该答案。

注意：在 Git 2.19 中，仅实现了客户端支持，仍然缺少服务器端支持，因此仅在克隆本地存储库时有效。另请注意，大型 Git 托管服务商，例如 GitHub，实际上并不使用 Git 服务器，它们使用自己的实现，因此即使 Git 服务器中出现支持，也并不意味着它自动适用于 Git 托管服务商。 （OTOH，因为他们不使用 Git 服务器，所以他们可以在自己的实现中更快地实现它，然后它才会出现在 Git 服务器中。）

不，这在 Git 中是不可能的。

在 Git 中实现这样的东西将是一项巨大的努力，这意味着客户端存储库的完整性将不再得到保证。如果您有兴趣，请在 git 邮件列表中搜索有关“稀疏克隆”和“稀疏获取”的讨论。

一般来说，Git 社区的共识是，如果你有几个总是独立签出的目录，那么它们实际上是两个不同的项目，应该存在于两个不同的存储库中。您可以使用 Git Submodules 将它们粘合在一起。

---

您可以结合稀疏结帐和浅克隆功能。浅克隆会切断历史记录，而稀疏检出只会提取与您的模式匹配的文件。

git init <repo>
cd <repo>
git remote add origin <url>
git config core.sparsecheckout true
echo "finisht/*" >> .git/info/sparse-checkout
git pull --depth=1 origin master

你需要最低 git 1.9 才能工作。仅使用 2.2.0 和 2.2.2 自己测试过。

这样，您仍然可以 push，而 git archive 则无法做到这一点。

---

对于只想从 github 下载文件/文件夹的其他用户，只需使用：

svn export <repo>/trunk/<folder>

例如

svn export https://github.com/lodash/lodash.com/trunk/docs

（是的，这里是 svn。显然在 2016 年你仍然需要 svn 来简单地下载一些 github 文件）

礼貌：Download a single folder or directory from a GitHub repo

重要提示 - 确保更新 github URL 并将 /tree/master/ 替换为“/trunk/”。

作为 bash 脚本：

git-download(){
    folder=${@/tree\/master/trunk}
    folder=${folder/blob\/master/trunk}
    svn export $folder
}

注意此方法下载一个文件夹，而不是克隆/签出它。您无法将更改推送回存储库。另一方面 - 与稀疏结帐或浅结帐相比，这会导致下载量更小。

---

如果您从不打算与从中克隆的存储库进行交互，您可以执行完整的 git clone 并使用重写您的存储库

git filter-branch --subdirectory-filter <subdirectory>

这样，至少历史将被保留。

---

This 看起来要简单得多：

git archive --remote=<repo_url> <branch> <path> | tar xvf -

---

Git 1.7.0 有“稀疏检出”。请参阅 git config manpage 中的“core.sparseCheckout”、git read-tree manpage 中的“Sparse checkout”和 git update-index manpage 中的“Skip-worktree bit”。

该接口不如 SVN 方便（例如，在初始克隆时无法进行稀疏检出），但现在可以使用可以构建更简单接口的基本功能。

---

仅使用 Git 无法克隆子目录，但以下是一些解决方法。

过滤器分支

您可能想要重写存储库，使其看起来好像 trunk/public_html/ 是它的项目根，并丢弃所有其他历史记录（使用 filter-branch），尝试已经签出分支：

git filter-branch --subdirectory-filter trunk/public_html -- --all

^{注意：将过滤器分支选项与修订选项分开的 --，以及重写所有分支和标签的 --all。包括原始提交时间或合并信息在内的所有信息都将保留。此命令尊重 refs/replace/ 命名空间中的 .git/info/grafts 文件和引用，因此如果您定义了任何移植或替换 refs，运行此命令将使它们永久化。}

警告！重写的历史对于所有对象将具有不同的对象名称，并且不会与原始分支收敛。您将无法在原始分支之上轻松推送和分发重写的分支。如果您不知道全部含义，请不要使用此命令，并且无论如何都避免使用它，如果一个简单的单个提交就足以解决您的问题。

稀疏结帐

以下是使用 sparse checkout 方法的简单步骤，它将稀疏地填充工作目录，因此您可以告诉 Git 工作目录中的哪些文件夹或文件值得检查。

像往常一样克隆存储库（--no-checkout 是可选的）： git clone --no-checkout git@foo/bar.git cd bar 如果您已经克隆了存储库，则可以跳过此步骤。提示：对于大型存储库，考虑浅克隆（--depth 1）以仅签出最新版本或/和--single-branch。启用 sparseCheckout 选项： git config core.sparseCheckout true 指定用于稀疏签出的文件夹（末尾没有空格）： echo "trunk/public_html/*"> .git/info/sparse-checkout 或编辑 .git/info/稀疏结帐。签出分支（例如 master）： git checkout master

现在您应该已经在当前目录中选择了文件夹。

如果您有太多级别的目录或过滤分支，则可以考虑使用符号链接。

---

这将克隆特定文件夹并删除与其无关的所有历史记录。

git clone --single-branch -b {branch} git@github.com:{user}/{repo}.git
git filter-branch --subdirectory-filter {path/to/folder} HEAD
git remote remove origin
git remote add origin git@github.com:{user}/{new-repo}.git
git push -u origin master

---

我只是为 GitHub wrote a script。

用法：

python get_git_sub_dir.py path/to/sub/dir <RECURSIVE>

---

这就是我所做的

git init
git sparse-checkout init
git sparse-checkout set "YOUR_DIR_PATH"
git remote add origin https://github.com/AUTH/REPO.git
git pull --depth 1 origin <SHA1_or_BRANCH_NAME>

简单的笔记

稀疏结帐

git sparse-checkout init 许多文章会告诉你设置 git sparse-checkout init --cone 如果我添加 --cone 会得到一些我不想要的文件。

git sparse-checkout set "..." 会将 .git\info\sparse-checkout 文件内容设置为 ... 假设您不想使用此命令。相反，您可以打开 git\info\sparse-checkout 然后进行编辑。

例子

假设我想获取2文件夹^{完整的repo大小>10GB↑（包括git）}，如下图^{总大小 2MB}

铬/通用/扩展/API 铬/通用/扩展/权限

git init
git sparse-checkout init
// git sparse-checkout set "chrome/common/extensions/api/"
start .git\info\sparse-checkout   👈 open the "sparse-checkut" file

/* .git\info\sparse-checkout  for example you can input the contents as below 👇
chrome/common/extensions/api/
!chrome/common/extensions/api/commands/     👈 ! unwanted : https://www.git-scm.com/docs/git-sparse-checkout#_full_pattern_set
!chrome/common/extensions/api/devtools/
chrome/common/extensions/permissions/
*/

git remote add origin https://github.com/chromium/chromium.git
start .git\config

/* .git\config
[core]
    repositoryformatversion = 1
    filemode = false
    bare = false
    logallrefupdates = true
    symlinks = false
    ignorecase = true
[extensions]
    worktreeConfig = true
[remote "origin"]
    url = https://github.com/chromium/chromium.git
    fetch = +refs/heads/*:refs/remotes/Github/*
    partialclonefilter = blob:none  // 👈 Add this line, This is important. Otherwise, your ".git" folder is still large (about 1GB)
*/
git pull --depth 1 origin 2d4a97f1ed2dd875557849b4281c599a7ffaba03
// or
// git pull --depth 1 origin master

partialclonefilter = blob:none 我知道要添加这一行，因为我知道： git clone --filter=blob:none 它会写这一行。所以我模仿它。

混帐版本：git version 2.29.2.windows.3

---

只是为了澄清这里的一些很好的答案，许多答案中概述的步骤假设您已经在某个地方拥有一个远程存储库。

鉴于：一个现有的 git 存储库，例如 git@github.com:some-user/full-repo.git，其中包含一个或多个您希望独立提取其余存储库的目录，例如名为 app1 的目录和app2

假设您有一个如上所述的 git 存储库...

然后：您可以运行以下步骤以仅从该较大的存储库中提取特定目录：

mkdir app1
cd app1
git init
git remote add origin git@github.com:some-user/full-repo.git
git config core.sparsecheckout true
echo "app1/" >> .git/info/sparse-checkout
git pull origin master

我错误地认为必须在原始存储库上设置稀疏签出选项，但事实并非如此：您在从远程提取之前定义了本地想要的目录。远程仓库不知道也不关心您只想跟踪仓库的一部分。

希望这个澄清对其他人有所帮助。

---

这是我为单个子目录稀疏结帐的用例编写的 shell 脚本

coSubDir.sh

localRepo=$1
remoteRepo=$2
subDir=$3


# Create local repository for subdirectory checkout, make it hidden to avoid having to drill down to the subfolder
mkdir ./.$localRepo
cd ./.$localRepo
git init
git remote add -f origin $remoteRepo
git config core.sparseCheckout true

# Add the subdirectory of interest to the sparse checkout.
echo $subDir >> .git/info/sparse-checkout

git pull origin master

# Create convenience symlink to the subdirectory of interest
cd ..
ln -s ./.$localRepo/$subDir $localRepo

---

使用 Linux？并且只想要易于访问和清洁工作树？无需打扰您机器上的其余代码。尝试符号链接！

git clone https://github.com:{user}/{repo}.git ~/my-project
ln -s ~/my-project/my-subfolder ~/Desktop/my-subfolder

测试

cd ~/Desktop/my-subfolder
git status

---

我写了一个 .gitconfig [alias] 来执行“稀疏结帐”。看看（不是双关语）：

在 Windows 上运行于 cmd.exe

git config --global alias.sparse-checkout "!f(){ [ $# -eq 2 ] && L=${1##*/} L=${L%.git} || L=$2; mkdir -p \"$L/.git/info\" && cd \"$L\" && git init --template= && git remote add origin \"$1\" && git config core.sparseCheckout 1; [ $# -eq 2 ] && echo \"$2\" >> .git/info/sparse-checkout || { shift 2; for i; do echo $i >> .git/info/sparse-checkout; done }; git pull --depth 1 origin master;};f"

否则：

git config --global alias.sparse-checkout '!f(){ [ $# -eq 2 ] && L=${1##*/} L=${L%.git} || L=$2; mkdir -p "$L/.git/info" && cd "$L" && git init --template= && git remote add origin "$1" && git config core.sparseCheckout 1; [ $# -eq 2 ] && echo "$2" >> .git/info/sparse-checkout || { shift 2; for i; do echo $i >> .git/info/sparse-checkout; done }; git pull --depth 1 origin master;};f'

用法：

# Makes a directory ForStackExchange with Plug checked out
git sparse-checkout https://github.com/YenForYang/ForStackExchange Plug

# To do more than 1 directory, you have to specify the local directory:
git sparse-checkout https://github.com/YenForYang/ForStackExchange ForStackExchange Plug Folder

为了方便和存储，git config 命令被“缩小”，但这里是扩展的别名：

# Note the --template= is for disabling templates.
# Feel free to remove it if you don't have issues with them (like I did)
# `mkdir` makes the .git/info directory ahead of time, as I've found it missing sometimes for some reason
f(){
    [ "$#" -eq 2 ] && L="${1##*/}" L=${L%.git} || L=$2;
    mkdir -p "$L/.git/info"
        && cd "$L"
        && git init --template=
        && git remote add origin "$1"
        && git config core.sparseCheckout 1;
    [ "$#" -eq 2 ]
        && echo "$2" >> .git/info/sparse-checkout
        || {
            shift 2;
            for i; do
                echo $i >> .git/info/sparse-checkout;
            done
        };
    git pull --depth 1 origin master;
};
f

---

这里有很多很好的回应，但我想补充一点，在 Windows Sever 2016 上使用目录名称周围的引号对我来说失败了。文件根本没有被下载。

代替

"mydir/myfolder"

我不得不使用

mydir/myfolder

此外，如果您只想下载所有子目录，只需使用

git sparse-checkout set *

---

它对我有用-（git 版本 2.35.1）

git init
git remote add origin <YourRepoUrl>
git config core.sparseCheckout true
git sparse-checkout set <YourSubfolderName>
git pull origin <YourBranchName>

---

git init <repo>
cd <repo>
git remote add origin <url>
git config core.sparsecheckout true
echo "<path you want to clone>/*" >> .git/info/sparse-checkout
git pull --depth=1 origin <branch you want to fetch>

仅克隆此 repo 中的 Jetsurvey 文件夹的示例

git init MyFolder
cd MyFolder 
git remote add origin git@github.com:android/compose-samples.git
git config core.sparsecheckout true
echo "Jetsurvey/*" >> .git/info/sparse-checkout
git pull --depth=1 origin main

---

如果您实际上只对目录的最新修订文件感兴趣，Github 允许您将存储库下载为 Zip 文件，其中不包含历史记录。所以下载速度要快得多。

---

虽然我讨厌在处理 git repos 时实际上必须使用 svn：/ 我一直都在使用它；

function git-scp() (
  URL="$1" && shift 1
  svn export ${URL/blob\/master/trunk}
)

这允许您从 github url 复制而无需修改。用法;

--- /tmp » git-scp https://github.com/dgraph-io/dgraph/blob/master/contrib/config/kubernetes/helm                                                                                                                  1 ↵
A    helm
A    helm/Chart.yaml
A    helm/README.md
A    helm/values.yaml
Exported revision 6367.

--- /tmp » ls | grep helm
Permissions Size User    Date Modified    Name
drwxr-xr-x     - anthony 2020-01-07 15:53 helm/

---

上面有很多好的想法和脚本。我忍不住将它们组合成一个带有帮助和错误检查的 bash 脚本：

#!/bin/bash

function help {
  printf "$1
Clones a specific directory from the master branch of a git repository.

Syntax:
  $(basename $0) [--delrepo] repoUrl sourceDirectory [targetDirectory]

If targetDirectory is not specified it will be set to sourceDirectory.
Downloads a sourceDirectory from a Git repository into targetdirectory.
If targetDirectory is not specified, a directory named after `basename sourceDirectory`
will be created under the current directory.

If --delrepo is specified then the .git subdirectory in the clone will be removed after cloning.


Example 1:
Clone the tree/master/django/conf/app_template directory from the master branch of
git@github.com:django/django.git into ./app_template:

\$ $(basename $0) git@github.com:django/django.git django/conf/app_template

\$ ls app_template/django/conf/app_template/
__init__.py-tpl  admin.py-tpl  apps.py-tpl  migrations  models.py-tpl  tests.py-tpl  views.py-tpl


Example 2:
Clone the django/conf/app_template directory from the master branch of
https://github.com/django/django/tree/master/django/conf/app_template into ~/test:

\$ $(basename $0) git@github.com:django/django.git django/conf/app_template ~/test

\$ ls test/django/conf/app_template/
__init__.py-tpl  admin.py-tpl  apps.py-tpl  migrations  models.py-tpl  tests.py-tpl  views.py-tpl

"
  exit 1
}

if [ -z "$1" ]; then help "Error: repoUrl was not specified.\n"; fi
if [ -z "$2" ]; then help "Error: sourceDirectory was not specified."; fi

if [ "$1" == --delrepo ]; then
  DEL_REPO=true
  shift
fi

REPO_URL="$1"
SOURCE_DIRECTORY="$2"
if [ "$3" ]; then
  TARGET_DIRECTORY="$3"
else
  TARGET_DIRECTORY="$(basename $2)"
fi

echo "Cloning into $TARGET_DIRECTORY"
mkdir -p "$TARGET_DIRECTORY"
cd "$TARGET_DIRECTORY"
git init
git remote add origin -f "$REPO_URL"
git config core.sparseCheckout true

echo "$SOURCE_DIRECTORY" > .git/info/sparse-checkout
git pull --depth=1 origin master

if [ "$DEL_REPO" ]; then rm -rf .git; fi

---

degit 制作 git 存储库的副本。当你运行 degit some-user/some-repo 时，它会在 https://github.com/some-user/some-repo 上找到最新的提交并将相关的 tar 文件下载到 ~/.degit/some-user/ some-repo/commithash.tar.gz 如果它在本地不存在。 （这比使用 git clone 快得多，因为您没有下载整个 git 历史记录。）

degit <https://github.com/user/repo/subdirectory> <output folder>

了解更多https://www.npmjs.com/package/degit

---

您仍然可以使用 svn：

svn export https://admin@domain.example/home/admin/repos/finisht/static static --force

到“git clone”一个子目录，然后到“git pull”这个子目录。

（它不打算提交和推送。）

---

如果你想克隆 git clone --no-checkout cd 现在设置你希望拉入工作目录的特定文件/目录： git sparse-checkout set 之后，你应该硬重置您希望提取的提交的工作目录。例如，我们会将其重置为默认的 origin/master 的 HEAD 提交。 git reset --hard HEAD

现在设置您希望拉入工作目录的特定文件/目录： git sparse-checkout set

之后，您应该将您的工作目录硬重置为您希望提取的提交。例如，我们会将其重置为默认的 origin/master 的 HEAD 提交。 git reset --hard HEAD

如果你想 git init 然后远程添加 git init git remote add origin 现在设置你希望拉入工作目录的特定文件/目录： git sparse-checkout set 拉最后一次提交： git拉原点大师

现在设置您希望拉入工作目录的特定文件/目录： git sparse-checkout set

拉最后一次提交： git pull origin master

注意：如果要将另一个目录/文件添加到工作目录，可以这样做： git sparse-checkout add 如果要将所有存储库添加到工作目录，请这样做: git sparse-checkout add * 如果你想清空工作目录，这样做： git sparse-checkout set empty

如果需要，您可以通过运行以下命令查看您指定的跟踪文件的状态：

git status

如果要退出稀疏模式并克隆所有存储库，则应运行：

git sparse-checkout set *
git sparse-checkout set init
git sparse-checkout set disable

---

不知道有没有人成功拉取特定目录，这是我的经验：git clone --filter=blob:none --single-branch ，下载对象时立即取消，进入repo，然后git checkout origin/master

，忽略错误（sha1），输入目录，为每个子目录重复检出（使用新目录）。我设法以这种方式快速获取源文件

---

对于 macOS 用户

对于使用 ssh 克隆 Repos 的 zsh 用户（特别是 macOS 用户），我只是根据@Ciro Santilli 的回答创建了一个 zsh 命令：

要求：git 的版本很重要。由于 --sparse 选项，它不适用于 2.25.1。尝试将您的 git 升级到最新版本。 （例如测试 2.36.1）

示例用法：

git clone git@github.com:google-research/google-research.git etcmodel

代码：

function gitclone {
    readonly repo_root=${1?Usage: gitclone repo.git sub_dir}
    readonly repo_sub=${2?Usage: gitclone repo.git sub_dir}
    echo "-- Cloning $repo_root/$repo_sub"
    git clone \
      --depth 1 \
      --filter=tree:0 \
      --sparse \
      $repo_root \
    ;
    repo_folder=${repo_root#*/}
    repo_folder=${repo_folder%.*}
    cd $repo_folder
    git sparse-checkout set $repo_sub
    cd -
}


gitclone "$@"

---

所以我尝试了这方面的一切，但对我没有任何效果......结果是在 Git 的 2.24 版本（在这个答案时随 cpanel 一起提供的版本），你不需要这样做

echo "wpm/*" >> .git/info/sparse-checkout

您只需要文件夹名称

wpm/*

所以简而言之，你这样做

git config core.sparsecheckout true

然后，您编辑 .git/info/sparse-checkout 并在末尾添加文件夹名称（每行一个）和 /* 以获取子文件夹和文件

wpm/*

保存并运行结帐命令

git checkout master

结果是我的 repo 中的预期文件夹，如果这对你有用，没有别的 Upvote

---