重命名文件的脚本

Question

我在几个不同的文件夹中有大约2200个不同的文件，我需要重命名大约1/3的文件夹在他们自己的子文件夹中。那些700也在各种文件夹中。

例如，有可能是 最顶层的文件夹名员工，其中有那几个文件，那么该文件夹2002年有几个，2003有多个文件，2004年等

我只需要在每个文件的现有名称之前附加“协议”一词。所以，而不是它只是“乔Schmoe.doc”它将是“协议Joe Schmoe.doc”，而不是。

我试着用搜索引擎这样的脚本，我可以找到类似我想要的东西，但它一切看起来完全陌生给我，让我不明白我怎么会修改，以适合我的需要。

哦，这是为Windows服务器'03。

Answer 1

我需要约2分钟写一个* NIX系统，脚本（可能更少），但对于Windows它是一个长歌......））

我已经为WSH写简单的VBS脚本，尝试它（保存到{script-name} .vbs，更改路径值（在脚本的第一行）并执行）。我建议第一次在少量数据上测试脚本，以确定它是否正常工作。

Path = "C:\Users\rootDirectory" 
Set FSO = CreateObject("Scripting.FileSystemObject") 

Sub visitFolder(folderVar) 
    For Each fileToRename In folderVar.Files 
     fileToRename.Name = "Agreement " & fileToRename.Name 
    Next 
    For Each folderToVisit In folderVar.SubFolders 
     visitFolder(folderToVisit) 
    Next 
End Sub 

If FSO.FolderExists(Path) Then 
    visitFolder(FSO.getFolder(Path)) 
End If 

Answer 2

我以前在Windows下使用批处理脚本进行批量重命名。我知道它是一个* nix（find。-maxdepth N -type f -name“$ pattern”| sed -e'p'-e“s/$ str1/$ str2/g”| xargs -n2 mv）。 Buf经过一番徒劳挣扎后，发现，使用批处理脚本来达到这种效果几乎是不可能的。所以我转向了javascript。

有了这个脚本，你可以添加前缀由 'rename.js “S/^ /协议/” -r * .DOC' 为文件名。脱字号（^）表示匹配开头。 '-r'选项表示'递归'，即包括子文件夹。您可以使用'-d N'选项指定最大深度。如果既没有'-r'也没有'-d N'，脚本不会递归。

如果你知道* nix的“查找”工具，你会发现，“查找”将匹配的完整路径（而不仅仅是文件名部分）到指定的正则表达式。这种行为可以通过提供'-f'选项来实现。默认情况下，此脚本将使文件名部分与给定的正则表达式匹配。

如果您熟悉正则表达式，则可以进行复杂的重命名。例如，'rename.js's /（\ d +）/ [$ 1] /“*'，它使用分组将括号添加到文件名中的数字序列中。

// rename.js --- bulk file renaming utility (like *nix rename.pl) 
// (c) Copyright 2012, Ji Han (hanji <at> outlook <dot> com) 
// you are free to distribute it under the BSD license. 

// oops... jscript doesn't have array.map 
Array.prototype.map = function(f, t){ 
    var o = Object(this); 
    var a = new Array(o.length >>> 0); 
    for (var i = 0; i < a.length; ++i){ if (i in o) a[i] = f.call(t, o[i], i, o) } 
    return a; 
}; 

/// main 
(function(){ 

if (WScript.Arguments.Length == 0){ 
    WScript.Echo('rename "<operator>/<pattern>/<string>/[<modifiers>]" [-f] [-r] [-d <maxdepth>] [<files>]'); 
    WScript.Quit(1); 
} 

var fso = new ActiveXObject('Scripting.FileSystemObject'); 

// folder is a Folder object [e.g. from fso.GetFolder()] 
// fn is a function which operates on File/Folder object 
var recurseFolder = function(folder, fn, depth, maxdepth){ 
    if (folder.Files){ 
     for (var e = new Enumerator(folder.Files); !e.atEnd(); e.moveNext()){ 
      fn(e.item()) 
     } 
    } 
    if (folder.Subfolders){ 
     for (var e = new Enumerator(folder.SubFolders); !e.atEnd(); e.moveNext()){ 
      fn(e.item()); 
      if (depth < maxdepth){ arguments.callee(e.item(), fn, depth + 1, maxdepth) } 
     } 
    } 
} 

// expand wildcards (asterisk [*] and question mark [?]) recursively 
// given path may be relative, and may contain environment variables. 
// but wildcards only work for the filename part of a path. 
// return an array of full paths of matched files. 
// {{{ 
var expandWildcardsRecursively = function(n, md){ 
    var pattern = fso.GetFileName(n); 
    // escape regex metacharacters (except \, /, * and ?) 
    // \ and/wouldn't appear in filename 
    // * and ? are treated as wildcards 
    pattern = pattern.replace(/([\[\](){}^$.+|-])/g, '\\$1'); 
    pattern = pattern.replace(/\*/g, '.*'); // * matches zero or more characters 
    pattern = pattern.replace(/\?/g, '.'); // ? matches one character 
    pattern = pattern.replace(/^(.*)$/, '\^$1\$'); // matches the whole filename 
    var re = new RegExp(pattern, 'i'); // case insensitive 
    var folder = fso.GetFolder(fso.GetParentFolderName(fso.GetAbsolutePathName(n))); 
    var l = []; 
    recurseFolder(folder, function(i){ if (i.Name.match(re)) l.push(i.Path) }, 0, md); 
    return l; 
} 
// }}} 

// parse "<operator>/<pattern>/<string>/[<modifiers>]" 
// return an array splitted at unescaped forward slashes 
// {{{ 
var parseExpr = function(s){ 
    // javascript regex doesn't have lookbehind... 
    // reverse the string and lookahead to parse unescaped forward slashes. 
    var z = s.split('').reverse().join(''); 

    // match unescaped forward slashes and get their positions. 
    var re = /\/(\\\\)*(?!\\)/g; 
    var l = []; 
    while (m = re.exec(z)){ l.push(m.index) } 

    // split s at unescaped forward slashes. 
    var b = [0].concat(l.map(function(x){ return s.length - x }).reverse()); 
    var e = (l.map(function(x){ return s.length - x - 1 }).reverse()).concat([s.length]); 
    return b.map(function(_, i){ return s.substring(b[i], e[i]) }); 
} 
// }}} 

var expr = WScript.Arguments(0); 
var args = []; 
var options = {}; 

for (var i = 1; i < WScript.Arguments.Length; ++i){ 
    if (WScript.Arguments(i).substring(0, 1) != '-'){ 
     args.push(WScript.Arguments(i)); 
    } else if (WScript.Arguments(i) == '-f'){ 
     options['fullpath'] = true; 
    } else if (WScript.Arguments(i) == '-r'){ 
     options['recursive'] = true; 
    } else if (WScript.Arguments(i) == '-d'){ 
     options['maxdepth'] = WScript.Arguments(++i); 
    } else if (WScript.Arguments(i) == '--'){ 
     continue; 
    } else { 
     WScript.Echo('invalid option \'' + WScript.Arguments(i) +'\''); 
     WScript.Quit(1); 
    } 
} 

if (options['maxdepth']){ 
    var md = options['maxdepth']; 
} else if (options['recursive']){ 
    var md = 1<<31>>>0; 
} else { 
    var md = 0; 
} 

var tokens = parseExpr(expr); 
if (tokens.length != 4){ 
    WScript.Echo('error parsing expression \'' + expr + '\'.'); 
    WScript.Quit(1); 
} 
if (tokens[0] != 's'){ 
    WScript.Echo('<operator> must be s.'); 
    WScript.Quit(1); 
} 

var pattern = tokens[1]; 
var substr = tokens[2]; 
var modifiers = tokens[3]; 
var re = new RegExp(pattern, modifiers); 

for (var i = 0; i < args.length; ++i){ 
    var l = expandWildcardsRecursively(args[i], md); 
    for (var j = 0; j < l.length; ++j){ 
     var original = l[j]; 
     if (options['fullpath']){ 
      var nouveau = original.replace(re, substr); 
     } else { 
      var nouveau = fso.GetParentFolderName(original) + '\\' + fso.GetFileName(original).replace(re, substr); 
     } 
     if (nouveau != original){ 
      (fso.FileExists(original) && fso.GetFile(original) || fso.GetFolder(original)).Move(nouveau) 
     } 
    } 
} 

})();