Manpages

______________________________________________________________________________

NAME

string - 操 纵 字 符 串

总 览 SYNOPSIS

string option arg ?arg ...? _________________________________________________________________

描 述 DESCRIPTION

依 赖 于 option (选 项 )进 行 某 种 字 符 串 操 作 。 合 法 的 option (可 以 是 缩 写 )有 : │

string bytelength string │ 返 回 一 个 十 进 制 字 符 串 ， 给 出 在 内 存 中 表 示 string 用 的 字 节 数 。 因 为 │ UTF-8 使 用 一 到 三 字 节 来 表 示 Unicode 字 符 ， 字 节 长 度 可 能 与 通 常 的 字 │ 符 长 度 不 同 。 一 个 脚 本 关 心 字 节 长 度 的 情 况 较 少 见 。 多 数 情 况 下 ， 你 应 该 │ 使 用 string length 操 作 。 关 于 UTF-8 表 示 的 详 情 请 参 考 │ Tcl_NumUtfChars 手 册 页 。 │
string compare ?-nocase? ?-length int? string1 string2 │ 对 字 符 串 string1 和 string2 进 行 逐 个 字 符 的 比 较 。 依 赖 于 string1 在 词 典 顺 序 上 (lexicographically)小 于 、 等 于 、 大 于 string2， 返 回 -1、 0、 或 1。 如 果 指 定 了 -length ， 则 在 比 较 中 │ 只 使 用 前 length 个 字 符 。 如 果 -length 是 负 数 ， 则 被 忽 略 。 如 果 │ 指 定 了 -nocase ， 则 使 用 大 小 写 不 敏 感 方 式 比 较 字 符 串 。 │
string equal ?-nocase? ?-length int? string1 string2 │ 对 字 符 串 string1 和 string2 进 行 逐 个 字 符 的 比 较 。 如 果 string1 │ 和 string2 等 同 则 返 回 1， 否 则 返 回 0。 如 果 指 定 了 -length ， 则 │ 在 比 较 中 只 使 用 前 length 个 字 符 。 如 果 -length 是 负 数 ， 则 被 忽 │ 略 。 如 果 指 定 了 -nocase ， 则 使 用 大 小 写 不 敏 感 方 式 比 较 字 符 串 。 │
string first string1 string2 ?startIndex? │ 在 string2 中 查 找 精 确 的 匹 配 string1 中 的 字 符 的 一 个 字 符 序 列 。 如 果 找 到 ， 返 回 string2 中 的 第 一 个 这 样 的 匹 配 的 第 一 个 字 符 的 索 引 。 如 果 未 找 到 ， 返 回 -1。 如 果 指 定 了 startIndex (以 可 被 │ index 方 法 接 受 的 任 何 形 式 )， 则 约 束 查 找 为 在 string2 中 从 用 │ 索 引 指 定 的 字 符 开 始 。 例 如 ， │

string first a 0a23456789abcdef 5 │ 将 返 回10, but │
string first a 0123456789abcdef 11 │ 将 返 回-1. │

string index string charIndex 返 回 string 参 数 的 第 charIndex 个 字 符 。 charIndex 中 0 对 应 着 字 符 串 的 第 一 个 字 符 。 │

charIndex 可 以 被 指 定 如 下 : │
integer │ 用 整 数 索 引 指 定 字 符 。 │
end │ 字 符 串 的 最 后 一 个 字 符 。 │
end-integer │ 字 符 串 最 后 一 个 字 符 减 去 指 定 整 数 偏 移 量 (例 如 ， end-1 将 参 │ 照 “abcd”中 的 “c”)。 │ 如 果 charIndex 小 于 0 或 大 于 等 于 字 符 串 的 长 度 则 返 回 一 个 空 串 。 │

string is class ?-strict? ?-failindex varname? string │ 如 果 string 是 指 定 字 符 类 的 一 个 有 效 成 员 则 返 回 1， 否 则 返 回 │ 0。 如 果 指 定 了 -strict， 则 对 一 个 空 串 返 回 0， 否 则 在 任 何 类 上 对 一 个 │ 空 串 返 回 1。 如 果 指 定 了 -failindex， 则 若 函 数 返 回 0， 把 字 符 串 │ 中 类 不 再 有 效 的 地 方 的 索 引 存 储 到 叫 做 varname 的 变 量 中 。 如 果 函 │ 数 返 回 1则 不 设 置 varname 。 识 别 下 列 字 符 类 (类 的 名 字 可 以 被 缩 │ 写 ): │

alnum │ 任 何 Unicode 字 母 或 数 字 字 符 。 │
alpha │ 任 何 Unicode 字 母 字 符 。 │
ascii │ 值 小 于 \u0080 的 任 何 字 符 (这 是 7-bit ascii 的 范 围 )。 │
boolean │

Tcl_GetBoolean 所 允 许 的 任 何 形 式 。 │

control │ 任 何 Unicode 控 制 字 符 。 │
digit │ 任 何 Unicode 数 字 字 符 。 注 意 这 包 括 在 [0-9] 范 围 外 的 字 │ 符 。 │
double │ 双 精 度 数 在 Tcl 中 的 任 何 有 效 形 式 ， 可 以 有 可 选 的 围 绕 白 空 │ 格 。 在 值 下 溢 /上 溢 的 情 况 下 ， 返 回 0 并 且 varname 将 包 含 │ -1。 │
false │

Tcl_GetBoolean 允 许 的 任 何 形 式 ， 这 里 的 值 是 假 。 │

graph │ 除 了 空 格 之 外 的 任 何 Unicode 打 印 字 符 。 │
integer │ 整 数 在 Tcl 中 的 任 何 有 效 形 式 ， 可 以 有 可 选 的 围 绕 白 空 │ 格 。 在 值 下 溢 /上 溢 的 情 况 下 ， 返 回 0 并 且 varname 将 包 含 │ -1。 │
lower │ 任 何 Unicode 小 写 字 母 字 符 。 . │
print │ 包 括 空 格 在 内 的 任 何 Unicode 打 印 字 符 。 │
punct │ 任 何 Unicode 标 点 字 符 。 │
space │ 任 何 Unicode 空 格 字 符 。 │
true │

Tcl_GetBoolean 所 允 许 的 任 何 形 式 ， 这 里 的 值 是 真 。 │

upper │ 在 Unicode 中 的 任 何 大 写 字 符 。 │
wordchar │ 任 何 Unicode 单 字 字 符 。 它 是 任 何 字 母 字 符 和 Unicode 连 │ 接 符 标 点 字 符 (例 如 ， 下 划 线 )。 │
xdigit │ 任 何 十 六 进 制 数 字 字 符 ([0-9A-Fa-f]). │ 在 boolean、 true 和 false 的 情 况 下 ， 如 果 函 数 将 返 回 0， 则 varname │ 总 是 被 设 置 为 0， 原 因 是 一 个 有 效 boolean 值 有 多 种 本 地 (表 示 )。 │

string last string1 string2 ?startIndex? │ 在 string2 中 查 找 精 确 的 匹 配 在 string1 中 的 字 符 的 一 个 字 符 序 列 。 如 果 找 到 ， 返 回 在 string2 中 最 后 一 个 这 样 的 匹 配 的 第 一 个 字 符 的 索 引 。 如 果 没 有 匹 配 ， 则 返 回 -1。 如 果 指 定 了 startIndex(以 可 被 │ index 方 法 接 受 的 任 何 形 式 )， 则 查 找 只 针 对 string2 中 用 │ startIndex 指 定 的 和 此 前 的 字 符 。 例 如 ， │

string last a 0a23456789abcdef 15 │ 将 返 回10, 而 │
string last a 0a23456789abcdef 9 │ 将 返 回1. │

string length string 返 回 一 个 十 进 制 字 符 串 ， 给 出 在 string 中 字 符 的 数 目 。 注 意 这 不 是 必 须 与 用 于 存 储 这 个 字 符 串 的 字 节 的 数 目 相 同 。 │
string map ?-nocase? charMap string │ 基 于 在 charMap 中 的 键 -值 对 替 代 string 中 的 字 符 。 charMap 是 形 │ 如 key value key value ... 的 一 个 列 表 ， 同 于 从 array get 返 回 的 │ 那 种 形 式 。 在 字 符 串 中 这 些 键 的 每 个 实 例 将 被 替 代 为 相 应 的 值 。 如 果 指 定 │ 了 -nocase， 则 进 行 匹 配 时 不 区 别 大 小 写 。 key 和 value 二 者 都 可 以 是 │ 多 字 节 的 。 以 一 种 有 次 序 的 方 式 进 行 替 代 ， 所 以 在 列 表 中 出 现 在 最 前 面 的 │ 键 将 被 首 先 检 查 ， 以 此 类 推 。 string 只 被 重 复 操 作 (iterate)一 次 ， 所 以 │ 早 先 的 键 替 代 将 不 影 响 以 后 的 键 匹 配 。 例 如 ， │

string map {abc 1 ab 2 a 3 1 0} 1abcaababcabababc │ 将 返 回 字 符 串 01321221. │

string match ?-nocase? pattern string │ 查 看 pattern 是 否 匹 配 string； 如 果 是 则 返 回 1， 不 是 则 返 回 0。 如 │ 果 指 定 了 -nocase， 则 针 对 字 符 串 的 模 式 匹 配 采 用 大 小 写 不 敏 感 的 方 式 。 对 于 要 进 行 匹 配 的 这 两 个 字 符 串 ， 除 了 在 pattern 中 可 以 出 现 的 下 列 特 殊 序 列 之 外 它 们 的 内 容 必 须 相 同 :