Manpages

NAME

perldata- Perl 数 据 类 型

DESCRIPTION 描 述

Variable names 变 量 名
Perl 有 三 种 内 建 的 数 据 类 型 : 标 量 , 数 组 和 关 联 数 组 ( 即 “哈 希 表 , hash”) 。 数 组 以 数 字 为 索 引 , 通 常 以 0开 始 , 升 序 排 列 。 哈 希 表 以 与 值 相 关 联 的 字 符 串 为 索 引 , 内 部 排 列 是 无 序 的 。 值 通 常 通 过 一 个 变 量 名 ( 或 变 量 名 的 引 用 ) 来 引 用 。 变 量 名 的 前 缀 字 符 显 示 了 值 的 数 据 类 型 。 其 余 部 分 指 明 了 引 用 的 是 哪 一 个 特 定 的 值 。 通 常 变 量 名 是 一 个 唯 一 的 标 识 符 , 以 字 母 或 下 划 线 开 始 , 包 括 字 母 、 下 划 线 和 数 字 。 某 些 情 况 下 , 也 可 以 是 以 ’::’ 分 隔 的 一 串 标 识 符 (或 者 是 过 时 的 ’’’); 除 了 最 后 一 个 , 其 它 都 是 包 名 , 用 来 定 位 最 后 一 个 标 识 符 所 在 的 位 置 (详 情 参 见 perlmod 中 的 Packages)。 可 以 用 一 个 简 单 的 标 识 符 来 替 代 它 , 利 用 引 用 就 可 以 。 下 文 有 详 述 , 也 可 参 见 perlref .

Perl 也 有 内 建 的 变 量 , 其 名 称 不 遵 循 这 一 规 则 。 它 们 名 称 古 怪 , 这 样 可 以 避 免 与 你 的 变 量 名 冲 突 。 模 式 匹 配 中 被 匹 配 到 的 字 符 串 是 以 ’$’ 加 一 个 数 字 的 变 量 名 来 存 放 的 (参 见 the perlop manpage 和 the perlre manpage)。 另 外 , 还 有 几 个 使 你 可 以 介 入 perl 内 部 工 作 的 特 殊 变 量 , 其 名 称 中 包 含 标 点 和 控 制 字 符 ( 参 见 perlvar ) 标 量 以 ’$’开 始 , 即 使 它 是 数 组 或 哈 希 的 元 素 也 是 如 此 。 可 以 把 ’$’ 理 解 为 ’s’ , 表 示 scalar( 标 量 ) 。 ( 译 者 注 : 此 处 根 据 有 关 文 档 , 做 了 改 动 , 下 面 的 @处 也 是 这 样 )

$days # 简 单 标 量 "days"
$days[28] # 数 组 @days的 第 29个 元 素
$days{’Feb’} # 哈 希 %days的 ’Feb’ 所 对 应 的 值
$#days # 数 组 @days的 最 后 一 个 元 素 的 索 引 值 整 个 数 组 ( 或 数 组 和 哈 希 的 局 部 ) 以 ’@’开 始 , 它 类 似 英 文 中 的 “these” 或 “those” (这 些 ...那 些 ...), 表 示 期 望 有 多 个 值 。

@days # ($days[0], $days[1],... $days[n])
@days[3,4,5] # 即 ($days[3],$days[4],$days[5])
@days{’a’,’c’} # 即 ($days{’a’},$days{’c’}) 整 个 哈 希 以 ’%’ 开 始 :

%days # (key1, val1, key2, val2 ...) 另 外 , 子 程 序 以 ’&’来 表 示 , 但 有 时 在 不 引 起 误 解 的 情 况 下 也 可 以 不 用 , 就 象 “do” 在 英 语 中 常 常 省 略 一 样 。 符 号 表 项 以 ’*’ 作 为 开 始 字 符 , 不 过 你 现 在 还 不 用 关 心 这 个 (if ever ;-) 每 一 种 数 据 类 型 都 有 它 自 己 的 名 字 空 间 , 常 量 标 识 符 也 一 样 。 这 意 味 着 你 可 以 使 用 同 一 个 名 字 来 命 名 标 量 、 数 组 、 哈 希 、 文 件 句 柄 、 目 录 句 柄 、 子 程 序 、 格 式 或 标 签 。 即 $foo 和 @foo 是 不 同 的 变 量 。 也 即 意 味 着 $foo[1] 是 @foo 的 一 部 分 , 而 不 是 $foo的 一 部 分 . 这 看 来 有 些 怪 异 , 不 过 很 正 常 , 因 为 它 本 来 就 怪 异 。 因 为 变 量 名 以 ’$’, ’@’, 或 ’%’开 始 , 保 留 词 对 变 量 没 有 什 么 影 响 。 保 留 词 影 响 的 是 标 签 和 文 件 句 柄 , 因 为 它 们 不 是 以 特 殊 字 符 前 缀 开 始 的 。 你 不 能 用 “log” 来 命 名 文 件 句 柄 , 因 为 它 是 保 留 词 ( 提 示 : 你 可 以 用 ’open(LOG,’logfile’)’ 而 不 是 ’open(log,’logfile’)’). 使 用 大 写 的 文 件 句 柄 既 增 加 了 可 读 性 , 又 减 少 了 冲 突 的 发 生 。 大 小 写 是 有 意 义 的 --“ FOO ”,“Foo”, 和 “foo” 是 不 同 的 名 称 。 以 字 母 或 下 划 线 开 始 的 名 称 可 以 包 含 数 字 和 下 划 线 。 可 以 用 一 个 返 回 相 关 引 用 的 表 达 式 来 替 换 这 样 的 变 量 名 。 参 见 perlref 以 数 字 开 始 的 变 量 名 只 能 包 含 数 字 。 不 是 以 字 母 、 下 划 线 或 数 字 开 始 的 变 量 名 只 能 含 有 一 个 字 符 , 如 : $% 或 $$. (大 部 分 这 样 的 变 量 都 有 特 殊 的 意 义 。 例 如 , $$ 是 当 前 进 程 的 id。 )

Context 上 下 文 在 Perl 中 有 时 操 作 或 值 的 意 义 取 决 于 该 操 作 或 值 所 处 的 上 下 文 。 有 两 个 主 要 的 上 下 文 : 列 表 和 标 量 上 下 文 。 相 当 一 部 分 操 作 在 需 要 列 表 的 上 下 文 中 返 回 列 表 , 在 需 要 标 量 的 上 下 文 中 返 回 标 量 。 这 在 有 关 该 操 作 的 文 档 中 会 提 到 。 换 句 话 讲 , Perl会 重 载 这 些 操 作 符 。 英 语 中 的 某 些 词 , 如 ’fish’和 ’sheep’与 此 类 似 。 操 作 可 以 根 据 不 同 的 上 下 文 返 回 不 同 的 值 。 例 如 , 如 果 这 样 写 :

int( <STDIN> )

integer 操 作 提 供 标 量 上 下 文 给 <> 操 作 符 , <> 会 从 STDIN 读 入 一 行 返 回 给 integer 操 作 , 然 后 它 返 回 其 中 的 整 型 量 。 但 如 果 你 这 样 写 :

sort( <STDIN> )

sort操 作 提 供 列 表 上 下 文 给 <>, <>会 读 入 STDIN中 的 每 一 行 直 到 结 束 , 然 后 将 其 传 递 给 sort, sort然 后 将 其 排 序 输 出 。 赋 值 比 较 特 殊 , 左 侧 的 参 数 决 定 了 右 侧 的 参 数 的 上 下 文 。 赋 值 给 标 量 , 则 右 侧 参 数 的 上 下 文 是 标 量 上 下 文 ; 赋 值 给 数 组 或 哈 希 , 则 右 侧 参 数 的 上 下 文 是 列 表 上 下 文 。 赋 值 给 列 表 ( 或 片 段 , 其 实 也 是 列 表 ) , 右 侧 的 上 下 文 也 是 列 表 上 下 文 。 当 你 使 用 ’use warnings’ 编 译 指 示 或 Perl 的 -w 参 数 时 , 你 可 能 会 看 到 这 样 的 警 告 : 在 “无 效 的 上 下 文 , void context” 中 使 用 了 常 量 或 函 数 。 无 效 上 下 文 的 意 思 是 值 被 丢 弃 不 用 , 比 如 只 包 含 有 "fred"; 的 语 句 ; 或 是 ’getpwuid(0);’;. 在 要 求 列 表 上 下 文 的 函 数 被 标 量 上 下 文 环 境 调 用 时 ,也 会 出 现 这 个 警 告 . 用 户 定 义 的 子 程 序 可 能 会 需 要 查 看 上 下 文 是 无 效 , 标 量 , 还 是 列 表 。 不 过 , 大 多 数 并 不 需 要 这 么 做 。 因 为 标 量 和 列 表 会 自 动 插 入 到 一 个 列 表 中 。 参 见 perlfunc 中 的 “wantarray” 以 了 解 如 何 辨 明 你 的 函 数 调 用 时 的 上 下 文 。

Scalar values 标 量
Perl 中 的 所 有 数 据 都 是 标 量 , 标 量 的 数 组 ,标 量 的 哈 希 . 标 量 可 以 是 三 种 不 同 的 值 : 数 字 , 字 符 (串 ), 引 用 . 通 常 , 不 同 值 之 间 的 转 换 是 透 明 的 . 虽 然 一 个 标 量 不 可 能 有 多 个 值 , 但 是 它 可 以 是 一 个 包 含 多 个 值 的 数 组 或 哈 希 的 引 用 . 标 量 不 一 定 非 此 即 彼 . 不 需 要 声 明 变 量 的 类 型 是 "字 符 串 ","数 字 ","引 用 "或 其 它 什 么 . 因 为 标 量 会 自 动 转 换 , 所 以 其 类 型 不 用 关 心 . Perl 是 上 下 文 多 形 语 言 ,它 的 标 量 可 以 是 字 符 串 ,数 字 或 引 用 (包 括 对 象 ). 其 中 字 符 串 和 数 字 在 大 多 数 情 况 下 并 没 有 什 么 不 同 , 引 用 是 强 化 的 ,不 可 变 的 带 有 内 建 引 用 计 数 和 析 构 器 的 指 针 . 标 量 在 不 是 空 字 符 串 和 数 字 0的 时 候 被 解 释 为 真 TRUE. 布 尔 上 下 文 是 这 样 一 种 上 下 文 , 这 时 不 会 发 生 数 字 或 字 符 串 的 自 动 转 换 . 有 两 种 空 字 符 串 (有 时 以 "empty"表 示 ), 定 义 了 的 和 未 定 义 的 . 定 义 了 的 空 字 符 串 就 是 长 度 为 零 的 字 符 串 ,如 "". 未 定 义 的 空 字 符 串 是 一 个 值 ,这 个 值 表 示 某 事 物 并 没 有 真 实 值 与 它 对 应 , 比 如 出 错 , 或 到 达 文 件 尾 , 或 者 你 引 用 一 个 未 定 义 的 数 组 或 哈 希 的 元 素 时 ,都 会 返 回 一 个 未 定 义 的 空 字 符 串 . 虽 然 在 早 期 Perl 中 ,在 要 求 已 定 义 变 量 的 上 下 文 中 使 用 未 定 义 的 变 量 可 以 使 得 该 变 量 得 到 定 义 , 现 在 却 只 有 在 特 殊 的 情 况 下 才 会 出 现 这 种 结 果 ,参 见 the perlref manpage. 可 以 用 defined() 函 数 来 检 测 标 量 是 否 已 经 定 义 (对 数 组 和 哈 希 无 效 ),也 可 以 用 undef() 去 除 对 变 量 的 定 义 . 要 弄 清 楚 一 个 字 符 串 是 否 是 有 效 的 非 0数 字 ,只 要 看 它 是 不 是 数 字 0和 字 母 “0” 就 足 够 了 (不 过 这 在 使 用 -w参 数 时 ,会 显 示 警 告 ). 因 为 非 数 字 的 字 符 串 被 看 作 0, 与 awk中 相 似 :

if ($str == 0 && $str ne "0") {
warn "That doesn’t look like a number"; } 这 种 方 法 可 能 是 最 好 的 ,因 为 如 若 不 然 你 不 会 正 确 对 待 IEEE 的 注 释 ,比 如 ’NaN’ 和 无 穷 大 . 别 的 时 候 , 你 可 能 更 愿 意 用 POSIX::strtod() 函 数 或 是 正 则 表 达 式 来 检 测 字 符 串 是 否 能 用 做 数 字 (参 见 perlre).

warn "has nondigits" if /\D/;
warn "not a natural number" unless /^\d+$/; # rejects -3
warn "not an integer" unless /^-?\d+$/; # rejects +3
warn "not an integer" unless /^[+-]?\d+$/;
warn "not a decimal number" unless /^-?\d+\.?\d*$/; # rejects .2
warn "not a decimal number" unless /^-?(?:\d+(?:\.\d*)?|\.\d+)$/;
warn "not a C float"
unless /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/; 数 组 的 长 度 是 标 量 . 通 过 $#days你 可 以 知 道 @days的 长 度 . 技 术 上 讲 ,这 不 是 数 组 的 长 度 ; 而 是 最 后 一 个 元 素 的 下 标 ,因 为 第 一 个 元 素 的 下 标 是 0. 对 $#days 赋 值 会 改 变 数 组 的 长 度 . 以 这 种 方 式 减 少 数 组 的 话 , 会 破 坏 其 中 的 值 , 再 增 加 其 长 度 也 不 能 恢 复 . (Perl 4中 是 可 以 的 , 我 们 改 变 了 它 以 确 保 析 构 器 被 及 时 调 用 .) 你 可 以 使 用 一 些 小 技 巧 来 预 扩 展 一 个 数 组 (如 果 你 知 道 它 将 会 变 得 很 大 的 话 ). 可 以 用 给 超 出 数 组 范 围 的 元 素 赋 值 的 方 法 扩 展 数 组 . 可 以 给 数 组 赋 值 一 个 空 列 表 以 清 空 数 组 . 下 面 语 句 等 价 :

@whatever = ();
$#whatever = -1; 数 组 处 于 标 量 上 下 文 中 时 , 返 回 值 是 数 组 的 长 度 . (列 表 在 标 量 上 下 文 中 ,返 回 值 是 列 表 的 最 后 一 个 元 素 ,像 是 C中 的 逗 号 操 作 符 , 而 内 建 函 数 的 返 回 值 由 它 们 自 己 决 定 .) 以 下 语 句 为 真 :

scalar(@whatever) == $#whatever - $[ + 1;

Perl 5 改 变 了 $[ 的 意 义 : 不 必 担 心 别 的 程 序 改 变 了 $[ 的 值 . (换 言 之 ,不 推 荐 使 用 $[ ) 所 以 ,可 以 写 成 这 样 :

scalar(@whatever) == $#whatever + 1; 有 些 程 序 员 为 了 明 确 起 见 , 会 使 用 显 式 的 转 换 :

$element_count = scalar(@whatever); 当 哈 希 处 于 标 量 上 下 文 中 时 , 如 果 哈 希 为 空 , 返 回 值 为 假 , 如 果 非 空 , 返 回 值 为 真 ; 说 得 更 精 确 些 , 返 回 值 是 个 字 符 串 , 由 已 经 使 用 的 存 储 段 和 分 配 的 全 部 存 储 段 组 成 ,二 者 之 间 以 斜 杠 分 隔 . 这 可 以 用 来 反 映 Perl的 哈 希 算 法 的 好 坏 . 例 如 , 你 的 哈 希 中 有 10,000个 元 素 ,但 是 %HASH 的 标 量 值 为 "1/16", 则 说 明 仅 用 到 了 16个 存 储 段 中 的 一 个 , 也 许 10,000个 元 素 都 在 这 一 个 存 储 段 中 . 最 好 不 要 发 生 这 种 情 况 . 你 可 以 预 先 为 哈 希 分 配 空 间 , 这 要 使 用 给 keys() 函 数 赋 值 的 方 法 来 实 现 . 实 际 分 配 的 空 间 是 大 于 所 给 值 的 二 的 幂 :

keys(%users) = 1000; # 分 配 1024 空 间

Scalar value constructors 标 量 数 据 构 造 数 值 常 量 有 以 下 浮 点 和 整 数 格 式 :

12345
12345.67
.23E-10 # a very small number
3.14_15_92 # a very important number
4_294_967_296 # underscore for legibility
0xff # hex
0xdead_beef # more hex
0377 # octal
0b011011 # binary 在 数 字 常 量 中 可 以 在 数 字 间 插 入 下 划 线 来 增 加 可 读 性 。 例 如 , 可 以 三 位 一 组 (Unix 样 式 的 分 组 , 例 如 0b110_110_100), 或 者 四 位 一 组 (来 表 示 nibbles, 例 如 0b1010_0110), 或 者 其 他 分 组 。 字 符 串 通 常 以 单 引 号 或 双 引 号 括 起 . 与 标 准 Unix shells中 的 引 号 相 似 : 双 引 号 可 以 接 收 转 义 和 变 量 ; 单 引 号 不 可 以 (除 了 ’\’’ 和 ’\\’)). C 样 式 的 转 义 字 符 可 以 用 来 输 入 新 行 , 跳 格 等 字 符 , 转 义 字 符 的 列 表 可 以 参 见 perlop 中 的 “Quote and Quote-like Operators” 十 六 进 制 ,八 进 制 ,或 二 进 制 以 字 符 串 形 式 表 示 (如 :’0xff’),不 能 自 动 转 换 为 十 进 制 形 式 . hex() 和 oct() 函 数 可 以 实 现 转 换 . 参 见 perlfunc 中 的 hex 和 oct 了 解 详 情 . 可 以 在 字 符 串 中 直 接 加 入 新 行 . 字 符 串 中 的 变 量 只 能 是 标 量 ,数 组 和 数 组 或 哈 希 的 片 段 (换 言 之 , 以 $或 @开 始 , 后 跟 下 标 .). 以 下 语 句 打 印 ’’The price is $100.’’

$Price = ’$100’; # not interpolated
print "The price is $Price.\n"; # interpolated

perl 中 没 有 double interpolation, 因 此 $100 保 持 不 变 。 正 如 在 有 些 shell中 一 样 , 你 可 以 用 花 括 号 括 起 变 量 名 , 以 便 区 分 变 量 名 和 其 后 的 字 母 及 下 划 线 . 如 果 要 将 一 个 变 量 改 写 为 字 符 串 时 , 必 须 这 样 做 , 以 避 免 与 后 面 的 双 冒 号 或 单 引 号 连 接 起 来 , 否 则 会 被 当 作 包 名 :

$who = "Larry";
print PASSWD "${who}::0:0:Superuser:/:/bin/perl\n";
print "We use ${who}speak when ${who}’s here.\n"; 如 果 没 有 花 括 号 , Perl会 寻 找 $whospeak, $who::0, 和 $who’s 变 量 . 后 两 个 是 不 存 在 的 who 包 中 的 $0 和 $s. 实 际 上 , 花 括 号 中 的 标 识 符 必 须 是 字 符 串 , 哈 希 的 下 标 也 必 须 是 字 符 串 . 都 不 需 要 引 号 , 前 面 的 例 子 $days{’Feb’} 可 以 写 作 $days{Feb} 引 号 会 自 动 加 上 . 但 是 下 标 中 的 其 它 复 杂 内 容 被 解 释 为 表 达 式 .

Version Strings 注 意 : Version Strings (v-strings) have been deprecated. They will not be available after Perl 5.8. The marginal benefits of v-strings were greatly outweighed by the potential for Surprise and Confusion. 类 似 ’v1.20.300.4000’ 这 样 的 形 式 被 解 释 为 一 个 字 符 串 . 这 种 形 式 称 为 v-strings, 提 供 了 更 易 读 的 方 法 来 构 造 字 符 串 , 比 起 "\x{1}\x{14}\x{12c}\x{fa0}" 更 加 易 读 . 这 在 表 示 Unicode 字 符 串 时 很 有 用 , 在 使 用 字 符 串 比 较 命 令 (’cmp’,’gt’,’lt’ 等 )比 较 版 本 号 时 也 非 常 有 用 . 如 果 其 中 的 点 号 多 于 两 个 , 则 开 始 的 ’v’ 可 以 省 略 .

print v9786; # prints UTF-8 encoded SMILEY, "\x{263a}"
print v102.111.111; # prints "foo"
print 102.111.111; # same 这 种 形 式 可 以 用 于 require 和 use 中 作 版 本 检 查 .“$^V” 特 殊 变 量 中 的 Perl版 本 号 就 是 以 这 种 形 式 保 存 的 . 参 见 perlvar 中 的 “$^V” 注 意 使 用 v-strings 来 保 存 IPv4 地 址 是 不 可 移 植 的 , 除 非 同 时 使 用 Socket 包 的 inet_aton()/inet_ntoa() 函 数 。 注 意 从 Perl 5.8.1 开 始 单 个 数 字 的 v-strings (类 似 ’v65’) 如 果 在 ’=>’ 操 作 符 (通 常 用 来 从 hash 值 中 区 分 开 hash 键 ) 之 前 , 不 是 一 个 v-strings, 而 是 解 释 为 字 符 串 (’v65’)。 在 Perl 5.6.0 到 Perl 5.8.0 它 一 直 是 v-strings, 但 是 这 样 带 来 了 更 多 混 淆 和 错 误 而 不 是 优 点 。 多 个 数 字 的 v-strings, 类 似 ’v65.66’ 和 65.66.67, 继 续 总 是 被 当 作 v-strings 特 殊 常 量 特 殊 变 量 __FILE__, __LINE__, 和 __PACKAGE__ 代 表 当 前 文 件 名 ,行 号 ,和 包 名 . 它 们 只 能 作 为 单 独 的 符 号 来 使 用 ; 不 能 用 于 字 符 串 中 内 插 . 如 果 没 有 当 前 包 (用 ’package;’ 指 令 来 实 现 ), 则 __PACKAGE__ 是 一 个 未 定 义 的 值 . 控 制 字 符 ^D 和 ^Z, 以 及 __END__ 和 __DATA__ 变 量 可 以 表 示 文 件 的 逻 辑 结 束 . 其 后 的 文 本 被 忽 略 .

__DATA__ 之 后 的 文 本 可 以 通 过 文 件 句 柄 ’PACKNAME::DATA’ 读 取 ,’PACKNAME’ 是 __DATA__ 所 在 的 包 的 名 称 . 句 柄 指 向 __DATA__ 后 面 的 文 本 . 读 取 结 束 程 序 会 自 动 关 闭 该 句 柄 ’close DATA’. 为 了 与 __DATA__ 还 没 有 出 现 以 前 已 经 存 在 的 程 序 兼 容 , __END__ 在 顶 级 脚 本 中 与 __DATA__ 性 质 相 同 (在 用 ’require’ 或 ’do’ 调 用 时 是 不 同 的 ) 不 过 可 以 通 过 ’main::DATA’ 来 调 用 其 中 的 内 容 . 参 见 SelfLoader 详 细 了 解 __DATA__, 其 中 还 有 例 子 . 要 注 意 在 BEGIN 块 中 无 法 读 取 DATA句 柄 : 因 为 BEGIN 块 在 编 译 时 即 被 执 行 , 而 此 时 __DATA__ (或 __END__) 还 未 被 程 序 看 到 . 裸 词 在 文 法 上 没 有 特 殊 意 义 的 词 语 都 被 看 作 字 符 串 . 称 之 为 "裸 词 ". 和 文 件 句 柄 以 及 标 签 一 样 , 仅 包 含 小 写 字 母 的 裸 词 有 可 能 在 将 来 与 程 序 中 的 保 留 词 发 生 冲 突 , 实 际 上 ,当 你 使 用 ’use warnings’ 语 句 ,或 是 -w 选 项 时 , Perl会 对 此 提 出 警 告 . 一 些 人 可 能 希 望 完 全 禁 止 这 样 的 词 . 如 果 有 如 下 语 句 :

use strict ’subs’; 那 么 不 能 被 解 释 为 子 程 序 的 裸 词 会 引 起 编 译 时 错 误 . 这 种 限 制 到 块 结 束 时 终 止 . 而 内 部 的 块 可 以 撤 消 这 一 限 制 , 用 ’no strict ’subs’’ 数 组 合 并 分 隔 符 数 组 和 序 列 被 合 并 为 双 引 号 引 用 的 字 符 串 时 , 以 变 量 $" 指 定 的 值 (如 果 指 定 了 “use English;” 那 么 是 $LIST_SEPARATOR 的 值 ) 作 为 分 隔 符 , 默 认 是 空 格 。 下 列 语 句 等 价 :

$temp = join($", @ARGV);
system "echo $temp";

system "echo @ARGV"; 在 搜 索 模 式 中 (在 双 引 号 字 符 串 中 也 是 )有 一 个 易 混 淆 之 处 :’/$foo[bar]/’ 应 该 是 ’/${foo}[bar]/’ (’[bar]’ 是 正 则 表 达 式 的 字 符 类 ) 还 是 ’/${foo[bar]}/’/ (’[bar]’ 是 数 组 @foo 的 下 标 ) 呢 ? 如 果 @foo 不 存 在 , 那 很 明 显 它 应 该 是 字 符 类 . 如 果 @foo 存 在 , Perl 会 尽 力 猜 测 ’[bar]’ 的 含 义 , 且 它 几 乎 总 是 对 的 . 如 果 它 猜 错 了 , 或 者 你 比 较 偏 执 , 你 可 以 使 用 花 括 号 .

here-document 的 语 法 已 经 被 移 动 到 perlop 中 的 “Quote and Quote-like Operators”

List value constructors 列 表 值 构 造 列 表 是 用 逗 号 分 开 的 各 个 值 组 成 的 (如 果 优 先 级 需 要 的 话 ,外 面 还 要 用 圆 括 号 包 围 ):

(LIST) 在 不 需 要 列 表 的 上 下 文 中 , 列 表 的 值 是 最 后 一 个 元 素 的 值 , 这 与 C中 的 逗 号 操 作 符 类 似 . 例 如 :

@foo = (’cc’, ’-E’, $bar); 将 列 表 赋 给 数 组 @foo, 但 是

$foo = (’cc’, ’-E’, $bar); 将 $bar 的 值 赋 给 $foo. 注 意 , 数 组 在 标 量 上 下 文 中 的 值 是 数 组 的 长 度 ; 下 例 将 3赋 给 $foo:

@foo = (’cc’, ’-E’, $bar);
$foo = @foo; # $foo gets 3 列 表 的 最 后 可 以 输 入 逗 号 , 所 以 这 样 也 是 正 确 的 :

@foo = (
1,
2,
3,
); 要 将 here-document 赋 给 数 组 , 一 行 作 为 一 个 元 素 , 可 以 这 样 作 :

@sauces = <<End_Lines =~ m/(\S.*\S)/g;
normal tomato
spicy tomato
green chile
pesto
white wine
End_Lines 列 表 会 自 动 插 入 子 列 表 . 也 即 , 下 例 将 展 开 数 组 ,哈 希 等 , 并 将 其 中 的 每 一 个 元 素 作 为 该 新 列 表 的 一 个 元 素 . 数 组 或 哈 希 失 去 其 原 来 的 身 份 .列 表

(@foo,@bar,&SomeSub,%glarch) 包 括 @foo,@bar的 每 一 个 元 素 ,包 括 函 数 SomeSub 返 回 值 列 表 的 每 一 个 元 素 , 包 括 %glarch 的 每 一 个 字 值 对 . 要 想 使 用 不 内 插 的 列 表 , 可 以 参 见 perlref 空 列 表 可 以 表 示 为 (). 在 列 表 中 插 入 空 列 表 没 有 意 义 . ((),(),()) 与 ()相 同 . 同 样 , 内 插 一 个 空 数 组 也 没 有 意 义 . 合 并 的 语 法 表 示 开 和 闭 括 号 都 是 可 选 的 (除 非 为 表 示 优 先 级 需 要 ); 而 列 表 可 以 以 可 选 的 逗 号 结 束 表 示 列 表 中 的 多 个 逗 号 是 合 法 的 语 法 。 列 表 ’1,,3’ 是 两 个 列 表 的 并 置 , ’1,’ 还 有 3, 第 一 个 以 可 选 的 逗 号 结 束 。 ’1,,3’ 是 ’(1,),(3)’ 也 是 ’1,3’ (类 似 的 , ’1,,,3’ 是 ’(1,),(,),3’ 也 是 ’1,3’ 等 等 ) 不 过 我 们 不 建 议 你 使 用 这 么 混 乱 的 写 法 列 表 也 可 以 象 数 组 一 样 使 用 下 标 . 为 了 避 免 歧 义 需 要 在 列 表 外 使 用 括 号 . 例 如 :

# Stat returns list value.
$time = (stat($file))[8];

# SYNTAX ERROR HERE.
$time = stat($file)[8]; # OOPS, FORGOT PARENTHESES

# Find a hex digit.
$hexdigit = (’a’,’b’,’c’,’d’,’e’,’f’)[$digit-10];

# A "reverse comma operator".
return (pop(@foo),pop(@foo))[0]; 可 以 给 列 表 赋 值 , 当 然 列 表 中 的 每 个 元 素 必 须 合 法 才 行 :

($a, $b, $c) = (1, 2, 3);

($map{’red’}, $map{’blue’}, $map{’green’}) = (0x00f, 0x0f0, 0xf00); 特 例 是 可 以 赋 值 为 ’undef’。 当 忽 略 程 序 的 某 些 返 回 值 时 这 很 有 用 :

($dev, $ino, undef, undef, $uid, $gid) = stat($file); 列 表 赋 值 处 于 标 量 上 下 文 中 时 , 返 回 值 是 等 号 右 侧 的 表 达 式 的 元 素 个 数 :

$x = (($foo,$bar) = (3,2,1)); # set $x to 3, not 2
$x = (($foo,$bar) = f()); # set $x to f()’s return count 这 在 布 尔 上 下 文 中 很 方 便 , 因 为 多 数 列 表 函 数 在 结 束 时 返 回 空 列 表 , 这 时 列 表 赋 值 会 返 回 0, 被 解 释 为 FALSE. 它 也 是 一 个 有 用 的 习 惯 的 来 源 , 就 是 在 列 表 上 下 文 中 执 行 一 个 函 数 或 操 作 , 然 后 记 录 返 回 值 的 个 数 , 方 法 是 为 一 个 空 列 表 赋 值 , 然 后 在 标 量 上 下 文 中 使 用 这 个 值 。 例 如 , 如 下 代 码 :

$count = () = $string =~ /\d+/g; 将 置 $count 为 $string 中 找 到 的 数 字 组 数 量 。 这 样 能 行 的 原 因 是 模 式 匹 配 是 列 表 上 下 文 (因 为 它 被 赋 予 一 个 空 列 表 ), 因 此 返 回 所 有 匹 配 部 分 的 列 表 。 在 标 量 上 下 文 中 的 列 表 赋 值 将 它 转 换 为 元 素 的 个 数 (这 里 是 模 式 被 匹 配 的 数 量 ), 然 后 赋 值 给 $count。 注 意 简 单 地 使 用

$count = $string =~ /\d+/g; 没 有 作 用 , 因 为 在 标 量 上 下 文 中 的 模 式 匹 配 只 会 返 回 true 或 false, 而 不 是 所 有 的 匹 配 。 最 后 一 个 元 素 可 以 是 数 组 或 哈 希 :

($a, $b, @rest) = split;
my($a, $b, %rest) = @_; 当 然 可 以 在 任 何 位 置 使 用 数 组 或 哈 希 , 不 过 第 一 个 数 组 或 哈 希 会 将 所 有 的 值 都 据 为 己 有 , 其 它 的 元 素 都 会 变 为 undefined.这 在 my() 或 local()中 或 许 有 用 . 哈 希 可 以 用 含 有 字 值 对 的 列 表 来 初 始 化 :

# same as map assignment above
%map = (’red’,0x00f,’blue’,0x0f0,’green’,0xf00); 列 表 和 数 组 交 互 性 很 强 , 哈 希 则 不 然 . 你 可 以 象 使 用 数 组 时 一 样 对 列 表 使 用 下 标 并 不 意 味 着 可 以 象 使 用 哈 希 一 样 使 用 列 表 . 同 样 ,处 于 列 表 中 的 哈 希 总 是 以 字 值 对 的 形 式 展 开 . 因 此 有 时 使 用 引 用 要 更 好 一 些 . 通 常 在 字 值 对 中 使 用 ’=>’ 操 作 符 会 更 易 读 .’=>’ 与 逗 号 作 用 相 同 , 不 过 它 还 有 一 个 作 用 , 那 就 是 可 以 使 它 左 侧 的 对 象 被 解 释 为 字 符 串 : 如 果 该 对 象 是 裸 字 的 话 ,将 是 合 法 的 标 识 符 (’=>’ 不 引 用 包 含 双 冒 号 的 复 合 标 识 符 ). 这 在 初 始 化 哈 希 时 棒 极 了 :

%map = (
red => 0x00f,
blue => 0x0f0,
green => 0xf00,
); 或 者 初 始 化 哈 希 的 引 用 :

$rec = {
witch => ’Mable the Merciless’,
cat => ’Fluffy the Ferocious’,
date => ’10/31/1776’, };

or for using call-by-named-parameter to complicated functions:

$field = $query->radio_group(
name => ’group_name’,
values => [’eenie’,’meenie’,’minie’],
default => ’meenie’,
linebreak => ’true’,
labels =>\%labels
); 注 意 哈 希 初 始 化 时 的 顺 序 和 输 出 时 的 顺 序 并 不 一 定 相 同 . 要 得 到 顺 序 的 输 出 可 以 参 见 perlfunc 中 的 “sort”

Subscripts 下 标 数 组 可 以 用 一 个 美 元 符 号 , 加 上 它 的 名 字 (不 包 括 前 导 的 ’@’), 加 上 方 括 号 和 其 中 包 含 的 下 标 来 取 得 值 。 例 如 :

@myarray = (5, 50, 500, 5000);
print "Element Number 2 is", $myarray[2], "\n"; 数 组 下 标 从 0 开 始 。 负 值 下 标 返 回 从 尾 部 开 始 数 的 值 。 在 我 们 的 例 子 中 , $myarray[-1] 将 是 5000,$myarray[-2] 是 500。

Hash 下 标 与 此 类 似 , 但 是 不 使 用 方 括 号 而 是 花 括 号 。 例 如 :

%scientists =
(
"Newton" => "Isaac",
"Einstein" => "Albert",
"Darwin" => "Charles",
"Feynman" => "Richard",
);

print "Darwin’s First Name is ", $scientists{"Darwin"}, "\n";

Slices 片 段 通 常 对 哈 希 或 数 组 一 次 访 问 一 个 元 素 . 也 可 以 使 用 下 标 对 列 表 元 素 进 行 访 问 .

$whoami = $ENV{"USER"}; # one element from the hash
$parent = $ISA[0]; # one element from the array
$dir = (getpwnam("daemon"))[7]; # likewise, but with list 片 段 可 以 一 次 访 问 列 表 ,数 组 或 哈 希 中 的 几 个 元 素 , 这 是 通 过 列 表 下 标 来 实 现 的 . 这 比 分 别 写 出 每 个 值 要 方 便 一 些 .

($him, $her) = @folks[0,-1]; # array slice
@them = @folks[0 .. 3]; # array slice
($who, $home) = @ENV{"USER", "HOME"}; # hash slice
($uid, $dir) = (getpwnam("daemon"))[2,7]; # list slice 既 然 可 以 给 列 表 赋 值 , 当 然 也 可 以 哈 希 或 数 组 的 片 段 赋 值 .

@days[3..5] = qw/Wed Thu Fri/;
@colors{’red’,’blue’,’green’}
= (0xff0000, 0x0000ff, 0x00ff00);
@folks[0, -1] = @folks[-1, 0]; 上 面 的 操 作 与 下 列 语 句 等 价 :

($days[3], $days[4], $days[5]) = qw/Wed Thu Fri/;
($colors{’red’}, $colors{’blue’}, $colors{’green’})
= (0xff0000, 0x0000ff, 0x00ff00);
($folks[0], $folks[-1]) = ($folks[-1], $folks[0]); 既 然 改 变 片 段 就 会 改 变 数 组 或 哈 希 的 原 始 值 , 那 么 ’foreach’ 结 构 可 以 部 分 或 全 部 地 改 变 数 组 或 哈 希 的 值 .

foreach (@array[ 4 .. 10 ]) { s/peter/paul/ }

foreach (@hash{qw[key1 key2]}) {
s/^\s+//; # trim leading whitespace
s/\s+$//; # trim trailing whitespace
s/(\w+)/\u\L$1/g; # "titlecase" words } 空 列 表 的 片 段 还 是 空 列 表 , 因 此 :

@a = ()[1,0]; # @a has no elements
@b = (@a)[0,1]; # @b has no elements
@c = (0,1)[2,3]; # @c has no elements 但 是 :

@a = (1)[1,0]; # @a has two elements
@b = (1,undef)[1,0,2]; # @b has three elements 下 例 利 用 了 这 一 特 性 ,当 返 回 空 列 表 时 循 环 终 止 :

while ( ($home, $user) = (getpwent)[7,0]) {
printf "%-8s %s\n", $user, $home; } 我 们 在 前 面 说 过 , 标 量 上 下 文 中 的 列 表 赋 值 返 回 值 是 右 侧 的 元 素 个 数 . 空 列 表 没 有 元 素 , 所 以 当 口 令 文 件 读 完 后 , 返 回 值 是 0而 不 是 2. 为 什 么 对 哈 希 的 片 段 使 用 ’@’而 不 是 ’%’呢 . 因 为 括 号 的 类 型 (方 括 号 或 花 括 号 )决 定 了 它 是 数 组 还 是 哈 希 . 而 数 组 或 哈 希 的 开 始 字 符 (’$’或 ’@’)表 示 返 回 值 是 单 个 值 还 是 多 个 值 (列 表 ).

Typeglobs and Filehandles 全 局 类 型 和 文 件 句 柄
Perl 使 用 叫 做 全 局 类 型 的 类 型 来 支 持 整 个 符 号 表 项 . 全 局 类 型 的 前 缀 是 *, 因 为 它 表 示 所 有 的 类 型 . 这 在 过 去 通 常 用 来 给 函 数 传 递 数 组 或 哈 希 的 引 用 , 但 是 现 在 有 了 真 正 的 引 用 , 这 就 几 乎 不 需 要 了 . 现 在 ,全 局 类 型 的 主 要 用 途 是 创 建 符 号 表 别 名 . 如 下 赋 值 :

*this = *that; 使 得 $this 成 为 $that的 别 名 , @this 成 为 @that的 别 名 ,%this 成 为 %that的 别 名 , &this 成 为 &that的 别 名 , 等 等 . 使 用 引 用 会 更 安 全 . 这 样 :

local *Here::blue =\$There::green; 暂 时 使 $Here::blue 成 为 $There::green的 别 名 , 但 不 会 使 @Here::blue 成 为 @There::green的 别 名 , 也 不 会 使 %Here::blue 成 为 %There::green的 别 名 , 等 等 . 参 见 perlmod 中 的 Symbol Tables 有 多 个 例 子 . 看 起 来 可 能 有 些 怪 异 , 不 过 这 却 是 整 个 import/export系 统 的 基 础 . 全 局 类 型 的 其 它 用 途 还 有 , 给 函 数 传 输 文 件 句 柄 或 是 创 建 新 的 文 件 句 柄 . 如 果 你 要 使 用 全 局 类 型 代 替 文 件 句 柄 , 可 以 这 样 做 :

$fh = *STDOUT; 或 者 使 用 真 正 的 引 用 , 象 这 样 :

$fh =\*STDOUT; 参 见 perlsub 有 关 于 间 接 句 柄 的 多 个 例 子 . 全 局 类 型 也 是 使 用 local() 创 建 局 部 文 件 句 柄 的 一 种 方 法 . 作 用 范 围 在 当 前 块 之 内 , 但 是 可 以 被 传 回 .例 如 :

sub newopen {
my $path = shift;
local *FH; # not my!
open (FH, $path) or return undef;
return *FH; }
$fh = newopen(’/etc/passwd’); 既 然 我 们 有 *foo{THING} 这 样 的 记 法 , 全 局 类 型 不 再 多 用 于 文 件 句 柄 ,但 在 从 函 数 传 出 或 向 函 数 传 入 新 的 文 件 句 柄 时 它 还 是 必 需 的 .因 为 *HANDLE{IO} 只 有 在 HANDLE 已 经 是 文 件 句 柄 时 才 起 作 用 . 换 言 之 , 在 建 立 新 符 号 表 项 时 必 须 使 用 *FH; *foo{THING} 是 不 行 的 . 不 知 道 该 用 谁 时 , 使 用 *FH 所 有 能 创 建 文 件 句 柄 的 函 数 (open(), opendir(), pipe(), socketpair(), sysopen(), socket(), 和 accept()) ,在 传 递 给 它 们 的 句 柄 是 标 量 时 ,会 自 动 创 建 一 个 匿 名 句 柄 . 这 使 得 象 open(my $fh, ...) 和 open(local $fh,...) 这 样 的 结 构 可 以 创 建 一 个 在 超 出 范 围 时 可 以 自 动 关 闭 的 句 柄 ,如 果 没 有 另 外 的 对 它 们 的 引 用 的 话 . 这 大 大 减 少 了 全 局 类 型 的 使 用 ,当 需 要 打 开 一 个 可 以 到 处 使 用 的 句 柄 时 , 可 以 这 样 做 :

sub myopen {
open my $fh, "@_"
or die "Can’t open ’@_’: $!";
return $fh; }

{
my $f = myopen("</etc/motd");
print <$f>;
# $f implicitly closed here } 注 意 如 果 使 用 了 初 始 化 的 标 量 , 那 么 结 果 会 有 不 同 : ’my $fh=’zzz’; open($fh, ...)’ 与 ’open( *{’zzz’}, ...)’ 等 价 。 ’use strict ’refs’’ 禁 止 了 这 样 做 。 另 一 个 创 建 匿 名 句 柄 的 方 法 是 用 Symbol 模 块 或 IO::Handle 模 块 或 诸 如 此 类 的 东 西 . These modules have the advantage of not hiding different types of the same name during the local(). 在 open() in the perlfunc manpage 的 文 末 有 个 例 子 .(译 者 注 :说 实 话 ,对 匿 名 句 柄 我 现 在 也 是 一 头 雾 水 ,翻 译 的 不 当 之 处 ,请 高 手 指 出 .)

SEE ALSO 参 见

参 见 the perlvar manpage 了 解 Perl的 内 建 变 量 和 合 法 变 量 。 参 见 the perlref manpage, the perlsub manpage, 和 Symbol Tables in the perlmod manpage 了 解 全 局 类 型 和 *foo{THING} 语 法 。

中 文 版 维 护 人

redcandle <redcandle51 [AT] nospam.com>

中 文 版 最 新 更 新

2001年 12月 4日 星 期 二

中 文 手 册 页 翻 译 计 划

http://cmpp.linuxforum.net

本 页 面 中 文 版 由 中 文 man 手 册 页 计 划 提 供 。 中 文 man 手 册 页 计 划 : https://github.com/man-pages-zh/manpages-zh