5.1) $array[1]と@array[1]の違いは何ですか?

$は単一の値に、@は複数の値に使うことを常に確認しなさい。つまり@foo の2番目の要素は@foo[1]ではなく$foo[1]でアクセスします。@foo[1]だと スカラーではなく長さ一のリストになります。これは初心者が陥りがちな ミスです。場合によっては@foo[1]がつかえるかもしれません。しかし、 それはあなたが思っている理由によって本当にそれが行なわれているので はなく、あなたが時を待たずして自滅するだろう、ということを意味して います。以下が、本当には何をしているのかをしばらく熟考して見なさい。

        @foo[0] = `cmd args`;
        @foo[1] = <FILE>

これは混乱しているように見えるかも知れなせん。しかし、次のように考 えてみて下さい: 「あなたは *返して欲しい* 型の文字を使う」。あなた は@foo[1..3]と書くことでを@fooの3つの要素からなる断片を使う事がで き、あるいは%fooの断片のためには、@foo{A,B,C}を使うことさえできま す。これはそれぞれに対して($foo[1], $foo[2], $foo[3])と($foo{A}, $foo{B}, $foo{C})を使うことと同じです。実際には、@foo[@bar]や @foo{@bar}のようにして配列の添字としてリストを使い、さらにリストを 引き出すこともできます。この両者の例では、@barはたぶん添字のリスト なのでしょう。

        %T = (
            key0, { k0, v0, k1, v1 },   
            key1, { k2, v2, k3, v3 },   
            key2, { k2, v2, k3, [ 'a' .. 'z' ] },    
        );

Perl4 では非常に難しいです。Perl[0..4] では入れ子のデータ構造はな いということを思い出して下さい。それは平坦なものなので、もしあなた がこれを実現しようとしているなら、間違った方法や、間違ったツールの 使い方をすることになるかも知れません。共通のサブスクリプトには並列 の配列を用いたらどうでしょう。

しかし、もしあなたに義務があり決められているなら、$a{'x','y','z'} という多次元配列エミュレーションを使うことができます、さもなくば、 配列の名前の配列を作ってそれを評価することもできます。

例えば、@name に配列名のリストが入っているなら、以下のようにして、 i番目の配列の j番目の要素を取り出すことができます:

        $ary = $name[$i];
        $val = eval "\$$ary[$j]";

        $val = eval "\$$name[$i][\$j]";

例えば:

        { local(*ary) = $name[$i]; $val = $ary[$j]; }

配列の配列の配列がなければならないとちょっと簡単に仮定して見て下さ い。あなたがすることは、上記のポインタが *name の値であるところに、 ポインタの配列を指すポインタの配列を作ることです。最も外側の配列を 普通に初期化すると、そこからポインタができあがります。例えば:

        @w = ( 'ww' .. 'xx' );
        @x = ( 'xx' .. 'yy' );
        @y = ( 'yy' .. 'zz' );
        @z = ( 'zz' .. 'zzz' );

        @ww = reverse @w;
        @xx = reverse @x;
        @yy = reverse @y;
        @zz = reverse @z;

        @A = ( *w, *x, *y, *z );
        @B = ( *ww, *xx, *yy, *zz );

        @AAA = ( *A, *B );

        local(*foo) = $AAA[$i];
        local(*bar) = $foo[$j];
        $answer = $bar[$k];

Felex Lee* の投稿した recurse.pl パッケージを良く見ることもできま す。それは、型グロブ参照やいくつかの大変重要な魔術を使うことによっ て、ベクタや表 (リストと連想配列) をシミュレートさせます。

C では、再帰的降下パーサや木探索のような操作のために、再帰的なデー タ型をよく作ったものです。Perl では、これらのアルゴリズムは連想配 列を使って最適な実装がなされています。%parent という配列を取り、 $parent{$person} が その人の親の名前であるようなポインタを作りなさ い。$parent{'adam'} が 'adam' であることを確かめて下さい。:-) ちょっ と注意すれば、このアプローチが一般のグラフ探索アルゴリズムの実装に も使えることができます。

        @all = (
           {
               'field1'        => "value1",
               'field2'        => "value2",
               'field3'        => "value3",
               ...
           },
           {
               'field1'        => "value1",
               'field2'        => "value2",
               'field3'        => "value3",
               ...
           },
           ...
        )

        $t{$value} = [ @bar ];

        %{$a[$i]} = %old;

        $table{'some key'}    =   @big_list_o_stuff;   # SCARY #0
        $table{'some key'}    =  \@big_list_o_stuff;   # SCARY #1
        @$table{'some key'}   =   @big_list_o_stuff;   # SCARY #2
        @{$table{'some key'}} =   @big_list_o_stuff;   # 不愉快なRANDALIAのコードだ
        $table{'some key'}    = [ @big_list_o_stuff ]; # 同様にRANDALIAのコードだがこれはナイスである

        $table{"051"}         = $some_scalar;          # SCARY #3
        $table{"0x51"}        = $some_scalar;          #   〃
        $table{051}           = $some_scalar;          #   〃
        $table{0x51}          = $some_scalar;          #   〃
        $table{51}            = $some_scalar;          # 良いだろう
        $table{"51"}          = $some_scalar;          # もっと良い

        $table{\@x}           = $some_scalar;          # SCARY #4
        $table{[@x]}          = $some_scalar;          #   〃
        $table{@x}            = $some_scalar;          # SCARY #5 (cf #0)

b) もし @in がソートされているかどうか分からなければ:

        undef %saw;
        @out = grep(!$saw{$_}++, @in);

        @out = grep(!$saw[$_]++, @in);

        undef %saw;
        @saw{@in} = ();
        @out = sort keys %saw;  # remove sort if undesired

        undef @ary;
        @ary[@in] = @in;
        @out = sort @ary;

もし、すべての値が小さな整数値だったら、あなたは単に索引付け配列を 使うことができます。この種の配列は、より小さなメモリ領域しか使いま せん。

        @primes = (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31);
        undef @is_tiny_prime;
        for (@primes) { $is_tiny_prime[$_] = 1; }

もし、ご質問の値が文字列の代わりに整数であるならば、ビット文字列を 代わりに使うことでかなりたくさんのメモリ領域を節約することができま す。

        @articles = ( 1..10, 150..2000, 2017 );
        undef $read;
        grep (vec($read,$_,1) = 1, @articles);

以下のようにして、ソートのサブルーチンを宣言しなければなりません。 さもなくばインライン関数を使わなければなりません。連想配列 %ary の 値で、ASCII ソートしたい、と仮定して下さい。以下のようにすることが できます:

        foreach $key (sort by_value keys %ary) {
            print $key, '=', $ary{$key}, "\n";
        } 
        sub by_value { $ary{$a} cmp $ary{$b}; }

        sub by_value { $ary{$b} <=> $ary{$a}; }

        foreach $key ( sort { $ary{$b} <=> $ary{$a} } keys %ary ) {
            print $key, '=', $ary{$key}, "\n";
        } 

        foreach $key (&sort_by_value(*ary)) {
            print $key, '=', $ary{$key}, "\n";
        } 
        sub sort_by_value {
            local(*x) = @_;
            sub _by_value { $x{$a} cmp $x{$b}; } 
            sort _by_value keys %x;
        } 

もしあなたが、split や unpack や パターンマッチング あるいは substr などを通して展開した断片のような値の一部にソーティングをし ているなら、その断片に対するそれぞれの呼び出しにおいて、あなたのソー トルーチンの中でその処理を実行するよりはむしろ、あなたがソーティン グを行なうそれらの一部の並列な配列を作り上げたり、この並列な配列の 添字をソートするか、あるいは新たにソートされた配列の添字を使うあな たのオリジナルなサブスクリプトを使った方が重要でより効果的である、 ということを捕捉しておきます。@ary[@idx] と @ary{@idx} は両方とも 意味をなしているので、この方法は普通の配列と連想配列の両方で動きま す。これの簡単な例として、ラクダ本の245ページにある「計算可能なフィー ルドで配列をソーティングする」というのを参照して下さい。

例えば、ここに効果的な case-insensitive(大文字小文字を区別しない) の比較があります。

        @idx = ();
        for (@data) { push (@idx, "\U$_") }
        @sorted = @data[ sort { $idx[$a] cmp $idx[$b] } 0..$#data];

しかしながら、この方法では要素数を数えることができなくても、そのた めにあなたが使うことが *可能な* 一つの事柄を、その配列中にあるどの 要素でも決定することができます。なぜなら、“if (%table)”はその配 列中になにも格納されていなければ失敗することが保証されているからで す。

perl4.035においては、あなたは以下のように書くことができます。

        $count = keys %ARRAY;

            $ary{'a'}                       is true
            $ary{'d'}                       is false
            defined $ary{'d'}               is true
            defined $ary{'a'}               is true
            exists $ary{'a'}                is true (perl5 のみ)
            grep ($_ eq 'a', keys %ary)     is true

            undef $ary{'a'}

              keys  values
            +------+------+
            |  a   | undef|
            |  x   |  7   |
            |  d   |  0   |
            |  e   |  2   |
            +------+------+

            $ary{'a'}                       is FALSE
            $ary{'d'}                       is false
            defined $ary{'d'}               is true
            defined $ary{'a'}               is FALSE
            exists $ary{'a'}                is true (perl5 only)
            grep ($_ eq 'a', keys %ary)     is true

次は以下のようなのを考えてみましょう:

            delete $ary{'a'}

              keys  values
            +------+------+
            |  x   |  7   |
            |  d   |  0   |
            |  e   |  2   |
            +------+------+

            $ary{'a'}                       is false
            $ary{'d'}                       is false
            defined $ary{'d'}               is true
            defined $ary{'a'}               is false
            exists $ary{'a'}                is FALSE (perl5 のみ)
            grep ($_ eq 'a', keys %ary)     is FALSE

         $foo = "$bar is " . `wc $file`;

         $back = `pwd`; chdir($somewhere); chdir($back); # 駄目

          chop($back = `pwd`); chdir($somewhere); chdir($back);

        Shell: foo=`cmd 'safe $dollar'`
        Perl:  $foo=`cmd 'safe \$dollar'`;

        next unless /%/;

        next if /Mon/;
        next if /Tue/;
        next if /Wed/;
        next if /Thu/;
        next if /Fri/;

        next if /Mon/ || /Tue/ || /Wed/ || /Thu/ || /Fri/;

        next if /Mon|Tue|Wed|Thu|Fri/;

        next if /(Mon|Tue|Wed|Thu|Fri)/;

printf は単なる print よりも高くつくということを覚えておいて下さい。

必要がなければ、すべての行を split() しないで下さい。

もう一つ注目すべきことはループです。ハッシュ配列の中に全てを置くよ り添字付きの配列を繰り返していますか? 例えば、

        @list = ('abc', 'def', 'ghi', 'jkl', 'mno', 'pqr', 'stv');

        for $i ($[ .. $#list) {
            if ($pattern eq $list[$i]) { $found++; } 
        } 

        foreach $elt (@list) {
            if ($pattern eq $elt) { $found++; } 
        } 

        %list = ('abc', 1, 'def', 1, 'ghi', 1, 'jkl', 1, 
                 'mno', 1, 'pqr', 1, 'stv', 1 );
        $found += $list{$pattern};

正規表現中の変数についても見てみましょう。それは高くつきます。もし はさまれている変数がプロセス中で変わることがなければ、正規表現をた だ一回だけコンパイルするよう Perl に教えるため /o モディファイアを 使って下さい。以下のように:

        for $i (1..100) {
            if (/$foo/o) {
                &some_func($i);
            } 
        } 

        @pats = ('_get.*', 'bogus', '_read', '.*exit', '_write');
        foreach $pat (@pats) {
            if ( $name =~ /^$pat$/ ) {
                &some_func();
                last;
            }
        }

        @pats = ('_get.*', 'bogus', '_read', '.*exit', '_write');
        $code = <<EOS
                while (<>) { 
                    study;
EOS
        foreach $pat (@pats) {
            $code .= <<EOS
                if ( /^$pat\$/ ) {
                    &some_func();
                    next;
                }
EOS
        }
        $code .= "}\n";
        print $code if $debugging;
        eval $code;

[注: perl5の時点で、もしあなたのシステムがダイナミックローディング をサポートしているなら、たぶんとにかく、代わりに h2xsを使うべきで す。]

これらは、Perlのソースディレクトリにある、(かつては makelibと呼ば れた) h2ph というスクリプトを使って、システムのインクルードファイ ルから生成されます。これは、&SYS_getitimer のような、サブルーチン 定義を含んでいるファイルを作り、あなたの関数に引数として使うことが できます。

これらを $SYS_getitimer のような形式に変換する方法のための h2pl サ ブディレクトリを、Perl ソース中で、あなたは見つけたかもしれません。 これらには長所と短所の両方があります。詳細を知りたければ、そのディ レクトリの中の notes を読んで下さい。

いずれの場合にも、これらの仕事を成すために、それをいじらなければな らないかもしれません。それは、あなたのシステムの C のインクルード ファイルがどのくらい奇妙か、ということに依存しています。

もしあなたが、C の構造体に触ろうとしているなら、c2phをちらっと見て みるべきです。それは、データ構造のためのマシン非依存の perl 定義を 作るために、BSD あるいは GNU の C コンパイラによって生成されたデバッ ガの "stab" エントリを使います。これによって、構造体の配置、型、パ ディングあるいはサイズ、といったハードコーディングを防ぐことができ、 大いに移植性を高めます。c2phは perlと一緒に配布されています。SCOシ ステムでは、GCC は標準で COFF のみのデバッギングサポートがあります。 ですから、あなたは GCC を DBX_DEBUGGING_INFO を定義して構築し、そ こで c2ph を動かすために -gstabs を使わなければならないでしょう。

この手順に関する詳細なtrap と tip のために、匿名ftp で convex.com 上の /pub/perl/info/ch2ph というファイルを見て下さい。

一般的に、デッドロック状態に陥るため、これは危険な手段です。片方の パイプの終端をファイルにくっつけるのが良いでしょう。例えば:

        # 最初に a_file の中に some_cmd の入力を書きます、
        open(CMD, "some_cmd its_args < a_file |");
        while (<CMD>) {

        # あるいは、他の方法で、 cmd を実行します。
        open(CMD, "| some_cmd its_args > a_file");
        while ($condition) {
            print CMD "some output\n";
            # 消された他のコード
        } 
        close CMD || warn "cmd exited $?";

        # そしてファイルを読みます
        open(FILE,"a_file");
        while (<FILE>) {

デッドロックを覚悟で、双方向パイプを手でセットアップするために fork と 2つのパイプと exec を使うことも理論的には可能です。(BSD シ ステムでは、二つのパイプの代わりに socketpair() を使ってもよいです が、これは移植可能ではありません。) 現在の perl リリースと一緒に配 布されている、open2 ライブラリ関数がこれをしてくれるでしょう。

adb のように書き込みと読み込みの両方を行なう物に対して、やりとりを 行なうことを、これは仮定しています。これはおそらく安全です、なぜな らあなたは adb のようなコマンドは一度に一行を読み込み、一度に一行 を書き込むことをあなたは "知っている" からです。しかしながら、最初 に入力ストリームを全部読み込む sort や cat のようなプログラムはか なりデッドロックの原因となりがちです。

stderr のために、これを同様に扱う open3.pl ライブラリもあります。

        $output = `$cmd 2>&1`;
        open (PIPE, "cmd 2>&1 |");

        $output = `$cmd 2>&1`;
        open (PIPE, "cmd 2>&1 |");

        open(STDERR, ">&STDOUT");
        $alloutput = `cmd args`;  # stderr still escapes

        open (CMD,
          "(cmd args | sed 's/^/STDOUT:/') 2>&1 |");

        while (<CMD>) {
          if (s/^STDOUT://)  {
              print "line from stdout: ", $_;
          } else {
              print "line from stderr: ", $_;
          }
        }

perl5の製品では&open2とマージされていた&open3ルーチンが、あそこに はあります。

これらの実行文:

        open(TOPIPE, "|bogus_command") || die ...
        open(FROMPIPE, "bogus_command|") || die ...

もしあなたが TOPIPE に書き込みを行なっているなら、子供が早く終了す るか、あるいは実行されなかった時に SIGPIPE を受けとるでしょう。も しあなたが FROMPIPE から読み込んでいるなら、何が起こったか見るため に、close() を調べる必要があります。

もし、パイプがバッファリングをしてあなたに余裕を与えるよりも、早く 答が欲しいなら、以下のようにすることができます:

        $kid = open (PIPE, "bogus_command |");   # XXX: check defined($kid)
        (kill 0, $kid) || die "bogus_command failed";

        $kid = open (PIPE, "bogus_command </dev/null |");
        sleep 1;
        (kill 0, $kid) || die "bogus_command failed";

もしあなたが、SIGPIPE をとらえたくないなら、書き込み可能なパイプを 使って似たようなトリックを演じることができます。

     $?      最後のパイプ close、バッククォート(``) コマンド、または
             system() 演算子によって返されたステータスです。これは
             wait() システムコールによって返されるステータスであり、
             サブプロセスの exit の値 は実際は ($? >> 8) であることを
             に気をつけて下さい。そのため、多くのシステム上では、
             $? & 255 はシグナルか、死んだプロセスか、コアダンプがある
             か、のどれかを与えます。(暗記法: sh や ksh に似ている)

Larry がファイル名グロブを内蔵させず、(perl)システムでは csh を使っ ているということを、あなたが *知って* いるなら、以下のようにすること ができます。

        $filename = <~tchrist/dir1/file1>

よりよい方法は以下のように、自分自身で変換をすることです:

        $filename =~ s#^~(\w+)(/.*)?$#(getpwnam($1))[7].$2#e;

        open(FOO, "echo * | tr -s ' \t\r\f' '\\012\\012\\012\\012'|");
        while (<FOO>) {
            chop;
            chmod 0644, $_;
        }

以下のようなものがそれをするコードです:

        opendir(DIR,'.');
        chmod 0644, grep(/\.c$/, readdir(DIR));
        closedir(DIR);

もしtcshを/bin/cshとしてインストールしていたなら、この問題は決して 起こりません。

もしそれが動かないのであれば (あなたのシステムの stdio の実装に依存 しますが) 以下のようにする必要があります。

    for (;;) {
        for ($curpos = tell(GWFILE); $_ = <GWFILE> $curpos = tell(GWFILE)) {
            # いくつかの要素を探し、それをファイルに入れる。
        }
        sleep for a while
        seek(GWFILE, $curpos, 0);
    }

最も制限された意味では、それは "できません"。しかし、それを許すシェ ルの特別な魔法があります。comp.unix.shell をチェックし、 comp.unix.questions の FAQ を読むことを、私はお薦めします。

perl が起動される時、あなたは子プロセスを生成しています。Unix シス テムの設計思想によって、子供達はその親のシェルに影響を与えることは 永遠にできません。

子プロセスが生成される時、その親の環境のコピーを継承します (変数、 カレントディレクトリ、等)。子供がこの環境を変える時は、コピーを変 えるのであって、そのオリジナルを変えるのではありません。つまり親は 影響を受けません。

もしあなたが、perl スクリプトの中で親を変更しなければならないなら、 それを シェルスクリプトあるいは Cシェルスクリプトで書いてみて、 ". スクリプト" あるいは "source スクリプト" (それぞれ、sh, Csh) を 使ってみて下さい。

        $fharray[$i] = "/some/path";
        open($fharray[$i], "< $fharray[$i]");
        print $fharray[$i] "stuff\n";

        $tmp_fh = $fharray[$i];
        print $tmp_fh "stuff\n";

        print { $fharray[$i] } "stuff\n";

        printit(Some_Handle);

単純な修正方法は、それを完全に修飾して渡すようにすることです。

        printit(main::Some_Handle);

    CODE 1:

        sub printit {
            my $fh = shift;
            my $package = (caller)[0];
            $fh =~ s/^[^':]+$/$package::$&/;
            while (<$fh>) {
                print;
            }
        }

    CODE 2:

        printit(*Some_Handle);
        sub printit {
            local *FH = shift;
            while (<FH>) {
                print;
            }
        }

しかしながら、これはこの関数の内側で型グロブを使う必要がない、とい うことを外に出してしまう。これは以下のようにもはたらく:

    CODE 3:

        printit(*Some_Handle);
        sub printit {
            my $fh = shift;
            while (<$fh>) {
                print;
            }

    CODE 4:

        printit(\*Some_Handle);
        sub printit {
            my $fh = shift;
            while (<$fh>) {
                print;
            }
        }

私はあなたがCODE 1あるいはむしろCODE 2を使う必要があると考えてきま したが、どうやらあなたは同様にCODE 3と4から同様に逃れることができ ます。このことは、それによりCODE 2でやっているような型グロブへの代 入を避けることができるため、好ましいことです。しかし少し危険ではあ ります。

他にCODE 1のちょっとした問題としては、もしあなたが厳密にサブルーチ ンを使うとしたら、あなたが得られるであろう厳密なサブルーチンをする ことができるようにはならない、ということです。

その代わりに、あなたは'main::Some_Handle'で渡す必要がありますが、 あなたの関数の中に降りてしまい、あなたは厳密な参照で吹き飛ばされて しまいます。

なぜならあなたは文字列やシンボルを使っているだろうからです。だから 本当は、最上の方法は型グロブ(あるいは時おりは同じ物への参照)を受け 渡す事です。

通常、perl はファイル名中の最後の空白を無視し、何か特別なものを意 味する、ある文字で始まる (あるいは、"|" で終る) ものを解釈します。 これを防ぐには、以下のようなルーチンを使った方が良い。それはフルパ ス名でないものを、明示的な相対パス名にし、perl がそれを独立したま まにしておけるようにファイル名の末尾に null バイトを付加します。

        sub safe_filename {
          local($_) = shift;
          m#^/# ? "$_\0" : "./$_\0";
        }
        $fn = &safe_filename("<<<something really wicked   ");
        open(FH, "> $fn") || "couldn't open $fn: $!";