递归查找/替换文件，但仅触摸匹配的文件

Question

I would like to quickly search and replace with or without regexp in files recursively. In addition, I need to search only in specific files and I do not want to touch the files that do not match my search_pattern otherwise git will think all the parsed files were modified (it what happens with find . --exec sed).

I tried many solutions that I found on internet using find, grep, sed or ack but I don't think they are really good to match specific files only.

Eventually I wrote this perl script:

#!/bin/perl
use strict;
use warnings;
use File::Find;

my $search_pattern  = $ARGV[0];
my $replace_pattern = $ARGV[1];
my $file_pattern    = $ARGV[2];
my $do_replace = 0;

sub process {
    return unless -f;
    return unless /(.+)[.](c|h|inc|asm|mac|def|ldf|rst)$/;
    open F, $_ or print "couldn't open $_\n" && return;

    my $file = $_;
    my $i = 0;

    while (<F>) {
        if (m/($search_pattern)/o) {$i++};
    }
    close F;

    if ($do_replace and $i)
    {
        printf "found $i occurence(s) of $search_pattern in $file\n";
        open F, "+>".$file or print "couldn't open $file\n" && return;
        while (<F>)
        {
            s/($search_pattern)/($replace_pattern)/g;
            print F;
        }
        close F;
    }
}

find(\&process, ".");   

My question is:

Is there any better solution like this one below (which not exists) ?

`repaint -n/(.+)[.](c|h|inc|asm|mac|def|ldf|rst)$/ s/search/replacement/g .`

Subsidiary questions:

1. How's my perl script ? Not too bad ? Do I really need to reopen every files that match my search_pattern ?

2. How people deal with this trivial task ? Almost every good text editor have a "Search and Replace in files" feature, but not vim. How vim users can do this ?

Edit:

I also tried this script ff.pl with ff | xargs perl -pi -e 's/foo/bar/g' ff | xargs perl -pi -e 's/foo/bar/g' but it doesnt work as I expected. It created a backup .bak even though I didn't give anything after the -pi. It seems it is the normal behaviour within cygwin but with this I cannot really use perl -pi -e

#!/bin/perl
use strict;
use warnings;
use File::Find;
use File::Basename;
my $ext = $ARGV[0];

sub process {
    return unless -f;
    return unless /\.(c|h|inc|asm|mac|def|ldf|rst)$/;
    print $File::Find::name."\n" ;
}

find(\&process, "."); 

Reedit:

I finally came across this solution (under cygwin I need to remove the backup files)

find . | egrep '\.(c|h|asm|inc)$' | xargs perl -pi.winsucks -e 's/<search>/<replace>/g'
find . | egrep '\.(c|h|asm|inc)\.winsucks$' | xargs rm   

Answer 1

Not bad, but several minor notes:

• $do_replace is always 0 so it will not replace
• in-place open F, "+>" will not work on cygwin + windows
• m/($search_pattern)/o /o is good, () is not needed.
• $file_pattern is ignored, you overwrite it with your own

• s/($search_pattern)/($replace_pattern)/g;

  () is unneeded and will actually disturb a counter in the $replace_pattern

• /(.+)[.](c|h|inc|asm|mac|def|ldf|rst)$/ should be written as

  /\\.(c|h|inc|asm|mac|def|ldf|rst)$/ and maybe /i also

Do I really need to reopen every files that match my search_pattern ?

• You don't do.

Have no idea about vim, I use emacs, which has several method to accomplish this.

Answer 2

What's wrong with the following command?

:grep foo **/*.{foo,bar,baz}
:cw

It won't cause any problem with any VCS and is pretty basic Vimming.

You are right that Vim doesn't come with a dedicated "Search and Replace in files" feature but there are plugins for that.

Answer 3

why not just:

grep 'pat' -rl *|xargs sed -i 's/pat/rep/g'

or I didn't understand the Q right?

Answer 4

The following is a cleaned up version of your code.

• Always include use strict; and use warnings at the top of EVERY perl script. If you're doing file processing, include use autodie; as well.
• Go ahead and slurp the entire file. That way you only have to read and write optionally write it once.
• Consider using File::Find::Rule for cases like this. Your implmentation using File::Find works, and actually is probably the preferred module in this case, but I like the interface for the latter.
• I removed the capture groups from the regex. In ones in the RHS were a bug, and the ones in the LHS were superfluous.

And the code:

use strict;
use warnings;
use autodie;

use File::Find;

my $search_pattern  = $ARGV[0];
my $replace_pattern = $ARGV[1];
my $file_pattern    = $ARGV[2];

my $do_replace = 0;

sub process {
    return if !-f;
    return if !/[.](?:c|h|inc|asm|mac|def|ldf|rst)$/;

    my $data = do {
        open my $fh, '<', $_;
        local $/;
        <$fh>;
    };

    my $count = $data =~ s/$search_pattern/$replace_pattern/g
        or return;

    print "found $count occurence(s) of $search_pattern in $_\n";

    return if !$do_replace;

    open my $fh, '>', $_;
    print $fh $data;
    close $fh;
}

find(\&process, ".");   

Answer 5

I suggest find2perl if it doesn't work out of the box, you can tweak the code it generates:

find2perl /tmp \! -name ".*?\.(c|h|inc|asm|mac|def|ldf|rst)$"  -exec "sed -e s/aaa/bbb/g {}"

it will print the following code to stdout:

#! /usr/bin/perl -w
    eval 'exec /usr/bin/perl -S $0 ${1+"$@"}'
        if 0; #$running_under_some_shell

use strict;
use File::Find ();

# Set the variable $File::Find::dont_use_nlink if you're using AFS,
# since AFS cheats.

# for the convenience of &wanted calls, including -eval statements:
use vars qw/*name *dir *prune/;
*name   = *File::Find::name;
*dir    = *File::Find::dir;
*prune  = *File::Find::prune;

sub wanted;
sub doexec ($@);


use Cwd ();
my $cwd = Cwd::cwd();


# Traverse desired filesystems
File::Find::find({wanted => \&wanted}, '/tmp');
exit;


sub wanted {
    my ($dev,$ino,$mode,$nlink,$uid,$gid);

    (($dev,$ino,$mode,$nlink,$uid,$gid) = lstat($_)) &&
    ! /^\..*.?\\.\(c|h|inc|asm|mac|def|ldf|rst\)\$\z/s &&
    doexec(0, 'sed -e s/aaa/bbb/g {}');
}


sub doexec ($@) {
    my $ok = shift;
    my @command = @_; # copy so we don't try to s/// aliases to constants
    for my $word (@command)
        { $word =~ s#{}#$name#g }
    if ($ok) {
        my $old = select(STDOUT);
        $| = 1;
        print "@command";
        select($old);
        return 0 unless <STDIN> =~ /^y/;
    }
    chdir $cwd; #sigh
    system @command;
    chdir $File::Find::dir;
    return !$?;
}

If you want to execute, you can pipe it to perl:

find2perl /tmp \! -name ".*?\.(c|h|inc|asm|mac|def|ldf|rst)$"  -exec "sed -e s/aaa/bbb/g" | perl

Answer 6

You can try this plugin for Vim: https://github.com/skwp/greplace.vim

Basically, it allows you to type in a search phases (with/without regex) and ask you for the files to search in.