Perl笔记:08、用正则表达式处理文…

1、用s///替换

$_ = "He's out bowling with Barney tonight." ;
s/Barney/Fred/ ; # 将 Barney 替换为 Fred
print "$_\n" ;

当然这里可以使用比较复杂的正则表达式

s /with ( \w + ) /against $1 's team/;
print "$_\n";

输出He's out bowling against Fred's team tonight.

再来看看更多的示例：

$_ = "green scaly dinosaur" ;
s/(\w+) (\w+)/$2, $1/ ; # 替换后为 "scaly, green dinosaur"
s/^/huge, / ; # 替换后为"huge, scaly, green dinosaur"
s/,.*een// ; # 将模式内容清空后为 "huge dinosaur"
s/green/red/ ; # 匹配失败，结果仍为 "huge dinosaur"
s/\w+$/($`!)$&/ ; # 替换后为 "huge (huge !)dinosaur"
s/\s+(!\W+)/$1 / ; # 替换后为 "huge (huge!) dinosaur"
s/huge/gigantic/ ; # 替换后为 "gigantic (huge!) dinosaur"

s///返回的是布尔值，替换成功为真，否则为假。

使用/g进行全局替换

s///的模式只会替换到第一个匹配的结果，但如果在后面加上一个/g情况就发生了变化，它会替换所有匹配的内容。

示例：

$_ = "home, sweet home!" ;
s/home/cave/g ;
print "$_\n" ; # "cave, sweet cave!"

常见的替换应用是将多个空白替换为一个空格，如下：

$_ = "Input data\t may have extra whitespace." ;
s/\s+/ /g ; # 结果为 "Input data may have extra whitespace."

删除开头和结尾的空格
s/^\s+//;
s/\s+$//;
也可以写成：s/^\s+|\s+$//g;

不同的定界符

和m//与qw//一样，我们也可以改变s///的定界符。由于替换运算符要用到三个定界符，因此与先前的例子还有些不同，在使用成对出现的定界符是书写方式略有不同，如果不是成对出现的定界符就无所谓了，如下：

s #^https://#http://#;
s {fred } {barney } ;
s [fred ] (barney ) ;
s <fred> #barney#;

第一个例子由于使用的不是成对出现的定界符，因此使用上与/差不多，后面几个例子使用的都是成对出现的定界符，因此在形式上有些不同，你甚至可以在一个替换模式中使用两种定界符！

可选修饰符

不仅是 /g 操作符，替换运算也可以使用我们经常在模式匹配中使用的 /i 、/x 与 /s 修饰符。它们使用时的顺序对结果没有影响。
s#wilma#Wilma#gi; # 将所有的 WiLmA 或 WILMA 替换为 Wilma
s{__END__.*}{}s; # 将__END__标记之后的所有内容都清除

绑定操作符

像之前m//时提到的，我们可以使用绑定操作符为s///选择不同的目标

$file_name =~ s#^.*/##s; # 将 $file_name变量中所有Unix风格路径全部去掉

大小写转换

这里介绍几个转义字符：
\U 将其后的所有字符转换为大写
\u 将其后的第一个字符转换为大写
\L 将其后所有的字符转为小写
\l 将其后的第一个字符转换为小写
\E 结束大小写转换的影响

示例：

 

$_ = "I saw Barney with Fred." ;
s/(fred|barney)/\U$1/gi ; # $_ 现在成了 "I saw BARNEY with FRED."
s/(fred|barney)/\L$1/gi ; # $_ 现在成了 "I saw barney with fred."
s/(\w+) with (\w+)/\U$2\E with $1/i ; # $_ 替换为 "I saw FRED with barney."
s/(fred|barney)/\u$1/ig ; # $_ 替换后为 "I saw FRED with Barney."
s/(fred|barney)/\u\L$1/ig ; # $_ 这里将首字母变为大写 "I saw Fred with Barney."

这里介绍的转义字符也适用于双引号包含的字符串中，如下：
print "Hello, \L\u$name\E, would you like to play a game?\n";

#!/usr/bin/perl -w
use strict ;

$_ = "I saw Barney with Fred." ;

s/(barney|fred)/\U$1/gi ;

print "$_ \n" ;

s/(barney|fred)/\L$1/gi ;

print "$_\n" ;

s/(\w+) with (\w+)/\U$2\E with $1/gi ;

print "$_\n" ;

s/(barney|fred)/\u$1/gi ;
print "$_\n" ;

s/(barney|fred)/\L\u$1/gi ;
print "$_\n" ;

输出结果：
I saw BARNEY with FRED.
I saw barney with fred.
I saw FRED with barney.
I saw FRED with Barney.
I saw Fred with Barney.

Split操作符

split会根据分隔符拆分一个字符串，如果分割成功，返回的结果是按照分隔符切分的字段，否则返回空。

写法：@fields = split /separator/,$string;

任何匹配模式的内容都不会出现在返回的字段中。下面就是以冒号作为分隔符的典型split模式:
@fields = split /:/, "abc:def:g:h"; # 得到 ("abc", "def", "g", "h")

如果两个分隔符连在一起，会产生空字段：
@fields = split /:/, "abc:def::g:h"; # 得到 ("abc", "def", "", "g", "h")

split 还有一个不成文的规则：它会保留开头处的空字段，但却会省略结尾处的空字段。
@fields = split /:/, ":::a:b:c:::"; # 得到 ("", "", "", "a", "b", "c")

利用/\s+/模式进行空白分隔也是常见的做法。在此模式下，所有的空白会被当成一个空格来处理：

my $some_input = "This is a \t test.\n" ;
my @args = split /\s+/ , $some_input ;
# 得到 ("This", "is", "a", "test.")
# 上面的可以简写为下面的方式，因为split操作符默认是以空白分隔$_变量
my @fields = split ; # 与 split /\s+/, $_; 一致

Join函数

join函数不会使用模式，它的功能与split功能恰好相反，split会将字符串分解为数个子字符串，而join会把这些子字符串合并为一个字符串。用法如下：
my $result = join $glue,@pieces;
join函数的第一个参数是各个字符的分隔符，第二个参数就是需要合并的数组。
my $x = join ":",4,5,6,7,8,9,10,11;
结果$x为"4:5:6:7:8:9:10:11"

join与split的用法类似，但要记住join的第一个参数是字符串而非模式！

列表上下文中的m//

在列表上下文中使用的模式匹配操作符(m//)时，如果模式匹配成功，那么返回的是所有捕获变量的列表；如果匹配失败，则返回空列表：

$_ = "Hello there, neighbor!" ;
my ( $first , $second , $third ) = /(\S+) (\S+), (\S+)/ ;
print "$second is my $third\n" ;

输出结果：there is my neighbor!
如此就能给那些匹配变量起即好记又动听的名字。

先前已经在s///的例子中用到了/g修饰符，该修饰符同样也可以用在m//操作符上，其效果就是让模式能够匹配到字符串中的许多地方。下面的例子中具有一对圆括号的模式，它会在每次匹配成功时返回一个捕获串：

my $text = "Fred dropped a 5 ton granite block on Mr. Slate" ;
my @words = ( $text =~ /([a-z]+)/ig ) ;
print "Result: @words\n" ;

输出结果：Result: Fred dropped a ton granite block on Mr Slate

这就相当于自己动手实现了split的功能，但并不是指定想要去除的部分（split中的第一个参数，也即是分隔符实际上就是要去除的部分），反而是指定想要流行的部分。

如果模式中有多对圆括号，那么每次匹配就能捕获多个串。假设，我想让一个字符串变成哈希，可以这样做：

#!/usr/bin/perl -w

use strict ;

my $letter2name = "a apple b banana c carry
d dog e edit f fllow g good h height i idle" ;

my %newhash = ( $letter2name =~ /(\w+)\s+(\w+)/g ) ;

while ( my ( $key , $value ) = each %newhash ) {
print "$key => $value\n" ;
}

输出结果：
e => edit
a => apple
d => dog
c => carry
h => height
b => banany
g => good
f => fllow
i => idle
注意：本例中的模式匹配中一定要加上修饰符/g 否则就会匹配字符串中一次，这样的话哈希中也就只有一对值。如果加上/g的话就会对整个字符串进行全面的扫描了，从而将字符串完整的转换为哈希。

非贪婪量词

到目前为止我们碰到的4个量词({} + * ?)都是贪婪量词。也就是说在保证整体匹配的前提下，它们会尽量匹配长字符串。与之相对的就是非贪婪量词。对于每一个贪婪的量词，都有一个非贪婪的量词。以加号(+)为例，它的非贪婪量词为(+?)，这表示一次或更多匹配(加号的本意)。但是匹配的字符串却是越短越好，而不是越长越好。举例来说：假如我想处理一个HTML文本，需要将去除<BOLD>跟</BOLD>这样的标记，并保留剩余的内容。如果要处理的字符串是这样：
I’m talking about the cartoon with Fred and <BOLD>Wilma</BOLD>!
那么可以用下面的这个替换表达式把标记去掉。
s#<BOLD>(.*)</BOLD>#$1#g;
但这样会不会有问题呢？实际上这个表达式考虑得太简单了，也可以说这里的星号量词太贪心了，如果换成下面的字符串该怎么办呢？
I thought you said Fred and <BOLD>Velma</BOLD>, not <BOLD>Wilma</BOLD>
这种情况下该模式会从第一个<BOLD>匹配直到最后一个</BOLD>，把这中间的部分全部取出来。这就错了，在这里我们就需要使用非贪婪量词。非贪婪版本的星号是*?,所以新的替换表达式应该写成这样：
s#<BOLD>(.*?)</BOLD>#$1#g;
这样就正确无误了！

看到这里你也就知道了剩下的两个量词的非贪婪版本了：
?? 虽然问号已经是匹配零次或一次了，但是这样写的话会优先考虑零次
{5,10}? 优先考虑5次

跨行的模式匹配

传统的正则表达式都是用来匹配单行文本。由于Perl可以处理任意长度的字符串，其模式匹配也可以处理多行文本，与处理单行文本并无差异。看看下面可以表示4行的文本：
$_ = "I'm much better\nthan Barney is\nat bowling,\nWilma.\n";
^和$通常是用来匹配整个字符串的开始和结束的。但当模式加上/m修饰符后，就可以让它们也匹配串内的换行符，这样一来，它们所代表的位置就不再是整个字符串的头尾，而是每行的开头跟结尾。因此，下面的模式就成立了：
print "Found 'wilma' at start of line\n" if /^wilma\b/im;

同样，也可以对多行文本逐个进行替换，参见下面的例子，先把整个文件读进一个变量，然后把文件名前置于每一行的开头：

#!/usr/bin/perl -w

use strict ;

my $filename = "test.log" ;
open MAILLOG , $filename
or die "Can't open $filename:$!" ;

my $line = join '' , <MAILLOG> ;

$line =~ s/^/$filename : /gm ;

print "$line" ;

一次更新多个文件

要在Perl中直接修改文件内容可以使用钻石操作符(<>)，先看下面的例子：

#!/usr/bin/perl -w
use strict ;
chomp ( my $date = `date` ) ;
$^I = ".bak" ;
while ( <> ) {
s/^Author:.*/Author: Randal L. Schwartz/ ;
s/^Phone:.*\n// ;
s/^Date:.*/Date: $date/ ;
print ;
}

程序一开始使用了系统的date命令，下一行则是对$^I变量的赋值，这个赋值是个扩展名，也就是再修改的时候要先备份一下，以防万一。
钻石操作符会读取命令行参数指定的那些文件。程序的主循环一次会读取、更新及输出一行

===================本章习题======================

1、写个程序来赋值并修改指定的文本文件。在副本里，此程序会把出现字符串Fred(大小写不计)的每一处都换成Larry。输入文件名应该在命令行上指定，输出文件名是本来的文件名加上.out。
答：

#!/usr/bin/perl -w

use strict ;

my $in = $ARGV [ 0 ] ;

unless ( defined $in ) {
die "Usage $0 filename" ;
}

my $out = $in ;
$out =~ ( s / (\ . \w ) ? $/ .out / ) ;

unless ( open IN , "<$in" ) {
die "Open file $in error:$?" ;
}

unless ( open OUT , ">$out" ) {
die "Write file $out error:$?" ;
}

while ( <IN> ) {
s/fred/Larry/gi ;
print OUT $_ ;
}

2、修改前一题的程序，以便把所有的Fred换成Wilma并把所有的Wilma换成Fred。如果输入的是fred&wilma，那么正确的输出应是Wilma&Fred。
答：

#!/usr/bin/perl -w

use strict ;

my $in = $ARGV [ 0 ] ;

unless ( defined $in ) {
die "Usage $0 filename" ;
}

my $out = $in ;
$out =~ ( s / (\ . \w ) ? $/ .out / ) ;

open IN , "<$in" or die "Open file $in error:$?" ;

unless ( open OUT , ">$out" ) {
die "Write file $out error:$?" ;
}

while ( <IN> ) {
s/fred/\0/gi ;
s/wilma/Fred/gi ;
s/\0/Willma/g ;
print OUT $_ ;
}

注意：这里的替换是不能用正则表达式一步完成的，必须用一个中间量替换一下，然后再替换回来。本例使用\0也就是NULL作为中间量。

3、写个程序，把你目前写过的所有程序都加上版权声明，也就是在第一行的后面加上如下信息：## Copyright (C) 20XX by Yours Truly。你应该直接修改修改文件内容并且做备份。假设你将在命令行指定待修改的文件名。
答：

#!/usr/bin/perl -w

use strict ;

$^I = ".bak" ;

while ( <> ) {
if ( /^#!/ ) {
$_ .= "## Copyright (C) 2010 by Cooper!\n"
}
print ;
}

4、修改前一题程序里的模式，如果文件中已经有版权声明，就不在进行修改。提示：你可能需要知道钻石操作符当前正在读取的文件名称，可以在$ARGV里找到。
答：

为了避免重复加上版权声明，我们得分两次处理文件。第一次，我们需要先建立一个哈希，它的键是文件名称，而它的值是什么无关紧要，为了安全起见，此处将值置为1：

my %file ;
foreach ( @ ARGV ) {
$file { $_ } = 1 ;
}

第二次，我们会吧这个哈希当成待办列表逐个处理，并把已经包含版权声明的文件移除。目前正在读取的文件名称可用$ARGV获取，所以可以直接把它拿来当哈希键：

while ( <> ) {
if ( /^## Copyright/i ) {
delete $file ( $ARGV ) ;
}
}

最后的部分跟之前所写的程序一样，但我们会会事先把@ARGV的内容改掉：

@ ARGV = sort keys %file ;
$^I = ".bak" ;
while ( <> ) {
if ( /^#!/ ) {
$_ .= "## Copyright (C) 2010 by Cooper!\n"
}
print ;
}