注册
登录
| 关键词： nbsp 变量 子程序 方法 函数 一个 对象 Perl 语句 数组 |
第十三章 Perl的面向对象编程 本章介绍如何使用Perl的面向对象编程(OOP)特性及如何构建对象，还包括继承、方法重载和数据封装等内容。一、模块简介 模块(module)就是Perl包(pachage)。Perl中的对象基于对包中数据项的引用。（引用见第x章引用）。详见http://www.metronet.com的perlmod和perlobj。 在用其它语言进行面向对象编程时，先声明一个类然后创建该类的对象（实例），特定类所有对象的行为方式是相同的，由类方法确定，可以通过定义新类或从现存类继承来创建类。已熟悉面向对象编程的人可以在此遇到许多熟悉的术语。Perl一直是一个面向对象的语言，在Perl5中，语法略有变动，更规范化了对象的使用。 下面三个定义对理解对象、类和方法在Perl中如何工作至关重要。 .类是一个Perl包，其中含提供对象方法的类。 .方法是一个Perl子程序，类名是其第一个参数。 .对象是对类中数据项的引用。二、Perl中的类 再强调一下，一个Perl类是仅是一个包而已。当你看到Perl文档中提到“类”时，把它看作“包”就行了。Perl5的语法可以创建类，如果你已熟悉C++，那么大部分语法你已经掌握了。与Perl4不同的概念是用双冒号(::)来标识基本类和继承类（子类）。 面向对象的一个重要特性是继承。Perl中的继承特性与其它面向对象语言不完全一样，它只继承方法，你必须用自己的机制来实现数据的继承。 因为每个类是一个包，所以它有自己的名字空间及自己的符号名关联数组（详见第x章关联数组），每个类因而可以使用自己的独立符号名集。与包的引用结合，可以用单引号(')操作符来定位类中的变量，类中成员的定位形式如：$class'$member。在Perl5中，可用双冒号替代单引号来获得引用，如：$class'$member与$class::$member相同。三、创建类。 本节介绍创建一个新类的必要步骤。下面使用的例子是创建一个称为Cocoa的简单的类，其功能是输出一个简单的Java应用的源码的必要部分。放心，这个例子不需要你有Java的知识，但也不会使你成为Java专家，其目的是讲述创建类的概念。 首先，创建一个名为Cocoa.pm的包文件(扩展名pm是包的缺省扩展名，意为Perl Module)。一个模块就是一个包，一个包就是一个类。在做其它事之前，先加入“1;”这样一行，当你增加其它行时，记住保留“1;”为最后一行。这是Perl包的必需条件，否则该包就不会被Perl处理。下面是该文件的基本结构。 package Cocoa;## Put "require" statements in for all required,imported packages### Just add code here#1; # terminate the package with the required 1; 接下来，我们往包里添加方法使之成为一个类。第一个需添加的方法是new()，它是创建对象时必须被调用的，new()方法是对象的构造函数。四、构造函数 构造函数是类的子程序，它返回与类名相关的一个引用。将类名与引用相结合称为“祝福”一个对象，因为建立该结合的函数名为bless()，其语法为： bless YeReference [,classname] YeReference是对被“祝福”的对象的引用，classname是可选项，指定对象获取方法的包名，其缺省值为当前包名。 创建一个构建函数的方法为返回已与该类结合的内部结构的引用，如： sub new { my $this = {}; # Create an anonymous hash, and #self points to it. bless $this; # Connect the hash to the package Cocoa. return $this; # Return the reference to the hash.}1; {}创建一个对不含键/值对的哈希表（即关联数组）的引用，返回值被赋给局域变量$this。函数bless()取出该引用，告诉对象它引用的是Cocoa，最后返回该引用。函数的返回值现在指向这个匿名哈希表。 从new()函数返回后，$this引用被销毁，但调用函数保存了对该哈希表的引用，因此该哈希表的引用数不会为零，从而使Perl在内存中保存该哈希表。创建对象可如下调用： $cup = new Cocoa; 下面语句为使用该包创建对象的例子： 1 #!/usr/bin/perl2 push (@INC,'pwd');3 use Cocoa;4 $cup = new Cocoa; 第一行指出Perl解释器的位置，第二行中，将当前目录加到路径寻找列表@INC中供寻找包时使用。你也可以在不同的目录中创建你的模块并指出该绝对路径。例如，如果在/home/test/scripts/创建包，第二行就应该如下： push (@INC , "/home/test/scripts"); 在第三行中，包含上包Cocoa.pm以获取脚本中所需功能。use语句告诉Perl在@INC路径寻找文件Cocoa.pm并包含到解析的源文件拷贝中。use语句是使用类必须的。第四行调用new函数创建对象，这是Perl的妙处，也是其易混淆之处，也是其强大之处。创建对象的方法有多种，可以这样写： $cup = cocoa->new(); 如果你是C程序员，可以用双冒号强制使用Cocoa包中的new()函数，如： $cup = Cocoa::new(); 可以在构造函数中加入更多的代码，如在Cocoa.pm中，可以在每个对象创建时输出一个简单声明，还可以用构造函数初始化变量或设置数组或指针。注意： 1、一定要在构造函数中初始化变量；2、一定要用my函数在方法中创建变量；3、一定不要在方法中使用local，除非真的想把变量传递给其它子程序；4、一定不要在类模块中使用全局变量。 加上声明的Cocoa构造函数如下： sub new { my $this = {}; print "\n /* \n ** Created by Cocoa.pm \n ** Use at own risk"; print "\n ** Did this code even get pass the javac compiler? "; print "\n **/ \n"; bless $this; return $this;} 也可以简单地调用包内或包外的其它函数来做更多的初始化工作，如： sub new { my $this = {} bless $this; $this->doInitialization(); return $this;} 创建类时，应该允许它可被继承，应该可以把类名作为第一个参数来调用new函数，那么new函数就象下面的语句： sub new { my $class = shift; # Get the request class name my $this = {}; bless $this, $class # Use class name to bless() reference $this->doInitialization(); return $this; } 此方法使用户可以下列三种方式之一来进行调用： Cocoa::new() Cocoa->new() new Cocoa 可以多次bless一个引用对象，然而，新的将被bless的类必然把对象已被bless的引用去掉，对C和Pascal程序员来说，这就象把一个指针赋给分配的一块内存，再把同一指针赋给另一块内存而不释放掉前一块内存。总之，一个Perl对象每一时刻只能属于一个类。 对象和引用的真正区别是什么呢？Perl对象被bless以属于某类，引用则不然，如果引用被bless，它将属于一个类，也便成了对象。对象知道自己属于哪个类，引用则不属于任何类。 实例变量 作为构造函数的new()函数的参数叫做实例变量。实例变量在创建对象的每个实例时用于初始化，例如可以用new()函数为对象的每个实例起个名字。 可以用匿名哈希表或匿名数组来保存实例变量。 用哈希表的代码如下： sub new { my $type = shift;my %parm = @_;my $this = {};$this->{'Name'} = $parm{'Name'};$this->{'x'} = $parm{'x'};$this->{'y'} = $parm{'y'};bless $this, $type; } 用数组保存的代码如下： sub new { my $type = shift;my %parm = @_;my $this = [];$this->[0] = $parm{'Name'};$this->[1] = $parm{'x'};$this->[2] = $parm{'y'};bless $this, $type; } 构造对象时，可以如下传递参数： $mug = Cocoa::new( 'Name' => 'top','x' => 10,'y' => 20 ); 操作符=>与逗号操作服功能相同，但=>可读性好。访问方法如下： print "Name=$mug->{'Name'}\n"; print "x=$mug->{'x'}\n"; print "y=$mug->{'y'}\n";五、方法 Perl类的方法只不过是一个Perl子程序而已，也即通常所说的成员函数。Perl的方法定义不提供任何特殊语法，但规定方法的第一个参数为对象或其被引用的包。Perl有两种方法：静态方法和虚方法。 静态方法第一个参数为类名，虚方法第一个参数为对象的引用。方法处理第一个参数的方式决定了它是静态的还是虚的。静态方法一般忽略掉第一个参数，因为它们已经知道自己在哪个类了，构造函数即静态方法。虚方法通常首先把第一个参数shift到变量self或this中，然后将该值作普通的引用使用。如： 1. sub nameLister {2. my $this = shift;3. my ($keys ,$value );4. while (($key, $value) = each (%$this)) {5. print "\t$key is $value.\n";6. }7. } 六、方法的输出 如果你现在想引用Cocoa.pm包，将会得到编译错误说未找到方法，这是因为Cocoa.pm的方法还没有输出。输出方法需要Exporter模块，在包的开始部分加上下列两行： require Exporter; @ISA = qw (Exporter); 这两行包含上Exporter.pm模块，并把Exporter类名加入@ISA数组以供查找。接下来把你自己的类方法列在@EXPORT数组中就可以了。例如想输出方法closeMain和declareMain，语句如下： @EXPORT = qw (declareMain , closeMain); Perl类的继承是通过@ISA数组实现的。@ISA数组不需要在任何包中定义，然而，一旦它被定义，Perl就把它看作目录名的特殊数组。它与@INC数组类似，@INC是包含文件的寻找路径。@ISA数组含有类(包)名，当一个方法在当前包中未找到时就到@ISA中的包去寻找。@ISA中还含有当前类继承的基类名。 类中调用的所有方法必须属于同一个类或@ISA数组定义的基类。如果一个方法在@ISA数组中未找到，Perl就到AUTOLOAD()子程序中寻找，这个可选的子程序在当前包中用sub定义。若使用AUTOLOAD子程序，必须用use Autoload;语句调用autoload.pm包。AUTOLOAD子程序尝试从已安装的Perl库中装载调用的方法。如果AUTOLOAD也失败了，Perl再到UNIVERSAL类做最后一次尝试，如果仍失败，Perl就生成关于该无法解析函数的错误。七、方法的调用 调用一个对象的方法有两种方法，一是通过该对象的引用（虚方法），一是直接使用类名（静态方法）。当然该方法必须已被输出。现在给Cocoa类增加一些方法，代码如下： package Cocoa;require Exporter;@ISA = qw(Exporter);@EXPORT = qw(setImports, declareMain, closeMain);## This routine creates the references for imports in Java functions#sub setImports{ my $class = shift @_; my @names = @_; foreach (@names) { print "import " . $_ . ";\n"; } }## This routine declares the main function in a Java script#sub declareMain{ my $class = shift @_; my ( $name, $extends, $implements) = @_; print "\n public class $name"; if ($extends) { print " extends " . $extends; } if ($implements) { print " implements " . $implements; } print " { \n";}## This routine declares the main function in a Java script#sub closeMain{ print "} \n";}## This subroutine creates the header for the file.#sub new { my $this = {}; print "\n /* \n ** Created by Cocoa.pm \n ** Use at own risk \n */ \n"; bless $this; return $this;}1; 现在，我们写一个简单的Perl脚本来使用该类的方法，下面是创建一个Java applet源代码骨架的脚本代码： #!/usr/bin/perluse Cocoa;$cup = new Cocoa;$cup->setImports( 'java.io.InputStream', 'java.net.*');$cup->declareMain( "Msg" , "java.applet.Applet", "Runnable");$cup->closeMain(); 这段脚本创建了一个叫做Msg的Java applet，它扩展(extend)了java.applet.Applet小应用程序并使之可运行(runnable)，其中最后三行也可以写成如下： Cocoa::setImports($cup, 'java.io.InputStream', 'java.net.*');Cocoa::declareMain($cup, "Msg" , "java.applet.Applet", "Runnable");Cocoa::closeMain($cup); 其运行结果如下： /*** Created by Cocoa.pm** Use at own risk */import java.io.InputStream;import java.net.*;public class Msg extends java.applet.Applet implements Runnable {} 注意：如果用->操作符调用方法（也叫间接调用），参数必须用括号括起来，如：$cup->setImports( 'java.io.InputStream', 'java.net.*');而双冒号调用如：Cocoa::setImports($cup, 'java.io.InputStream', 'java.net.*');也可去掉括号写成：Cocoa::setImports $cup, 'java.io.InputStream', 'java.net.*' ;八、重载 有时需要指定使用哪个类的方法，如两个不同的类有同名方法的时候。假设类Espresso和Qava都定义了方法grind，可以用::操作符指定使用Qava的方法： $mess = Qava::grind("whole","lotta","bags"); Qava::grind($mess, "whole","lotta","bags"); 可以根据程序的运行情况来选择使用哪个类的方法，这可以通过使用符号引用去调用来实现： $method = $local ? "Qava::" : "Espresso::"; $cup->{$method}grind(@args);九、析构函数 Perl跟踪对象的链接数目，当某对象的最后一个应用释放到内存池时，该对象就自动销毁。对象的析构发生在代码停止后，脚本将要结束时。对于全局变量而言，析构发生在最后一行代码运行之后。 如果你想在对象被释放之前获取控制权，可以定义DESTROY()方法。DESTROY()在对象将释放前被调用，使你可以做一些清理工作。DESTROY()函数不自动调用其它DESTROY()函数，Perl不做内置的析构工作。如果构造函数从基类多次bless，DESTROY()可能需要调用其它类的DESTROY()函数。当一个对象被释放时，其内含的所有对象引用自动释放、销毁。 一般来说，不需要定义DESTROY()函数，如果需要，其形式如下： sub DESTROY {## Add code here.#} 因为多种目的，Perl使用了简单的、基于引用的垃圾回收系统。任何对象的引用数目必须大于零，否则该对象的内存就被释放。当程序退出时，Perl的一个彻底的查找并销毁函数进行垃圾回收，进程中的一切被简单地删除。在UNIX类的系统中，这像是多余的，但在内嵌式系统或多线程环境中这确实很必要。十、继承 类方法通过@ISA数组继承，变量的继承必须明确设定。下例创建两个类Bean.pm和Coffee.pm，其中Coffee.pm继承Bean.pm的一些功能。此例演示如何从基类（或称超类）继承实例变量，其方法为调用基类的构造函数并把自己的实例变量加到新对象中。 Bean.pm代码如下： package Bean;require Exporter;@ISA = qw(Exporter);@EXPORT = qw(setBeanType);sub new { my $type = shift; my $this = {}; $this->{'Bean'} = 'Colombian'; bless $this, $type; return $this;}## This subroutine sets the class namesub setBeanType{ my ($class, $name) = @_; $class->{'Bean'} = $name; print "Set bean to $name \n";}1; 此类中，用$this变量设置一个匿名哈希表，将'Bean'类型设为'Colombian'。方法setBeanType()用于改变'Bean'类型，它使用$class引用获得对对象哈希表的访问。 Coffee.pm代码如下： 1 #2 # The Coffee.pm file to illustrate inheritance.3 #4 package Coffee;5 require Exporter;6 require Bean;7 @ISA = qw(Exporter, Bean);8 @EXPORT = qw(setImports, declareMain, closeMain);9 #10 # set item11 #12 sub setCoffeeType{13 my ($class,$name) = @_;14 $class->{'Coffee'} = $name;15 print "Set coffee type to $name \n";16 }17 #18 # constructor19 #20 sub new {21 my $type = shift;22 my $this = Bean->new(); ##### <- LOOK HERE!!! ####23 $this->{'Coffee'} = 'Instant'; # unless told otherwise24 bless $this, $type;25 return $this;26 }27 1; 第6行的require Bean;语句包含了Bean.pm文件和所有相关函数，方法setCoffeeType()用于设置局域变量$class->{'Coffee'}的值。在构造函数new()中，$this指向Bean.pm返回的匿名哈希表的指针，而不是在本地创建一个，下面两个语句分别为创建不同的哈希表从而与Bean.pm构造函数创建的哈希表无关的情况和继承的情况： my $this = {}; #非继承 my $this = $theSuperClass->new(); #继承 下面代码演示如何调用继承的方法： 1 #!/usr/bin/perl2 push (@INC,'pwd');3 use Coffee;4 $cup = new Coffee;5 print "\n -------------------- Initial values ------------ \n";6 print "Coffee: $cup->{'Coffee'} \n";7 print "Bean: $cup->{'Bean'} \n";8 print "\n -------------------- Change Bean Type ---------- \n";9 $cup->setBeanType('Mixed');10 print "Bean Type is now $cup->{'Bean'} \n";11 print "\n ------------------ Change Coffee Type ---------- \n";12 $cup->setCoffeeType('Instant');13 print "Type of coffee: $cup->{'Coffee'} \n"; 该代码的结果输出如下： -------------------- Initial values ------------Coffee: InstantBean: Colombian-------------------- Change Bean Type ----------Set bean to MixedBean Type is now Mixed ------------------ Change Coffee Type ----------Set coffee type to InstantType of coffee: Instant 上述代码中，先输出对象创建时哈希表中索引为'Bean'和'Coffee'的值，然后调用各成员函数改变值后再输出。 方法可以有多个参数，现在向Coffee.pm模块增加函数makeCup()，代码如下： sub makeCup { my ($class, $cream, $sugar, $dope) = @_; print "\n================================== \n"; print "Making a cup \n"; print "Add cream \n" if ($cream); print "Add $sugar sugar cubes\n" if ($sugar); print "Making some really addictive coffee ;-) \n" if ($dope); print "================================== \n";} 此函数可有三个参数，不同数目、值的参数产生不同的结果，例如： 1 #!/usr/bin/perl2 push (@INC,'pwd');3 use Coffee;4 $cup = new Coffee;5 #6 # With no parameters7 #8 print "\n Calling with no parameters: \n";9 $cup->makeCup;10 #11 # With one parameter12 #13 print "\n Calling with one parameter: \n";14 $cup->makeCup('1');15 #16 # With two parameters17 #18 print "\n Calling with two parameters: \n";19 $cup->makeCup(1,'2');20 #21 # With all three parameters22 #23 print "\n Calling with three parameters: \n";24 $cup->makeCup('1',3,'1'); 其结果输出如下： Calling with no parameters:==================================Making a cup==================================Calling with one parameter:==================================Making a cupAdd cream==================================Calling with two parameters:==================================Making a cupAdd creamAdd 2 sugar cubes==================================Calling with three parameters:==================================Making a cupAdd creamAdd 3 sugar cubesMaking some really addictive coffee ;-)================================== 在此例中，函数makeCup()的参数既可为字符串也可为整数，处理结果相同，你也可以把这两种类型的数据处理区分开。在对参数的处理中，可以设置缺省的值，也可以根据实际输入参数值的个数给予不同处理。十一、子类方法的重载 继承的好处在于可以获得基类输出的方法的功能，而有时需要对基类的方法重载以获得更具体或不同的功能。下面在Bean.pm类中加入方法printType()，代码如下： sub printType { my $class = shift @_; print "The type of Bean is $class->{'Bean'} \n";} 然后更新其@EXPORT数组来输出： @EXPORT = qw ( setBeanType , printType ); 现在来调用函数printType()，有三种调用方法： $cup->Coffee::printType();$cup->printType();$cup->Bean::printType(); 输出分别如下： The type of Bean is MixedThe type of Bean is MixedThe type of Bean is Mixed 为什么都一样呢？因为在子类中没有定义函数printType()，所以实际均调用了基类中的方法。如果想使子类有其自己的printType()函数，必须在Coffee.pm类中加以定义： ## This routine prints the type of $class->{'Coffee'}#sub printType { my $class = shift @_; print "The type of Coffee is $class->{'Coffee'} \n";} 然后更新其@EXPORT数组： @EXPORT = qw(setImports, declareMain, closeMain, printType); 现在输出结果变成了： The type of Coffee is InstantThe type of Coffee is InstantThe type of Bean is Mixed 现在只有当给定了Bean::时才调用基类的方法，否则直接调用子类的方法。 那么如果不知道基类名该如何调用基类方法呢？方法是使用伪类保留字SUPER::。在类方法内使用语法如：$this->SUPER::function(...argument list...); ，它将从@ISA列表中寻找。刚才的语句用SUPER::替换Bean::可以写为$cup->SUPER::printType(); ，其结果输出相同，为： The type of Bean is Mixed十二、Perl类和对象的一些注释 OOP的最大好处就是代码重用。OOP用数据封装来隐藏一些复杂的代码，Perl的包和模块通过my函数提供数据封装功能，但是Perl并不保证子类一定不会直接访问基类的变量，这确实减少了数据封装的好处，虽然这种动作是可以做到的，但却是个很坏的编程风格。注意： 1、一定要通过方法来访问类变量。2、一定不要从模块外部直接访问类变量。 当编写包时，应该保证方法所需的条件已具备或通过参数传递给它。在包内部，应保证对全局变量的访问只用通过方法传递的引用来访问。对于方法要使用的静态或全局数据，应该在基类中用local()来定义，子类通过调用基类来获取。有时，子类可能需要改变这种数据，这时，基类可能就不知道怎样去寻找新的数据，因此，这时最好定义对该数据的引用，子类和基类都通过引用来改变该数据。 最后，你将看到如下方式来使用对象和类： use coffee::Bean; 这句语句的含义是“在@INC数组所有目录的Coffee子目录来寻找Bean.pm”。如果把Bean.pm移到./Coffee目录，上面的例子将用这一use语句来工作。这样的好处是有条理地组织类的代码。再如，下面的语句： use Another::Sub::Menu; 意味着如下子目录树： ./Another/Sub/Menu.pm 第十四章 Perl5的包和模块 一、require函数 用require函数可以把程序分割成多个文件并创建函数库。例如，在myfile.pl中有定义好的Perl函数，可用语句require ("myfile.pl"); 在程序中包含进来。当Perl解释器看到这一语句，就在内置数组变量@INC指定的目录中寻找文件myfile.pl。如果找到了，该文件中的语句就被执行，否则程序终止并输出错误信息： Can't find myfile.pl in @INC 作为子程序调用参数，文件中最后一个表达式的值成为返回值，require函数查看其是否为零，若为零则终止。例如myfile.pl最后的语句是： print ("hello, world!\n"); $var = 0; 因为最后的语句值为零，Perl解释器输出下列错误信息并推出： myfile.pl did not reture true value 可以用简单变量或数组元素等向require传递参数，如： @reqlist = ("file1.pl", "file2.pl", "file3.pl");require ($reqlist[$0]);require ($reqlist[$1]);require ($reqlist[$2]); 还可以不指定文件名，即： require; 这时，变量$_的值即作为文件名传递给require。 注：如果@INC中有多个目录中含有同一个文件，则只有第一个被包含。1、require函数和子程序库 用require函数可以创建可用于所有Perl程序的子程序库，步骤如下： a、确定存贮子程序库的目录b、将子程序抽取放到单独的文件中，将文件放到子程序库目录c、每个文件末尾加一句非零值的语句，最简单的办法是语句 1;d、在主程序中用require包含一个或多个所需的文件。e、运行主程序时，用 -I 选项指定子程序库目录，或者在调用require前将该目录添加到@INC数组中。 例如：假设目录/u/perldir中存有你的Perl子程序库，子程序mysub存贮在文件mysub.pl中。现在来包含上该文件： unshift (@INC, "/u/perldir"); require ("mysub.pl"); 对unshift的调用把目录/u/perldir添加到@INC数组，对require的调用将mysub.pl文件的内容包含进来作为程序的一部分。注意： 1、应该使用unshift来向@INC中添加目录，而不是push。因为push增加到@INC的末尾，则该目录将被最后搜寻。2、如果你的库文件名与/usr/local/lib/perl中的某文件同名，则不会被包含进来，因为require只包含同名文件中的第一个。 2、用require指定Perl版本 Perl 5中，可以用require语句来指定程序运行所需的Perl版本。当Perl解释器看到require后跟着数字时，则只有其版本高于或等于该数字时才运行该程序。例如，下面语句表明只有Perl解释器为5.001版或更高时才运行该程序： require 5.001;二、包 Perl程序把变量和子程序的名称存贮到符号表中，perl的符号表中名字的集合就称为包(package)。1、包的定义 在一个程序中可以定义多个包，每个包有一个单独的符号表，定义语法为： package mypack; 此语句定义一个名为mypack的包，从此以后定义的所有变量和子程序的名字都存贮在该包关联的符号表中，直到遇到另一个package语句为止。 每个符号表有其自己的一组变量、子程序名，各组名字是不相关的，因此可以在不同的包中使用相同的变量名，而代表的是不同的变量。如： $var = 14;package mypack;$var = 6; 第一个语句创建变量$var并存贮在main符号表中，第三个语句创建另一个同名变量$var并存贮在mypack包的符号表中。2、在包间切换 在程序里可以随时在包间来回切换，如： 1: #!/usr/local/bin/perl2: 3: package pack1;4: $var = 26;5: package pack2;6: $var = 34;7: package pack1;8: print ("$var\n"); 运行结果如下： $ program26$ 第三行定义了包pack1，第四行创建变量$var，存贮在包pack1的符号表中，第五行定义新包pack2，第六行创建另一个变量$var，存贮在包pack2的符号表中。这样就有两个独立的$var，分别存贮在不同的包中。第七行又指定pack1为当前包，因为包pack1已经定义，这样，所有变量和子程序的定义和调用都为该包的符号表中存贮的名字。因此第八行对$var的调用为pack1包中的$var，其值为26。3、main包 存贮变量和子程序的名字的缺省符号表是与名为main的包相关联的。如果在程序里定义了其它的包，当你想切换回去使用缺省的符号表，可以重新指定main包： package main; 这样，接下来的程序就好象从没定义过包一样，变量和子程序的名字象通常那样存贮。4、包的引用 在一个包中可以引用其它包中的变量或子程序，方法是在变量名前面加上包名和一个单引号，如： package mypack;$var = 26;package main;print ("$mypack'var\n"); 这里，$mypack'var为mypack包中的变量$var。 注意：在Perl 5中，包名和变量名用双冒号隔开，即$mypack::var。单引号引用的方式仍然支持，但将来的版本中未必支持。5、指定无当前包 在Perl 5中，可以用如下语句指定无当前包： package; 这时，所有的变量必须明确指出所属包名，否则就无效--错误。 $mypack::var = 21; #ok $var = 21; #error - no current package 这种情况直到用package语句指定当前包为止。6、包和子程序 包的定义影响到程序中的所有语句，包括子程序，如： package mypack;subroutine mysub { local ($myvar); # stuff goes here} 这里，mysub和myvar都是包mypack的一部分。在包mypack外调用子程序mysub，则要指定包：$mypack'mysub。 可以在子程序中切换包： package pack1;subroutine mysub { $var1 = 1; package pack2; $var1 = 2;} 这段代码创建了两个变量$var1，一个在包pack1中，一个在包pack2中，包中的局域变量只能在其定义的子程序等语句块中使用，像普通的局域变量一样。7、用包定义私有数据 包最通常的用途是用在含有子程序和子程序所使用的全局变量的文件中，为子程序定义这样的包，可以保证子程序使用的全局变量不可在其它地方使用，这样的数据即为私有数据。更进一步，可以保证包名不可在其它地方使用。私有数据例： 1 : package privpack;2 : $valtoprint = 46;3 : 4 : package main;5 : # This function is the link to the outside world.6 : sub printval {7 : &privpack'printval();8 : }9 :10: package privpack;11: sub printval {12: print ("$valtoprint\n");13: }14:15: package main;16: 1; # return value for require 此子程序只有在调用printval后才能产生输出。 该文件分为两个部分：与外界联系的部分和私有部分。前者为缺省的main包，后者为包privpack。第6~8行定义的子程序printval可被其它程序或子程序调用。printval输出变量$valtoprint的值，此变量仅在包privpack中定义和使用。第15、16行确保其被其它程序用require语句包含后工作正常，15行将当前包设置回缺省包main，16行返回非零值使require不报错。8、包和系统变量 下列变量即使从其它包中调用，也在main包中起作用： 文件变量STDIN, STDOUT, STDERR 和 ARGV 变量%ENV, %INC, @INC, $ARGV 和 @ARGV 其它含有特殊字符的系统变量 9、访问符号表 在程序中查找符号表可用数组%_package，此处package为想访问的符号表所属的包名。例如%_main含有缺省的符号表。 通常不需要亲自查找符号表。三、模块 多数大型程序都分割成多个部件，每一部件通常含有一个或多个子程序及相关的变量，执行特定的一个或多个任务。集合了变量和子程序的部件称为程序模块。1、创建模块 Perl 5中用包来创建模块，方法是创建包并将之存在同名的文件中。例如，名为Mymodult的包存贮在文件Mymodult.pm中（扩展名.pm表示Perl Module）。下例的模块Mymodult含有子程序myfunc1和myfunc2及变量$myvar1和$myvar2。 1 : #!/usr/local/bin/perl2 :3 : package Mymodule;4 : require Exporter;5 : @ISA = qw(Exporter);6 : @EXPORT = qw(myfunc1 myfunc2);7 : @EXPORT_OK = qw($myvar1 $myvar2);8 :9 : sub myfunc1 {10: $myvar1 += 1;11: }12:13: sub myfunc2 {14: $myvar2 += 2; 15: } 第3~7行是标准的Perl模块定义方式。第3行定义包，第4行包含内置Perl模块Exporter，6、7行进行子程序和变量的输出以与外界联系。第6行创建名为@EXPORT的特殊数组，该数组中的子程序可以被其它程序调用，这里，myfunc1和myfunc2可以被访问。其它任何在模块中定义但没有赋给数组@EXPORT的子程序都是私有的，只能在模块内部调用。第7行创建另一个名为@EXPORT_OK的特殊数组，其中含有可被外部程序访问的变量，这里含有$myvar1和$myvar2。2、导入模块 将模块导入你的Perl程序中使用use语句，如下句导入了Mymodule模块： use Mymodule; 这样，模块Mymodule中的子程序和变量就可以使用了。 取消导入模块使用no语句，如下句取消了Mymodule模块的导入： no Mymodule; 下面看一个导入模块和取消导入的例子，使用integer模块要求所有数字运算基于整数，浮点数在运算前均被转化为整数。 1: #!/usr/local/bin/perl2:3: use integer;4: $result = 2.4 + 2.4;5: print ("$result\n");6:7: no integer;8: $result = 2.4 + 2.4;9: print ("$result\n"); 程序输出如下： $ program44.8$ 如果use或no语句出现在语句块中，则只在该块的有效范围内起作用，如： use integer;$result1 = 2.4 + 2.4;if ($result1 == 4) {no integer;$result2 = 3.4 + 3.4;}$result3 = 4.4 + 4.4; 结果输出如下： 46.88 这里，no语句只在if语句中有效，出了if语句仍使用integer模块，因此4.4在做加法前被转化成了4。3、预定义模块 Perl 5提供了许多有用的预定义模块，可以用use导入和no语句取消。下面是库中最有用的一些模块： integer 使用整数运算 Diagnostics 输出较多的诊断信息（警告） English 允许英文名用作系统变量的别名 Env 导入环境变量的Perl模块 POSIX POSIX标准（IEEE 1003.1）的Perl接口 Socket 装载C语言的套接字处理机制 Perl文档中有完整的预定义模块列表。 注：世界各地的Perl 5用户写了许多有用的模块，CPAN(Comprehensive Perl Archive Network)的Perl文档有其完整的列表。关于CPAN的更多信息见其网址：http://www.perl.com/perl/CPAN/README.html。 |
|
声明：文章版权归原作者所有 部分文章转自互联网 如有侵权请联系
[邮箱地址] 删除
|
