14 JavaScript 语 言 与 Ajax 应 用 变 量 赋 值 和 变 量 声 明 可 以 同 时 进 行 例 如, 下 面 的 代 码 声 明 名 为 age 的 变 量, 同 时 给 该 变 量 赋 初 值 25: var age = 25; 当 然, 可 在 一 句 JavaScri

第 2 章 JavaScript 语 法 JavaScript 脚 本 语 言 作 为 一 门 功 能 强 大 使 用 范 围 较 广 的 程 序 语 言, 其 语 言 基 础 包 括 数 据 类 型 变 量 运 算 符 函 数 及 核 心 语 句 等 内 容 本 章 主 要 介 绍 JavaScript 脚 本 语 言 的 基 础 知 识, 带 领 读 者 初 步 领 会 JavaScript 脚 本 语 言 的 精 妙 之 处, 并 为 后 续 章 节 的 深 入 学 习 打 下 坚 实 的 基 础 JavaScript 的 基 本 数 据 类 型 JavaScript 的 表 达 式 和 常 用 运 算 符 JavaScript 的 语 句 构 成 函 数 的 使 用 及 其 属 性 和 方 法 2.1 JavaScript 语 法 基 础 2.1.1 变 量 变 量 (Variable) 是 相 对 于 常 量 而 言 的, 常 量 通 常 是 一 个 不 会 改 变 的 固 定 值, 而 变 量 是 对 应 到 某 个 值 的 一 个 符 号, 这 个 符 号 中 的 值 可 能 会 随 着 程 序 的 执 行 而 改 变, 因 此 称 为 变 量 JavaScript 脚 本 语 言 和 其 他 程 序 设 计 语 言 一 样 也 引 入 了 变 量, 其 主 要 作 用 是 存 取 数 据 及 提 供 存 放 信 息 的 容 器 在 实 际 脚 本 开 发 过 程 中, 变 量 为 开 发 者 与 脚 本 程 序 交 互 的 主 要 工 具 JavaScript 中 的 变 量 命 名 同 其 他 语 言 非 常 相 似, 这 里 要 注 意 以 下 几 点 : (1) 第 一 个 字 符 必 须 是 字 母 ( 大 小 写 均 可 ) 下 划 线 (_) 或 者 美 元 符 号 ($) (2) 后 续 的 字 符 可 以 是 字 母 数 字 下 划 线 或 者 美 元 符 号 (3) 变 量 名 称 不 能 是 关 键 字 或 保 留 字 (4) 不 允 许 出 现 中 文 变 量 名, 且 大 小 写 敏 感 在 JavaScript 脚 本 语 言 中, 声 明 变 量 的 过 程 相 当 简 单, JavaScript 脚 本 语 言 使 用 关 键 字 var 作 为 其 唯 一 的 变 量 标 识 符, 其 用 法 为 在 关 键 字 var 后 面 加 上 变 量 名 例 如, 通 过 下 面 的 代 码 声 明 名 为 age 的 变 量 : var age; JavaScript 脚 本 语 言 允 许 开 发 者 不 用 声 明 变 量 就 能 直 接 使 用, 而 在 变 量 赋 值 时 自 动 声 明 该 变 量 一 般 来 说, 为 培 养 良 好 的 编 程 习 惯, 同 时 为 了 使 程 序 结 构 更 加 清 晰 易 懂, 建 议 在 使 用 变 量 前 对 变 量 进 行 声 明

14 JavaScript 语 言 与 Ajax 应 用 变 量 赋 值 和 变 量 声 明 可 以 同 时 进 行 例 如, 下 面 的 代 码 声 明 名 为 age 的 变 量, 同 时 给 该 变 量 赋 初 值 25: var age = 25; 当 然, 可 在 一 句 JavaScript 脚 本 代 码 中 同 时 声 明 两 个 以 上 的 变 量, 例 如 : var age, name; 同 时 初 始 化 两 个 以 上 的 变 量 也 是 允 许 的, 例 如 : var age = 35, name = "tom"; JavaScript 中 的 变 量 可 以 根 据 其 有 效 范 围 分 为 全 局 变 量 和 局 部 变 量 两 种 其 中, 全 局 (Globe) 变 量 从 定 义 开 始, 到 整 个 JavaScript 代 码 结 束 为 止, 都 可 以 使 用 ; 而 局 部 (Local) 变 量 只 有 在 函 数 内 部 才 有 效 如 果 不 写 var, 而 是 直 接 对 变 量 进 行 赋 值, 那 么 JavaScript 将 自 动 把 这 个 变 量 声 明 为 全 局 变 量 2.1.2 关 键 字 与 保 留 字 ECMA 262 定 义 了 JavaScript 支 持 的 一 套 关 键 字 (Keyword) 根 据 规 定, 关 键 字 不 能 用 作 变 量 名 或 函 数 名 表 2 1 是 关 键 字 的 完 整 列 表 表 2 1 JavaScript 关 键 字 break case catch continue default delete do else finally for function if in instanceof new return switch this throw try typeof var void while with JavaScript 还 定 义 了 一 套 保 留 字 (Reserved Word) 保 留 字 在 某 种 意 义 上 是 为 将 来 的 关 键 字 而 保 留 的 单 词 因 此, 保 留 字 也 不 能 被 用 作 变 量 名 或 函 数 名 保 留 字 的 完 整 列 表 如 表 2 2 所 示 表 2 2 JavaScript 保 留 字 abstract boolean byte char class const debugger double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile 2.1.3 原 始 值 与 引 用 值 在 JavaScript 中, 变 量 可 以 存 放 两 种 类 型 的 值, 即 原 始 值 和 引 用 值 原 始 值 指 的 就 是 代 表 原 始 数 据 类 型 ( 基 本 数 据 类 型 ) 的 值, 即 Undefined Null Number String Boolean 类 型 所 表 示 的 值 引 用 值 指 的 就 是 复 合 数 据 类 型 的 值, 即 Object Function Array 及 自 定 义 对 象 等

第 2 章 JavaScript 语 法 15 原 始 值 是 存 储 在 栈 中 的 简 单 数 据 段, 也 就 是 说, 它 们 的 值 直 接 存 储 在 变 量 访 问 的 位 置 堆 是 存 放 数 据 的 基 于 散 列 算 法 的 数 据 结 构, 在 JavaScript 中, 引 用 值 是 存 放 在 堆 中 的 引 用 值 是 存 储 在 堆 中 的 对 象, 也 就 是 说, 存 储 在 变 量 处 的 值 ( 即 指 向 对 象 的 变 量, 存 储 在 栈 中 ) 是 一 个 指 针, 指 向 存 储 对 象 的 内 存 处 为 变 量 赋 值 时,JavaScript 的 解 释 程 序 必 须 判 断 该 值 是 原 始 类 型 的 还 是 引 用 类 型 的 要 实 现 这 一 点, 解 释 程 序 需 要 尝 试 判 断 该 值 是 否 为 JavaScript 的 原 始 类 型 之 一, 即 Undefined Null Boolean String 类 型 由 于 这 些 原 始 类 型 占 据 的 空 间 是 固 定 的, 所 以 可 以 将 它 们 存 储 在 较 小 的 内 存 区 域 栈 中 这 样 便 于 迅 速 查 询 变 量 的 值 如 果 一 个 值 是 引 用 类 型 的, 那 么 它 的 存 储 空 间 将 从 堆 中 分 配 由 于 引 用 值 的 大 小 会 改 变, 所 以 不 能 把 它 放 在 栈 中, 否 则 会 降 低 变 量 查 询 的 速 度 相 反, 放 在 变 量 的 栈 空 间 中 的 值 是 该 对 象 存 储 在 堆 中 的 地 址 地 址 的 大 小 是 固 定 的, 所 以 把 它 存 储 在 栈 中 对 变 量 性 能 无 任 何 负 面 影 响 2.2 JavaScript 数 据 类 型 2.2.1 基 础 数 据 类 型 变 量 包 含 多 种 类 型,JavaScript 脚 本 语 言 支 持 的 基 本 数 据 类 型 包 括 Number 型 String 型 Boolean 型 Undefined 型 和 Null 型, 分 别 对 应 于 不 同 的 存 储 空 间, 如 表 2 3 所 示 表 2 3 基 本 数 据 类 型 类 型 举 例 简 要 说 明 Number 45, 34, 32.13, 3.7E 2 数 值 型 数 据 String "name", 'Tom' 字 符 型 数 据, 需 加 双 引 号 或 单 引 号 Boolean true, flase 布 尔 型 数 据, 不 加 引 号, 表 示 逻 辑 真 或 假 Undefined 表 示 未 定 义 Null null 表 示 空 值 1.Number 型 Number 型 数 据 即 为 数 值 型 数 据, 包 括 整 数 型 和 浮 点 型, 整 数 型 数 制 可 以 使 用 十 进 制 八 进 制 及 十 六 进 制 标 识, 而 浮 点 型 为 包 含 小 数 点 的 实 数, 且 可 用 科 学 记 数 法 来 表 示 一 般 来 说, Number 型 数 据 为 不 在 括 号 内 的 数 字, 例 如 : var mydataa=8; var mydatab=6.3; 上 述 代 码 分 别 定 义 值 为 整 数 8 的 Number 型 变 量 mydataa 和 值 为 浮 点 数 6.3 的 Number 型 变 量 mydatab 除 了 常 用 的 数 字 之 外,JavaScript 还 支 持 以 下 两 个 特 殊 的 数 值 : (1)Infinity 当 在 JavaScript 中 使 用 的 数 字 大 于 JavaScript 所 能 表 示 的 最 大 值 时, JavaScript 就 会 将 其 输 出 为 Infinity, 即 无 穷 大 的 意 思 当 然, 如 果 JavaScript 中 使 用 的 数 字 小 于 JavaScript 所 能 表 示 的 最 小 值,JavaScript 也 会 输 出 Infinity (2)NaN JavaScript 中 的 NaN 是 not a number ( 不 是 数 字 ) 的 意 思 通 常 是 在 进 行 数

16 JavaScript 语 言 与 Ajax 应 用 字 运 算 时 产 生 了 未 知 的 结 果 或 错 误,JavaScript 就 会 返 回 NaN, 这 代 表 着 数 字 运 算 的 结 果 是 一 个 非 数 字 的 特 殊 情 况 如 用 0 来 除 以 0,JavaScript 就 会 返 回 NaN NaN 是 一 个 很 特 殊 的 数 字, 不 会 与 任 何 数 字 相 等, 包 括 NaN 在 JavaScript 中 只 能 使 用 isnan() 函 数 来 判 断 运 算 结 果 是 不 是 NaN 2.String 型 String 型 数 据 表 示 字 符 型 数 据 JavaScript 不 区 分 单 个 字 符 和 字 符 串, 任 何 字 符 或 字 符 串 都 可 以 用 双 引 号 或 单 引 号 括 起 来 例 如, 下 列 语 句 中 定 义 的 String 型 变 量 namea 和 nameb 包 含 相 同 的 内 容 : var namea = "Tom"; var nameb = 'Tom'; 如 果 字 符 串 本 身 含 有 双 引 号, 则 应 使 用 单 引 号 将 字 符 串 括 起 来 ; 若 字 符 串 本 身 含 有 单 引 号, 则 应 使 用 双 引 号 将 字 符 串 括 起 来 一 般 来 说, 在 编 写 脚 本 过 程 中, 双 引 号 或 单 引 号 的 选 择 在 整 个 JavaScript 脚 本 代 码 中 应 尽 量 保 持 一 致, 以 养 成 好 的 编 程 习 惯 3.Boolean 型 Boolean 型 数 据 表 示 的 是 布 尔 型 数 据, 取 值 为 true 或 false, 分 别 表 示 逻 辑 真 和 逻 辑 假, 且 任 何 时 刻 都 只 能 使 用 两 种 状 态 中 的 一 种, 不 能 同 时 出 现 例 如, 下 列 语 句 分 别 定 义 Boolean 变 量 bchoosea 和 bchooseb, 并 分 别 赋 予 初 值 true 和 false: var bchoosea = true; var bchooseb = false; 值 得 注 意 的 是, 给 Boolean 型 变 量 赋 值 时, 不 能 在 true 或 false 外 面 加 引 号, 例 如 : var happya = true; var happyb = "true"; 上 述 语 句 分 别 定 义 初 始 值 为 true 的 Boolean 型 变 量 happya 和 初 始 值 为 字 符 串 "true" 的 String 型 变 量 happyb 4.Undefined 型 Undefined 型 即 为 未 定 义 类 型, 用 于 声 明 了 变 量 但 未 对 其 初 始 化 时 赋 予 该 变 量 的 值 例 如, 下 列 语 句 定 义 变 量 name 为 Undefined 型 : var name; Undefined 类 型 只 有 一 个 值, 即 undefined 当 声 明 的 变 量 未 初 始 化 时, 该 变 量 的 默 认 值 是 undefined 定 义 Undefined 型 变 量 后, 可 在 后 续 的 脚 本 代 码 中 对 其 进 行 赋 值 操 作, 从 而 自 动 获 得 由 其 值 决 定 的 数 据 类 型 5.Null 型 Null 型 数 据 表 示 空 值, 它 只 有 一 个 专 值 null,null 用 来 表 示 尚 未 存 在 的 对 象 如 果 函 数 或 方 法 要 返 回 的 是 对 象, 找 不 到 该 对 象 时, 返 回 的 通 常 是 null 2.2.2 数 据 类 型 转 换 JavaScript 是 一 种 无 类 型 的 语 言, 这 种 无 类 型 并 不 是 指 JavaScript 没 有 数 据 类 型, 而 是 指 JavaScript 是 一 种 松 散 类 型 动 态 类 型 的 语 言 因 此, 在 JavaScript 中 定 义 一 个 变 量 时, 不 需 要 制 定 变 量 的 数 据 类 型, 这 就 使 得 JavaScript 可 以 很 方 便 灵 活 地 进 行 隐 式 类 型 转 换 所 谓 隐 式 类 型 转 换, 就 是 不 需 要 程 序 员 定 义,JavaScript 会 自 动 将 某 一 个 类 型 的 数 据 转 换 成 另 一 个 类 型 的 数 据 JavaScript 隐 式 类 型 转 换 的 规 则 是 : 将 类 型 转 换 到 环 境 中 应 该 使 用 的 类 型

第 2 章 JavaScript 语 法 17 JavaScript 中 除 了 可 以 隐 式 转 换 数 据 类 型 之 外, 还 可 以 显 式 转 换 数 据 类 型 显 式 转 换 数 据 类 型 可 以 增 强 代 码 的 可 读 性 常 用 的 类 型 转 换 方 法 有 以 下 几 种 : 1. 转 换 成 字 符 串 JavaScript 中 三 种 主 要 的 原 始 值 布 尔 值 数 字 字 符 串 及 其 他 对 象 都 有 tostring() 方 法, 可 以 把 它 们 的 值 转 换 成 字 符 串 代 码 如 下 : var mynum = 100; console.log(mynum.tostring()); // 输 出 100 var bfound = false; console.log(bfound.tostring()); 各 种 类 型 向 字 符 串 型 转 换 的 结 果 如 下 : // 输 出 false (1)undefined 值 : 转 换 成 undefined (2)null 值 : 转 换 成 null (3) 布 尔 值 : 值 为 true, 则 转 换 成 true ; 值 为 false, 则 转 换 成 false (4) 数 字 型 值 :NaN 或 数 字 型 变 量 的 完 整 字 符 串 (5) 其 他 对 象 : 如 果 该 对 象 的 tostring() 方 法 存 在, 则 返 回 tostring 方 法 的 返 回 值, 否 则 返 回 undefined 2. 转 换 成 数 字 ECMAScript 提 供 了 两 种 把 非 数 字 的 原 始 值 转 换 成 数 字 的 方 法, 即 parseint() 和 parsefloat() 只 有 对 String 类 型 调 用 这 些 方 法, 它 们 才 能 正 确 运 行, 对 其 他 类 型 返 回 的 都 是 NaN (1) 提 取 整 数 的 parseint() 方 法 parseint() 方 法 用 于 将 字 符 串 转 换 为 整 数, 其 格 式 为 : parseint(numstring,[radix]) 需 要 说 明 的 是 : 1) 第 一 个 参 数 为 必 选 项, 用 来 指 定 要 转 化 为 整 数 的 字 符 串 当 使 用 仅 包 括 第 一 个 参 数 的 parseint() 方 法 时, 表 示 将 字 符 串 转 换 为 整 数 其 转 换 过 程 为 : 从 字 符 串 第 一 个 字 符 开 始 读 取 数 字 ( 跳 过 前 导 空 格 ), 直 至 遇 到 非 数 字 字 符 时 停 止 读 取, 将 已 经 读 取 的 数 字 字 符 串 转 换 为 整 数, 并 返 回 该 整 数 值 如 果 字 符 串 的 开 始 位 置 不 是 数 字, 而 是 其 他 字 符 ( 空 格 除 外 ), 那 么 parseint() 方 法 返 回 NaN, 表 示 所 传 递 的 参 数 不 能 转 换 为 一 个 整 数 例 如 : parseint(''437abc45''); // 返 回 值 为 437 2) 第 二 个 参 数 是 可 选 项 使 用 该 参 数 的 parseint() 方 法 能 够 完 成 八 进 制 十 六 进 制 等 数 据 的 转 换 其 中 [radix] 表 示 要 将 numstring 作 为 几 进 制 数 进 行 转 化,[radix] 的 值 在 2~36 之 间 当 省 略 第 二 个 参 数 时, 默 认 将 第 一 个 参 数 按 十 进 制 转 换 但 如 果 字 符 以 0x 或 0X 开 头, 那 么 按 十 六 进 制 转 换 不 管 指 定 按 哪 一 种 进 制 转 换, 方 法 parseint() 总 是 以 十 进 制 值 返 回 结 果 例 如 : parseint(''100abc'',8); 表 示 将 100abc 按 八 进 制 数 进 行 转 换, 由 于 abc 不 是 数 字, 所 以 实 际 是 将 八 进 制 数 100 转 换 为 十 进 制 数, 转 换 的 结 果 为 十 进 制 数 64 (2) 提 取 浮 点 数 的 parsefloat() 方 法 parsefloat() 方 法 用 于 将 字 符 串 转 换 为 浮 点 数, 其 格 式 为 : parsefloat(numstring) parsefloat() 方 法 与 parseint() 方 法 很 相 似 不 同 之 处 在 于 parsefloat() 方 法 能 够 转 换 浮 点 数 参 数 numstring 即 为 要 转 换 的 字 符 串, 如 果 字 符 串 不 是 以 数 字 开 始, 则 parsefloat() 方 法 返 回

18 JavaScript 语 言 与 Ajax 应 用 NaN, 表 示 所 传 递 的 参 数 不 能 转 换 为 一 个 浮 点 数 例 如 : parsefloat(19.3abc); // 转 化 的 结 果 为 19.3 3. 基 本 数 据 类 型 转 换 在 JavaScript 中 可 以 使 用 下 面 3 个 函 数 将 数 据 转 换 成 数 字 型 布 尔 型 和 字 符 串 型, 下 面 看 一 下 它 的 几 个 强 制 转 换 的 函 数 : (1)Boolean(value): 把 值 转 换 成 Boolean 类 型 (2)Number(value): 把 值 转 换 成 数 字 ( 整 型 数 或 浮 点 数 ) (3)String(value): 把 值 转 换 成 字 符 串 首 先 来 看 Boolean() 如 果 要 转 换 的 值 为 至 少 有 一 字 符 的 字 符 串 非 0 的 数 字 或 对 象, 那 么 Boolean() 将 返 回 true; 如 果 要 转 换 的 值 为 空 字 符 串 数 字 0 undefined null, 那 么 Boolean() 会 返 回 false 例 如 : var t1 = Boolean(""); // 返 回 false, 空 字 符 串 var t2 = Boolean("s"); // 返 回 true, 非 空 字 符 串 var t3 = Boolean(0); // 返 回 false, 数 字 0 var t4 = Boolean(1), t5 = Boolean( 1); // 返 回 true, 非 0 数 字 var t6 = Boolean(null), t7 = Boolean(undefined); // 返 回 false var t8 = Boolean(new Object()); // 返 回 true, 对 象 再 来 看 看 Number() Number() 与 parseint() 和 parsefloat() 类 似, 它 们 区 别 在 于 Number() 转 换 的 是 整 个 值, 而 parseint() 和 parsefloat() 则 可 以 只 转 换 开 头 的 数 字 部 分 例 如,Number("1.2.3") Number("123abc") 会 返 回 NaN, 而 parseint("1.2.3") 返 回 1 parseint("123abc") 返 回 123 parsefloat("1.2.3") 返 回 1.2 parsefloat("123abc") 返 回 123 Number() 会 先 判 断 要 转 换 的 值 能 否 被 完 整 地 转 换, 然 后 再 判 断 是 调 用 parseint() 还 是 parsefloat() 表 2 4 列 出 了 一 些 值 调 用 Number() 之 后 的 结 果 表 2 4 调 用 Number() 方 法 的 结 果 用 法 结 果 Number(false) 0 Number(true) 1 Number(undefined) NaN Number(null) 0 Number("1.2") 1.2 Number("12") 12 Number("1.2.3") Number(new Object()) NaN NaN Number(123) 123 最 后 是 String() 这 个 就 比 较 简 单 了, 它 可 以 把 所 有 类 型 的 数 据 转 换 成 字 符 串, 例 如 : String(false); // 返 回 "false" String(1); // 返 回 "1" String() 和 tostring() 方 法 有 些 不 同, 区 别 在 于 对 null 或 undefined 值 用 String() 进 行 强 制 类 型 转 换 可 以 生 成 字 符 串 而 不 引 发 错 误, 代 码 如 下 :

第 2 章 JavaScript 语 法 19 var t1 = null; var t2 = String(t1); //t2 的 值 "null" var t3 = t1.tostring(); // 这 里 会 报 错 var t4; var t5 = String(t4); //t5 的 值 "undefined" var t6 = t4.tostring(); // 这 里 会 报 错 2.2.3 引 用 类 型 除 了 基 本 的 数 据 类 型 之 外,JavaScript 还 支 持 引 用 类 型, 引 用 类 型 包 括 对 象 和 数 组 两 种 本 节 将 简 要 介 绍 上 述 引 用 类 型 的 基 本 概 念 及 其 用 法, 在 本 书 后 续 章 节 将 进 行 专 门 论 述 1. 对 象 JavaScript 中 的 对 象 是 一 个 属 性 的 集 合, 其 中 的 每 一 个 都 包 含 一 个 基 本 值 对 象 中 的 数 据 是 已 命 名 的 数 据, 通 常 作 为 对 象 的 属 性 来 引 用, 这 些 属 性 可 以 访 问 值 保 存 在 属 性 中 的 每 个 值 都 可 以 是 一 个 值 或 是 一 个 对 象, 甚 至 是 一 个 函 数 对 象 使 用 花 括 号 创 建 例 如, 下 面 的 代 码 创 建 了 一 个 名 为 myobject 的 空 对 象 : var myobject = ; 这 里 有 一 个 带 有 几 个 属 性 的 对 象 : var dvdcatalog = "identifier": "1", "name": "Coho Vineyard" ; 这 段 示 例 代 码 创 建 了 一 个 名 为 dvdcatalog 的 对 象, 它 有 两 个 属 性, 一 个 叫 做 identifier, 另 一 个 叫 做 name 两 个 属 性 中 包 含 的 值 分 别 是 1 和 Coho Vineyard 可 以 使 用 以 下 方 法 访 问 dvdcatalog 对 象 的 name 属 性 : dvdcatalog.name JavaScript 中 的 对 象 除 了 拥 有 属 性 之 外, 还 可 以 拥 有 方 法 例 如, 一 个 窗 口 (Window) 对 象 有 一 个 名 为 alert 的 方 法, 可 以 通 过 以 下 方 法 来 引 用 : window.alert(message) 2. 数 组 数 组 和 对 象 一 样, 也 是 一 些 数 据 的 集 合, 这 些 数 据 也 可 以 是 字 符 串 类 型 数 字 类 型 布 尔 类 型, 或 者 是 引 用 类 型 例 如, 下 面 的 定 义 : var score = [56,34,23,76,45]; 上 述 语 句 创 建 数 组 score, 中 括 号 [] 内 的 成 员 为 数 组 元 素 由 于 JavaScript 是 弱 类 型 语 言, 因 此 不 要 求 目 标 数 组 中 各 元 素 的 数 据 类 型 均 相 同, 例 如 : var score = [56,34, "23",76, "45"]; 在 数 组 中 为 每 个 数 据 都 编 了 一 个 号, 这 个 号 称 为 数 组 的 下 标 在 JavaScript 中 数 组 的 下 标 是 从 0 开 始 的, 通 过 使 用 数 组 名 加 下 标 的 方 法 可 以 获 取 数 组 中 的 某 个 数 据 例 如, 下 列 语 句 声 明 变 量 m 返 回 数 组 score 中 第 四 个 元 素 : var m = score [3]; 2.3 JavaScript 运 算 符 编 写 JavaScript 脚 本 代 码 过 程 中, 对 目 标 数 据 进 行 运 算 操 作 需 用 到 运 算 符 运 算 符 用 于

20 JavaScript 语 言 与 Ajax 应 用 将 一 个 或 者 几 个 值 变 成 结 果 值, 使 用 运 算 符 的 值 称 为 操 作 数, 运 算 符 即 操 作 数 的 组 合 称 为 表 达 式 JavaScript 脚 本 语 言 支 持 很 多 种 运 算 符, 下 面 分 别 予 以 介 绍 2.3.1 算 术 运 算 符 算 术 运 算 符 是 最 简 单 最 常 用 的 运 算 符, 可 以 使 用 它 们 进 行 通 用 的 数 学 计 算, 如 表 2 5 所 示 : 表 2 5 算 术 运 算 符 运 算 符 表 达 式 说 明 示 例 + x+y 返 回 x 加 y 的 值 x=4+2, 结 果 为 6 x y 返 回 x 减 y 的 值 x=8 6, 结 果 为 2 * x*y 返 回 x 乘 以 y 的 值 x=3*5, 结 果 为 15 / x/y 返 回 x 除 以 y 的 值 x=6/3, 结 果 为 2 % x%y 返 回 x 与 y 的 模 (x 除 以 y 的 余 数 ) x=8%3, 结 果 为 2 ++ x++ ++x 返 回 数 值 递 增 递 增 并 返 回 数 值 x x 返 回 数 值 递 减 递 减 并 返 回 数 值 这 里 需 要 注 意 的 是 : 自 加 和 自 减 运 算 符 放 置 在 操 作 数 的 前 面 和 后 面 其 含 义 不 同 运 算 符 写 在 变 量 名 前 面, 则 返 回 值 为 自 加 或 自 减 前 的 值 ; 而 写 在 后 面, 则 返 回 值 为 自 加 或 自 减 后 的 值 如 下 面 代 码 所 示 : var x = 5, y = 0; y = x++; // 先 执 行 y=x; 后 执 行 x=x+1; 上 述 代 码 执 行 后,x 的 值 为 6,y 的 值 为 5 如 果 将 代 码 改 成 下 面 的 前 置 形 式 : var x = 5, y = 0; y = ++ x; // 先 执 行 x=x+1; 后 执 行 y=x; 修 改 后 的 代 码 执 行 后,x 的 值 为 6,y 的 值 也 为 6 由 上 面 的 代 码 示 例 可 以 看 出 : (1) 若 自 加 ( 或 自 减 ) 运 算 符 放 置 在 操 作 数 之 后, 执 行 该 自 加 ( 或 自 减 ) 操 作 时, 先 将 操 作 数 的 值 赋 值 给 运 算 符 前 面 的 变 量, 然 后 操 作 数 自 加 ( 或 自 减 ) (2) 若 自 加 ( 或 自 减 ) 运 算 符 放 置 在 操 作 数 之 前, 执 行 该 自 加 ( 或 自 减 ) 操 作 时, 操 作 数 先 进 行 自 加 ( 或 自 减 ), 然 后 将 操 作 数 的 值 赋 值 给 运 算 符 前 面 的 变 量 JavaScript 脚 本 语 言 的 运 算 符 在 参 与 数 值 运 算 时, 其 右 侧 的 变 量 将 保 持 不 变 从 本 质 上 讲, 运 算 符 右 侧 的 变 量 作 为 运 算 的 参 数 而 存 在, 脚 本 解 释 器 执 行 指 定 的 操 作 后, 将 运 算 结 果 作 为 返 回 值 赋 予 运 算 符 左 侧 的 变 量 赋 值 运 算 符 (=) 是 编 写 JavaScript 脚 本 代 码 时 最 为 常 用 的 操 作, 其 作 用 是 给 一 个 变 量 赋 值, 即 将 某 个 数 值 制 定 给 某 个 变 量 有 些 赋 值 运 算 符 可 以 和 其 他 运 算 符 组 合 使 用, 对 变 量 中 包 含 的 值 进 行 计 算, 然 后 用 新 值 更 新 变 量, 表 2 6 中 列 出 了 一 些 常 用 的 赋 值 运 算 符 表 2 6 赋 值 运 算 符 运 算 符 说 明 示 例 = 将 运 算 符 右 边 变 量 的 值 赋 给 左 边 变 量 m=n += 将 运 算 符 两 侧 变 量 的 值 相 加 并 将 结 果 赋 给 左 边 变 量 m+=n

第 2 章 JavaScript 语 法 21 运 算 符 说 明 示 例 = 将 运 算 符 两 侧 变 量 的 值 相 减 并 将 结 果 赋 给 左 边 变 量 m =n *= 将 运 算 符 两 侧 变 量 的 值 相 乘 并 将 结 果 赋 给 左 边 变 量 m*=n /= 将 运 算 符 两 侧 变 量 的 值 相 除 并 将 整 除 的 结 果 赋 给 左 边 变 量 m/=n %= 将 运 算 符 两 侧 变 量 的 值 相 除 并 将 余 数 赋 给 左 边 变 量 m%=n 2.3.2 逻 辑 运 算 符 逻 辑 运 算 符 通 常 用 于 执 行 布 尔 运 算,JavaScript 脚 本 语 言 的 逻 辑 运 算 符 包 括 && 和! 等, 用 于 两 个 逻 辑 型 数 据 之 间 的 操 作, 返 回 值 的 数 据 类 型 为 布 尔 型 表 2 7 列 出 了 JavaScript 的 逻 辑 运 算 符 表 2 7 逻 辑 运 算 符 运 算 符 表 达 式 说 明 示 例 续 表 && 表 达 式 1&& 表 达 式 2 若 两 边 表 达 式 的 值 都 为 true, 则 返 回 true; 任 意 一 个 值 为 false, 则 返 回 false 表 达 式 1 表 达 式 2 只 有 表 达 式 的 值 都 为 false 时, 才 返 回 false, 否 则 返 回 true!! 表 达 式 求 反 若 表 达 式 的 值 为 true, 则 返 回 false, 否 则 返 回 true 5>3&&5<6 返 回 true 5>3&&5>6 返 回 false 5>3 5>6 返 回 true 5>7 5>6 返 回 false!(5>3) 返 回 false!(5>6) 返 回 true 2.3.3 关 系 运 算 符 JavaScript 脚 本 语 言 中 用 于 比 较 两 个 数 据 的 运 算 符 称 为 关 系 运 算 符, 包 括 = =!= > < <= 和 >= 等 关 系 运 算 符 用 于 比 较 两 个 操 作 数 的 大 小, 其 比 较 的 结 果 是 一 个 布 尔 型 的 值 当 两 个 操 作 数 满 足 关 系 运 算 符 指 定 的 关 系 时, 表 达 式 的 值 为 true, 否 则 为 false 其 具 体 作 用 见 表 2 8 表 2 8 关 系 运 算 符 运 算 符 说 明 示 例 == 相 等, 若 两 数 据 相 等, 则 返 回 布 尔 值 true, 否 则 返 回 false num==8!= 不 相 等, 若 两 数 据 不 相 等, 则 返 回 布 尔 值 true, 否 则 返 回 false num!=8 > 大 于, 若 左 边 数 据 大 于 右 边 数 据, 则 返 回 布 尔 值 true, 否 则 返 回 false num>8 < 小 于, 若 左 边 数 据 小 于 右 边 数 据, 则 返 回 布 尔 值 true, 否 则 返 回 false num<8 >= 大 于 或 等 于, 若 左 边 数 据 大 于 或 等 于 右 边 数 据, 则 返 回 布 尔 值 true, 否 则 返 回 false num>=8 <= 小 于 或 等 于, 若 左 边 数 据 小 于 或 等 于 右 边 数 据, 则 返 回 布 尔 值 true, 否 则 返 回 false num<=8 2.3.4 位 运 算 符 位 运 算 符 是 对 操 作 数 按 其 在 计 算 机 内 表 示 的 二 进 制 数 逐 位 地 进 行 逻 辑 运 算 或 移 位 运 算 位 运 算 符 是 对 其 操 作 数 ( 要 求 是 整 型 的 操 作 数 ) 按 二 进 制 形 式 逐 位 进 行 运 算, 运 算 完 毕 后, 将

22 JavaScript 语 言 与 Ajax 应 用 结 果 转 换 成 十 进 制 数 值 位 操 作 运 算 符 如 表 2 9 所 示 表 2 9 位 运 算 符 运 算 符 说 明 示 例 & 按 位 与, 若 两 数 据 对 应 位 都 是 1, 则 该 位 为 1, 否 则 为 0 9&4 ^ 按 位 异 或, 若 两 数 据 对 应 位 相 反, 则 该 位 为 1, 否 则 为 0 9^4 按 位 或, 若 两 数 据 对 应 位 都 是 0, 则 该 位 为 0, 否 则 为 1 9 4 ~ 按 位 非, 若 数 据 对 应 位 为 0, 则 该 位 为 1, 否 则 为 0 ~4 >> 算 术 右 移, 将 左 侧 数 据 的 二 进 制 值 向 左 移 动 由 右 侧 数 值 表 示 的 位 数, 右 边 空 位 补 0 9>>2 << 算 术 左 移, 将 左 侧 数 据 的 二 进 制 值 向 右 移 动 由 右 侧 数 值 表 示 的 位 数, 忽 略 被 移 出 的 位 9<<2 >>> 逻 辑 右 移, 将 左 边 数 据 表 示 的 二 进 制 值 向 右 移 动 由 右 边 数 值 表 示 的 位 数, 忽 略 被 移 出 的 位, 左 侧 空 位 补 0 9>>>2 例 如, 有 下 面 的 例 子 var a = 6; var b = 36; // 二 进 制 值 0000 0110b // 二 进 制 值 0010 0100b var result = 0; result = a&b; // 结 果 为 二 进 制 0000 0100b, 对 应 的 十 进 制 结 果 为 4 result = a^b; // 结 果 为 二 进 制 0010 0010b, 对 应 的 十 进 制 结 果 为 34 result = a b; // 结 果 为 二 进 制 0010 0110b, 对 应 的 十 进 制 结 果 为 38 result = ~a; // 结 果 为 二 进 制 1000 0111b, 对 应 的 十 进 制 结 果 为 7 var targetvalue = 189; // 目 标 数 据 二 进 制 值 1011 1101b var ipos = 2; // 目 标 数 据 移 动 的 位 数 result = targetvalue>>ipos; // 结 果 为 二 进 制 0010 1111b, 对 应 的 十 进 制 结 果 为 47 result = targetvalue<<ipos; // 结 果 为 二 进 制 10 1111 0100b, 对 应 的 十 进 制 结 果 为 756 result = targetvalue>>>ipos; // 结 果 为 二 进 制 0010 1111b, 对 应 的 十 进 制 结 果 为 47 2.4 JavaScript 语 句 表 达 式 的 作 用 只 是 生 成 并 返 回 一 个 值, 在 JavaScript 中 还 有 很 多 种 语 句, 通 过 这 些 语 句 可 以 控 制 程 序 代 码 的 执 行 次 序, 从 而 可 以 完 成 比 较 复 杂 的 程 序 操 作 2.4.1 选 择 语 句 选 择 语 句 是 JavaScript 中 的 基 本 控 制 语 句 之 一, 其 作 用 是 让 JavaScript 根 据 条 件 选 择 执 行 哪 些 语 句 或 不 执 行 哪 些 语 句 在 JavaScript 中 的 选 择 语 句 可 以 分 为 if 语 句 和 switch 语 句 两 种 1.if 语 句 if 条 件 假 设 语 句 是 比 较 简 单 的 一 种 选 择 结 构 语 句, 若 给 定 的 逻 辑 条 件 表 达 式 为 真, 则 执 行 一 组 给 定 的 语 句 其 基 本 结 构 如 下 : if(conditions) statements; 逻 辑 条 件 表 达 式 conditions 必 须 放 在 小 括 号 里, 且 仅 当 该 表 达 式 为 真 时, 执 行 花 括 号 内 包

第 2 章 JavaScript 语 法 23 含 的 语 句, 否 则 将 跳 过 该 条 件 语 句 而 执 行 其 下 的 语 句 花 括 号 内 的 语 句 可 为 一 个 或 多 个, 当 仅 有 一 个 语 句 时, 花 括 号 可 以 省 略 但 一 般 而 言, 为 养 成 良 好 的 编 程 习 惯, 同 时 增 强 程 序 代 码 的 结 构 化 和 可 读 性, 建 议 使 用 花 括 号 将 指 定 执 行 的 语 句 括 起 来 if 后 面 可 增 加 else 进 行 扩 展, 即 组 成 if...else 语 句, 其 基 本 结 构 如 下 : if(conditions) statement1; else statement2; 当 逻 辑 条 件 表 达 式 conditions 运 算 结 果 为 真 时, 执 行 statement1 语 句 ( 或 语 句 块 ), 否 则 执 行 statement2 语 句 ( 或 语 句 块 ) 当 需 要 提 供 多 重 选 择 时, 可 以 使 用 if...else if...else 语 句 其 语 法 格 式 如 下 : if ( 条 件 1) 条 件 1 成 立 时 执 行 代 码 else if ( 条 件 2) 条 件 2 成 立 时 执 行 代 码 else 条 件 1 和 条 件 2 均 不 成 立 时 执 行 代 码 if( 或 if...else) 结 构 可 以 嵌 套 使 用 来 表 示 所 示 条 件 的 一 种 层 次 结 构 关 系 值 得 注 意 的 是, 嵌 套 时 应 重 点 考 虑 各 逻 辑 条 件 表 达 式 所 表 示 的 范 围 例 2 1 求 一 元 二 次 方 程 ax 2 +bx+c=0 的 根 <title>if...else... 示 例 </title> var a,b,c,x1,x2; a=1; b=3; c=2; if(a==0) x1= c/b; x2=x1; var str=" 方 程 的 解 为 :x="+x1; console.log(str); else if(b*b 4*a*c>=0)

24 JavaScript 语 言 与 Ajax 应 用 x1=( b+math.sqrt(b*b 4*a*c))/(2*a); x2=( b Math.sqrt(b*b 4*a*c))/(2*a); var str=" 方 程 的 解 为 :x1= "+x1+", x2= "+x2; console.log(str); else console.log(" 该 方 程 无 解!"); 其 中 用 到 了 Math.sqrt() 方 法 来 求 平 方 根, 程 序 输 出 结 果 为 : 方 程 的 解 为 :x1= 1, x2= 2 在 if else 语 句 中 可 以 添 加 任 意 多 个 else if 子 句 提 供 多 种 选 择, 但 是 使 用 多 个 else if 子 句 经 常 会 使 代 码 变 得 非 常 繁 琐 在 多 个 条 件 中 进 行 选 择 的 更 好 方 法 是 使 用 switch case 语 句 2.switch 语 句 switch case 语 句 提 供 了 if else 语 句 的 一 个 变 通 形 式, 可 以 从 多 个 语 句 块 中 选 择 其 中 一 个 执 行 switch case 语 句 提 供 的 功 能 与 if else 语 句 类 似, 但 是 可 以 使 代 码 更 加 简 练 易 读 switch case 语 句 在 其 开 始 处 使 用 一 个 简 单 的 测 试 表 达 式, 表 达 式 的 结 果 将 与 结 构 中 每 个 case 子 句 的 值 进 行 比 较 如 果 匹 配, 则 执 行 与 该 case 关 联 的 语 句 块 其 基 本 语 法 结 构 如 下 : switch (a) case a1: statement 1; [break;] case a2: statement 2; [break]; default: [statement n;] 其 中 a 是 数 值 型 或 字 符 型 数 据, 将 a 的 值 与 a1 a2 an 相 比 较, 若 a 与 其 中 某 个 值 相 等 时, 执 行 相 应 数 据 后 面 的 语 句, 且 当 遇 到 关 键 字 break 时, 程 序 跳 出 statement n 语 句, 并 重 新 进 行 比 较 ; 若 找 不 到 与 a 相 等 的 值, 则 执 行 关 键 字 default 下 面 的 语 句 例 2 2 使 用 switch case 语 句 对 学 生 分 数 进 行 分 级 <title>switch...case... 示 例 </title> var score,flag;

第 2 章 JavaScript 语 法 25 score=85; flag=(score score%10)/10; switch(flag) case 10: case 9: console.log(" 成 绩 为 优 (90~100)"); 程 序 输 出 结 果 为 : 成 绩 为 良 (80~89) break; case 8: console.log(" 成 绩 为 良 (80~89)"); break; case 7: console.log(" 成 绩 为 一 般 (70~79)"); break; case 6: console.log(" 成 绩 为 及 格 (60~69)"); break; default: console.log(" 成 绩 不 及 格 "); 需 要 注 意 switch case 语 句 只 计 算 一 次 开 始 处 的 一 个 表 达 式, 而 if else 语 句 计 算 每 个 else if 子 句 的 表 达 式, 这 些 表 达 式 可 以 各 不 相 同 仅 当 每 个 else if 子 句 计 算 的 表 达 式 都 相 同 时, 才 可 以 使 用 switch case 语 句 代 替 if else 语 句 3.?...: 运 算 符 在 JavaScript 脚 本 语 言 中,?...: 运 算 符 用 于 创 建 条 件 分 支 在 动 作 较 为 简 单 的 情 况 下, 较 之 if else 语 句 更 加 简 便, 其 语 法 结 构 如 下 : (condition)?statementa:statementb; 载 入 上 述 语 句 后, 首 先 判 断 条 件 condition, 若 结 果 为 真 则 执 行 语 句 statementa, 否 则 执 行 语 句 statementb 值 得 注 意 的 是, 由 于 JavaScript 脚 本 解 释 器 将 分 号 ; 作 为 语 句 的 结 束 符,statementA 和 statementb 语 句 均 必 须 为 单 个 脚 本 代 码, 若 使 用 多 个 语 句 会 报 错 例 如, 下 列 代 码 浏 览 器 解 释 执 行 时 得 不 到 正 确 的 结 果 : (condition)?statementa:statementb;ststementc; 例 如 :var flag = (x>y)? 1 : 0; 如 果 x 的 值 大 于 y 的 值, 则 表 达 式 的 值 为 1; 否 则, 如 果 x 的 值 小 于 或 等 于 y 值, 则 表 达 式 的 值 为 0 可 以 看 出, 使 用?...: 运 算 符 进 行 简 单 的 条 件 分 支, 语 法 简 单 明 了, 但 若 要 实 现 较 为 复 杂 的 条 件 分 支, 推 荐 使 用 if else 语 句 或 者 switch 语 句

26 JavaScript 语 言 与 Ajax 应 用 2.4.2 循 环 语 句 在 编 写 程 序 的 过 程 中, 有 时 需 要 重 复 执 行 某 个 语 句 块, 这 时 就 用 到 了 循 环 语 句 JavaScript 中 的 循 环 语 句 包 括 while 语 句 do while 语 句 for 语 句 和 for in 语 句 4 种 1.while 语 句 while 语 句 属 于 基 本 循 环 语 句, 用 于 在 指 定 条 件 为 真 时 重 复 执 行 一 组 语 句 while 语 句 的 语 法 结 构 如 下 : while(condition) statements; 参 数 condition 表 示 一 个 条 件 表 达 式, statements 表 示 当 条 件 为 true 时 所 要 反 复 执 行 的 语 句 模 块 while 循 环 语 句 是 在 逻 辑 条 件 表 达 式 为 真 的 情 况 下, 反 复 执 行 循 环 体 内 包 含 的 语 句 ( 或 语 句 块 ) 例 2 3 依 次 打 印 输 出 10 以 内 的 偶 数 <title>while 循 环 </title> var i=0; while(i<10) console.log(i); i+=2; 代 码 运 行 结 果 为 : 0 2 4 6 8 该 例 中 的 while 循 环 体 执 行 了 5 次 需 要 注 意 的 是 :while 语 句 的 循 环 变 量 i 的 赋 值 语 句 在 循 环 体 前, 循 环 变 量 i 的 更 新 则 放 在 循 环 体 内 在 某 些 情 况 下,while 循 环 花 括 号 内 的 statements 语 句 ( 或 语 句 块 ) 可 能 一 次 也 不 被 执 行, 因 为 对 逻 辑 条 件 表 达 式 的 运 算 在 执 行 statements 语 句 ( 或 语 句 块 ) 之 前 若 逻 辑 条 件 表 达 式 运 算 结 果 为 假, 则 程 序 直 接 跳 过 循 环 而 一 次 也 不 执 行 statements 语 句 ( 或 语 句 块 ) 2.do while 语 句 do while 语 句 类 似 于 while 语 句, 不 同 的 是 while 语 句 是 先 判 断 逻 辑 条 件 表 达 式 的 值 是 否 为 true 之 后 再 决 定 是 否 执 行 循 环 体 中 的 语 句, 而 do while 循 环 语 句 是 先 执 行 循 环 体 中 的 语 句 之 后, 再 判 断 逻 辑 条 件 表 达 式 是 否 为 true, 如 果 为 true 则 重 复 执 行 循 环 体 中 的 语 句 do while 语 句 的 语 法 结 构 如 下 : do

第 2 章 JavaScript 语 法 27 statements; while(condition); do while 语 句 中 各 参 数 定 义 与 while 语 句 相 同 若 希 望 至 少 执 行 一 次 statements 语 句 ( 或 语 句 块 ), 就 可 用 do while 语 句 下 面 将 通 过 一 个 例 子 区 别 do while 语 句 和 while 语 句 的 用 法 例 2 4 使 用 do while 语 句 <title>do...while 语 句 </title> var i=1,j=1,m=0,n=0; while(i<1) m=m+1; i++; console.log("while 语 句 循 环 执 行 了 "+m+" 次 "); do n=n+1; j++; while(j<1); console.log("do...while 语 句 循 环 执 行 了 "+n+" 次 ") 代 码 运 行 结 果 为 : while 语 句 循 环 执 行 了 0 次 do...while 语 句 循 环 执 行 了 1 次 在 这 个 例 子 中 变 量 i j 的 初 始 值 都 为 1,do...while 语 句 与 while 语 句 的 循 环 条 件 都 是 小 于 1, 但 是 由 于 do...while 语 句 是 先 执 行 循 环 体 再 进 行 条 件 判 断, 因 此 即 使 条 件 判 断 为 false, 但 是 循 环 体 还 是 执 行 了 一 次 3.for 语 句 for 循 环 语 句 也 类 似 于 while 语 句, 使 用 起 来 更 为 方 便 for 语 句 按 照 指 定 的 循 环 次 数, 循 环 执 行 循 环 体 内 语 句 ( 或 语 句 块 ), 它 提 供 的 是 一 种 常 用 的 循 环 模 式, 即 初 始 化 变 量 判 断 逻 辑 条 件 表 达 式 和 改 变 变 量 值 for 语 句 的 语 法 结 构 如 下 : for(initialization; condition; loop update) statements; 循 环 控 制 代 码 ( 即 小 括 号 内 代 码 ) 内 各 参 数 的 含 义 如 下 : (1)initialization 表 示 循 环 变 量 初 始 化 语 句 (2)condition 为 控 制 循 环 结 束 与 否 的 条 件 表 达 式, 程 序 每 执 行 完 一 次 循 环 体 内 语 句 ( 或

28 JavaScript 语 言 与 Ajax 应 用 语 句 块 ), 均 要 计 算 该 表 达 式 是 否 为 真, 若 结 果 为 真, 则 继 续 运 行 下 一 次 循 环 体 内 语 句 ( 或 语 句 块 ); 若 结 果 为 假, 则 跳 出 循 环 体 (3)loop update 指 循 环 变 量 更 新 的 语 句, 程 序 每 执 行 完 一 次 循 环 体 内 语 句 ( 或 语 句 块 ), 均 需 要 更 新 循 环 变 量 上 述 循 环 控 制 参 数 之 间 使 用 分 号 ; 间 隔 开 来 初 始 化 语 句 条 件 语 句 和 更 新 语 句 都 可 以 选 择, 也 可 以 省 略, 但 是 分 号 ; 不 可 以 省 略 例 2 5 使 用 for 语 句 求 一 个 数 的 阶 乘 <title>untitled Document</title> var i=1,n=5,sum=1; for(i=1;i<=n;i++) sum*=i; console.log(n+" 的 阶 乘 是 "+sum); 代 码 运 行 结 果 为 : 5 的 阶 乘 是 120 这 个 例 子 中 for 循 环 的 执 行 过 程 如 下 : 1) 执 行 i=1; 初 始 化 变 量 2) 判 断 表 达 式 i<=n 是 否 为 true, 如 果 返 回 true 就 执 行 步 骤 3) ; 如 果 返 回 false 则 结 束 for 循 环 语 句 如 下 : 3) 执 行 i++ 语 句, 更 新 循 环 变 量 4) 执 行 循 环 体 中 的 语 句 5) 重 复 执 行 步 骤 2) 4.for in 语 句 使 用 for in 循 环 语 句 可 以 遍 历 数 组 或 者 对 指 定 对 象 的 属 性 和 方 法 进 行 遍 历, 其 语 法 结 构 for ( 变 量 名 in 对 象 名 ) statements; 下 面 给 出 一 个 使 用 for in 语 句 的 具 体 示 例, 输 出 了 数 组 中 的 所 有 元 素 例 2 6 使 用 for in 语 句 遍 历 数 组 <title>for...in 语 句 </title>

第 2 章 JavaScript 语 法 29 var mycars=["audi","volvo","bmw"]; for(var k in mycars) console.log(mycars[k]); 代 码 运 行 结 果 为 : Audi Volvo BMW 2.4.3 跳 转 语 句 所 谓 跳 转 语 句, 就 是 在 循 环 控 制 语 句 的 循 环 体 中 的 指 定 位 置 或 是 满 足 一 定 条 件 的 情 况 下 直 接 退 出 循 环 JavaScript 跳 转 语 句 分 为 break 语 句 和 continue 语 句 1.break 语 句 使 用 break 语 句 可 以 无 条 件 地 从 当 前 执 行 的 循 环 结 构 或 者 switch 结 构 的 语 句 块 中 中 断 并 退 出, 其 语 法 格 式 如 下 : break; 由 于 它 是 用 来 退 出 循 环 或 者 switch 语 句, 所 以 只 有 当 它 出 现 在 这 些 语 句 时, 这 种 形 式 的 break 语 句 才 是 合 法 的 例 2 7 使 用 break 语 句 <title>untitled Document</title> for(var i=1;i<=5;i++) if(i==3) break; console.log(i); 代 码 运 行 结 果 为 : 1 2 上 述 代 码 中 for 语 句 在 变 量 i 为 1 和 2 时 执 行, 当 i 为 3 时,if 语 句 条 件 为 真, 执 行 break 语 句, 终 止 for 循 环 这 时 程 序 将 跳 出 for 循 环 而 不 再 执 行 下 面 的 循 环 如 果 未 使 用 break 语 句, 程 序 将 执 行 for 循 环 语 句 中 的 循 环 体, 直 到 变 量 i 的 值 不 满 足 条 件 i<=5

30 JavaScript 语 言 与 Ajax 应 用 注 意 : 在 嵌 套 的 循 环 语 句 中 使 用 break 语 句 时,break 语 句 只 能 跳 出 最 近 的 一 层 循 环, 而 不 是 跳 出 所 有 的 循 环 2.continue 语 句 continue 语 句 的 工 作 方 式 与 break 语 句 有 点 类 似, 但 是 其 作 用 不 同 continue 语 句 是 只 跳 出 本 次 循 环 而 立 即 进 入 到 下 一 次 循 环 ;break 语 句 则 是 跳 出 循 环 后 结 束 整 个 循 环 下 面 将 例 2 7 中 的 break 语 句 换 成 continue 语 句, 看 看 输 出 结 果 有 什 么 不 同 例 2 8 使 用 continue 语 句 <title>continue 语 句 </title> for(var i=1;i<=5;i++) if(i==3) continue; console.log(i); 代 码 运 行 结 果 为 : 1 2 4 5 在 修 改 后 的 代 码 执 行 中,for 循 环 在 i 等 于 1 2 3 4 5 时 都 执 行 了, 但 是 输 出 结 果 中 却 没 有 3 当 i 为 3 时,if 语 句 条 件 为 真, 执 行 continue 语 句, 跳 过 循 环 体 后 面 的 语 句, 继 续 执 行 下 一 次 循 环, 所 以 3 没 有 被 输 出 2.4.4 异 常 处 理 语 句 在 代 码 的 运 行 过 程 中 一 般 会 发 生 两 种 错 误 : 一 是 程 序 内 部 的 逻 辑 错 误 或 者 语 法 错 误 ; 二 是 运 行 环 境 或 者 用 户 输 入 中 不 可 预 知 的 数 据 造 成 的 错 误 JavaScript 可 以 捕 获 异 常 并 进 行 相 应 的 处 理, 通 常 用 到 的 异 常 处 理 语 句 包 括 throw 和 try catch finally 语 句 两 种 1.throw 语 句 throw( 抛 出 ) 语 句 的 作 用 是 抛 出 一 个 异 常 所 谓 抛 出 异 常, 就 是 用 信 号 通 知 发 生 了 异 常 情 况 或 错 误 throw 语 句 的 预 防 代 码 如 下 : throw 表 达 式 ; 以 上 代 码 中 的 表 达 式, 可 以 是 任 何 类 型 的 表 达 式 该 表 达 式 通 常 是 一 个 Error 对 象 或 Error 对 象 的 某 个 实 例 可 以 通 过 new Error(message) 来 创 建 这 个 对 象, 异 常 的 描 述 被 作 为 error 对 象 的 一 个 属 性 message, 可 以 由 构 造 函 数 传 入, 也 可 以 以 后 赋 值 通 过 这 个 异 常 描 述, 可 以 让 程 序 获 取 异 常 的 详 细 信 息, 从 而 自 动 处 理 2.try catch finally 语 句 try catch finally 语 句 是 JavaScript 中 的 用 于 处 理 异 常 的 语 句, 该 语 句 与 throw 语 句 不 同 throw 语 句 只 是 抛 出 一 个 异 常, 但 对 该 异 常 并 不 进 行 处 理, 而 try catch finally 语 句 可 以 处 理 所

第 2 章 JavaScript 语 法 31 抛 出 的 异 常 其 语 法 形 式 如 下 : try // 语 句 块 1: 要 执 行 的 代 码 catch(e) // 语 句 块 2: 处 理 异 常 的 代 码 finally // 语 句 块 3: 无 论 异 常 发 生 与 否, 都 会 执 行 的 代 码 说 明 如 下 : (1) 语 句 块 1 是 有 可 能 要 抛 出 异 常 的 语 句 块 (2)catch(e) 中 的 e 是 一 个 变 量, 该 变 量 为 从 try 语 句 块 中 抛 出 的 Error 对 象 或 其 他 值 (3) 语 句 块 2 是 处 理 异 常 的 语 句 块 ; 如 果 在 语 句 块 1 中 没 有 抛 出 异 常, 则 不 执 行 该 语 句 块 中 的 代 码 (4) 无 论 在 语 句 块 1 中 是 否 抛 出 异 常,JavaScript 都 会 执 行 语 句 块 3 中 的 代 码 ; 但 是 语 句 块 3 中 的 语 句 与 finally 关 键 字 可 以 一 起 省 略 例 2 9 计 算 两 个 数 据 相 除 的 异 常 处 理 <title> 异 常 处 理 </title> function myfun(x,y) var z; try if(y==0) throw new Error(" 除 数 不 能 为 0"); z=x/y; catch(e) z=e.message; return z; console.log(myfun(1,0)); 代 码 运 行 结 果 为 : 除 数 不 能 为 0 在 这 个 例 子 中, 创 建 了 一 个 名 为 myfun 的 函 数, 该 函 数 的 作 用 是 将 两 个 参 数 相 除, 并 返

32 JavaScript 语 言 与 Ajax 应 用 回 结 果, 如 果 在 相 除 时 产 生 异 常, 则 返 回 错 误 信 息 当 用 1 除 以 0 时 抛 出 异 常,catch 语 句 接 收 到 由 throw 语 句 抛 出 的 异 常, 并 进 行 处 理 2.5 JavaScript 函 数 JavaScript 脚 本 语 言 允 许 开 发 者 通 过 编 写 函 数 的 方 式 组 合 一 些 可 重 复 使 用 的 脚 本 代 码 块, 增 加 了 脚 本 代 码 的 结 构 化 和 模 块 化 函 数 是 通 过 参 数 接 口 进 行 数 据 传 递, 以 实 现 特 定 的 功 能 2.5.1 函 数 的 创 建 与 调 用 函 数 由 函 数 定 义 和 函 数 调 用 两 部 分 组 成, 应 首 先 定 义 函 数, 然 后 再 进 行 调 用, 以 养 成 良 好 的 编 程 习 惯 函 数 的 定 义 应 使 用 关 键 字 function, 其 语 法 规 则 如 下 : function funcname ([parameters]) statements; [return 表 达 式 ;] 函 数 的 各 部 分 含 义 如 下 : (1)funcName 为 函 数 名, 函 数 名 可 由 开 发 者 自 行 定 义, 与 变 量 的 命 名 规 则 基 本 相 同 (2)parameters 为 函 数 的 参 数, 在 调 用 目 标 函 数 时, 需 将 实 际 数 据 传 递 给 参 数 列 表 以 完 成 函 数 特 定 的 功 能 参 数 列 表 中 可 定 义 一 个 或 多 个 参 数, 各 参 数 之 间 用 逗 号, 分 隔 开 来, 当 然, 参 数 列 表 也 可 为 空 (3)statements 是 函 数 体, 规 定 了 函 数 的 功 能, 本 质 上 相 当 于 一 个 脚 本 程 序 (4)return 指 定 函 数 的 返 回 值, 为 可 选 参 数 自 定 义 函 数 一 般 放 置 在 HTML 文 档 的 head 标 记 之 间 除 了 自 定 义 函 数 外,JavaScript 脚 本 语 言 提 供 大 量 的 内 建 函 数, 无 需 开 发 者 定 义 即 可 直 接 调 用 例 如,window 对 象 的 alert() 方 法 即 为 JavaScript 脚 本 语 言 支 持 的 内 建 函 数 函 数 定 义 过 程 结 束 后, 可 在 文 档 中 任 意 位 置 调 用 该 函 数 引 用 目 标 函 数 时, 只 需 在 函 数 名 后 加 上 小 括 号 即 可 若 目 标 函 数 需 引 入 参 数, 则 需 在 小 括 号 内 添 加 传 递 参 数 如 果 函 数 有 返 回 值, 可 将 最 终 结 果 赋 值 给 一 个 自 定 义 的 变 量 并 用 关 键 字 return 返 回 例 2 10 函 数 调 用 实 例 <title> 函 数 调 用 实 例 </title> function test() console.log(" 无 返 回 值 的 函 数 调 用!"); var str="123456"; function add(x,y)

第 2 章 JavaScript 语 法 33 console.log(" 有 返 回 值 的 函 数 调 用!"); var z=x+y; return z; test(); var a=10,b=20; var c=add(a,b); console.log(a+"+"+b+"="+c); 代 码 运 行 结 果 为 : 无 返 回 值 的 函 数 调 用! 有 返 回 值 的 函 数 调 用! 10+20=30 在 本 例 中, 定 义 了 两 个 函 数, 一 个 是 没 有 参 数 也 没 有 返 回 值 的 函 数 test, 另 一 个 是 带 两 个 参 数 并 且 有 返 回 值 的 函 数 add 调 用 时 test 函 数 直 接 用 函 数 名 加 上 括 号 成 为 调 用 语 句 ; 而 add 函 数 需 要 将 函 数 的 返 回 值 赋 给 变 量 c, 再 输 出 结 果 2.5.2 函 数 的 参 数 与 其 他 程 序 设 计 语 言 不 同,JavaScript 不 会 验 证 传 递 给 函 数 的 参 数 个 数 是 否 等 于 函 数 定 义 的 参 数 个 数 如 果 传 递 的 参 数 个 数 与 函 数 定 义 的 参 数 不 同, 则 函 数 执 行 起 来 往 往 会 有 可 能 产 生 一 些 意 想 不 到 的 错 误 开 发 者 定 义 的 函 数 都 可 以 接 收 任 意 个 参 数 ( 根 据 Netscape 的 文 档, 最 多 能 接 收 25 个 ), 而 不 会 引 发 错 误, 任 何 遗 漏 的 参 数 都 会 以 undefined 传 递 给 函 数, 多 余 的 参 数 将 忽 略 为 了 避 免 产 生 错 误, 一 个 程 序 员 应 该 会 让 传 递 的 函 数 参 数 个 数 与 函 数 定 义 的 参 数 个 数 相 同 在 JavaScript 中 提 供 了 一 个 arguments 对 象, 该 对 象 可 以 获 取 从 JavaScript 代 码 中 传 递 过 来 的 参 数, 并 将 这 些 参 数 存 放 在 arguments[] 数 组 中, 因 此 也 可 以 通 过 arguments 对 象 来 判 断 传 递 过 来 的 参 数 个 数, 引 用 属 性 arguments.length 即 可 arguments 为 数 组, 因 此 通 过 arguments[i] 可 以 获 得 实 际 传 递 的 参 数 值 例 2 11 判 断 函 数 的 参 数 传 递 个 数 <title>untitled Document</title> function add(x,y) if(arguments.length!=2) var str=" 传 递 的 参 数 个 数 有 误, 一 共 传 递 了 "+ arguments.length+" 个 参 数, 分 别 为 :\n"; for(var i=0;i<arguments.length;i++)

34 JavaScript 语 言 与 Ajax 应 用 str+=" 第 "+(i+1)+" 个 参 数 的 值 为 :"+arguments[i]+"\n"; return str; else var z=x+y; return z; console.log("add(2,4,6): "+add(2,4,6)+"\n"); console.log("add(2): "+add(2)+"\n"); console.log("add(2,4): "+add(2,4)+"\n"); //1 //2 //3 代 码 运 行 结 果 为 : add(2,4,6): 传 递 的 参 数 个 数 有 误, 一 共 传 递 了 3 个 参 数, 分 别 为 : 第 1 个 参 数 的 值 为 :2 第 2 个 参 数 的 值 为 :4 第 3 个 参 数 的 值 为 :6 add(2): 传 递 的 参 数 个 数 有 误, 一 共 传 递 了 1 个 参 数, 分 别 为 : 第 1 个 参 数 的 值 为 :2 add(2,4): 6 在 本 例 中 调 用 语 句 1 传 递 了 3 个 参 数, 此 时 add 函 数 会 将 参 数 x 的 值 赋 为 2, 将 参 数 y 的 值 赋 为 4, 并 将 传 递 过 来 的 第 3 个 参 数 值 6 忽 略 掉 但 是 在 add 函 数 中 的 arguments 对 象 可 以 完 全 接 收 传 递 过 来 的 3 个 参 数, 因 此 arguments.length 的 值 为 3,arguments[0] 的 值 为 2, arguments[1] 的 值 为 4,arguments[2] 的 值 为 6 程 序 进 入 错 误 处 理 代 码, 并 输 出 错 误 信 息 然 后 调 用 语 句 2 只 传 递 了 一 个 参 数, 此 时 add 函 数 会 将 参 数 x 的 值 赋 为 2, 而 参 数 y 的 值 保 持 为 初 始 值, 即 undefined arguments.length 的 值 为 1,arguments[0] 的 值 为 2 程 序 进 入 错 误 处 理 代 码, 并 输 出 错 误 信 息 最 后 调 用 语 句 3 传 递 了 两 个 参 数, 此 时 add 函 数 会 将 参 数 x 的 值 赋 为 2, 将 参 数 y 的 值 赋 为 4 而 arguments.length 的 值 为 2,arguments[0] 的 值 为 2,arguments[1] 的 值 为 4, 程 序 不 会 进 入 错 误 处 理 代 码, 而 会 直 接 返 回 结 果 6 由 于 JavaScript 是 一 种 无 类 型 的 语 言, 因 此 在 定 义 函 数 时, 不 需 要 为 函 数 的 参 数 指 定 数 据 类 型 事 实 上,JavaScript 也 不 会 去 检 测 传 递 过 来 的 参 数 类 型 是 否 符 合 函 数 的 需 要 如 果 一 个 函 数 对 参 数 的 要 求 很 严 格, 那 么 可 以 在 函 数 体 内 使 用 typeof 运 算 符 来 检 测 传 递 过 来 的 参 数 是 否 符 合 要 求 例 2 12 判 断 函 数 的 参 数 传 递 的 类 型

第 2 章 JavaScript 语 法 35 <title> 判 断 函 数 的 参 数 传 递 的 类 型 </title> function myfun(a,b) if(typeof(a)=="number"&&typeof(b)=="number") var c=a*b; return c; else return " 传 递 的 参 数 不 正 确, 请 使 用 数 字 型 的 参 数!"; console.log(myfun(2,4)); console.log(myfun(2,"s")); 代 码 运 行 结 果 为 : 8 传 递 的 参 数 不 正 确, 请 使 用 数 字 型 的 参 数! 本 例 中 使 用 typeof 运 算 符 判 断 传 递 过 来 的 参 数 类 型, 如 果 都 是 数 字 型, 则 返 回 两 个 参 数 之 积 ; 否 则 返 回 错 误 信 息 2.5.3 函 数 的 属 性 与 方 法 在 JavaScript 中, 函 数 也 是 一 个 对 象 既 然 函 数 是 对 象, 那 么 函 数 也 拥 有 自 己 的 属 性 与 方 法 1.length 属 性 函 数 的 length 属 性 与 arguments 对 象 的 length 属 性 不 一 样,arguments 对 象 的 length 属 性 可 以 获 得 传 递 给 函 数 的 实 际 参 数 的 个 数, 而 函 数 的 length 属 性 可 以 获 得 函 数 定 义 的 参 数 个 数 同 时 arguments 对 象 的 length 属 性 只 能 在 函 数 体 内 使 用, 而 函 数 的 length 属 性 可 以 在 函 数 体 之 外 使 用 例 2 13 函 数 的 length 属 性 与 arguments 对 象 的 length 属 性 的 区 别 <title> 函 数 的 length 属 性 </title> function add(x,y) if(add.length!=arguments.length)

36 JavaScript 语 言 与 Ajax 应 用 return " 传 递 过 来 的 参 数 个 数 与 函 数 定 义 的 参 数 个 数 不 一 致!"; else var z=x+y; return z; console.log(" 函 数 add 的 length 值 为 :"+add.length); console.log("add(3,4):"+add(3,4)); console.log("add(3,4,5):"+add(3,4,5)); 代 码 运 行 结 果 为 : 函 数 add 的 length 值 为 :2 add(3,4):7 add(3,4,5): 传 递 过 来 的 参 数 个 数 与 函 数 定 义 的 参 数 个 数 不 一 致! 本 例 中 定 义 了 一 个 名 为 add 的 函 数, 该 函 数 的 作 用 是 返 回 两 个 参 数 的 和 代 码 中 有 两 处 用 到 了 函 数 add 的 length 属 性 : 一 次 是 在 add 函 数 体 内, 在 返 回 两 个 参 数 之 和 之 前, 先 判 断 传 递 过 来 的 参 数 个 数 与 函 数 定 义 的 参 数 个 数 是 否 相 同, 如 果 不 同 则 返 回 错 误 信 息 ; 另 一 次 是 在 函 数 体 之 外 使 用 直 接 输 出 函 数 add 的 length 属 性 值 2.call() 和 apply() 方 法 在 JavaScript 中, 每 个 函 数 都 有 call() 方 法 和 apply() 方 法, 使 用 这 两 个 方 法 可 以 像 调 用 其 他 对 象 的 方 法 一 样 来 调 用 某 个 函 数, 它 们 的 作 用 都 是 将 函 数 绑 定 到 另 一 个 对 象 上 去 运 行, 两 者 仅 在 定 义 参 数 的 方 式 上 有 所 区 别 call() 方 法 的 使 用 语 法 格 式 如 下 : 函 数 名.call( 对 象 名, 参 数 1, 参 数 2, ) apply() 方 法 的 使 用 语 法 格 式 如 下 : 函 数 名.apply( 对 象 名, 数 组 ) 由 上 可 以 看 出, 两 个 方 法 的 区 别 是, call() 方 法 直 接 将 参 数 列 表 放 在 对 象 名 之 后, 而 apply() 方 法 却 是 将 列 表 放 在 数 组 里, 并 将 数 组 放 在 对 象 名 之 后 请 看 以 下 代 码, 在 该 代 码 的 第 一 行 定 义 了 一 个 对 象, 第 二 行 定 义 了 一 个 数 组, 第 三 行 中 使 用 call() 方 法 来 调 用 myfun 函 数, 第 四 行 中 使 用 了 apply() 方 法 来 调 用 myfun 函 数 var myobj = new Object(); var arr = [1,3,5]; myfun.call(myobj,1,2,3); myfun.apply(myobj, arr); 其 中 apply() 方 法 要 求 第 2 个 参 数 为 数 组,JavaScript 会 自 动 将 数 组 中 的 元 素 值 作 为 参 数 列 表 传 递 给 myfun 函 数, 也 可 以 将 数 组 作 为 参 数 直 接 放 在 apply() 方 法 内, 代 码 如 下 : myfun.apply(myobj, [2,4,6]); 例 2 14 函 数 的 call() 方 法 和 apply() 方 法 的 使 用

第 2 章 JavaScript 语 法 37 <title> 函 数 的 call() 方 法 和 apply() 方 法 的 使 用 </title> function getsum() var sum=0; for(var i=0;i<arguments.length;i++) sum+=arguments[i]; return sum; var myobj=new Object(); var arr=[1,3,5]; console.log("sum1="+getsum.call(myobj,2,4,6)); console.log("sum2="+getsum.apply(myobj,arr)); 代 码 运 行 结 果 为 : sum1=12 sum2=9 2.5.4 闭 包 JavaScript 支 持 闭 包 (Closure) 所 谓 闭 包, 是 指 词 法 表 示 包 括 不 必 计 算 的 变 量 的 函 数, 也 就 是 说, 该 函 数 能 使 用 函 数 外 定 义 的 变 量 在 JavaScript 中 使 用 全 局 变 量 时 一 个 简 单 的 闭 包 实 例 如 下 面 的 代 码 : var smessage = "Hello World!"; function sayhelloworld() alert(smessage); sayhelloworld(); 在 这 段 代 码 中, 脚 本 被 载 入 内 存 后, 并 未 为 函 数 sayhelloworld() 计 算 变 量 smessage 的 值, 该 函 数 捕 获 smessage 的 值 只 是 为 以 后 使 用, 也 就 是 说, 解 释 程 序 知 道 在 调 用 该 函 数 时 要 检 查 smessage 的 值 smessage 将 在 函 数 调 用 sayhelloworld() 时 ( 最 后 一 行 ) 被 赋 值, 显 示 消 息 Hello World! 在 一 个 函 数 中 定 义 另 一 个 函 数 会 使 闭 包 变 得 复 杂, 代 码 如 下 : var ibasenum = 10; function addnumbers(inum1, inum2) function doaddition() return inum1 + inum2 + ibasenum;

38 JavaScript 语 言 与 Ajax 应 用 return doaddition(); 这 里, 函 数 addnumbers() 包 括 函 数 doaddition()( 闭 包 ) 内 部 函 数 是 个 闭 包, 因 为 它 将 获 取 外 部 函 数 的 参 数 inum1 和 inum2 及 全 局 变 量 ibasenum 的 值 addnumbers() 的 最 后 一 步 调 用 了 内 部 函 数, 把 两 个 参 数 和 全 局 变 量 相 加, 并 返 回 它 们 的 和 这 里 要 掌 握 的 重 要 概 念 是 doaddition() 函 数 根 本 不 接 收 参 数, 它 使 用 的 值 是 从 执 行 环 境 中 获 取 的 可 以 看 到, 闭 包 是 JavaScript 中 功 能 非 常 强 大 的 一 部 分, 可 以 用 于 执 行 复 杂 的 计 算 就 像 使 用 任 何 高 级 函 数 一 样, 在 使 用 闭 包 时 要 当 心, 因 为 它 们 可 能 会 变 得 非 常 复 杂 本 章 小 结 JavaScript 与 其 他 语 言 一 样, 也 支 持 常 量 与 变 量, 不 过 JavaScript 中 的 变 量 是 无 类 型 的, 即 可 以 存 储 任 何 一 种 类 型 的 数 据 JavaScript 中 的 基 本 数 据 类 型 有 数 字 型 字 符 串 型 和 布 尔 型, 此 外,JavaScript 还 支 持 对 象 数 组 Null 和 Undefined 数 据 类 型 各 种 不 同 的 数 据 类 型 直 接 可 以 通 过 显 式 或 隐 式 方 式 进 行 转 换 本 章 主 要 介 绍 了 JavaScript 中 的 表 达 式 操 作 数 与 运 算 符 JavaScript 的 所 有 功 能 都 是 通 过 语 句 来 实 现 的, 本 章 对 JavaScript 中 的 表 达 式 语 句 语 句 块 选 择 语 句 循 环 语 句 跳 转 语 句 异 常 处 理 语 句 和 其 他 语 句 进 行 了 详 细 介 绍, 熟 练 掌 握 这 些 语 句 是 学 习 JavaScript 必 不 可 少 的 基 础 本 章 还 介 绍 了 函 数 的 定 义 与 使 用 方 法 函 数 在 JavaScript 中 是 一 个 很 重 要 的 部 分, JavaScript 有 很 多 内 置 函 数, 程 序 员 可 以 直 接 使 用 这 些 内 置 函 数, 也 可 以 自 定 义 函 数 以 供 程 序 使 用 习 题 2 1 JavaScript 中 的 变 量 是 使 用 什 么 关 键 字 来 进 行 声 明 的? 2 2 声 明 3 个 变 量, 一 个 数 字 型 变 量 和 两 个 字 符 串 变 量 数 字 型 变 量 的 值 是 120, 字 符 串 变 量 的 值 分 别 为 "2150" 和 "Two Hundred" 将 创 建 的 两 个 字 符 串 类 型 变 量 转 换 成 数 字 型 变 量, 它 们 能 否 转 换 成 功? 如 果 不 行, 为 什 么? 2 3 创 建 一 个 带 有 3 个 数 字 的 数 组 2 4 简 述 for 循 环 while 循 环 和 do while 循 环 的 区 别 2 5 throw 语 句 的 作 用 是 什 么? 2 6 通 过 什 么 方 法 获 取 函 数 中 传 递 的 参 数 个 数? 综 合 实 训 一 目 标 定 义 一 个 函 数, 该 函 数 的 作 用 是 使 用 冒 泡 法 将 传 递 过 来 的 数 字 从 小 到 大 进 行 排 序, 并 输 出 排 序 的 结 果

第 2 章 JavaScript 语 法 39 二 准 备 工 作 在 进 行 本 实 训 前, 必 须 掌 握 JavaScript 的 基 本 语 法 条 件 和 循 环 控 制 语 句, 函 数 的 定 义 和 使 用 函 数 的 参 数 由 于 排 序 的 数 字 个 数 不 定, 因 此, 在 定 义 该 函 数 时 并 没 有 定 义 参 数, 只 有 在 调 用 该 函 数 时 才 使 用 arguments 对 象 来 获 取 实 际 的 传 递 参 数 值 获 取 实 际 传 递 的 参 数 后, 再 通 过 冒 泡 法 对 参 数 值 进 行 排 序, 最 后 通 过 循 环 输 出 排 序 后 的 结 果 三 实 训 预 估 时 间 :45 分 钟 按 升 序 排 序 的 冒 泡 算 法 的 基 本 思 路 是 将 要 排 序 的 数 字 放 在 一 个 数 组 中, 并 将 数 组 中 相 邻 的 两 个 元 素 值 进 行 比 较, 将 数 值 小 的 数 字 放 在 数 组 的 前 面, 具 体 操 作 方 法 如 下 : (1) 假 设 数 组 a 中 有 n 个 数 字, 在 初 始 状 态 下,a[0]~a[n 1] 的 值 为 无 序 数 字 (2) 第 一 次 扫 描, 从 数 组 最 后 一 个 元 素 开 始 比 较 相 邻 两 个 元 素 的 值, 大 的 放 在 数 组 后 面, 小 的 放 在 数 组 前 面 即 依 次 比 较 a[n 1] 与 a[n 2] a[n 2] 与 a[n 3] a[2] 与 a[1] a[1] 与 a[0] 的 值, 小 的 放 前 面, 大 的 放 后 面 例 如,a[1] 的 值 小 于 a[2] 的 值, 就 将 这 两 个 元 素 的 值 交 换 一 次 扫 描 完 毕 后, 最 小 的 数 字 就 会 存 放 在 a[0] 元 素 上 (3) 第 二 次 扫 描, 第 二 小 的 数 字 就 会 存 放 在 a[1] 元 素 上 (4) 依 此 类 推, 直 到 循 环 结 束