Manpages

NAME

perlcompile - 關 於 Perl 編 譯 器 和 翻 譯 器 的 介 紹

DESCRIPTION 描 述

Perl 一 直 是 有 一 個 編 譯 器 的 ： 你 的 源 文 件 會 被 編 譯 成 一 種 內 部 格 式 （ 一 種 語 法 分 析 樹 ） ， 並 且 在 運 行 前 還 會 被 優 化 。 從 5.005版 本 起 ， Perl 在 發 行 時 就 帶 有 一 個 模 塊 可 以 檢 查 優 化 過 的 語 法 分 析 樹 （ 該 模 塊 稱 作 B模 塊 ("B")） ， 它 被 用 來 編 寫 許 多 有 用 的 功 能 ， 包 括 一 個 可 以 將 你 的 Perl轉 成 C源 代 碼 的 模 塊 ， 這 樣 再 編 譯 後 就 可 以 得 到 一 個 可 執 行 的 文 件 了 。

"B" 模 塊 提 供 了 訪 問 語 法 分 析 樹 的 方 法 , 其 它 的 一 些 模 塊 （ “後 端 ”） 則 對 這 個 樹 進 行 操 作 。 一 些 把 它 （ 語 法 樹 ） 以 字 節 碼 的 形 式 輸 出 ， 還 有 以 C源 代 碼 形 式 的 輸 出 的 ， 後 者 以 半 可 讀 的 文 本 形 式 輸 出 的 。 另 一 些 遍 歷 整 棵 語 法 樹 以 建 立 一 個 關 於 所 使 用 的 子 程 序 ， 格 式 及 變 量 的 交 叉 引 用 表 。 還 有 另 外 一 些 檢 查 你 的 代 碼 ， 看 看 有 沒 有 模 棱 兩 可 的 構 造 。 另 一 些 則 重 新 將 語 法 樹 導 出 成 Perl代 碼 ， 可 以 起 代 碼 美 化 或 是 消 除 混 亂 的 代 碼 的 作 用 。 因 爲 "B" 模 塊 的 最 初 目 的 是 提 供 一 種 能 將 Perl程 序 轉 爲 對 應 C代 碼 的 方 法 ， 接 着 就 能 把 它 變 成 可 執 行 文 件 了 ， 所 以 "B" 模 塊 和 它 的 那 些 後 端 模 塊 就 被 認 爲 是 “編 譯 器 ”了 ， 即 使 它 們 實 際 上 沒 有 做 任 何 編 譯 方 面 的 事 。 這 個 編 譯 器 的 各 個 部 分 精 確 的 說 應 該 是 個 “翻 譯 器 ”， 或 者 一 個 “檢 視 器 ”， 但 是 用 Perl的 人 們 想 要 一 個 “編 譯 選 項 ”而 不 是 一 個 叫 做 “檢 視 器 ”的 小 玩 藝 。 你 能 怎 麼 辦 呢 ？ 這 篇 文 章 的 主 要 內 容 是 講 Perl編 譯 器 的 用 法 ： 它 包 含 的 模 塊 ， 怎 樣 使 用 那 些 最 重 要 的 後 端 模 塊 ， 它 們 有 什 麼 問 題 ， 如 何 讓 它 們 工 作 。

Layout 佈 局 編 譯 器 的 後 端 放 在 "B::" 裏 面 ， 而 前 端 （ 就 是 你 ， 編 譯 器 的 使 用 者 ， 有 時 候 要 與 之 交 互 的 ） 是 O 模 塊 。 一 些 後 端 （ 如 "B::C")） 提 供 了 一 些 程 序 （ 如 perlcc） 來 隱 藏 模 塊 的 複 雜 性 。 這 裏 是 一 些 值 得 知 道 的 重 要 後 端 ， 並 附 有 它 們 目 前 的 狀 態 ， 用 0到 10的 整 數 表 示 。 （ 狀 態 0表 示 目 前 該 部 分 功 能 只 是 有 一 個 框 架 ， 還 沒 有 實 現 ； 狀 態 10則 表 示 如 果 還 有 Bug的 話 ， 我 們 會 感 到 很 奇 怪 的 ） ：
B::Bytecode 將 語 法 樹 存 成 機 器 相 關 的 格 式 ， 可 供 BtyeLoader模 塊 可 以 在 以 後 重 新 裝 入 。 狀 態 ： 5（ 一 些 部 分 可 以 工 作 ， 一 些 不 可 以 ， 還 有 一 些 還 沒 有 測 試 ）
B::C 創 建 C代 碼 文 件 ， 其 中 包 括 了 重 建 語 法 樹 和 恢 復 解 釋 器 的 代 碼 。 狀 態 ： 6（ 許 多 情 況 下 可 以 正 常 工 作 ， 包 括 使 用 了 Tk的 程 序 ） 。
B::CC 按 照 語 法 樹 中 運 行 期 代 碼 的 路 徑 創 建 C代 碼 文 件 。 這 是 最 像 Perl - C 翻 譯 器 的 一 個 ， 但 是 它 生 成 的 代 碼 幾 乎 是 不 能 看 懂 的 ， 因 爲 它 把 語 法 樹 翻 譯 成 了 一 個 巨 大 的 switch結 構 來 操 作 Perl中 的 結 構 。 最 終 的 目 的 是 在 perl程 序 中 給 出 足 夠 的 類 型 信 息 後 ， 可 以 將 perl 數 據 結 構 的 操 作 轉 換 爲 c 級 別 的 數 據 結 構 ， 對 int 和 float 的 操 作 。 狀 態 ： 5 (有 些 可 以 工 作 ， 包 括 不 復 雜 的 Tk 示 例 ).
B::Lint 當 發 現 你 的 代 碼 中 有 模 棱 兩 可 的 構 造 時 會 發 出 警 告 。 狀 態 ： 6（ 許 多 情 況 下 可 以 正 常 工 作 ， 僅 僅 在 很 少 數 的 領 域 內 它 會 停 止 工 作 ） 。
B::Deparse 重 新 生 成 Perl代 碼 ， 試 着 把 代 碼 用 一 致 的 格 式 寫 出 來 。 狀 態 ： 8（ 它 工 作 得 很 好 ， 只 是 會 略 去 一 些 晦 澀 難 懂 的 部 分 ） 。
B::Xref 生 成 關 於 申 明 和 關 於 變 量 以 及 子 程 序 的 使 用 情 況 的 報 告 。 狀 態 ： 8（ 它 工 作 得 很 好 ， 只 是 仍 有 一 點 延 遲 方 面 的 bugs） 。

Using The Back Ends 使 用 後 端

接 下 來 的 部 分 介 紹 怎 樣 使 用 各 種 各 樣 的 編 譯 器 後 端 。 介 紹 的 順 序 按 照 後 端 的 成 熟 程 度 排 列 ， 所 以 最 爲 穩 定 的 ， 經 過 了 驗 證 的 後 端 會 最 先 介 紹 ， 還 在 試 驗 中 和 沒 有 完 成 的 後 端 就 放 到 後 面 描 述 了 。

O模 塊 默 認 讓 -c 開 關 有 效 ， 這 防 止 Perl在 編 譯 完 代 碼 後 運 行 程 序 。 這 也 是 爲 什 麼 所 有 的 後 端 在 產 生 任 何 輸 出 前 都 會 打 印 一 句 ：

  myperlprogram syntax OK

The Cross Referencing Back End 交 叉 引 用 後 端 交 叉 引 用 後 端 （ B::Xref） 生 成 一 個 關 於 你 的 程 序 的 報 表 ， 把 各 個 申 明 以 及 子 程 序 ， 變 量 （ 包 括 格 式 ） 的 使 用 情 況 存 入 文 件 中 去 。 舉 例 來 說 ， 這 有 一 段 摘 自 對 pod2man程 序 分 析 後 生 成 的 報 表 （ 該 程 序 是 Perl自 帶 的 一 個 例 程 ） ：

  Subroutine clear_noremap
    Package (lexical)
      $ready_to_print   i1069, 1079
    Package main
      $&                1086
      $.                1086
      $0                1086
      $1                1087
      $2                1085, 1085
      $3                1085, 1085
      $ARGV             1086
      %HTML_Escapes     1085, 1085這 裏 展 示 了

"clear_noremap" 子 程 序 中 變 量 的 使 用 情 況 。 就 像 變 量 $ready_to_print 是 my() (詞 法 ) 的 一 個 變 量 ， 在 第 1069行 被 引 入 ( 原 文 用 的 詞 是 introduced， 也 就 是 在 my() 中 第 一 次 被 定 義 的 意 思 )， 然 後 在 第 1079行 該 變 量 被 使 用 了 。 從 主 包 （ main package） 中 來 的 變 量 $& 又 在 第 1086行 被 使 用 , 等 等 。 行 號 前 面 可 能 會 有 一 個 字 母 作 爲 前 綴 ， 它 們 的 意 思 是 ：

i 變 量 首 次 被 引 入

(在 my()中 申 明 ) 。

& 子 程 序 或 者 方 法 的

引 用 。

s 定 義 的 子 程 序 。

r 定 義 的 格 式 。 交 叉 引 用 中 最 爲 有 用 的 選 項 就 是 把 報 表 存 入 不 同 的 文 件 ， 例 如 要 把 關 於

myperlprogram 的 報 表 存 入 文 件 report 中 ：

  $ perl -MO=Xref,-oreport myperlprogram

The Decompiling Back End 反 編 譯 後 端 反 編 譯 後 端 將 把 你 的 Perl語 法 樹 重 新 變 成 源 代 碼 。 生 成 的 源 代 碼 會 按 照 某 種 格 式 組 織 ， 所 以 這 個 後 端 可 以 用 來 消 除 代 碼 中 的 混 亂 部 分 。 此 後 端 的 基 本 使 用 方 法 如 下 ：

$ perl -MO=Deparse myperlprogram 你 也 許 馬 上 會 發 現 Perl並 不 知 道 如 何 給 你 的 代 碼 分 段 。 你 要 自 己 手 動 添 入 新 行 來 把 這 大 斷 的 代 碼 分 開 。 然 而 現 在 ， 讓 我 們 看 看 代 碼 只 有 一 行 時 情 況 怎 樣 ， 這 個 後 端 會 做 些 什 麼 ：

  $ perl -MO=Deparse -e ’$op=shift⎪⎪die "usage: $0
  code [...]";chomp(@ARGV=<>)unless@ARGV; for(@ARGV){$was=$_;eval$op;
  die$@ if$@; rename$was,$_ unless$was eq $_}’
  -e syntax OK
  $op = shift @ARGV ⎪⎪ die("usage: $0 code [...]");
  chomp(@ARGV = <ARGV>) unless @ARGV;
  foreach $_ (@ARGV) {
      $was = $_;
      eval $op;
      die $@ if $@;
      rename $was, $_ unless $was eq $_;}這 個 後 端 也 有 幾 條 選 項 控 制 生 成 的 代 碼 ， 舉 例 說 ， 你 可 以 把 縮 進 的 尺 寸 設 在

4（ 最 大 ） 到 2之 間 ：

  $ perl -MO=Deparse,-si2 myperlprogram

-p 開 關 控 制 在 常 常 可 以 不 加 圓 括 號 的 地 方 加 上 它 們 ：

  $ perl -MO=Deparse -e ’print "Hello, world\n"’
  -e syntax OK
  print "Hello, world\n";
  $ perl -MO=Deparse,-p -e ’print "Hello, world\n"’
  -e syntax OK
  print("Hello, world\n");要 知 道 更 多 ， 請 參 考

B::Deparse

Lint 後 端

lint 後 端 （ B::Lint） 檢 察 程 序 中 不 好 的 程 序 風 格 。 一 個 程 序 認 爲 的 不 好 風 格 可 能 對 另 外 一 個 程 序 員 來 說 是 用 起 來 很 有 效 的 工 具 ， 所 以 有 選 項 讓 你 設 定 哪 些 東 東 將 會 受 到 檢 查 。 要 運 行 一 個 風 格 檢 查 器 檢 察 你 的 代 碼 ：

$ perl -MO=Lint myperlprogram 要 取 消 對 上 下 文 和 沒 有 定 義 的 子 程 序 的 檢 查 ：

$ perl -MO=Lint,-context,-undefined-subs myperlprogram 要 知 道 更 多 的 選 項 信 息 ， 請 看 B::Lint

The Simple C Back End 簡 化 的 C後 端 這 個 模 塊 用 來 把 你 的 Perl程 序 的 內 部 編 譯 狀 態 存 儲 到 一 個 C代 碼 文 件 中 去 ， 而 生 成 的 C代 碼 就 可 以 被 特 定 平 臺 上 的 C編 譯 器 轉 換 成 一 個 可 執 行 文 件 了 。 最 後 的 程 序 還 會 和 Perl解 釋 器 的 庫 文 件 靜 態 鏈 接 起 來 ， 所 以 它 不 會 節 省 你 的 磁 盤 空 間 （ 除 非 你 的 Perl是 用 共 享 的 庫 文 件 創 建 的 ） 或 是 程 序 大 小 ， 然 而 ， 另 一 方 面 ， 程 序 啓 動 起 來 會 快 一 些 。

"perlcc" 工 具 缺 省 是 生 成 以 下 的 可 執 行 文 件 。

  perlcc myperlprogram.pl

The Bytecode Back End 字 節 碼 後 端 這 個 模 塊 只 有 在 你 能 夠 找 到 一 種 方 法 來 裝 入 並 運 行 它 生 成 的 字 節 碼 時 纔 會 顯 得 有 用 。 ByteLoader模 塊 提 供 了 這 項 功 能 。 要 把 Perl轉 換 成 可 執 行 的 字 節 碼 ， 你 可 以 使 用 "perlcc" 的 "-B" 開 關 :

perlcc -B myperlprogram.pl 字 節 碼 是 和 機 器 類 型 無 關 的 ， 所 以 一 旦 你 編 譯 了 一 個 模 塊 或 是 程 序 ， 它 就 可 以 像 Perl源 代 碼 一 樣 具 有 可 移 植 性 。 （ 假 設 那 個 模 塊 或 者 程 序 的 使 用 者 有 一 個 足 夠 新 的 Perl解 釋 器 來 對 字 節 碼 進 行 解 碼 ） 有 一 些 選 項 用 來 控 制 要 生 成 的 字 節 碼 的 性 質 和 關 於 優 化 方 面 的 參 數 ， 要 知 道 這 些 選 項 的 詳 細 情 況 ， 請 參 考 B::Bytecode

The Optimized C Back End 優 化 的 C後 端 優 化 的 C後 端 按 照 語 法 樹 中 運 行 期 代 碼 的 路 徑 將 你 的 Perl程 序 轉 換 成 等 效 的 (但 是 被 優 化 了 的 )C代 碼 文 件 。 這 個 C程 序 會 直 接 對 Perl的 數 據 結 構 進 行 操 作 ， 而 且 也 會 鏈 接 Perl的 解 釋 器 的 庫 文 件 ， 以 支 持 eval(), "s///e", "require" 等 等 。

"perlcc" 工 具 使 用 -O 開 關 生 成 這 種 可 執 行 文 件 。 要 編 譯 一 個 Perl程 序 （ 以 ".pl" 或 者 ".p" 結 尾 ） ：

perlcc -O myperlprogram.pl 從 Perl模 塊 創 建 一 個 共 享 庫 文 件 （ 以 ".pm" 結 尾 ） ：

perlcc -O Myperlmodule.pm 知 道 更 多 ， 請 參 考 perlcc 和 B::CC.

Module List for the Compiler Suite 編 譯 套 件 的 模 塊 列 表

B 這 個 模 塊 是 一 個 自 省 的 （

introspective， 用 Java的 術 語 說 就 是

“reflective”） 模 塊 ， 允 許 Perl程 序 審 視 自 己 的 內 部 。 後 端 模 塊 都 是 通 過 這 個 模 塊 來 訪 問 語 法 分 析 樹 的 。 而 你 ， 後 端 模 塊 的 用 戶 ， 就 不 用 和 B模 塊 打 交 道 了 。

O 這 個 模 塊 是 編 譯 器 的 那 些 後 端 的 前 端 ， 一 般 像 這 樣 進 行 調 用 ：

$ perl -MO=Deparse myperlprogram 這 與 在 這 個 Perl程 序 中 使 用 "use O ’Deparse’" 相 同 。

B::Asmdata 這 個 模 塊 被 B::Assembler 模 塊 使 用 ， 而 B::Assembler 又 接 着 被 B::Bytecode 模 塊 使 用 ， B::Bytecode中 有 一 個 字 節 碼 形 式 存 放 的 語 法 分 析 樹 以 便 以 後 裝 入 。 B::Asmdata自 己 並 不 算 是 一 個 後 端 ， 也 許 說 它 是 後 端 的 一 個 組 件 比 較 好 。
B::Assembler 這 個 模 塊 可 以 將 語 法 樹 轉 爲 適 合 存 儲 和 恢 復 的 數 據 形 式 。 它 本 身 不 是 一 個 後 端 ， 但 是 算 是 某 個 後 端 的 一 個 組 件 。 assemble 程 序 用 它 來 生 成 字 節 碼 。
B::Bblock 這 個 模 塊 被 B::CC 後 端 使 用 。 它 被 用 來 運 行 “基 本 塊 ”。 一 個 基 本 塊 就 是 一 段 從 頭 到 尾 的 操 作 ， 中 間 是 不 可 能 停 下 來 或 出 現 分 支 的 。
B::Bytecode 這 個 模 塊 可 以 由 程 序 的 語 法 樹 生 成 字 節 碼 。 生 成 的 字 節 碼 會 被 寫 入 到 文 件 中 ， 以 後 還 能 被 重 新 恢 復 成 語 法 樹 。 總 的 目 標 就 是 爲 了 只 進 行 一 次 費 時 的 程 序 編 譯 工 作 ， 然 後 把 解 釋 器 的 狀 態 存 入 文 件 中 ， 運 行 程 序 時 再 把 狀 態 從 文 件 中 恢 復 。 具 體 的 用 法 請 參 考 "The Bytecode Back End" 。
B::C 這 個 模 塊 按 照 語 法 樹 和 其 他 一 些 解 釋 器 的 內 部 數 據 結 構 生 成 C代 碼 。 然 後 你 再 編 譯 生 成 的 C代 碼 ， 就 可 以 得 到 一 個 可 執 行 文 件 了 。 運 行 時 這 個 可 執 行 文 件 會 恢 復 解 釋 器 和 內 部 的 數 據 結 構 來 轉 動 程 序 。 要 知 道 細 節 請 參 考 "The Simple C Back End"。
B::CC 這 個 模 塊 按 照 你 程 序 中 的 操 作 生 成 C代 碼 。 不 像 B::C 模 塊 只 是 把 解 釋 和 它 的 狀 態 存 入 C程 序 中 ， B::CC 模 塊 生 成 的 是 不 包 含 解 釋 器 的 C 程 序 ， 所 以 用 B::CC 翻 譯 的 C 程 序 運 行 速 度 比 一 般 的 解 釋 執 行 的 程 序 速 度 要 快 ， 具 體 用 法 請 參 考 "The Optimized C Back End" 。
B::Concise 這 個 模 塊 輸 出 一 個 簡 潔 的 (但 是 完 整 的 ) Perl 分 析 樹 。 它 的 輸 出 比 B::Terse 或 者 B::Debug 的 結 果 更 容 易 定 製 (並 且 也 可 以 模 仿 它 們 )。 這 個 模 塊 對 書 寫 自 己 的 後 端 ， 或 者 學 習 Perl 實 現 的 人 有 用 。 它 對 一 般 的 程 序 員 沒 有 用 處 。
B::Debug 這 個 模 塊 把 Perl語 法 分 析 樹 非 常 詳 細 地 輸 出 到 標 準 輸 出 上 去 。 這 對 正 在 編 寫 自 己 的 後 端 程 序 ， 或 正 在 深 入 Perl內 部 機 制 的 人 們 來 說 是 非 常 有 用 的 。 對 普 通 程 序 員 來 說 則 沒 什 麼 用 。
B::Deparse 這 個 模 塊 將 編 譯 了 的 語 法 樹 反 向 分 析 得 出 Perl源 代 碼 ， 這 在 調 試 或 是 反 編 譯 他 人 代 碼 的 時 候 會 是 非 常 有 用 的 。 另 外 讓 它 爲 你 自 己 的 代 碼 做 一 些 美 化 工 作 也 是 可 以 的 。 要 知 道 細 節 請 參 考 "The Decompiling Back End"。
B::Disassembler 這 個 模 塊 把 字 節 碼 恢 復 成 語 法 樹 ， 它 本 身 不 是 一 個 後 端 ， 而 是 某 個 後 端 的 一 個 組 件 。 它 會 被 和 字 節 碼 在 一 起 的 disassemble 程 序 使 用 。
B::Lint 這 個 模 塊 審 視 你 的 代 碼 編 譯 後 的 格 式 ， 並 且 找 到 那 些 容 易 讓 人 皺 眉 ， 卻 又 不 至 於 引 起 警 告 的 地 方 。 舉 例 來 說 ， 使 用 一 個 標 量 內 容 （ scalar context） 的 數 組 ， 而 不 顯 式 地 申 明 成 "scalar(@array)" 。 這 種 情 況 是 會 被 Lint 標 示 出 來 的 。 要 知 道 細 節 請 參 考 "The Lint Back End"。
B::Showlex 這 個 模 塊 打 印 出 my() 中 的 變 量 在 函 數 或 是 文 件 中 的 使 用 情 況 ， 以 得 到 一 份 關 於 my() 中 的 變 量 在 定 義 於 文 件 myperlprogram 中 的 子 程 序 mysub() 中 的 使 用 情 況 的 列 表 ：

$ perl -MO=Showlex,mysub myperlprogram 要 得 到 一 份 關 於 my() 中 的 變 量 在 文 件 myperlprogram中 的 使 用 情 況 的 列 表 ：

  $ perl -MO=Showlex myperlprogram

[ BROKEN ]

B::Stackobj 這 個 模 塊 被 B::CC 模 塊 調 用 。 它 本 身 不 是 後 端 ， 但 是 是 某 個 後 端 的 一 個 組 件 。
B::Stash 這 個 模 塊 被 perlcc 程 序 調 用 ， 而 perlcc可 以 把 一 個 模 塊 編 譯 成 可 執 行 文 件 。 B::Stash 把 程 序 使 用 的 符 號 表 打 印 出 來 ， 並 被 用 來 阻 止 B::CC 爲 B::* 或 是 O 模 塊 生 成 C 代 碼 。 它 本 身 不 是 後 端 ， 但 是 是 某 個 後 端 的 一 個 組 件 。
B::Terse 這 個 模 塊 用 來 打 印 語 法 樹 的 內 容 ， 但 是 信 息 不 會 有 B::Debug打 印 的 那 麼 多 。 對 比 來 說 ， "print "Hello, world."" 會 讓 B::Debug 產 生 96行 輸 出 ， 但 是 B::Terse只 會 有 6行 。 這 個 模 塊 對 正 在 編 寫 自 己 的 後 端 程 序 ， 或 正 在 深 入 Perl內 部 機 制 的 人 們 來 說 是 非 常 有 用 的 。 對 普 通 程 序 員 來 說 則 沒 什 麼 用 。
B::Xref 這 個 模 塊 打 印 一 個 報 表 列 出 在 程 序 中 哪 裏 定 義 和 使 用 了 哪 些 變 量 ， 子 程 序 或 格 式 ， 報 表 還 會 列 出 程 序 裝 入 的 模 塊 。 要 知 道 詳 細 的 使 用 方 法 ， 請 參 考 "The Cross Referencing Back End" 。

KNOWN PROBLEMS 已 知 的 問 題

簡 單 C 後 端 目 前 只 保 存 以 字 符 和 數 字 命 名 的 類 型 說 明 優 化 的 C 後 端 會 爲 一 些 不 該 爲 之 輸 出 的 模 塊 （ 比 如 說 DirHandle） 輸 出 代 碼 。 而 且 它 不 太 可 能 正 確 地 處 理 正 在 執 行 的 子 程 序 外 部 的 goto語 句 （ goto &sub is OK） 。 目 前 "goto LABEL" 語 句 在 這 個 後 端 中 完 全 不 會 工 作 。 他 還 會 生 成 讓 C 編 譯 器 頭 痛 無 比 的 巨 大 的 初 始 化 函 數 。 如 果 把 這 個 初 始 化 函 數 分 割 開 是 能 得 到 比 目 前 更 好 的 效 果 的 。 另 外 的 問 題 包 括 ： 處 理 無 符 號 的 數 學 問 題 時 不 能 正 確 工 作 ； 一 些 操 作 碼 如 果 按 照 默 認 的 操 作 碼 機 制 處 理 也 會 有 非 正 常 的 結 果 。

BEGIN{} 塊 會 在 編 譯 你 的 代 碼 的 時 候 被 執 行 。 所 有 的 在 BEGIN{} 中 初 始 化 的 外 部 狀 態 ， 如 打 開 的 文 件 ， 初 始 的 數 據 庫 連 結 等 等 ， 會 有 不 正 確 的 表 現 。 爲 了 解 決 這 個 問 題 ， Perl中 又 提 供 了 一 個 INIT{} 塊 來 對 應 程 序 編 譯 之 後 ， 正 式 運 行 之 前 要 執 行 的 那 段 代 碼 。 執 行 的 順 序 是 ： BEGIN{}, (後 端 編 譯 程 序 可 能 這 時 會 保 存 狀 態 ), INIT{}, 程 序 運 行 , END{}。

AUTHOR 作 者

這 篇 文 章 最 初 是 由 Nathan Torkington 編 寫 ， 現 在 由 郵 件 列 表 (perl5-porters [AT] perl.org.)維 護

譯 者

郭 銳 (sunny65535) <sunny65535 [AT] 263.net> 跋 本 頁 面 中 文 版 由 中 文 man 手 冊 頁 計 劃 提 供 。 中 文 man 手 冊 頁 計 劃 ： https://github.com/man-pages-zh/manpages-zh