5.10.1

名前

perlintro -- a brief introduction and overview of Perl

perlintro -- Perl の概要

説明

This document is intended to give you a quick overview of the Perl programming language, along with pointers to further documentation. It is intended as a "bootstrap" guide for those who are new to the language, and provides just enough information for you to be able to read other peoples' Perl and understand roughly what it's doing, or write your own simple scripts.

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

This introductory document does not aim to be complete. It does not even aim to be entirely accurate. In some cases perfection has been sacrificed in the goal of getting the general idea across. You are strongly advised to follow this introduction with more information from the full Perl manual, the table of contents to which can be found in perltoc.

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

Throughout this document you'll see references to other parts of the Perl documentation. You can read that documentation using the perldoc command or whatever method you're using to read this document.

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

Perl って何?

Perl is a general-purpose programming language originally developed for text manipulation and now used for a wide range of tasks including system administration, web development, network programming, GUI development, and more.

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

The language is intended to be practical (easy to use, efficient, complete) rather than beautiful (tiny, elegant, minimal). Its major features are that it's easy to use, supports both procedural and object-oriented (OO) programming, has powerful built-in support for text processing, and has one of the world's most impressive collections of third-party modules.

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

Different definitions of Perl are given in perl, perlfaq1 and no doubt other places. From this we can determine that Perl is different things to different people, but that lots of people think it's at least worth writing about.

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

Perl プログラムの実行

To run a Perl program from the Unix command line:

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

    perl progname.pl

Alternatively, put this as the first line of your script:

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

    #!/usr/bin/env perl

... and run the script as /path/to/script.pl. Of course, it'll need to be executable first, so chmod 755 script.pl (under Unix).

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

(This start line assumes you have the env program. You can also put directly the path to your perl executable, like in #!/usr/bin/perl).

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

For more information, including instructions for other platforms such as Windows and Mac OS, read perlrun.

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

セーフティネット

Perl by default is very forgiving. In order to make it more robust it is recommended to start every program with the following lines:

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

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

The two additional lines request from perl to catch various common problems in your code. They check different things so you need both. A potential problem caught by use strict; will cause your code to stop immediately when it is encountered, while use warnings; will merely give a warning (like the command-line switch -w) and let your code run. To read more about them check their respective manual pages at strict and warnings.

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

基本的な文法の概要

A Perl script or program consists of one or more statements. These statements are simply written in the script in a straightforward fashion. There is no need to have a main() function or anything of that kind.

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

Perl statements end in a semi-colon:

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

    print "Hello, world";

Comments start with a hash symbol and run to the end of the line

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

    # This is a comment
    # これはコメント

Whitespace is irrelevant:

空白は無視されます:

    print
        "Hello, world"
        ;

... except inside quoted strings:

…但しクォートされた文字列の中は例外です:

    # this would print with a linebreak in the middle
    print "Hello
    world";
    # これは途中に改行が入る
    print "Hello
    world";

Double quotes or single quotes may be used around literal strings:

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

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

However, only double quotes "interpolate" variables and special characters such as newlines (\n):

しかし、ダブルクォートのみが変数と改行(\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 という文字をそのまま表示する

Numbers don't need quotes around them:

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

    print 42;

You can use parentheses for functions' arguments or omit them according to your personal taste. They are only required occasionally to clarify issues of precedence.

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

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

More detailed information about Perl syntax can be found in perlsyn.

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

Perl の変数型

Perl has three main variable types: scalars, arrays, and hashes.

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 にあります。

Scalars, arrays and hashes are documented more fully in perldata.

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

More complex data types can be constructed using references, which allow you to build lists and hashes within lists and hashes.

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

A reference is a scalar value and can refer to any other Perl data type. So by storing a reference as the value of an array or hash element, you can easily create lists and hashes within lists and hashes. The following example shows a 2 level hash of hash structure using anonymous hash references.

リファレンスはスカラ値で、任意の他の 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";

Exhaustive information on the topic of references can be found in perlreftut, perllol, perlref and perldsc.

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

変数のスコープ

Throughout the previous section all the examples have used the syntax:

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

    my $var = "value";

The my is actually not required; you could just use:

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

    $var = "value";

However, the above usage will create global variables throughout your program, which is bad programming practice. my creates lexically scoped variables instead. The variables are scoped to the block (i.e. a bunch of statements surrounded by curly-braces) in which they are defined.

しかし、上述の使用法はプログラム全体でグローバルな変数を作ることになり、 これは悪いプログラミング手法です。 代わりに、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 はスコープ外

Using my in combination with a use strict; at the top of your Perl scripts means that the interpreter will pick up certain common programming errors. For instance, in the example above, the final print $y would cause a compile-time error and prevent you from running the program. Using strict is highly recommended.

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

条件とループ構造

Perl has most of the usual conditional and looping constructs except for case/switch (but if you really want it, there is a Switch module in Perl 5.8 and newer, and on CPAN. See the section on modules, below, for more information about modules and CPAN).

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

The conditions can be any Perl expression. See the list of operators in the next section for information on comparison and boolean logic operators, which are commonly used in conditional statements.

任意の 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";
    }

For more detail on looping constructs (and some that weren't mentioned in this overview) see perlsyn.

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

組み込みの演算子と関数

Perl comes with a wide selection of builtin functions. Some of the ones we've already seen include print, sort and reverse. A list of them is given at the start of perlfunc and you can easily read about any given function by using perldoc -f functionname.

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

Perl operators are documented in full in perlop, but here are a few of the most common ones:

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   文字列乗算
    ..  範囲演算子 (数値のリストを作る)

Many operators can be combined with a = as follows:

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

    $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

You can open a file for input or output using the open() function. It's documented in extravagant detail in perlfunc and perlopentut, but in short:

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

    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: $!";

You can read from an open filehandle using the <> operator. In scalar context it reads a single line from the filehandle, and in list context it reads the whole file in, assigning each line to an element of the list:

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

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

Reading in the whole file at one time is called slurping. It can be useful but it may be a memory hog. Most text file processing can be done a line at a time with Perl's looping constructs.

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

The <> operator is most often seen in a while loop:

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

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

We've already seen how to print to standard output using print(). However, print() can also take an optional first argument specifying which filehandle to print to:

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

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

When you're done with your filehandles, you should close() them (though to be honest, Perl will clean up after you if you forget):

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

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

正規表現

Perl's regular expression support is both broad and deep, and is the subject of lengthy documentation in perlrequick, perlretut, and elsewhere. However, in short:

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 でこれらに関する全てを読んでください。

サブルーチンを書く

Writing subroutines is easy:

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

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

Now we can use the subroutine just as any other built-in function:

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

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

What's that shift? Well, the arguments to a subroutine are available to us as a special array called @_ (see perlvar for more on that). The default argument to the shift function just happens to be @_. So my $logmessage = shift; shifts the first item off the list of arguments and assigns it to $logmessage.

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

We can manipulate @_ in other ways too:

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

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

Subroutines can also return values:

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

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

Then use it like:

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

    $sq = square(8);

For more information on writing subroutines, see perlsub.

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

OO Perl

OO Perl is relatively simple and is implemented using references which know what sort of object they are based on Perl's concept of packages. However, OO Perl is largely beyond the scope of this document. Read perlboot, perltoot, perltooc and perlobj.

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

As a beginning Perl programmer, your most common use of OO Perl will be in using third-party modules, which are documented below.

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

Perl モジュールを使う

Perl modules provide a range of features to help you avoid reinventing the wheel, and can be downloaded from CPAN ( http://www.cpan.org/ ). A number of popular modules are included with the Perl distribution itself.

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

Categories of modules range from text manipulation to network protocols to database integration to graphics. A categorized list of modules is also available from CPAN.

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

To learn how to install modules you download from CPAN, read perlmodinstall.

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

To learn how to use a particular module, use perldoc Module::Name. Typically you will want to use Module::Name, which will then give you access to exported functions or an OO interface to the module.

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

perlfaq contains questions and answers related to many common tasks, and often provides suggestions for good CPAN modules to use.

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

perlmod describes Perl modules in general. perlmodlib lists the modules which came with your Perl installation.

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

If you feel the urge to write Perl modules, perlnewmod will give you good advice.

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

作者

Kirrily "Skud" Robert <skud@cpan.org>