批处理之家 - Powered by Discuz! Board

标题: [系统相关] 批处理如何查找完全相同的文件夹？ [打印本页]

作者: arter369 时间: 2017-1-15 15:46 标题: 批处理如何查找完全相同的文件夹？

一个或几个文件夹中有很多子文件夹，其中有些子文件夹里面的内容完全一模一样，如何把这些完全相同的子文件夹（注意：不是文件）从众多的文件夹中找出来，便于删除？

请不吝指教。谢谢。

作者: 523066680 时间: 2017-1-16 10:54

http://bbs.bathome.net/viewthrea ... C8%C8%FC&page=1

参考第九题以及后面其他论坛会员的方案

作者: taofan712 时间: 2017-1-17 15:42

本帖最后由 taofan712 于 2017-1-17 15:44 编辑

小菜鸟借楼继续提问，请问下我的代码为什么在处理tmp.txt的时候，没能把重复的行找出来？
我想的是把楼主问题里的文件夹的几个特征（文件个数，对象个数，字节大小）写进tmp.txt，然后对比字节大小，相同的就写进结果文本。再根据文件个数等特征肉眼判断文件夹是否一模一样。。。。。

@echo off
setlocal enabledelayedexpansion
for /f "delims=" %%a in ('dir /ad /b /s f:\test') do (
for /f %%b in ('dir /a /b %%~fa^|find /v /c ""') do set  n=%%b 
for /f "delims=" %%c in ('dir %%~fa^|find "个文件"') do set m=%%c 
set str=!n!_!m:~0,-3!
echo %%~fa  !str!>>tmp.txt
)
for /f "tokens=1,2,3,4,5 delims= " %%i in (tmp.txt) do (
echo %%i %%j %%k %%l %%m & pause>nul
 if not defined %%m (set %%m=D
) else (find "%%m" tmp.txt>>rst.txt & echo _____>>rst.txt)
)
复制代码

作者: 523066680 时间: 2017-1-17 21:19

本帖最后由 523066680 于 2017-1-17 22:40 编辑

回复 3# taofan712

以前考虑过，但是过了太久，忘了遇到什么问题了。

回想一下吧：

可能会遇到目录自身的链接而陷入无限递归的情况(symbolic link)，然后 dir /s 就输出大量冗余的结果并提示 “文件名太长”。
虽然 dir 会告诉你这是个 <JUNCTION>
举个例子
```
set name=abcdefghijklmnopqrstuvwxyz
mkdir %name%
mklink /J .\%name%\%name% .\%name%
复制代码
```
可能会遇到非一般GBK字符的文件名，比如 "董贞・ 01.剑如虹.[贞江湖].mp3"，需要确保能够正确访问这些文件的信息。
如果使用文件短名，也可能出现冲突的情况
当对比到两个目录内的文件一致的时候，它们的上一级目录也可能是完全一致的，甚至上上层，也意味着会有很多相同的子目录被冗余地显示出来。

准备用 C 配合 Perl 实现判断相同目录的程序，要做的事情很多，看心情吧

作者: GNU 时间: 2017-1-18 13:22

回复 3# taofan712

两个字节数相同的文件，它们的内容可能不同，根据这种判断来删除文件夹是不是风险太大啦，没啥实用价值吧。

作者: 523066680 时间: 2017-1-18 14:34

本帖最后由 523066680 于 2017-1-18 14:50 编辑

回复 5# GNU

列出疑似相同的目录然后可以做进一步的深层的对比，然后将结果列举作为参考，并非即刻删除。
至于实用价值，你不需要，不代表别人用不上。

举例一个场景，某职位频繁更换职员，新上任的职员一般会对之前的资料复制副本保存在某个位置（最外层目录名可能被修改）。
但是有一任职员突然辞职，未能完成交接。而电脑上的资料又非常重要，目录体系非常复杂，且占用磁盘。
刚上任的职员如果在不了解文件名（但是懂程序）的情况下，如何找到分布在磁盘的冗余的目录副本？

关于判断文件是否相同，用 MD5 校验值即可保证准确度（文件越大越耗时）。

作者: GNU 时间: 2017-1-18 14:59

回复 6# 523066680

我很赞同，希望对楼主有用。

作者: taofan712 时间: 2017-1-18 15:42

回复 5# GNU

先找到字节一样大小的，然后根据其他特征判断啊，比如文件数量，子文件夹数量，这两个特征也相同的话，应该是90%以上的可能是文件夹重复了。

作者: GNU 时间: 2017-1-18 17:29

回复 8# taofan712

同意。希望楼主不在乎剩下10%的误删概率。

作者: 523066680 时间: 2017-1-18 18:10

本帖最后由 523066680 于 2017-1-18 20:34 编辑

8楼人家说的概率是草率了点，可是人家没说删除呀。

希望楼主，希望楼主，楼主的心都让你操碎了。

想起之前看的一篇文章：有用，无用

作者: 523066680 时间: 2017-1-18 21:10

本帖最后由 523066680 于 2017-1-18 21:21 编辑

初步达到清除冗余信息的要求，
对以E盘备份资料处理了一次，贴部分结果，代码有待完善。

处理方法：
将目录树的信息整个重组为 Perl 的哈希（键值对）数据结构。将每个目录下的结构信息dump出来，作为字符串，
使用 md5 函数转成 MD5校验值作为标记，减少大量字符串对比的开销、内存开销。

信息去重：
获得第一阶段的疑似重复目录信息后，有很多是多余的结果，
清理方法：如果某一组目录是另一组目录的子目录，进行排除。（比较折腾就是了）

优化考虑：
通过文件累计数量 / 文件累计大小作为阀值，只输出足够复杂且内容相同的目录树（那些微不足道的暂时pass或另外输出）。

E:\售后\以色列升级工具\USB Debug Tool\USB_debug_tool_driver\tool\MProg 2.3
E:\S烧录程序_软件\升级工具MST712齐总\USB_debug_tool_driver\tool\MProg 2.3
E:\售后\DVD升级工具 for 印尼谢总\USB Debug Tool\USB_debug_tool_driver\tool\MProg 2.3
{
  "Drivers"         => {
                         "D2XX Release Info.txt" => {},
                         "FT8U2XX.RES"           => {},
                         "Ftccomms.vxd"          => {},
                         "FTCSENUM.SYS"          => {},
                         "FTCSENUM.VXD"          => {},
                         "FTCSER.INF"            => {},
                         "FTCSER2K.SYS"          => {},
                         "ftcser98.sys"          => {},
                         "FTCSMOU.INF"           => {},
                         "FTCSMOU.VXD"           => {},
                         "FTCSUI.DLL"            => {},
                         "FTCSUI2.DLL"           => {},
                         "ftcun2k.ini"           => {},
                         "ftcun98.ini"           => {},
                         "ftcunin.exe"           => {},
                         "FTCUSB.INF"            => {},
                         "FTCUSB.SYS"            => {},
                         "FTD2XX.DLL"            => {},
                         "Ftd2xx.h"              => {},
                         "FTD2XX.INF"            => {},
                         "FTD2XX.LIB"            => {},
                         "FTD2XX.SYS"            => {},
                         "Ftd2xxpg.rtf"          => {},
                         "FTD2XXUN.EXE"          => {},
                         "FTD2XXUN.INI"          => {},
                         "PG_Extra.doc"          => {},
                         "ReleaseNotes.doc"      => {},
                       },
  "FTD2XX.DLL"      => {},
  "FTUninstall.bat" => {},
  "Help"            => { "MProg.chm" => {} },
  "license.txt"     => {},
  "MProg.exe"       => {},
  "Templates"       => {
                         "com2p.ept"    => {},
                         "default.ept"  => {},
                         "default1.ept" => {},
                         "MSTAR.ept"    => {},
                       },
  "uninstall.exe"   => {},
  "uninstall.ini"   => {},
}
复制代码

作者: Nsqs 时间: 2017-1-18 21:35

这个问题用批处理来做本身就不合理,代码量大大超出了使用价值.用其他更好的语言来写就能简单完成.
要考虑的不单单是完全相同那么简单,如果文件夹里面的文件是几个G你确定你还能继续用bat来解决此问题?

作者: 523066680 时间: 2017-1-18 21:35 标题: 目录树结构转 Perl 哈希结构

本帖最后由 523066680 于 2017-1-18 21:39 编辑

=info
    Code by 523066680@163.com
=cut

# 备注，可能遇到 Unicode 文件名路径，
# 暂时使用系统 cmd /U /c dir 生成路径列表

use Encode;
use IO::Handle;
use Data::Dump qw/dump dd/; 

our $hash = {};
my $gstr;

{
    local $/ = "\x0d\x00\x0a\x00";

    print "getting file lists ...\n";
    @files = `cmd /U /c dir /s /b C:\\MinGW`;

    print "Deal ...\n";
    for my $n ( 0 .. $#files )
    {
        $files[$n] =~s/\x0d\x00\x0a\x00//;
        $gstr = encode('gbk', decode('utf16-le', $files[$n]));
        toStruct( $gstr );
    }
}

#举个栗子
dd( $hash->{'C:'}{'MinGW'}{'include'}{'boost'}{'accumulators'} );

sub toStruct
{
    my $path = shift;
    my @parts = split(/[\/\\]/, $path);
    my $ref;
    $ref = $hash;

    grep
    {
        $ref->{$_} = {} unless ( exists $ref->{$_} );
        $ref = $ref->{$_};
    }
    @parts;
}
复制代码

部分 Dump 结果

getting file lists ...
Deal ...
{
  "accumulators.hpp"     => {},
  "accumulators_fwd.hpp" => {},
  "framework"            => {
                              "accumulator_base.hpp"    => {},
                              "accumulator_concept.hpp" => {},
                              "accumulator_set.hpp"     => {},
                              "accumulators"            => {
                                                             "droppable_accumulator.hpp" => {},
                                                             "external_accumulator.hpp"  => {},
                                                             "reference_accumulator.hpp" => {},
                                                             "value_accumulator.hpp"     => {},
                                                           },
                              "depends_on.hpp"          => {},
                              "external.hpp"            => {},
                              "extractor.hpp"           => {},
                              "features.hpp"            => {},
                              "parameters"              => {
                                                             "accumulator.hpp" => {},
                                                             "sample.hpp"      => {},
                                                             "weight.hpp"      => {},
                                                             "weights.hpp"     => {},
                                                           },
                            },
  "numeric"              => {
                              "detail" => {
                                "function1.hpp"     => {},
                                "function2.hpp"     => {},
                                "function3.hpp"     => {},
                                "function4.hpp"     => {},
                                "function_n.hpp"    => {},
                                "pod_singleton.hpp" => {},
                              },
                              "functional" => { "complex.hpp" => {}, "valarray.hpp" => {}, "vector.hpp" => {} },
                              "functional.hpp" => {},
                              "functional_fwd.hpp" => {},
                            },
复制代码

对于文件/目录辨别、符号链接(symbolic link)判断、文件大小等属性的提取，Perl 也不太合适，
还是 C 实在，从根本解决问题，已经写了一部分功能

作者: GNU 时间: 2017-1-18 21:44

回复 10# 523066680

别瞎说，我没有操楼主的心。不信你问问楼主。我无所谓。你胡乱玷污楼主滴清白，小心楼主告你造谣。

作者: 523066680 时间: 2017-1-19 16:52

本帖最后由 523066680 于 2017-1-19 17:21 编辑

备注：

使用过程将在 D 盘生成 dirs.txt 和 md5map.txt，dirs.txt 为dir输出结果（Unicode），
md5map为所有目录的校验值
使用cmd /U /c 执行 dir 命令以确保Unicode字符的完整输出
使用 YAML::Tiny Dump 替代 Data:ump，减少结构体输出的体积
内存占用情况：如果 dir 导出的文件大小为 100MB，则内存占用约为 250MB
冗余信息的处理：
假设某个目录存在副本，且子目录下也存在副本
```
├─Fold
│  ├─a
│  └─a - 副本
└─Fold - 副本
    ├─a
    └─a - 副本
复制代码
```
程序将只显示 fold 这一层的结果。但是，如果在副本的中间某一层存在差异，则会详尽地列出相同的子目录
效率：个人PC（双核4G旧主机蓝标硬盘），dir /a /s /b D: ，254506 行数据，从 dir 到 Perl 输出判断结果
耗时 58 秒
该 Perl 代码可读性：自带混淆
未完待续

=info
    Code by 523066680@163.com
    2017-01
=cut
use Encode;
use IO::Handle;
use Digest::MD5 qw/md5_hex/;
use YAML::Tiny;
STDOUT->autoflush(1);

print "Dir ...\n";
#system("cmd /U /c dir /a /s /b C:\\ >D:\\dirs.txt");

print "Path to struct ...\n";
our $hash = {};
our @lines;
our %fold_md5;
our %md5map;
my $gstr;

open READ,"<:raw",'D:\\dirs.txt';
{
    local $/ = "\x0d\x00\x0a\x00";
    while ($line = <READ>)
    {
        $line =~s/\x0d\x00\x0a\x00//;
        $gstr = encode('gbk', decode('utf16-le', $line));
        push @lines, $gstr;
        toStruct( $gstr );
    }
}
close READ;

print "Compare ...\n";
compare();

sub compare
{
    my @parts;
    my $ref;
    my $md5;

    print "Getting md5 information ...\n";
    open WRT, ">:raw", "D:\\md5map.txt";
    for my $i ( 0 .. $#lines )
    {
        @parts = split(/[\/\\]/, $lines[$i]);
        $ref = $hash;
        grep { $ref = $ref->{$_} } ( @parts );   #将引用迭代到路径的最后一层
        next if (! keys %{$ref} );               #如果没有下一层文件内容则略过
        
        $md5 = md5_hex( Dump($ref) );
        $fold_md5{ $lines[$i] } = $md5;

        print WRT $md5 ." ". encode('utf8', decode('gbk', $lines[$i])) ."\n";
    }
    close WRT;


    for my $k ( keys %fold_md5 )
    {
        $md5 = $fold_md5{$k};
        push @{ $md5map{$md5} }, $k;
    }

    #去重，如果一组MD5内容相同的目录，且它们上一级目录的MD5也相同
    #则无需列出。
    print "Cut repeat case ...\n";
    my $tp;
    my $prev;
    for my $m ( keys %md5map )
    {
        if ( $#{$md5map{$m}} > 0  )
        {
            undef $md5;
ST:         for my $p ( @{ $md5map{$m} } )
            {
                #取得上一层路径
                $tp = $p;
                $tp =~ s/(\\|\/)[^\\\/]+$//;

                if (    ( defined $md5 )
                    and ( $md5 eq $fold_md5{$tp} ) #MD5相同
                    and ( $prev ne $tp )           #并且不是相邻目录
                    #例如 "Fold\a" "Fold\a副本" 的上一级都是 Fold，md5一致
                )
                {
                    delete $md5map{$m};
                    last ST;
                }
                else
                {
                    $md5 = $fold_md5{$tp};
                }
                $prev = $tp;
            }
        }
        else
        {
            #删除没必要列出的情况
            delete $md5map{$m};
        }
    }

    print "Find same folder\n";
    for my $k ( keys %md5map )
    {
        print join("\n", @{$md5map{$k}} );
        print "\n";
        #dump_byPath( $md5map{$k}->[0] );
        print "\n";
    }
}

sub dump_byPath
{
    my $path = shift;
    my $ref = $hash;
    for my $e ( split(/[\/\\]/, $path) )
    {
        $ref = $ref->{$e};
    }
    print Dump( $ref );
}

sub toStruct
{
    my $path = shift;
    my @parts = split(/[\/\\]/, $path);
    my $ref;
    $ref = $hash;

    for my $e ( @parts )
    {
        if ( not exists $ref->{$e} ) #如果不加判断，会不断地替换，最后只有一个路径的结构
        {
            $ref->{$e} = {};
        }
        $ref = $ref->{$e};
    }
}
复制代码

作者: 523066680 时间: 2017-1-20 15:19 标题: 这个时侯需要C的助攻了

本帖最后由 523066680 于 2017-1-20 16:27 编辑

枚举目录内容，如果是文件在开头给出尺寸，如果是文件夹，在开头给出 DIR 或者 FOLD 的标记，遇到链接自动绕开
输出UNICODE编码的字符。

须使用 g++ 编译

/*
    Code by:523066680@163.com
    2017-01
*/

#include <stdio.h>
#include <fcntl.h>
#include <dirent.h>
#include <wchar.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <string.h>
#include <windows.h>

#define NAME_MAX 10240

void func(wchar_t path[]);
void console_print(const wchar_t str[]);
void CheckConsoleRedirect(void);

DWORD written = 0;
static bool g_bRedirect = false;

int wmain(int argc, wchar_t *argv[] ) 
{
    wchar_t pth[NAME_MAX] = L"D:\\Extra\\";
    
    //首先判断是否为重定向
    CheckConsoleRedirect();

    if ( argc >= 2 )
    {
        if ( argv[1][wcslen(argv[1])-1] == '\\' )
            swprintf(pth, L"%ls", argv[1] );
        else
            swprintf(pth, L"%ls\\", argv[1] );
    }

    func( pth );

    return 0;
}

void func( wchar_t path[] )
{
    DWORD attr;
    _WDIR * a = _wopendir(path);
    _wdirent * dp;
    _WDIR * aa;
    struct stat stbuf;
    wchar_t full_info[NAME_MAX] = L"";

    WCHAR fullpath[NAME_MAX] = L"";

    swprintf(full_info, L"FOLD: %ls\r\n", path );
    console_print( full_info );

    //打印目录内容
    while ( dp = _wreaddir(a) )
    {
        //排除 当前文件夹 和 上一级 文件夹
        if ( 
               ( wcscmp(dp->d_name, L"." )  == 0 )
            || ( wcscmp(dp->d_name, L".." ) == 0 )
        )
        { continue; }
        swprintf(fullpath, L"%ls%ls", path, dp->d_name);
        wstat(fullpath, &stbuf);
        attr = GetFileAttributesW(fullpath);

        //排除符号链接类型的文件和目录
        if ( (attr & FILE_ATTRIBUTE_REPARSE_POINT) != FILE_ATTRIBUTE_REPARSE_POINT )
        {
            if ( (attr & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY )
            {
                swprintf(full_info, L"%16ls %ls\r\n", L"DIR", dp->d_name );
                console_print( full_info );
            }
            else
            {
                swprintf(full_info, L"%16lld %ls\r\n", stbuf.st_size, dp->d_name );
                console_print( full_info );
            }
        }
    }
    _wclosedir(a);

    //递归流程
    a = _wopendir(path);
    while ( dp = _wreaddir(a) )
    {
        //排除 当前文件夹 和 上一级 文件夹
        if ( 
               ( wcscmp(dp->d_name, L"." )  == 0 )
            || ( wcscmp(dp->d_name, L".." ) == 0 )
        )
        {
            continue;
        }

        swprintf(fullpath, L"%ls%ls", path, dp->d_name);
        attr = GetFileAttributesW(fullpath);

        //排除符号链接类型的文件和目录
        if ( (attr & FILE_ATTRIBUTE_REPARSE_POINT) != FILE_ATTRIBUTE_REPARSE_POINT )
        {
            if ( (attr & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY )
            {
                swprintf(fullpath, L"%ls%ls\\", path, dp->d_name);
                func( fullpath );
            }
        }
    }
    _wclosedir(a);
}

void console_print(const wchar_t str[])
{
    if ( ! g_bRedirect )
    {
        WriteConsoleW(
            GetStdHandle(STD_OUTPUT_HANDLE), str, wcslen(str)  , &written, NULL
        );
    }
    else
    {
        WriteFile(
            GetStdHandle(STD_OUTPUT_HANDLE), str, wcslen(str) * sizeof( str[0] ) , &written, NULL
        );
    }
}

void CheckConsoleRedirect(void)
{
    if (!GetConsoleMode(GetStdHandle(STD_OUTPUT_HANDLE), &written))
    {
        g_bRedirect = true;
        WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), "\xFF\xFE", 2, &written, 0);
    }
}
复制代码

输出的一部分示例：

Fold: D:\Extra\
       21253 065738_6eeL_1428332.jpg
      362664 1440339f6bzggbp0x16gp3.jpg
      398975 144034a5tty5g2s2azd3bg.jpg
      229915 144037xhfh2jhzh1g1b2jf.jpg
       40421 6cc028c79f3df8dc7a6e5322cd11728b461028c5.jpg
     1853657 7cefdfa5jw1ez6iowueepg206l067qv5.gif
         DIR Book
    11714560 freetype-2.4.0.tar
     2903989 ft27.zip
         DIR graphics
复制代码

如此一来可以顺便写一个文件夹按大小排序的脚本。

作者: 523066680 时间: 2017-1-20 16:58

感谢 happy886rr 的加分。

刚刚测试这个 C 有点问题，在遇到大于 4G 的文件时输出的文件大小不正确（超过4字节的溢出）。
把 stat() 改为 _wstat64()
把 struct stat 改为 struct _stat64
以及 printf 中的 %ld 改为 %lld 即可

作者: 523066680 时间: 2017-1-20 17:32 标题: 基本完成我要的功能 - 按占用大小来枚举

现在可以设定一个阀值，比如值列出大小超过100MB 且内容疑似相同的文件夹

代码自带混淆，看官自觉绕道

=info
    Code by 523066680@163.com
    2017-01
=cut

use Encode;
use IO::Handle;
use Digest::MD5 qw/md5_hex/;
use YAML::Tiny;
STDOUT->autoflush(1);

print "Getting file list ...\n";
system('listv1.3 D: >D:\a.txt');

our $hash = {};
our @lines;
our %fold_md5;
our %md5map;
my $gstr;
my $ref;

print "Path to struct ...\n";
open READ,"<:raw",'D:\a.txt';
seek(READ, 2, 0);
{
    local $/ = "\x0d\x00\x0a\x00";
    while ($line = <READ>)
    {
        $line =~s/\x0d\x00\x0a\x00//;
        $gstr = encode('gbk', decode('utf16-le', $line));
        if ( $gstr=~s/^FOLD: //i )
        {
            $ref = toStruct( $gstr );
            push @lines, $gstr;
        }
        else
        {
            if ( $gstr=~s/^\s+(\d+) // )
            {
                $ref->{$gstr} = $1;
            }
            else
            {
                #nothing to do
            }
        }
    }
}
close READ;

print "Compare ...\n";
compare();

sub compare
{
    my @parts;
    my $ref;
    my $md5;

    print "Getting md5 information ...\n";
    open WRT, ">:raw", "D:\\md5map.txt";
    for my $i ( 0 .. $#lines )
    {
        @parts = split(/[\/\\]/, $lines[$i]);
        $ref = $hash;
        grep { $ref = $ref->{$_} } ( @parts );   #将引用迭代到路径的最后一层
        next if (! keys %{$ref} );               #如果没有下一层文件内容则略过
        
        $md5 = md5_hex( Dump($ref) );
        $fold_md5{ $lines[$i] } = $md5;

        print WRT $md5 ." ". encode('utf8', decode('gbk', $lines[$i])) ."\n";
    }
    close WRT;

    for my $k ( keys %fold_md5 )
    {
        $md5 = $fold_md5{$k};
        push @{ $md5map{$md5} }, $k;
    }

    my $info = { 'sizes' => 0,
                 'folds' => 0,
                 'files' => 0 };

    print "Find same folder\n";
    for my $k ( keys %md5map )
    {
        if ( $#{$md5map{$k}} > 0 )
        {
            @parts = split(/[\/\\]/, $md5map{$k}->[0] );
            $info = { 'sizes' => 0, 'folds' => 0, 'files' => 0 };
            $ref = $hash;
            grep { $ref = $ref->{$_} } ( @parts );
            Summarize( $ref, $info );

            if ( $info->{sizes} > 1024*1024*100 ) #100MB
            {
                print int($info->{sizes}/1024/1024) ."mb\n";
                print join("\n", @{$md5map{$k}} );
                print "\n\n";
                #dump_byPath( $md5map{$k}->[0] );
            }
        }
    }
}

sub dump_byPath
{
    my $path = shift;
    my $ref = $hash;
    for my $e ( split(/[\/\\]/, $path) )
    {
        $ref = $ref->{$e};
    }
    print Dump( $ref );
}

#获取某个目录的文件大小总和
sub Summarize
{
    my ($ref, $info) = (shift, shift);

    for my $k ( keys %{$ref} )
    {
        if (ref( $ref->{$k} ) eq 'HASH')
        {
            $info->{folds} ++;
            Summarize( $ref->{$k}, $info );
        }
        else
        {
            $info->{files} ++;
            $info->{sizes} += $ref->{$k};
        }
    }
}

sub toStruct
{
    my $path = shift;
    my @parts = split(/[\/\\]/, $path);
    my $ref;
    $ref = $hash;

    for my $e ( @parts )
    {
        if ( not exists $ref->{$e} )
        {
            $ref->{$e} = {};
        }
        $ref = $ref->{$e};
    }
    return $ref;
}
复制代码

输出示例：

117mb
D:\Local\Dict\Youdao\Source\
D:\Dupl\Dict\有道\

506mb
D:\Dupl\设计软件\CoreldrawX5+资料\coreldraw x5\coreldraw x5\CGS15\
D:\Program Files (x86)\Corel\CorelDRAW Graphics Suite X5\Setup\CGS15\

1503mb
D:\3DGameProgramming\Figures\
D:\Data\Books\Book IV\Figures\

249mb
D:\3DGameProgramming\Figures\Chapter 8 Texturing\
D:\Data\Books\Book IV\Figures\Chapter 8 Texturing\
复制代码

这酸爽，原来我D盘有几个G 的副本……

作者: happy886rr 时间: 2017-1-22 10:41

回复 18# 523066680
判断大文件可抽样md5，二分法抽样，这样误判几率小于1/pow(2,n)，目前对大文件只能做抽样md5检测。

作者: CrLf 时间: 2017-1-22 16:07

回复 19# happy886rr

既然都明确要对比两个文件了，直接用 memcmp 不是更直接吗

作者: 523066680 时间: 2017-1-22 22:34

本帖最后由 523066680 于 2017-1-22 22:38 编辑

回复 19# happy886rr

也想过抽样。好在对于一般的硬盘，上G的文件也多不到哪里去。(先满足个人需求了

)
回老家了，爪机码字

作者: happy886rr 时间: 2017-1-23 01:53

回复 20# CrLf
这个函数不错嘛。

作者: happy886rr 时间: 2017-1-23 01:54

本帖最后由 happy886rr 于 2017-1-23 01:55 编辑

回复 21# 523066680
带个本本随地办公吧。不过，我觉得还是回老家有年味，城里都不热闹啊。

欢迎光临批处理之家 (http://bbs.bathome.net/)