名前¶

perlintro -- Perl の概要

説明¶

この文書は Perl プログラミング言語の簡単な概要を伝えて、更なる 文書へのポインタを示すことを目的としています。 これはこの言語を知らない人のためへの「自習」ガイドを目的としていて、 他の人の Perl を読んで何をしているかを大まかに理解したり、 自分自身で簡単なスクリプトを書くことができるようになるために 十分な情報を提供しています。

この導入文書は完全性を目的とはしていません。 完全な正確性すらも目的にしていません。 場合によっては、一般的な考え方を得るというゴールのために正確性を犠牲にしています。 この概要を読んだ後、完全な Perl マニュアル(目次は perltoc にあります)から さらなる情報を得ることを強く 勧めます。

この文書のあちこちに、他の Perl 文書のへの参照があります。 これらの文書は、perldoc コマンドや、この文書を読むために使っている 方法を使って読むことができます。

Perl って何?¶

Perl は、元々テキスト操作のために開発されましたが、今では システム管理、ウェブ開発、ネットワークプログラミング、GUI 開発などを 含む広い範囲で使われている汎用プログラミング言語です。

この言語は、綺麗さ (小規模、エレガント、最少) ではなく、 実用性 (使い易さ、効率、完全性) を目指しています。 主な機能は、簡単に使える、手続き的とオブジェクト指向 (OO) の両方で プログラミングできる、テキスト処理のための強力な組み込み機能がある、 世界でもっともめざましいサードパーティモジュールのコレクションがある、と いったことです。

Perl の異なった定義は perl と perlfaq1 にあり、きっと他の 場所にもあります。 ここから、Perl は色々な人によって色々な定義ができますが、多くの人々は 少なくとも書く価値があると考えています。

Perl プログラムの実行¶

Unix コマンドラインから Perl プログラムを実行するには:

    perl progname.pl

あるいは、スクリプトの先頭行に以下のように書いておいて:

    #!/usr/bin/env perl

…そしてスクリプトを /path/to/script.pl として実行します。 もちろん、このためには先に (Unix では) chmod 755 script.pl のようにして、 実行可能にする必要があります。

(この開始行は、env プログラムがあることを仮定しています。 #!/usr/bin/perl のように、perl 実行ファイルへのパスを直接 書くこともできます)。

Windows や Mac OS のような他のプラットホームでの説明を含む、さらなる 情報については、perlrun を読んでください。

セーフティネット¶

Perl はデフォルトでは非常に寛大です。 より堅牢にするには、全てのプログラムの先頭に以下の行を書くことが 推奨されています:

    #!/usr/bin/perl
    use strict;
    use warnings;

追加した 2 行は、コードにある様々な一般的な問題を捕らえるように perl に 要求します。 この 2 行は別のことをチェックするので、両方が必要です。 use strict; によって捕捉される潜在的な問題は、コードに発見されると 直ちに停止する一方、use warnings; は (コマンドラインオプション -w と同様) 警告を出すだけで、コードは実行されます。 これらに関するさらなる情報は、strict と warnings にあるそれぞれの マニュアルページをチェックしてください。

基本的な文法の概要¶

Perl スクリプトあるいはプログラムは 1 行以上の文で構成されます。 これらの文は直接的な形でスクリプトに書かれます。 main() 関数あるいは似たようなものは不要です。

Perl の文はセミコロンで終端されます:

    print "Hello, world";

コメントは # マークで始まり、行末まで続きます:

    # This is a comment

    # これはコメント

空白は無視されます:

    print
        "Hello, world"
        ;

    # this would print with a linebreak in the middle
    print "Hello
    world";

    # これは途中に改行が入る
    print "Hello
    world";

ダブルクォートやシングルクォートはリテラル文字列をくくるのに使われます:

    print "Hello, world";
    print 'Hello, world';

しかし、ダブルクォートのみが変数と改行(\n)のような特殊文字を 「展開」します:

    print "Hello, $name\n";     # works fine
    print 'Hello, $name\n';     # prints $name\n literally

    print "Hello, $name\n";     # うまく動作する
    print 'Hello, $name\n';     # $name\n という文字をそのまま表示する

数値はクォートする必要はありません:

    print 42;

関数の引数のかっこは、好みで付けたり省略したりできます。 必要なのは、優先順位の問題を明確化するときだけです。

    print("Hello, world\n");
    print "Hello, world\n";

Perl の文法に関するさらに詳細な情報は perlsyn にあります。

Perl の変数型¶

Perl には三つの主な変数型があります: スカラ、配列、ハッシュです。

Scalars

(スカラ)

A scalar represents a single value:

スカラは単一の値を表現します:

    my $animal = "camel";
    my $answer = 42;

Scalar values can be strings, integers or floating point numbers, and Perl will automatically convert between them as required. There is no need to pre-declare your variable types, but you have to declare them using the my keyword the first time you use them. (This is one of the requirements of use strict;.)

スカラ値には文字列、整数、浮動小数点数があり、Perl は必要なときに自動的に これらの値を相互に変換します。 変数型を事前に宣言する必要はありませんが、変数を使うときには my キーワードを使って宣言する必要があります。 (これは use strict; が要求することの一つです。)

Scalar values can be used in various ways:

スカラ値は色々な方法で利用できます:

    print $animal;
    print "The animal is $animal\n";
    print "The square of $answer is ", $answer * $answer, "\n";

There are a number of "magic" scalars with names that look like punctuation or line noise. These special variables are used for all kinds of purposes, and are documented in perlvar. The only one you need to know about for now is $_ which is the "default variable". It's used as the default argument to a number of functions in Perl, and it's set implicitly by certain looping constructs.

句読点や回線ノイズのように見える名前を持った、多くの「マジック」変数が あります。 これらの特殊変数はあらゆる目的のために利用され、perlvar に 文書化されています。 今のところ知っておくべきただ一つのことは、「デフォルト変数」である $_ です。 これは Perl の多くの関数でデフォルト引数として使われ、ある種のループ構造で 暗黙に設定されます。

    print;          # prints contents of $_ by default

    print;          # デフォルトで $_ の内容を表示する

Arrays

(配列)

An array represents a list of values:

配列は値のリストを表現します:

    my @animals = ("camel", "llama", "owl");
    my @numbers = (23, 42, 69);
    my @mixed   = ("camel", 42, 1.23);

Arrays are zero-indexed. Here's how you get at elements in an array:

配列は添え字 0 から始まります。 以下は配列の要素を取得する方法です:

    print $animals[0];              # prints "camel"
    print $animals[1];              # prints "llama"

    print $animals[0];              # "camel" を表示する
    print $animals[1];              # "llama" を表示する

The special variable $#array tells you the index of the last element of an array:

特殊変数 $#array は、配列の最後の要素の添え字を返します:

    print $mixed[$#mixed];       # last element, prints 1.23

    print $mixed[$#mixed];       # 最後の要素である 1.23 を表示する

You might be tempted to use $#array + 1 to tell you how many items there are in an array. Don't bother. As it happens, using @array where Perl expects to find a scalar value ("in scalar context") will give you the number of elements in the array:

配列にある要素の数を知るのに $#array + 1 を使いたくなるかも知れません。 心配はいりません。 偶然にも、Perl がスカラ値を想定しているところ(「スカラコンテキスト」)で @array を使うと、配列の要素の数を返します:

    if (@animals < 5) { ... }

The elements we're getting from the array start with a $ because we're getting just a single value out of the array -- you ask for a scalar, you get a scalar.

配列から一つの値を取り出したいだけなので、配列の要素は $ で始まります -- スカラを得ようとすれば、スカラを得ます。

To get multiple values from an array:

配列から複数の値を得るには:

    @animals[0,1];                  # gives ("camel", "llama");
    @animals[0..2];                 # gives ("camel", "llama", "owl");
    @animals[1..$#animals];         # gives all except the first element

    @animals[0,1];                  # ("camel", "llama") を返す
    @animals[0..2];                 # ("camel", "llama", "owl") を返す
    @animals[1..$#animals];         # 最初の要素以外全てを返す

This is called an "array slice".

これは「配列スライス」と呼ばれます。

You can do various useful things to lists:

リストに対して色々便利なことが出来ます:

    my @sorted    = sort @animals;
    my @backwards = reverse @numbers;

There are a couple of special arrays too, such as @ARGV (the command line arguments to your script) and @_ (the arguments passed to a subroutine). These are documented in perlvar.

@ARGV (スクリプトのコマンドライン引数) や @_ (サブルーチンに渡された 引数) のように、色々な特殊配列もあります。 これらは perlvar に文書化されています。

Hashes

(ハッシュ)

A hash represents a set of key/value pairs:

ハッシュはキー/値の組の集合を表現します:

    my %fruit_color = ("apple", "red", "banana", "yellow");

You can use whitespace and the => operator to lay them out more nicely:

より見やすくするために、空白と => 演算子が使えます:

    my %fruit_color = (
        apple  => "red",
        banana => "yellow",
    );

To get at hash elements:

ハッシュの要素を得るには:

    $fruit_color{"apple"};           # gives "red"

    $fruit_color{"apple"};           # "red" を返す

You can get at lists of keys and values with keys() and values().

キーのリストと値のリストは keys() と values() で得られます。

    my @fruits = keys %fruit_colors;
    my @colors = values %fruit_colors;

Hashes have no particular internal order, though you can sort the keys and loop through them.

ハッシュには特に決まった順序はありませんが、キーをソートして、 それを使ってループできます。

Just like special scalars and arrays, there are also special hashes. The most well known of these is %ENV which contains environment variables. Read all about it (and other special variables) in perlvar.

特殊スカラおよび配列と同様、特殊ハッシュもあります。 そのうち最もよく知られているものは、環境変数が入っている %ENV です。 これら全て (およびその他の特殊変数) は perlvar にあります。

スカラ、配列、ハッシュについては perldata により完全に 文書化されています。

より複雑なデータ型は、リストやハッシュの中にリストやハッシュを 入れることができるリファレンスを使って構築できます。

リファレンスはスカラ値で、任意の他の Perl データを参照できます。 従って、リファレンスを配列やハッシュの値として格納することで、 リストやハッシュの中に簡単にリストやハッシュを作成できます。 以下の例は、無名ハッシュリファレンスを使った 2 レベルのハッシュのハッシュを 説明しています:

    my $variables = {
        scalar  =>  {
                     description => "single item",
                     sigil => '$',
                    },
        array   =>  {
                     description => "ordered list of items",
                     sigil => '@',
                    },
        hash    =>  {
                     description => "key/value pairs",
                     sigil => '%',
                    },
    };

    print "Scalars begin with a $variables->{'scalar'}->{'sigil'}\n";

リファレンスに関する包括的な情報は、 perlreftut, perllol, perlref, perldsc にあります。

変数のスコープ¶

前述した章の全体で、全ての例は以下の文法を使っています:

    my $var = "value";

my は実際には必要ではありません; 単に以下のようにも使えます:

    $var = "value";

しかし、上述の使用法はプログラム全体でグローバルな変数を作ることになり、 これは悪いプログラミング手法です。 代わりに、my はレキシカルなスコープを持った変数を作ります。 変数は、宣言されたブロック (中かっこで囲まれた文のかたまり) 内の スコープを持ちます。

    my $x = "foo";
    my $some_condition = 1;
    if ($some_condition) {
        my $y = "bar";
        print $x;           # prints "foo"
        print $y;           # prints "bar"
    }
    print $x;               # prints "foo"
    print $y;               # prints nothing; $y has fallen out of scope

    my $x = "foo";
    my $some_condition = 1;
    if ($some_condition) {
        my $y = "bar";
        print $x;           # "foo" を表示する
        print $y;           # "bar" を表示する
    }
    print $x;               # "foo" を表示する
    print $y;               # 何も表示しない; $y はスコープ外

Perl スクリプトの先頭に use strict; を書くことと合わせて my を 使うことによって、インタプリタがある種のよくあるプログラミングミスを 検出できます。 例えば、上述の例で、最後の print $y はコンパイルエラーとなり、 プログラムの実行を妨げます。 strict を使うことを強く勧めます。

条件とループ構造¶

Perl には、case/switch を除く、一般的な条件構文とループ構文のほとんど 全てがあります (しかし、もし本当に必要なら、 Perl 5.8 以降と CPAN に Switch モジュールがあります。モジュールと CPAN に関するさらなる 情報については後述するモジュールの節を参照してください)。

任意の Perl 式は条件となります。 条件文でよく使われる、比較演算子と真偽値論理演算子に関する情報については、 次の節にある演算子の一覧を参照してください。

if

    if ( condition ) {
        ...
    } elsif ( other condition ) {
        ...
    } else {
        ...
    }

There's also a negated version of it:

これの否定版もあります:

    unless ( condition ) {
        ...
    }

This is provided as a more readable version of if (!condition).

これは、if (!condition) をより読みやすくしたものです。

Note that the braces are required in Perl, even if you've only got one line in the block. However, there is a clever way of making your one-line conditional blocks more English like:

たとえブロック中に 1 行しかなくても、Perl では中かっこが必要であることに 注意してください。 しかし、1 行の条件ブロックをより英語風にする気の利いた方法があります:

    # the traditional way
    if ($zippy) {
        print "Yow!";
    }

    # 伝統的な方法
    if ($zippy) {
        print "Yow!";
    }

    # the Perlish post-condition way
    print "Yow!" if $zippy;
    print "We have no bananas" unless $bananas;

    # Perl っぽい後置条件
    print "Yow!" if $zippy;
    print "We have no bananas" unless $bananas;

while

    while ( condition ) {
        ...
    }

There's also a negated version, for the same reason we have unless:

unless があるのと同じ理由で、これにも否定版があります。

    until ( condition ) {
        ...
    }

You can also use while in a post-condition:

while を後置条件にも使えます:

    print "LA LA LA\n" while 1;          # loops forever

    print "LA LA LA\n" while 1;          # 無限ループ

for

Exactly like C:

完全に C と同様です:

    for ($i = 0; $i <= $max; $i++) {
        ...
    }

The C style for loop is rarely needed in Perl since Perl provides the more friendly list scanning foreach loop.

C 形式のループは Perl ではめったに必要ではありません; なぜなら Perl は より親切なリストスキャンである foreach ループがあるからです。

foreach

    foreach (@array) {
        print "This element is $_\n";
    }

    print $list[$_] foreach 0 .. $max;

    # you don't have to use the default $_ either...
    foreach my $key (keys %hash) {
        print "The value of $key is $hash{$key}\n";
    }

    # デフォルトの $_ を使う必要はない…
    foreach my $key (keys %hash) {
        print "The value of $key is $hash{$key}\n";
    }

ループ構造に関するさらなる詳細 (およびこの概説で触れていないこと) に ついては perlsyn を参照してください。

組み込みの演算子と関数¶

Perl は幅広い組み込み関数を持っています。 print, sort, reverse など、その一部は既に見てきました。 その一覧は perlfunc の先頭にあり、関数の説明は perldoc -f functionname とすることで簡単に読むことができます。

Perl の演算子は perlop に完全に文書化されていますが、もっとも 一般的なものをいくつか以下に示します:

Arithmetic

(数値演算)

    +   addition
    -   subtraction
    *   multiplication
    /   division

    +   加算
    -   減算
    *   乗算
    /   除算

Numeric comparison

(数値比較)

    ==  equality
    !=  inequality
    <   less than
    >   greater than
    <=  less than or equal
    >=  greater than or equal

    ==  相等
    !=  不等
    <   より小さい
    >   より大きい
    <=  以下
    >=  以上

String comparison

(文字列比較)

    eq  equality
    ne  inequality
    lt  less than
    gt  greater than
    le  less than or equal
    ge  greater than or equal

    eq  相等
    ne  不等
    lt  より小さい
    gt  より大きい
    le  以下
    ge  以上

(Why do we have separate numeric and string comparisons? Because we don't have special variable types, and Perl needs to know whether to sort numerically (where 99 is less than 100) or alphabetically (where 100 comes before 99).

(どうして数値比較と文字列比較が分かれているのでしょう? なぜなら、特別な変数型はないので、数値として扱う (99 は 100 より小さい) か、文字として扱う (100 は 99 の前) かを Perl に知らせる必要があるからです。)

Boolean logic

(真偽値論理)

    &&  and
    ||  or
    !   not

(and, or and not aren't just in the above table as descriptions of the operators -- they're also supported as operators in their own right. They're more readable than the C-style operators, but have different precedence to && and friends. Check perlop for more detail.)

(and, or, not は演算子の記述としては上述の表にはありません -- これらも本来の演算子として対応しています。 これらは C 形式の演算子より読みやすいですが、&& およびその仲間とは 異なった優先順位を持ちます。 さらなる詳細については perlop を参照してください。)

Miscellaneous

(その他)

    =   assignment
    .   string concatenation
    x   string multiplication
    ..  range operator (creates a list of numbers)

    =   代入
    .   文字列結合
    x   文字列乗算
    ..  範囲演算子 (数値のリストを作る)

多くの演算子は、以下のように = と組み合わせることができます:

    $a += 1;        # same as $a = $a + 1
    $a -= 1;        # same as $a = $a - 1
    $a .= "\n";     # same as $a = $a . "\n";

    $a += 1;        # $a = $a + 1 と同じ
    $a -= 1;        # $a = $a - 1 と同じ
    $a .= "\n";     # $a = $a . "\n"; と同じ

ファイルと I/O¶

open() 関数を使って、入力や出力のためにファイルを開けます。 perlfunc と perlopentut に非常に詳細に文書化されていますが、 簡単には:

    open(my $in,  "<",  "input.txt")  or die "Can't open input.txt: $!";
    open(my $out, ">",  "output.txt") or die "Can't open output.txt: $!";
    open(my $log, ">>", "my.log")     or die "Can't open my.log: $!";

<> 演算子を使って、開いているファイルハンドルから読み込めます。 スカラコンテキストではファイルハンドルから 1 行を読み込み、リスト コンテキストではファイル全体を読み込んで、それぞれの行をリストの要素に 代入します:

    my $line  = <$in>;
    my @lines = <$in>;

ファイル全体を一度に読み込むことは「吸い込み」(slurping) と呼ばれます。 これは便利ですが、メモリを占有するかもしれません。 ほとんどのテキストファイル処理は、Perl のループ構文を使って 1 行ずつ処理できます。

<> 演算子は、while ループの中でもっともよく見られます:

    while (<$in>) {     # assigns each line in turn to $_
        print "Just read in this line: $_";
    }

    while (<$in>) {     # それぞれの行を $_ に代入する
        print "Just read in this line: $_";
    }

print() を使って標準出力に出力する方法はすでに見てきました。 しかし、print() はオプションとして、どのファイルハンドルに出力するかを 指定する第一引数を取ることもできます:

    print STDERR "This is your final warning.\n";
    print $out $record;
    print $log $logmessage;

ファイルハンドルを使ったら、close() を使うべきです (しかし正直に言うと、もしあなたが忘れても Perl はあなたの後始末をします):

    close $in or die "$in: $!";

正規表現¶

Perl の正規表現サポートは広く深く、長い文書は perlrequick, perlretut およびどこにでもあります。 しかし、短く言うと:

Simple matching

(単純なマッチング)

    if (/foo/)       { ... }  # true if $_ contains "foo"
    if ($a =~ /foo/) { ... }  # true if $a contains "foo"

    if (/foo/)       { ... }  # $_ に "foo" が含まれていれば真
    if ($a =~ /foo/) { ... }  # $a に "foo" が含まれていれば真

The // matching operator is documented in perlop. It operates on $_ by default, or can be bound to another variable using the =~ binding operator (also documented in perlop).

// マッチング演算子は perlop に文書化されています。 これはデフォルトでは $_ を操作しますし、=~ 結合演算子 (これも perlop で文書化されています) を使って他の変数に対して 適用することもできます。

Simple substitution

(単純な置換)

    s/foo/bar/;               # replaces foo with bar in $_
    $a =~ s/foo/bar/;         # replaces foo with bar in $a
    $a =~ s/foo/bar/g;        # replaces ALL INSTANCES of foo with bar in $a

    s/foo/bar/;               # $_ にある foo を bar に置き換える
    $a =~ s/foo/bar/;         # $a にある foo を bar に置き換える
    $a =~ s/foo/bar/g;        # $a にある全ての foo を bar に置き換える

The s/// substitution operator is documented in perlop.

s/// 置換演算子は perlop に文書化されています。

More complex regular expressions

(より複雑な正規表現)

You don't just have to match on fixed strings. In fact, you can match on just about anything you could dream of by using more complex regular expressions. These are documented at great length in perlre, but for the meantime, here's a quick cheat sheet:

単に固定した文字列にマッチングさせる必要はありません。 実際の所、より複雑な正規表現を使うことによって、思い付く限りほとんど 全てのものとマッチングさせることが出来ます。 これらは perlre に長文で文書化されていますが、今のところは、以下に カンニングペーパーを示します:

    .                   a single character
    \s                  a whitespace character (space, tab, newline, ...)
    \S                  non-whitespace character
    \d                  a digit (0-9)
    \D                  a non-digit
    \w                  a word character (a-z, A-Z, 0-9, _)
    \W                  a non-word character
    [aeiou]             matches a single character in the given set
    [^aeiou]            matches a single character outside the given set
    (foo|bar|baz)       matches any of the alternatives specified

    .                   単一の文字
    \s                  空白文字(空白、タブ、改行…)
    \S                  非空白文字
    \d                  数字 (0-9)
    \D                  非数字
    \w                  単語文字 (a-z, A-Z, 0-9, _)
    \W                  非単語文字
    [aeiou]             指定された集合に含まれる単一の文字
    [^aeiou]            指定された集合に含まれない単一の文字
    (foo|bar|baz)       指定された代替のいずれかにマッチング

    ^                   start of string
    $                   end of string

    ^                   文字列の先頭
    $                   文字列の末尾

Quantifiers can be used to specify how many of the previous thing you want to match on, where "thing" means either a literal character, one of the metacharacters listed above, or a group of characters or metacharacters in parentheses.

量指定子は直前に指定したマッチングさせたいものを何回マッチングさせたいかを 指定するために使います; ここで「もの」というのはリテラルな 1 文字、 上述したメタ文字の一つ、かっこに囲まれた文字やメタ文字のグループです。

    *                   zero or more of the previous thing
    +                   one or more of the previous thing
    ?                   zero or one of the previous thing
    {3}                 matches exactly 3 of the previous thing
    {3,6}               matches between 3 and 6 of the previous thing
    {3,}                matches 3 or more of the previous thing

    *                   手前にあるものに 0 回以上マッチング
    +                   手前にあるものに 1 回以上マッチング
    ?                   手前にあるものに 1 回または 0 回マッチング
    {3}                 手前にあるものにちょうど 3 回マッチング
    {3,6}               手前にあるものに 3 回から 6 回マッチング
    {3,}                手前にあるものに 3 回以上マッチング

Some brief examples:

いくつかの簡単な例です:

    /^\d+/              string starts with one or more digits
    /^$/                nothing in the string (start and end are adjacent)
    /(\d\s){3}/         a three digits, each followed by a whitespace
                        character (eg "3 4 5 ")
    /(a.)+/             matches a string in which every odd-numbered letter
                        is a (eg "abacadaf")

    /^\d+/              一つ以上の数字で始まる
    /^$/                空文字列 (先頭と末尾が隣接している)
    /(\d\s){3}/         3 桁の数字(それぞれに空白文字が引き続く)
                        (例えば "3 4 5 ")
    /(a.)+/             奇数番目が全て a である文字列
                        (例えば "abacadaf")

    # This loop reads from STDIN, and prints non-blank lines:
    while (<>) {
        next if /^$/;
        print;
    }

    # このループは STDIN から読み込み、非空行を表示する:
    while (<>) {
        next if /^$/;
        print;
    }

Parentheses for capturing

(かっこと捕捉)

As well as grouping, parentheses serve a second purpose. They can be used to capture the results of parts of the regexp match for later use. The results end up in $1, $2 and so on.

かっこは、グループ化だけではなく第二の目的の役目を果たします。 正規表現マッチングの一部の結果を後で使うために捕捉するために使えます。 結果は $1, $2 などに入ります。

    # a cheap and nasty way to break an email address up into parts

    # e メールアドレスをパーツに分解するちゃちで扱いにくい方法

    if ($email =~ /([^@]+)@(.+)/) {
        print "Username is $1\n";
        print "Hostname is $2\n";
    }

Other regexp features

(その他の正規表現の機能)

Perl regexps also support backreferences, lookaheads, and all kinds of other complex details. Read all about them in perlrequick, perlretut, and perlre.

Perl の正規表現は、後方参照、前方参照およびその他のあらゆる種類の複雑な 詳細に対応しています。 perlrequick, perlretut, perlre でこれらに関する全てを読んでください。

サブルーチンを書く¶

サブルーチンを書くのは簡単です:

    sub logger {
        my $logmessage = shift;
        open my $logfile, ">>", "my.log" or die "Could not open my.log: $!";
        print $logfile $logmessage;
    }

これでサブルーチンをその他の組み込み関数と同様に使えます:

    logger("We have a logger subroutine!");

shift とはなんでしょう? ええっと、サブルーチンの引数は @_ と呼ばれる特殊配列として利用可能に なります (これに関する詳細は perlvar を参照してください)。 shift 関数のデフォルト引数は たまたま @_ です。 それで、my $logmessage = shift; は引数のリストの最初のものを取り出して、 $logmessage に代入します。

その他の方法でも @_ を操作できます:

    my ($logmessage, $priority) = @_;       # common
    my $logmessage = $_[0];                 # uncommon, and ugly

    my ($logmessage, $priority) = @_;       # 一般的
    my $logmessage = $_[0];                 # 一般的でもなく、美しくもない

サブルーチンは値を返すこともできます:

    sub square {
        my $num = shift;
        my $result = $num * $num;
        return $result;
    }

それからこういう風に使います:

    $sq = square(8);

サブルーチンの書き方に関するさらなる情報については、perlsub を 参照してください。

OO Perl¶

OO Perl は比較的単純で、オブジェクトが Perl の概念であるパッケージの どれに基づいているかを知っているリファレンスを使って実装されています。 しかし、OO Perl はこの文書の範囲からは大きく外れます。 perlboot, perltoot, perltooc, perlobj を読んでください。

Perl プログラマを始めるに当たって、OO Perl の最も一般的な使用法は 以下に記述している、サードパーティーモジュールを使うことです。

Perl モジュールを使う¶

Perl モジュールは、車輪の再発明を避けるための様々な機能を提供していて、 CPAN ( http://www.cpan.org/ ) からダウンロードできます。 多くの有名なモジュールは Perl 配布自身に含まれています。

モジュールのカテゴリは、テキスト操作からネットワークプロトコル、 データベース統合、グラフィックまで多岐に渡ります。 カテゴリ別モジュールリストも CPAN で利用可能です。

CPAN からダウンロードしたモジュールのインストール方法を学ぶには、 perlmodinstall を読んでください。

特定のモジュールの使い方を学ぶには、perldoc Module::Name を 使ってください。 典型的には use Module::Name として、それからエクスポートされた 関数か、モジュールへの OO インターフェースにアクセスします。

perlfaq には多くの一般的なタスクに関する質問と答えがあり、しばしば よい CPAN モジュールの提案が提供されています。

perlmod は一般的な Perl モジュールについて記述しています。 perlmodlib は Perl インストール時に同梱されているモジュールの一覧です。

Perl モジュールを作りたいと思ったなら、perlnewmod がよい助言を 与えてくれるでしょう。

作者¶

Kirrily "Skud" Robert <[email protected]>