スクリプトファイル

Question

私は、いくつかの異なるフォルダには約2200の異なるファイルを持っている、と私は1/3程度にそれらの独自のサブフォルダにあるかについて名前を変更する必要があるの名前を変更します。それらの700も様々なフォルダにあります。

例えば、私はちょうど必要 最上位のフォルダがそれにいくつかのファイルを持っている従業員、そのフォルダ2002は、いくつかを持って、2003年には複数のファイルを持って、2004など

であるかもしれません各ファイルの既存の名前の前に "Agreement"という語を付けます。だから、単に "Joe Schmoe.doc"ではなく "Agreement Joe Schmoe.doc"となるでしょう。

私はそのようなスクリプトをグーグルで試してみた、と私は私が欲しいものに似たものを見つけることができますが、私は、私は私のニーズに合わせてそれを変更したいかを理解することはできませんので、それはすべて私には完全に外国人に見えます。

ああ、これは、Windows Server '03のためです。

Answer 1

）...私は（少なくてもよい）* NIXシステムのため、このようなスクリプトを記述するのに約2分を必要としますが、Windowsのためにそれが長い曲です）

私はWSHのための書き込みの簡単なVBSスクリプトをしました、それを試してみてください（{スクリプト名} .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の上のスナップ知っている（| 'P' -e "S/$のSTR1/$のSTR2/gの" -eのsed |。-maxdepth N型のF -name "$パターン" を見つけるxargsの-n2 MV）。バフスクリプトを使ってその効果を達成することはほとんど不可能であることが分かった。だから私はjavascriptになった。このスクリプトでは

、あなたは 'rename.js "S/^ /契約/" -r * .DOC' でファイル名に接頭辞を追加することができます。キャレット（^）は始まりにマッチすることを意味します。 '-r'オプションは、再帰的に、つまりサブフォルダを含むことを意味します。 '-d N'オプションで最大深度を指定することができます。 '-r'も '-d N'も指定されていない場合、スクリプトは再帰的に実行されません。

* nix 'find'ユーティリティを知っていれば、 'find'はファイル名の部分だけでなく、指定された正規表現と一致します。この動作は '-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) 
     } 
    } 
} 

})();