linux 统计各个文件夹大小，文件个数，子文件夹个数

理解问题

深度思考完成 用时132秒

嗯，用户想用Linux统计各个文件夹的大小、文件个数和子文件夹个数。那我应该怎么帮他呢？

首先，统计文件夹大小，常用的命令是du。不过du默认显示的是磁盘使用情况，可能需要一些参数调整。比如，用du -sh *可以显示当前目录下各文件夹的大小，-s是汇总，-h是易读的格式。不过这样可能不包括隐藏文件夹，所以用户可能需要加上-a或者调整通配符。或者用du -h --max-depth=1来限制深度。

接下来是文件个数和子文件夹个数。这里可能需要find命令配合wc。比如，统计文件个数可以用find . -maxdepth 1 -type f | wc -l，这样在当前目录找一级的文件数量。不过如果是要每个子文件夹的话，可能需要遍历每个目录。或者用find加上-exec来处理。

不过用户想要的是每个文件夹的信息，可能需要一个脚本，遍历每个目录，然后分别计算大小、文件数、子文件夹数。比如用for循环遍历当前目录下的所有文件夹，然后对每个文件夹执行du、find之类的命令。

不过这样可能效率不高，尤其是当目录层次比较深的时候。或者有没有现成的工具可以用？比如ncdu，不过那是交互式的，可能不符合用户需求。或者用tree命令，不过tree的统计可能不够详细。

可能需要组合多个命令。例如，用find来递归列出所有目录，然后对每个目录执行统计。或者写一个bash脚本来处理。

比如，使用find命令获取所有目录，然后循环处理每个目录：

find /path -type d -exec sh -c 'echo "{}"; du -sh "{}"; find "{}" -maxdepth 1 -type f | wc -l; find "{}" -maxdepth 1 -type d | wc -l' ;

不过这样可能不太高效，每个目录都要启动多个find和du进程。另外，输出可能比较混乱，需要格式化一下。

或者用awk来处理输出，将每个目录的信息整理成一行，显示路径、大小、文件数、子目录数。但这样可能需要更复杂的脚本。

或者用户可能只需要当前目录下的一级子目录的信息，这时候可以用一个循环：

for d in */ ; do
du -sh "$�\mathrm{"}��ℎ�\mathrm{"}�����:$(find "$�\mathrm{"}-�������ℎ1-�����\mathrm{\mid }��-�)\mathrm{"}��ℎ�\mathrm{"}��������������:$(find "$d" -maxdepth 1 -type d | wc -l - 1)" # 减去自身
done

但这里需要注意，子目录数可能需要减去1，因为find会包括目录本身。例如，如果目录下有3个子目录，maxdepth 1的话会包括当前目录，所以实际子目录数是结果减一。

不过用户可能想要的是每个文件夹下的直接子目录数，也就是不递归。所以对于每个目录，统计其下一级的子目录数，再减一，因为find会包含目录自己。比如：

find "$d" -maxdepth 1 -type d | wc -l 的结果减去1就是子目录的数量。

那可能需要在命令中使用$(($(find ...) -1))这样的表达式。

此外，处理带有空格或特殊字符的目录名时，需要用引号括起来，避免解析错误。

综合起来，可能需要一个脚本，遍历每个目录，然后分别计算大小、文件数、子目录数。例如：

#!/bin/bash
for dir in */ ; do
echo "目录: dir" # 计算文件夹大小 du -sh "dir" | awk '{print "大小: "1}' # 统计文件数 files=(find "$���\mathrm{"}-�������ℎ1-�����\mathrm{\mid }��-�)��ℎ�\mathrm{"}\text{文件数}:$files"
# 统计子目录数（排除自身）
subdirs=$(����\mathrm{"}$dir" -maxdepth 1 -type d | wc -l)
subdirs=$((�������-1))��ℎ�\mathrm{"}\text{子目录数}:$subdirs"
echo "------------------------"
done

不过这个脚本只处理当前目录下的每个子目录。如果用户需要递归地处理所有子目录，可能需要使用find来递归获取所有目录，然后对每个目录进行统计。比如：

find /path -type d -exec sh -c 'echo "目录: {}"; du -sh "{}"; files=$(����\mathrm{"}\mathrm{"}-�������ℎ1-�����\mathrm{\mid }��-�);�������=$(find "{}" -maxdepth 1 -type d | wc -l); subdirs=$((�������-1));��ℎ�\mathrm{"}\text{文件数}:$files 子目录数: $subdirs"; echo "------"' ;

不过这样的命令会非常慢，因为每个目录都会多次调用find。尤其是当目录结构很大时，性能可能很差。有没有更高效的方法？

或许可以考虑使用一个更高效的脚本，遍历每个目录一次，同时统计文件数和子目录数。比如，使用ls -l来列出目录内容，然后进行分类统计。例如：

for dir in */ ; do
echo "目录: $���\mathrm{"}��-�ℎ\mathrm{"}$dir"
# 统计文件和子目录数
files=0
subdirs=0
for item in "$���\mathrm{"}\mathrm{/}\ast ;����[-�\mathrm{"}$item" ]; then
files=$((�����+1))����[-�\mathrm{"}$item" ]; then
subdirs=$((�������+1))��������ℎ�\mathrm{"}\text{文件数}:$files"
echo "子目录数: $subdirs"
done

这个方法可能更高效，因为它直接遍历目录中的每个条目，判断是文件还是目录。但需要注意的是，这种方法不会处理隐藏文件或目录，因为通配符默认不包括以点开头的文件。如果要包括隐藏文件，需要设置shopt -s dotglob，或者在循环中使用"$���\mathrm{"}\mathrm{/}\mathrm{.}\ast \mathrm{"}$dir"/，但这样可能会重复处理.和..，需要排除掉。

比如：

shopt -s dotglob
for dir in */ ; do
echo "目录: $���\mathrm{"}��-�ℎ\mathrm{"}$dir"
files=0
subdirs=0
for item in "$���\mathrm{"}\mathrm{/}\ast ;����[-�\mathrm{"}$item" ]; then
files=$((�����+1))����[-�\mathrm{"}$item" ]; then
# 排除.和..
if [ "$����\mathrm{"}!=\mathrm{"}$dir/." ] && [ "$����\mathrm{"}!=\mathrm{"}$dir/.." ]; then
subdirs=$((�������+1))����������ℎ�\mathrm{"}\text{文件数}:$files"
echo "子目录数: $subdirs"
done
shopt -u dotglob

不过这样处理起来可能比较复杂，尤其是在处理隐藏文件的时候。而且，如果用户想要包括隐藏文件的话，需要考虑进去。

或者，使用ls -A来列出除.和..之外的所有条目：

for item in $(��-�\mathrm{"}$dir"); do
...
done

但这样可能会有问题，如果文件名中有空格或者换行符的话，会解析错误。更好的做法是使用find命令，或者在循环中使用通配符。

或者，可以调整find命令的参数，例如：

统计某个目录下的文件数（包括隐藏文件）：find "$dir" -maxdepth 1 -type f | wc -l

同样，子目录数：find "$dir" -maxdepth 1 -mindepth 1 -type d | wc -l，这样就不会包括目录自身，所以不用减一。

例如：

subdirs=$(����\mathrm{"}$dir" -maxdepth 1 -mindepth 1 -type d | wc -l)

这样更准确，因为-mindepth 1会排除掉目录本身，所以直接统计子目录的数量。

这可能更可靠，所以之前的例子可以修改，使用find的-mindepth参数。

因此，改进后的脚本可能如下：

#!/bin/bash
for dir in */ ; do
echo "目录: $���\mathrm{"}��-�ℎ\mathrm{"}$dir" | awk '{print "大小: "1}' files=(find "$���\mathrm{"}-�������ℎ1-�����\mathrm{\mid }��-�)�������=$(find "$���\mathrm{"}-�������ℎ1-�������ℎ1-�����\mathrm{\mid }��-�)��ℎ�\mathrm{"}\text{文件数}:$files"
echo "子目录数: $subdirs"
echo "------------------------"
done

这样每个目录的大小由du -sh给出，文件数用find查找，子目录数同样用find，但使用-mindepth 1来排除父目录自身，这样结果就是子目录的数量，不需要减一。

不过，当处理当前目录下的子目录时，用户可能想要包括隐藏文件夹吗？比如，假设有一个目录是.git，它可能以.开头。那么原来的循环中的*/ 通配符是否包含这些隐藏目录？

在Bash中，/ 会匹配所有以非.开头的目录名，即默认不包括隐藏目录。如果要包括隐藏目录，需要设置shopt -s dotglob，或者在循环中使用/ .*/，但这样可能会包括.和..，需要处理。

例如：

shopt -s dotglob
for dir in */ ; do
# 排除当前目录和父目录
if [ "$���\mathrm{"}==\mathrm{"}\mathrm{.}\mathrm{/}\mathrm{"}]\mathrm{\mid }\mathrm{\mid }[\mathrm{"}$dir" == "../" ]; then
continue
fi
...
done
shopt -u dotglob

不过这可能变得复杂。或者，用户可能希望包括隐藏目录，但原问题中并没有明确说明。可能默认情况下，用户只需要非隐藏的目录，所以原来的脚本就足够了。如果用户需要包括隐藏目录，那可能需要调整通配符的设置。

回到用户的问题，用户可能希望统计所有子文件夹的信息，而不仅仅是当前目录下的。例如，如果有一个目录结构，用户想要每个目录的大小、文件数、子目录数。这时候可能需要递归处理所有子目录。

或者，用户可能只需要当前目录下的每个子目录的信息。比如，在/home/user下，统计每个子目录的大小、文件数、子目录数。

如果是这样的话，原来的脚本是可行的。如果用户想要递归处理所有子目录，可能需要调整脚本。

比如，递归遍历所有目录，并输出每个目录的信息：

find . -type d -exec bash -c '
dir="$1\mathrm{"}��ℎ�\mathrm{"}\text{目录}:$dir"
du -sh "dir" | awk "{print \"大小: \"\1}"
files=$(����\mathrm{"}$dir" -maxdepth 1 -type f | wc -l)
subdirs=$(����\mathrm{"}$dir" -maxdepth 1 -mindepth 1 -type d | wc -l)
echo "文件数: $�����\mathrm{"}��ℎ�\mathrm{"}\text{子目录数}:$subdirs"
echo "------------------------"
' _ {} ;

不过这样做的话，每个目录都会触发一个子shell，执行多次find，效率可能很低，特别是目录很多的时候。这时候可能需要一个更高效的解决方案，比如使用ls或stat命令。

或者，可以写一个更复杂的脚本，使用深度优先遍历，同时在遍历过程中统计文件数和子目录数，但这样可能比较复杂。

另一个想法是，使用du命令来获取每个目录的大小，同时结合find来统计文件和子目录的数量。例如：

du -h --max-depth=1

可以显示当前目录下各子目录的大小，然后结合其他命令统计文件和子目录数。

不过这可能不够灵活，需要结合其他工具。

或者使用tree命令，tree可以显示目录中的文件和目录数量，例如：

tree -d -L 1 # 显示目录
tree -L 1 # 显示文件和目录

但tree的输出可能需要解析才能提取数量。例如：

tree -L 1 --noreport

这会列出当前目录下的文件和目录，最后不会显示报告。比如：

.
├── dir1
├── dir2
├── file1
└── file2

但这样的输出不太容易提取数量。不过，tree有一个选项可以输出统计信息：

tree -L 1 --noreport -d

这会显示当前目录下的子目录数量，但是不包括文件。或者，使用tree的-i参数来生成列表，然后进行处理。

或者，可以考虑以下命令组合：

统计文件数：
tree -a --noreport -L 1 -i -f | grep -v '/' | wc -l

统计目录数：
tree -a --noreport -L 1 -i -d -f | grep '/' | wc -l

不过这可能不可靠，特别是处理包含特殊字符的目录名时。

回到原问题，用户可能希望一个简单的方法，比如结合du和find。例如：

显示当前目录下各子目录的大小、文件数和子目录数：

for d in */; do
echo "$�\mathrm{"}��-�ℎ\mathrm{"}$d"
echo "文件数: $(����\mathrm{"}$d" -maxdepth 1 -type f | wc -l)"
echo "子目录数: $(����\mathrm{"}$d" -maxdepth 1 -mindepth 1 -type d | wc -l)"
done

这应该可以输出每个子目录的信息。不过对于每个子目录，执行了三个命令：du和两个find，这可能在目录很大时效率不高。

可能用户需要一个更高效的方式，但考虑到大多数情况下的目录结构不会过于庞大，这样的方法已经足够。

因此，总结一下，给出一个可以执行的命令组合或脚本，能够遍历每个子目录，统计大小、文件数、子目录数。同时，需要注意处理隐藏目录的问题，如果需要的话。

最后，用户可能需要将这些信息整理成表格形式，或者更易读的格式。例如，使用printf来对齐输出：

for d in */; do
size=$(��-�ℎ\mathrm{"}$d" | cut -f1)
files=$(����\mathrm{"}$d" -maxdepth 1 -type f | wc -l)
subdirs=$(����\mathrm{"}$d" -maxdepth 1 -mindepth 1 -type d | wc -l)
printf "目录: %-20s 大小: %-6s 文件数: %-4s 子目录数: %-4s\n" "$�\mathrm{"}\mathrm{"}$size" "$�����\mathrm{"}\mathrm{"}$subdirs"
done

这样可以让输出更整齐。

另外，用户可能需要递归处理所有子目录，这时候可以使用find来获取所有目录，然后对每个执行上述统计：

find . -type d -exec bash -c '
dir="$1\mathrm{"}����=$(du -sh "$���\mathrm{"}\mathrm{\mid }���-�1)�����=$(find "$���\mathrm{"}-�������ℎ1-�����\mathrm{\mid }��-�)�������=$(find "$���\mathrm{"}-�������ℎ1-�������ℎ1-�����\mathrm{\mid }��-�)������\mathrm{"}\text{目录}:$dir" "$����\mathrm{"}\mathrm{"}$files" "$subdirs"
' _ {} ;

这样会遍历所有子目录，但同样存在性能问题，尤其是目录数量多时。

可能用户需要根据具体需求来选择合适的方法。如果只是当前目录下的子目录，使用简单的循环即可；如果需要递归所有目录，则使用find结合脚本。

最后，应该提醒用户注意命令执行时的权限问题，比如某些目录可能无法访问，导致统计错误。此外，处理包含空格或特殊字符的目录名时，确保使用引号。

在Linux中，可以使用以下方法统计各个文件夹的大小、文件个数和子文件夹个数：

方法一：当前目录的一级子文件夹统计

bashCopy Codefor d in */; do
    echo "目录: $d"
    du -sh "$d" | awk '{print "大小: "$1}'
    files=$(find "$d" -maxdepth 1 -type f | wc -l)
    subdirs=$(find "$d" -maxdepth 1 -mindepth 1 -type d | wc -l)    echo "文件数: $files"
    echo "子目录数: $subdirs"
    echo "------------------------"done

‌说明‌：

• 遍历当前目录下所有一级子文件夹（不包括隐藏文件夹）。

• du -sh 显示文件夹大小。

• find 命令统计文件和子目录数量。

方法二：递归统计所有子文件夹（包括隐藏文件夹）

bashCopy Codefind . -type d -exec bash -c '
    dir="$1"
    size=$(du -sh "$dir" | cut -f1)
    files=$(find "$dir" -maxdepth 1 -type f | wc -l)
    subdirs=$(find "$dir" -maxdepth 1 -mindepth 1 -type d | wc -l)
    printf "目录: %-40s 大小: %-6s 文件数: %-4s 子目录数: %-4s\n" "$dir" "$size" "$files" "$subdirs"
' _ {} \;

‌说明‌：

• 使用 find 递归遍历所有子文件夹（包括隐藏文件夹）。

• 输出格式更整齐，包含路径、大小、文件数和子目录数。

方法三：使用格式化输出（仅一级子文件夹）

bashCopy Codeshopt -s dotglob  # 包括隐藏文件夹for d in */; do
    size=$(du -sh "$d" | cut -f1)
    files=$(find "$d" -maxdepth 1 -type f | wc -l)
    subdirs=$(find "$d" -maxdepth 1 -mindepth 1 -type d | wc -l)    printf "目录: %-20s 大小: %-6s 文件数: %-4s 子目录数: %-4s\n" "$d" "$size" "$files" "$subdirs"doneshopt -u dotglob

‌说明‌：

• shopt -s dotglob 包含以 . 开头的隐藏文件夹。

• 使用 printf 对齐输出，便于阅读。

参数解释：

• du -sh <目录>：统计文件夹大小（-s 汇总，-h 易读格式）。

• find -type f：查找文件。

• find -type d：查找文件夹。

• -maxdepth 1：仅当前目录层级。

• -mindepth 1：排除自身目录。

示例输出：

textCopy Code目录: ./Documents/               大小: 256M   文件数: 120  子目录数: 5
目录: ./Downloads/              大小: 1.2G   文件数: 45   子目录数: 3
目录: ./.config/                大小: 15M    文件数: 8    子目录数: 2

注意事项：

• 若目录名包含空格或特殊字符，确保变量用双引号包裹（如 "$d"）。

• 递归统计时性能可能较低，建议根据实际需求选择方法。

• 权限不足的目录可能无法访问，需使用 sudo 提升权限。

哪种方法更适合大型文件夹？

如何排除特定文件夹进行统计？

能否提供一个更简洁的统计脚本？

by cruboy