重命名文件的腳本

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) 
     } 
    } 
} 

})();