Esiste una app OSX / modo per rinominare i file in batch tramite un'interfaccia puramente testuale?

Emacs può farlo.

1. Apri Emacs
2. C-x C-f e apri la directory. Si aprirà in dired-mode .
3. M-x wdired-change-to-wdired-mode RET

Ora puoi modificare i nomi dei file come richiesto. Premendo C-c C-c si termina la modalità wdired e si eseguono le modifiche.

wdired-change-to-wdired-mode is an interactive autoloaded Lisp function in 'wdired.el'.

It is bound to .

(wdired-change-to-wdired-mode)

Put a Dired buffer in Writable Dired (WDired) mode.

In WDired mode, you can edit the names of the files in the buffer, the target of the links, and the permission bits of the files. After typing C-c C-c, Emacs modifies the files and directories to reflect your edits.

See 'wdired-mode'.

Segui questi passaggi:

1. Installa DiffMerge e gem install batch_rename (vedi README.md per i dettagli).

2. In Terminal.app, cd nella directory che contiene i file che desideri rinominare.
   (Per praticità, suggerisco di trascinare la cartella dal Finder nella finestra del Terminale.)

3. Digita batch-rename e premi Invio. Questo apre un editor interattivo.
   Lo script ti aspetterà per chiudere l'editor. Quindi rinominerà i file.

(Disclosure: sono l'autore dello strumento batch-rename .)

Modifica: il problema dell'OP mi è piaciuto così tanto che ho reso la mia risposta in uno strumento da riga di comando per la comodità di tutti. Per sfruttare la semplificazione, ho anche riscritto la mia risposta sopra.

Ho caricato l'origine in GitHub e lo ha pubblicato come gemma installabile su RubyGems.
Entrambi sono sotto una licenza ISC quindi sentitevi liberi di inviarmi problemi e richieste.

Puoi trovare la mia risposta originale qui sotto per riferimento.

1. Installa DiffMerge .

2. cd alla directory di lavoro corretta.

3. Esegui il seguente script Ruby:

( batch_rename.rb )

#!/usr/bin/env ruby
# encoding: utf-8

require 'shellwords'
require 'tmpdir'

Catalog = Struct.new(:time, :title, :file_name, :escaped_file_name) do
  def lines
    File.open(file_name).each.map(&:chop)
  end
end

CAPTION = "Batch rename - #{ Dir.pwd }"
DIFF_TMP_DIR = Dir.mktmpdir('batch-rename-')
DIFFMERGE = '/usr/local/bin/diffmerge'

catalogs = [:before, :after].map do |t|
  title = "#{ t.capitalize } renaming"
  file_name = "#{ DIFF_TMP_DIR }/#{ title }.utf8"
  escaped_file_name = Shellwords.escape(file_name)
  Catalog.new(t, title, file_name, escaped_file_name)
end

'ls -A | tee #{ catalogs.map(&:escaped_file_name).join(' >') }'

args = catalogs.map.with_index do |c, i|
  ["-t#{ i+1 }=#{ c.title }", c.file_name]
end

system(DIFFMERGE, "-c=\"#{ CAPTION }\"", *(args.flatten))

puts catalogs
  .map(&:lines)
  .reduce(&:zip)
  .select { |a| a.reduce(&:!=) }
  .map { |pair| pair.map(&Shellwords.method(:escape)) }
  .map { |a, b| "mv #{a} #{b}" }
  .join("\n")

Per gli utenti di Testo Sublime, c'è un pacchetto chiamato SublimeFileBrowser che fondamentalmente è dired in Sublime Text più il trucco di tutti i movimenti del cursore della tastiera di Sublime Text. Puoi accoppiare con Text-Pastry o qualsiasi altro pacchetto che possa aiutarti a manipolare facilmente il testo.

Se utilizzi OS X Yosemite (v10.10.x), Finder ha un modo integrato per rinominare i file in batch. Evidenzia tutti i file desiderati nel Finder, tieni premuto Control e fai clic su uno di essi per aprire un menu di scelta rapida, quindi fai clic su "Rinomina x file ...". Avrai una bella interfaccia di ricerca e sostituzione, nessun software di terze parti necessario!

È passato un po 'di tempo da quando l'ho usato. Ma FileBuddy è progettato per manipolare nomi di file e un sacco di altre cose. Potrebbe valere la pena dare un'occhiata.

Nel terminale, hai:

• perl
• python
• zsh / bash / sh
• awk / sed / trovare / mdfind / xargs

Tutti hanno pagine di manuale e volumi di testo scritti su Internet in tutorial. Direi che, se ti dedichi alla regex, la quantità di tempo necessario per adottare uno degli strumenti Unix per sfruttare la ridenominazione del testo sarebbe bassa e il ritorno sull'investimento elevato poiché potresti iniziare ad automatizzare anche cose più difficili piuttosto che rinominare i file.

Se hai davvero bisogno di una GUI - puoi sfruttare qualsiasi launcher come LaubchBar o Alfred per dare il via agli script ed eseguire gli script della shell.

Ecco YACLBFR (*) in perl basato sulla più semplice versione di molti anni fa di Larry Wall ...

#!/usr/bin/perl
#
# rename - originally from Larry Wall:
# Examples:
#   rename 's/\.orig$//' *.orig
#   rename 'y/A-Z/a-z/ unless /^Make/' *
#   rename '$_ .= ".bad"' *.f
#   rename 'print "$_: "; s/foo/bar/ if <stdin> =~ /^y/i' *
#
# Author: Eric Engstrom <eric (dot) engstrom (AT) g m a i l (dot) c o m>
##

use Getopt::Long qw(:config bundling);
use Pod::Usage;
use File::Basename;

GetOptions('h|help'     => \$HELP,
           'n|dryrun'   => \$DRYRUN,
           'v|verbose'  => \$VERBOSE,
           'f|force'    => \$FORCE
           )
  or pod2usage(2);
pod2usage(1) if $HELP;
($expr = shift) || pod2usage(2);

if (!@ARGV) {
  @ARGV = <STDIN>;
  chop(@ARGV);
}
for (@ARGV) {
  $was = $_;
  eval $expr;
  die $@ if $@;
  mkdirs($_);
  printf("%s%s >>> %s\n", $was, (length($was.$_) < 80 ? "" : "\n"), $_)
    if (($VERBOSE || $DRYRUN) && ! ($was eq $_));
  warn "$_ already exists - not renaming $was\n"
    if ( ! $DRYRUN && ! $FORCE && -e $_ );
  rename($was,$_)
    unless ($DRYRUN || $was eq $_ || (! $FORCE && -e $_));
}

sub mkdirs($) {
  my $dir = dirname(@_);
  if (! -d $dir) {
    mkdirs($dir);
    print "making directory: $dir\n"
      if $VERBOSE;
    mkdir $dir
      unless $DRYRUN;
  }
}


##

__END__

=head1 NAME

rename \- renames multiple files using perl expressions

=head1 SYNOPSIS

rename [options...] perlexpr [file...]

=head1 DESCRIPTION

B<Rename> renames the filenames supplied according to the rule
specified as the first argument.  The argument is a Perl expression
which is expected to modify the $_ string in Perl for at least some of
the filenames specified.  If a given filename is not modified by the
expression, it will not be renamed.  If no filenames are given on the
command line, filenames will be read via standard input.

For example, to rename all files matching *.bak to strip the extension,
you might say

    rename 's/\e.bak$//' *.bak

To translate uppercase names to lower, you'd use

    rename 'y/A-Z/a-z/' *

=head1 OPTIONS

    -h --help      brief help message
    -n --dryrun    show what would be renamed, but does not rename anything
    -v --verbose   be verbose during operation

=head1 AUTHOR

Eric Engstrom - email him as specified in the comments of this script
Seriously adapted from a previous incarnation by Father (Larry) Wall.

=head1 SEE ALSO

mv(1), perl(1), perlre(1)

(*) Ancora un altro Renamer file batch riga di comando ...

Esiste già un ottimo strumento di "servizio" chiamato "A Better Finder Rename" ora in V9 e perfettamente funzionante in Yosemite. link Lo collaudo / lo uso già da Leopard.