perl记号

箭头记号(取值)

$$rarray[1] 等价于   $rarray->[1]
$$rhash{'a'} 等价于  $rhash->{'a'}
注意;这种记号仅对单键值的索引起作用.对于分段存取不行.
$rarrapackegey->[1,2]同$rarray->[2],Perl将括号中的内容视为逗号分隔的表达式,该表达式返回最后一个元素.
两个下标间的箭头可以省略.
$rarray->[1]->[1] 等价于 $rarray->[1][1]
匿名存储的引用布尔值
匿名存储即为不使用变量名动态为数据分配存储空间.
匿名存储的引用即为动态分配的存储空间的引用,指向这个内存地址.
$ra=[]      #创建匿名数组,返回引用.

$rh={}      #创建匿名散列表,返回引用.

$line = ['solid', 'black', ['1','2','3'] , ['4', '5', '6']];

$line->[0] = solid

共享与同步
threads::shared
和现有大多数线程模型不同，在 Perl ithreads 线程模型中，默认情况下任何数据结构都不是共享的。当一个新线程被创建以后，它就已经包含了当前所有数据结构的一份私有拷贝，新建线程中对这份拷贝的数据结构的任何操作都不会在其他线程中有效。因此，如果需要使用任何共享的数据，都必须显式地申明。threads::shared 包可以用来实现线程间共享数据的目的。
清单 9. 在线程中申明和使用共享数据            
 #!/usr/bin/perl
 #
 use threads;
 use threads::shared;
 use strict;
 my $var   :shared  = 0;       # use :share tag to define
 my @array :shared = (); # use :share tag to define
 my %hash = ();
 share(%hash);                  # use share() funtion to define
 sub start {
 $var = 100;
 @array[0] = 200;
 @array[1] = 201;
 $hash{'1'} = 301;
 $hash{'2'} = 302;
 }
 sub verify {
    sleep(1);                      # make sure thread t1 execute firstly
    printf("var = $var\n");     # var=100
 for(my $i = 0; $i < scalar(@array); $i++) {
        printf("array[$i] = $array[$i]\n");    # array[0]=200; array[1]=201
 }
 foreach my $key ( sort( keys(%hash) ) ) {
 printf("hash{$key} = $hash{$key}\n"); # hash{1}=301; hash{2}=302
 }
 }
 my $t1 = threads->create( \&start );
 my $t2 = threads->create( \&verify );

 $t1->join();
 $t2->join();
锁
多线程间既然有了共享的数据，那么就必须对共享数据进行小心地访问，否则，冲突在所难免。Perl ithreads 线程模型中内置的 lock 方法实现了线程间共享数据的锁机制。有趣的是，并不存在一个 unlock 方法用来显式地解锁，锁的生命周期以代码块为单位，也就是说，当 lock 操作所在的代码块执行结束之后，也就是锁被隐式释放之时。例如
清单 10.线程中的锁机制            
 use threads::shared;
 # in thread 1
 {
    lock( $share );        # lock for 3 seconds
    sleep(3);               # other threads can not lock again
 }
 # unlock implicitly now after the block
 # in thread 2
 {
    lock($share);          # will be blocked, as already locked by thread 1
    $share++;               # after thread 1 quit from the block
 }
 # unlock implicitly now after the block
上面的示例中，我们在 thread 1 中使用 lock 方法锁住了一个普通的标量，这会导致 thread 2 在试图获取 $share 变量的锁时被阻塞，当 thread 1 从调用 lock 的代码块中退出时，锁被隐式地释放，从而 thread 2 阻塞结束，lock 成功以后，thread 2 才可以执行 $share++ 的操作。对于数组和哈希表来说，lock 必须用在整个数据结构上，而不是用在数组或哈希表的某一个元素上。例如

清单 11. 在数组或哈希表上使用锁机制    
 use threads;
 use threads::shared;

 {
    lock(@share);          # the array has been locked
    lock(%hash);           # the hash has been locked
    sleep(3);               # other threads can not lock again
 }

 {
    lock($share[1]);     # error will occur
    lock($hash{key});    # error will occur
 }
假如一个线程对某一个共享变量实施了锁操作，在它没有释放锁之前，如果另外一个线程也对这个共享变量实施锁操作，那么这个线程就会被阻塞，阻塞不会被自动中止而是直到前一个线程将锁释放为止。这样的模式就带来了我们常见的死锁问题。例如
清单 12. 线程中的死锁        
 use threads;
 use threads::shared;
 # in thread 1
 {
    lock($a);              # lock for 3 seconds
    sleep(3);              # other threads can not lock again
    lock($b);              # dead lock here
 }
 # in thread 2
 {
    lock($b);              # will be blocked, as already locked by thread 1
    sleep(3);              # after thread 1 quit from the block
    lock($a);              # dead lock here
 }
死锁常常是多线程程序中最隐蔽的问题，往往难以发现与调试，也增加了排查问题的难度。为了避免在程序中死锁的问题，在程序中我们应该尽量避免同时获取多个共享变量的锁，如果无法避免，那么一是要尽量使用相同的顺序来获取多个共享变量的锁，另外也要尽可能地细化上锁的粒度，减少上锁的时间。
信号量
Thread::Semaphore 包为线程提供了信号量的支持。你可以创建一个自己的信号量，并通过 down 操作和 up 操作来实现对资源的同步访问。实际上，down 操作和 up 操作对应的就是我们所熟知的 P 操作和 V 操作。从内部实现上看，Thread::Semaphore 本质上就是加了锁的共享变量，无非是把这个加了锁的共享变量封装成了一个线程安全的包而已。由于信号量不必与任何变量绑定，因此，它非常灵活，可以用来控制你想同步的任何数据结构和程序行为。例如

清单 13. 线程中的信号量        
 use threads;
 use threads::shared;
 use Thread::Semaphore;

 my $s = Thread::Semaphore->new();
 $s->down();                # P operation
 ...
 $s->up();                  # V operation

从本质上说，信号量是一个共享的整型变量的引用。默认情况下，它的初始值为 1，down 操作使它的值减 1，up 操作使它的值加 1。当然，你也可以自定义信号量初始值和每次 up 或 down 操作时信号量的变化。例如
清单 14. 线程中的信号量        
 use threads;
 use Thread::Semaphore;

 my $s = Thread::Semaphore->new(5);
 printf("s = " . ${$s} . "\n");         # s = 5
 $s->down(3);
 printf("s = " . ${$s} . "\n");         # s = 2
 ...
 $s->up(4);
 printf("s = " . ${$s} . "\n");         # s = 6
线程队列
Thread::Queue 包为线程提供了线程安全的队列支持。与信号量类似，从内部实现上看，Thread::Queue 也是把一个通过锁机制实现同步访问的共享队列封装成了一个线程安全的包，并提供统一的使用接口。Thread::Queue 在某些情况下可以大大简化线程间通信的难度和成本。例如在生产者 - 消费者模型中，生产者可以不断地在线程队列上做 enqueue 操作，而消费者只需要不断地在线程队列上做 dequeue 操作，这就很简单地实现了生产者和消费者之间同步的问题。例如

清单 15. 生产者 - 消费者模型中对线程队列的使用            
 #!/usr/bin/perl
 use threads;
 use Thread::Queue;
 my $q = Thread::Queue->new();
 sub produce {
    my $name = shift;
    while(1) {
        my $r = int(rand(100));
        $q->enqueue($r);
        printf("$name produce $r\n");
        sleep(int(rand(3)));
    }
 }
 sub consume {
    my $name = shift;
    while(my $r = $q->dequeue()) {
        printf("consume $r\n");
    }
 }
 my $producer1 = threads->create(\&produce, "producer1");
 my $producer2 = threads->create(\&produce, "producer2");
 my $consumer1 = threads->create(\&consume, "consumer2");
 $producer1->join();
 $producer2->join();
 $consumer1->join();

====以下是抄录别人的

1， Perl程序的扩张名为：.plx/pl/pm等。

2， 注释： #开始到行尾结束。

3， 传统的第一行会写成 #！perl

4， Perl没有”main”程序

5， 程序里面不必有变量声明段

6， 一对反引号（`  `）来表示外部的命令

7， 浮点数直接量 负6.5乘上10的24次方-6.5e24

8， 整数直接量 perl允许在整数直接量里插入下划线                                 61298040283768=61_298_040_283_768

9， 非十进制的整数直接量

       八进制直接为0开头      

       十六进制直接以0x开头

        二进制直接以0b开头

10，             模操作符只取两边的整数部分进行运算                                                                  10.5%3.2=10%3

11，             乘幂操作符                                                                                              

2**3代表2的3次方

12，             双引号内字符串的反斜线转义字符

13，             字符串可以用 .  操作符来彼此连接                                                                      “hello”.’ ’.”world”与’hello world’等价

14，             字符串复制操作符是个特殊的字符串操作符，它是一个小写字母x，此操作符会将左边的操作符与它本身重复连接，次数则由右边的操作数指定。                                       “fred” x 3等价于“fredfredfred”

15，             完全不需要担心手上要处理的是数字还是字符串，perl会帮忙做完所有的转换。

16，             要在运行程序时启用警告功能，使用-w命令行选项

17，             标量变量 $var

18，             另一个常见的双目赋值操作符，就是由字符串连接操作符（.）改造而成的添加操作符（.=）

$str=$str.” ”;等价于$str.=””；

19，             将变量分离出来，只要用一对花括号将变量括起来

       $whats=${whar}s

20，             数值与字符串的比较操作符：

  

21，             布尔值

由于字符串’0’跟数字0是同一个标量值，所以perl会将它们一视同仁。也就是说，字符串’0’是唯一被当成“假”值的非空字符串。

22，             取得用户的输入

运用整行输入操作符<STDIN>,Perl以“标准输入”读进一行文字（读取到换行符为止）。

Perl程序会停下来，等待输入某些字符，直到换行符（按下Enter键）出现为止。

<STDIN>所返回的字符串值通常最后都会跟着一个换行符。

23，             chomp操作符

它只能用在一种变量上，该变量的内容必须为字符串。如果此字符串的结尾是换行符，chomp就会将它移除。

  Chomp的使用多半像这样：

Chomp($text=<STDIN>);#读入文字，略过最后的换行符

使用chomp时，可以加上括号，也可以不加。

字符串后面如果有两个以上的换行符，chomp只会删除一个。

24，             特殊的数组索引值

假如对索引值超过数组尾端的元素进行赋值，数组将会依需要自动扩大----只要有可用的内存配置给Perl，数组的长度是没有上限的。

对于正在使用的数组rocks而言，最后一个元素的索引值$#rocks，但$#rocks并不等于元素的个数，因为还多出一个偏号为0的元素。

从数组尾端往回计数的“负数数组索引值”。

25，             列表直接量

圆括号内一串以逗号分隔的值

（1,2,3）

（1..100）#100个整数所构成的列表

..为范围操作符。这个操作符会由左边的标量计数到右边，每次加1，以产生一连串的数值。

26.，当希望引用整个数组时，只要在数组名之前加上@符号，就可以立即使用整个数组。可以将@符号读作“全部的”。

27，pop和push操作符

  把数组当成堆栈来用时常见的做法。项目的新增和移除都是在数组里位于“最后面”的那一端。

Pop操作符可用来取出数组中最后一个元素并且将它返回。

Push会添加一个元素（或是一串元素）到数组的尾端push(@array,0)

Push的一个参数或pop的唯一参数必须是数组变量。

28，shift和unshift操作符

Shift是数组的“开头”删除相应的元素

Unshift是数组的“开头”添加相应的元素。

29，foreach 等价于c语言里面的for

控制变量并不是列表元素的复制品，事实上，它就是列表元素本身。也就是说，假如在循环中修改了控制变量，实际上会修改到相应元素值本身。

30.，reverse操作符

  读取列表的值（可能来自数组）并依相反的次序返回列表。

31，sort操作符

读取列表的值（可能来自数组），而且会根据字符 编码的顺序对他们进行排序。

32，“上下文”：表达式所出现的位置

在Perl中，表达式的返回值一定会符合他们的上下文。

以数组的“名称”为例：在列表上下文中，它会产生元素的列表

但是在标量上下文中，则会返回数组中元素的个数

@people=qw(fred,barney,betty);

@sort=sort @people;  #列表上下文：barney,betty,fred

$number=42+@people;  #标量上下文：42+3等于45

33，只要元素是赋值给列表的，不管元素的个数，它就是列表上下文。

强制指定标量上下文 scalar,它不是函数，只是告诉perl提供标量上下文。

34，子例程的定义可以放在程序中的任何地方，通常不需任何形式的前置声明。即子例程的定义具有全局性。

35，定义子例程

   Subfunc

{….}

36,调用子例程

  任何表达式中只要使用了子例程的名称(加上&符号)，就会调用子例程。

37，子例程的返回值

  任何Perl子例程都有返回值。其中，最后一次运算的结果不管是多少，都会被自动当成子例程的返回值。

  *注意：若子例程最后使用了print语句，它的返回值通常是1，代表了“输出成功”，却不是我们真正想要的返回值。

38，子例程的参数

Perl子例程可以有参数。要传递参数列表到子例程里，只要在子例程调用后面加上被括号括住的列表表达式就可以了。

如$n=&max(10,15);

Perl会自动将参数列表存储到名为@_的特殊数组里，在子例程执行期间内都有效。即第一个参数存储与$_[0]，第二个参数存储于$_[1]。

假如已经有了全局变量@_,则该变量在子例程调用前会先被存起来，并在子例程返回时恢复原本的值。即,子例程可以将参数传给其他的子例程，而不用担心遗失自己的@_变量。

39，子例程里的私有变量

在Perl里，所有变量都被默认为全局变量。但可运用my 操作符来创建称为词法变量的私有变量。

sub max

{

   my($m,$n);

   ($m,$n)=@_;

   if ($m>$n) {$m} else {$n}

}

40,更好的&max例程

  $maxmin=&max(3,5,10,4,6);

   submax

{

   my($max_so_far)=shift @_;

   foreach(@_)

   {

       if($_>$max_so_far)

       {

           $max_so_far=$_;

}

}

$max_so_far;

}

41，my操作符并不会更改变量赋值时的上下文。

  my($num)=@_;#列表上下文，和($num)=@_;相同。此时为参数

   my$num=@_; #标量上下文，和$num=@_;相同。此时为个数

42，use strict编译命令

  它可以强制程序员使用一些良好的程序语言规则。

43，数组的索引$#

44，defined函数

   整行输入操作符<STDIN>有时会返回undef。在一般情况下，它会返回一行文字。但若是输入结束了，像遇到“文件结尾”符号，它就会返回undef来表示这个状况。要判断某个字符串是undef而不是空字符串，可以使用defined函数。这个函数对undef会返回“假”，对其他参数会返回“真”。

45，标准输入（1）chomp($line=<STDIN>);

             （2）while(defined($line=<STDIN>)){

                         print” $line”;

                         }

46，从钻石操作符输入 <>

   它能让程序处理调用参数。程序的调用参数通常是命令行跟在程序名称后面的几个“单词”。命令行参数代表依次处理的数个文件的名称

   如：$ ./ my_program fredbarney betty

   *注意：如果某个参数是连字符(-)，那也代表标准输入。所以，假如调用参数是fred-betty的话，意思是指程序应该处理文件fred，接着是标准输入流，最后才是文件betty。

   从文件读入并显示：

   while(<>)
      {

      chomp;

      print “$_”;

}

//默认的参数都是$_

47,调用参数

 @ARGV数组存储的是调用参数所组成的列表

  钻石操作符如何决定使用哪些文件名？

  它会查找@ARGV，如果是空列表，就会改用标准输入流；否则，就会使用@ARGV里的文件列表。

48，输出至标准输出

  print@array;

  print“@array”;

  第一个print语句会逐项输出列表，各个项目之间没有空格。

  第二个print语句只会输出一个项目，它是将@array替换进空字符串的结果。

  一般来说，如果数组里的字符串包含换行符号，则使用

   print @array;

  要是不包含换行符号，则使用print“@array\n”;

  *注意：print (2+3)*4 输出的并非是20

  Perl会认为是(print(2+3)*4

49，数组与printf

printf “The itemsare:\”.(s\n”x@items),@items;

在标量上下文中只用了一次@items以取得它的长度，然后又在列表上下文中用了一次@items以取得它的内容。

50，文件句柄

代表Perl进程与外界之间的输入/输出联系。

STDIN是标准输入流，STDOUT是标准输出流。

51，打开文件句柄

  Perl所提供的3中文件句柄STDIN,STDOUT,STDERR，都是由产生Perl进程的父进程自动打开文件或设备。当需要其他文件句柄时，用open 操作符告诉Perl

  OpenCONFIG,”dino”;--------(1)

  OpenCONFIG,”<dino”;------(2)

  OpenBEDROCK,”>fred”;---(3)

  OpenLOG,”>>logfile”;-------(4)

(1):打开（已存在）文件dino;

(2)利用shell重定向，将文件内容经STDIN读入程序里。

(3)创建一个新的文件，如果已经有一个名为Fred的文件，这么做会清楚原有的内容并且以新内容取代之。

(4)以添加的方式来打开文件，若不存在，会新建一个文件。

52，关闭文件句柄

  Close BEDROCK;

当重新打开某个文件句柄时，Perl会自动关闭原来的文件句柄。

53，用die来处理严重错误

 die函数会输出所指定的信息，并且让程序在非零的结束状态下立刻终止。

  $!存放了系统错误的信息。

 54，改变默认的输出文件句柄

     使用select操作符来改变默认的文件句柄，如

     Select BEDROCK;

     Print “…”;

     一旦选择了默认输出用的文件句柄，程序就会一直以此方式运行，所以这并不是一个好的方法。

    不过，只要将特殊变量$1设定为1，就会使当前的（即select所指定的）默认文件句柄在每次进行输出操作后，立刻清空缓冲区。

    Select LOG;

    $1=1;

    Select STDOUT;

    Print LOG “…”;

 55，散列和数组的相同之处：可以包含任意多个值，并能随心所欲地取用这些值；不同之处是：数组时以数字来编索引，而散列则是用名称来找寻相应的值。

    在散列里，没有固定的顺序，也没有所谓的第一个元素，它只是一些“键-值对”组合。

 56，为什么使用散列？

     需要将一组数据“对应到”另一个数据。

     由名字找姓、由主机名称找IP地址、由IP地址找出主机名称、由单词找出单词在文本中出现的次数……

  57，访问散列元素

      $hash{$some_key}

     *注1：在索引值（散列键）上旁边使用花括号，而不是方括号。

     *注2：键表达式现在是字符串，而不是数值。

         $family_name{$”fred”}=”flintstone”;

      当名称之前有一个美元符号而之后紧接着花括号，则此处要被访问的正是一个散列元素。

     访问不再散列里的值会得到undef。

  58，访问整个散列

      若要引用整个散列，则以百分比符号%开头。

      %some_hash=(“foo”,35,”hello”,”bye\n”);

      散列的值（在列表上下文中）则是简单的“键-值对”列表。

      @any_array=%some_hash;

      这些“键-值对”并不会保持原先列表的顺序。

59，散列的赋值运算

  一般的赋值语法：%new_hash=%old_hash;

  常见的做法是以某种方式转换散列，如：

  %inverse_hash=reverse %any_hash;

  下面可以轻松地用主机名称或IP地址来检索相应的IP地址或主机名称。

%ip_address=reverse %host_name;

60，大箭号

  将列表赋值到散列时，有时哪个元素是键，哪个元素是值并不怎么明显。

  %some_hash=(“foo”,35,”bar”,12.4,2.5,”hello”);

   Perl设计大箭号(=>)区分列表中的键与值

  上面可改为：

  %some_hash=(

  “foo”=>35,

  “bar”=>12.4,

  2.5=>”hello”);

61，散列函数 keys和values函数

  Keys函数会返回当前散列中所有的键，而values函数所返回的则是相应的每个值。

   My%hash=(“a”=>1,”b”=>2,”c”=>3);

   My@k=keys %hash;

   My@v=values %hash;

  所以，@k会包含”a”,”b”,”c”,而@v则会包含1,2,3,，但不一定会照着这个顺序。

62，each函数

   对整个散列进行迭代，使用each函数是常见的做法。此函数会返回含有两个元素的列表，也就是“键-值对”。

   实际使用时，唯一适合使用each的地方时在while循环中。

  While(($key,$value)=each %hash)

  {

      Print “$key=>$value\n”;

}

63，散列函数 exists函数和delete函数

  要查看某个键是否存在散列中，请使用exists函数

  Delete函数将会从列表中移除所指定的键和相应的值。

64，正则表达式：是一个“匹配”或“不匹配”特定字符串的模板。

65，使用简易模式

  要以某个模式（正则表达式）来匹配$_的内容，请将它放在两个斜线(/)之间。

66，关于元字符（是特殊符号）

  比如：点号（.）是通配符，它会匹配换行符(\n)以外的所有单个字符。

67，简易的量词

  在一个模式串中重复某些字是常见的情况。

  星号(*)会匹配它的前一个项目0次或多次。

  （.*）会匹配任意字符无限多次，故（.*）为“随意什么东西”模式。

  加号(+)会匹配前一个项目一次以上。

  问号(?)表示前一个项目是可有可无的。

68，模式组

  在数学中，圆括号用来归组。在此，圆括号也是元字符。

  模式/(fred)+/会匹配fredfredfred这种字符串。

69，择一匹配

  竖线(|)在这里使用时通常为“或”，表示左边匹配或右边匹配。

70，字符集：方括号（或称中括号）里一连串可能的字符。它只会匹配单一字符，但是该字符可以是字符集里的任何一个。

   字符集以外的连字符不具有特殊意思。

71，字符集简写

（1）      代表任意数字的字符集[0-9]可以被简写为\d。

（2）      “单词”字符[A-Za-z0-9_]可以简写为\w

单词则表示为” \w “

（3）      \s简写擅长处理空白，\s只会匹配字符集里的单一字符，\s*可匹配任意数目的空白。

72，反义简写的排除

   \D、\W或\S，他们所匹配的字符是相应的小写形式所不匹配的字符。即

  [\d]、[\w]、[\s]。

73，以/i来进行不区分大小写的模式匹配

74，以/s来匹配任意字符

   /s会将模式串的每个点号转换成字符集[\d\D]所作的事，来匹配任意字符。

75，用/x加上空白

   加上了/x修饰符之后，就可以在模式里随意加上空白，目的是使它看起来更容易阅读、理解。

   由于在Perl里，注释也算是一种空白，所以只要加上/x，我们甚至可以在模式里加上注释以指明其用途。

76，组合选项修饰符

   在同一个样式里，如果要用到两个以上的选项修饰符，则可将它们接续在一起使用，它们彼此的先后顺序并不会影响匹配的结果。

77，锚点

  加上锚点后，可以让模式直接匹配字符串的某处。

  插入记号(^)是一个锚点，用来标示字符串的开头，而美元符号($)也是一个锚点，用来标示字符串的结尾。

78，单词锚点

  除了字符串两端，还有其他锚点。\b是单词边界锚点，它所匹配的是一个单词的头尾两端。

  这在文字处理器里，通常称为“整字匹配”模式。

79，绑定操作符  =~

  匹配~=只是默认的方式而已。绑定操作符=~用来告诉perl拿右边的模式来匹配左边的字符串，而非匹配=~。

80，匹配变量

 圆括号同时也启动了正则表达式处理引擎的记忆功能。记忆指的是：把圆括号里的模式所实际匹配到的部分字符串暂时记下来的能力。在perl里，它们的命名方式向$1,$2。模式里的括号有多少对，匹配变量就有多少个。

81，记忆的持久性

这些“匹配变量”的内容通常会维持到下一次模式匹配时。也就是说，失败的匹配会保留前次的记忆内容，而成功地匹配会将它们重设。

82，通用量词

到目前为止，已经见过了3个量词：*、+和？。如果这3个量词都不符合需要，还可以在花括号里指定重现次数的范围。

如：/a{5,15}/

如果 省略第二个数字（但包含数字），则表示匹配次数没有上限。

如果同时省略逗号与上限次数，那么花括号里的数字就表示一个固定次数。

83，模式测试程序：测试正则表达式是否匹配成功

#!perl

While(<>){

Chomp;

If(/YOUR_PATTERN_GOES_HERE/){

Print“matched:|$`<$&>$’|\n”;

}else{

Print “no matched:|$_|\n”;

}

}

84，Perl的编译工具是ActivePerl。

85，以S/ / /进行替换

   S/a/b/

   它只会进行一次替换操作。

86，以/g进行全局替换

   /g修饰符可让S/ / /进行所有可能的、互不重叠的替换。

87，大小写转换

   \U转义字符会将其后的所有字符转换成大写

   \L转义字符会将其后的所有字符转换成小写

   \E关闭大小写转换的功能

   使用小写形式（\l与\u）时，只会影响之后的第一个字符。

   虽然这里是替换时的大小写转换，但它们也适用于任何双引号内的字符。

88，split操作符

  根据分隔符拆开一个字符串。这对处理以制表符、冒号、空白或任意符号所分割的数据有用。只要将分隔符写成模式。

  @fields=split/separator/,$string;

  如：my $some_imput=”Thisis a\t  test.\n”;

      my @args=split /\s+/,$some_input;

      #(“This”,”is”,”a”,”test.”)

89,join 函数

  join 与 split相反，会把片段联合成一个字符串。

   my$result=join $glue,@pieces;

             字符串而非模式

90，非贪心的量词

   /fred.+barney/

   先匹配fred，然后匹配(.+)直到文件尾，再逐一回溯匹配barney。

   +？：表示至少一次（跟加号一样），但所匹配到的字符串是越短越好，而不再是越长越好。

   *注：去掉<BOLD>跟</BOLD>标记

 ……with Fred and<BOLD> Wilma</BOLD>!

S#<BOLD>(.*)</BOLD>#$1#g;

若字符串为……with<BOLD> Fred</BOLD> and<BOLD> Wilma</BOLD>.

则去掉的是第一个<BOLD>和最后一个</BOLD>

所以应改为:

  S#<BOLD>(.*?)</BOLD>#$1#g;

           非贪心量词

91，/m修饰符：多行的意思，可对每一个操作。

92，要在Perl中直接修改文件内容，可利用钻石操作符(<>)。

93，系统时间命令：date

94，对于钻石操作符的再理解：它会自动打开文件，而且如果没有指定文件，它就会从标准输入读进数据。此时S^I的默认值为undef。但若S^I中是个字符串，该字符串就会变成备份文件的扩展名。

如：S^I=”.bal”;

若S^I=”“;则不会备份。

95，只从命令行来修改文件：

  $Perl –p –i.bak –w –e ‘s/Randal/Randall/g’  fred*.dat

  -p:选项用来要求Perl帮你写程序

  -i.bak：在程序开始运行之前把S^I设为”.bak”

  -w:开启警告功能

  -e:告诉Perl,”程序来了”

96，不具有记忆功能的圆括号

   在左圆括号后面加上问号和冒号(?:)

   如：(?:bronto)则bronto不会存到$1中。

97，unless控制结构

   让程序块的条件为“假”时执行。

98，until控制结构

   颠倒while循环的方式，

  这个循环一直执行，直到条件为真。

99，{…}：可以把某个变量放到一个未修饰块内并且在块内声明变量。

100，循环控制

（1）      last操作符会立即终止循环的执行，像C语言里面的break。

（2）      next操作符：会跳到当前循环的底端。在next之后，程序将会继续执行循环的下次迭代。跟C语言中的continue相似。

（3）      redo操作符：它会跳回当前循环块的顶端，而不经过任何测试条件，也不会前进到循环的下一次迭代。

（4）      next和redo两者之间最大的不同是next会正常继续下一次操作，但redo则会重新执行该次迭代。

101，在目录树中移动

    程序运行时会以自己的工作目录作为相对路径的起点。

    可以用chdir操作符改变当前的工作目录。

    chdir “/etc” or die “Cannot chdir to /etc:$!”;

102，glob操作符

    会将命令行里的文件名模式展开成所有匹配的文件名。

    my @pm_files=glob “*.pm”;

    @all_files会取得当前目录中的所有文件。

    像barney.pm dino.pmfred.pm Wilma.pm等

103，目录句柄

   若想从目录里取得文件名列表，还可以使用目录句柄。目录句柄看起来像文件句柄。可以打开它（以opendir代替open）、读取它的内容(以readdir代替readline),然后将它关闭（以closedir代替close）。

104，移除文件 unlink操作符

    移除文件的权限跟文件本身的权限无关，它取决于文件所在目录的权限位。

105，重命名文件

    Rename “old”,”new”;

106，建立及移除目录 mkdir函数及rmdir函数

    如：mkdir“fred”,0755 or warn”cannot make freddirectory:$!”;

                 目录建立时的权限

    对rmdir的说明：

    如果目录不是空的，则rmdir操作符会执行失败。可以先用unlink来删除目录的内容，再试着移除应该已经清空的目录。

107，用index寻找子字符串

    $where=index($big,$small);

    在$big字符串里寻找$small字符串首次出现的地方，并且返回一个整数代表第一个字符出现的位置。

    可以再加上第三个参数来指定开始搜索的地方。

    查子字符串最后出现的位置，用rindex函数。

108，使用substr操作子字符串

   $part=substr($string,$initial_position,$length);

   3个参数：一个字符串、一个从零起算的初始值以及子字符串的长度。

   如果想要一只取到字符串结尾，只要省略第三个参数就可以了。

      一个较大字符串中子字符串的起始位置可以为页，表示从字符串结尾开始倒数。