perl的語言特點

2010-09-26 星期六 晴朗 1. It is an interpreted language. 2.  It supports procedural, functional, and object-orientation programming. 3. Built-in regular expressions make it extremely suitable for web application development because web application programming involves processing and parsing data. With Perl, this is trivial. 4. Processing strings in other languages isn’t as elegant as it is with Perl since regular expressions are part of Perl. 5. It has its own garbage collection — you don’t have to explicitly allocate and free required memory, a common source of errors in programming languages without garbage collection. 6. It possesses C/shell-like syntax. 7.  It’s a very loosely typed language. Variable types (scalars, arrays, hashes) are indicated by the type of sigil in front of the variable name. (使用sigil印記來标注：$,@,%,etc.) 8.  It supports scoping —lexical, global, dynamic  9. It has a C API that allows for writing Perl programs that can internally call C programs as well as create Perl packages that interact at a lower level with a library such as a database driver. 10. It has an extensive library of Perl packages, CPAN (Comprehensive Archive Network), that provides reusable functionality for an endless number of features, needs, tasks, including the kitchen sink! Perl’s variables are all objects. Perl Data Types The basic data types of Perl are scalars, arrays, hashes, file handles, type globs, and subroutines. Perl需要顯示的dereferenced——使用$$ Variable Scope The point here is to explain scoping of variables in Perl. The Perl scoping mechanisms are:

•  my: This is lexical scoping, meaning that the variable is only visible within the block of code it is declared in, including functions called within that block. For instance, in the following code, even though the variable $val assumes a value of the current value being iterated over, since it is declared as my, aka lexical, within that for loop (in a block, within brackets). It is not the same variable as the variable $val declared at the beginning of mysub(). The variable $val, is returned at the end of mysub(), which returns a reference to this lexical variable, giving it life beyond mysub(). This means the variable $val itself is no longer in scope, but rather a reference to it. It is returned, gives access to it, and it ‘‘survives.’’ Internally, Perl keeps a reference count of variables that is a count of any reference created for this variable. When the reference count reaches zero,

the variable is destroyed. sub mysub {     my $val= ‘x’;     for (0 .. 1) {         my $val= $_;     }      return $val; }

•  local: This is dynamic scoping, meaning dynamic variables are visible to functions called within a block where those variables are declared. In other words, if you declare a global (package) variable and in another block declare that same variable as local, the value it previously had is temporarily stashed, and the new value assigned. Once the block containing the variable scoped as local is exited, the previous original value (prior to the local assignment) is assumed. This gives local the effect of being able to temporarily override a global variable with a different value without losing the original value, hence the name dynamic scoping.
• our: This is package scoping, meaning all subroutines have access to this variable. In previous versions of Perl, this was done by the following:

    use vars qw(var1 var2);     $var1= ‘some value’;     $var2= 33; It is now done with:     our ($var1, $var2); Scope Example Working code is always a good way to see a concept in action. The following example shows how scoping works: our $foo= "our foo"; sub main {

print "main: $foo/n"; my_foo(’main’); local_foo(’main’);

} sub my_foo {

my ($caller)= @_; my $foo= "my foo"; print "my_foo foo: $foo, caller $caller/n"; inner_foo(’my_foo’);

} sub local_foo {

my ($caller)= @_; local $foo= "local foo"; print "local_foo foo: $foo, caller $caller/n"; inner_foo(’local_foo’);

} sub inner_foo {

my ($caller)= @_; print "1: inner_foo foo $foo, caller $caller/n"; my $foo= "my foo"; print "2: inner_foo foo $foo, caller $caller/n";

} main(); Notice the following about the previous example: 1. The global/package variable $foo is declared at the top level of the code, outside any subroutines. This makes this variable visible in all subroutines. 2. The main() subroutine just prints out $foo without making any changes. 3. my_foo() declares a lexical $foo, which is not the global $foo, that will have its own value that is only scoped within my_foo() and not available to inner_foo(), which it then calls. 4. local_foo() scopes $foo as local, which will temporarily set the global $foo to "local foo". This should be visible to inner_foo(), which it calls, until the end of local_foo(). 5. inner_foo() first prints out whatever the current value of $foo is, then declares its own lexical $foo, just to drive home the idea of lexical variables. Regardless of whatever value that $foo was, whether scoped via our or local, the lexical variable will be "inner foo" until the end of inner_foo(). The program’s output confirms the expected functionality: main: our foo my_foo foo: my foo, caller main 1: inner_foo foo our foo, caller my_foo 2: inner_foo foo my foo, caller my_foo local_foo foo: local foo, caller main 1: inner_foo foo local foo, caller local_foo 2: inner_foo foo my foo, caller local_foo local的含義與python中的global含義想法，但是作用相同，這是因為在這些動态腳本語言中沒有顯示的變量聲明導緻的。