Go语言从入门到放弃(二)优势/关键字

 本来这里是写数据类型的，但是规划了一下还是要一步步来，那么本篇就先介绍一下Go语言的 优势/关键字 吧

本章转载  《The Way to Go》一书

Go语言起源和发展

Go 语 言 起 源 2007 年， 并 于 2009 年 正 式 对 外 发 布。 它 从 2009 年 9 月 21 日 开 始 作 为 谷 歌 公 司 20% 兼 职 项 目， 即 相 关 员 工 利 用 20% 的 空 余 时 间 来 参 与 Go 语 言 的 研 发 工 作。 该 项 目 的 三 位 领 导 者 均 是 著 名 的 IT 工 程 师： Robert Griesemer， 参 与 开 发 Java HotSpot 虚 拟 机； Rob Pike， Go 语 言 项 目 总 负 责 人， 贝 尔 实 验 室 Unix 团 队 成 员， 参 与 的 项 目 包 括 Plan 9， Inferno 操 作 系 统 和 Limbo 编 程 语 言； Ken Thompson， 贝 尔 实 验 室 Unix 团 队 成 员， C 语 言、 Unix 和 Plan 9 的 创 始 人 之 一， 与 Rob Pike 共 同 开 发 了 UTF-8 字 符 集 规 范。 自 2008 年 1 月 起， Ken Thompson 就 开 始 研 发 一 款 以 C 语 言 为 目 标 结 果 的 编 译 器 来 拓 展 Go 语 言 的 设 计 思 想。

在 2008 年 年 中， Go 语 言 的 设 计 工 作 接 近 尾 声， 一 些 员 工 开 始 以 全 职 工 作 状 态 投 入 到 这 个 项 目 的 编 译 器 和 运 行 实 现 上。 Ian Lance Taylor 也 加 入 到 了 开 发 团 队 中， 并 于 2008 年 5 月 创 建 了 一 个 gcc 前 端。 Russ Cox 加 入 开 发 团 队 后 着 手 语 言 和 类 库 方 面 的 开 发， 也 就 是 Go 语 言 的 标 准 包。 在 2009 年 10 月 30 日， Rob Pike 以 Google Techtalk 的 形 式 第 一 次 向 人 们 宣 告 了 Go 语 言 的 存 在。 直 到 2009 年 11 月 10 日， 开 发 团 队 将 Go 语 言 项 目 以 BSD-style 授 权（ 完 全 开 源） 正 式 公 布 在 Linux 和 Mac OS X 平 台 上 的 版 本。

Hector Chu 于 同 年 11 月 22 日 公 布 了 Windows 版 本。 作 为 一 个 开 源 项 目， Go 语 言 借 助 开 源 社 区 的 有 生 力 量 达 到 快 速 地 发 展， 并 吸 引 更 多 的 开 发 者 来 使 用 并 改 善 它。 自 该 开 源 项 目 发 布 以 来， 超 过 200 名 非 谷 歌 员 工 的 贡 献 者 对 Go 语 言 核 心 部 分 提 交 了 超 过 1000 个 修 改 建 议。 在 过 去 的 18 个 月 里， 又 有 150 开 发 者 贡 献 了 新 的 核 心 代 码。 这 俨 然 形 成 了 世 界 上 最 大 的 开 源 团 队， 并 使 该 项 目 跻 身 Ohloh 前 2% 的 行 列。 大 约 在 2011 年 4 月 10 日， 谷 歌 开 始 抽 调 员 工 进 入 全 职 开 发 Go 语 言 项 目。 开 源 化 的 语 言 显 然 能 够 让 更 多 的 开 发 者 参 与 其 中 并 加 速 它 的 发 展 速 度。 Andrew Gerrand 在 2010 年 加 入 到 开 发 团 队 中 成 为 共 同 开 发 者 与 支 持 者。 在 Go 语 言 在 2010 年 1 月 8 日 被 Tiobe（ 闻 名 于 它 的 编 程 语 言 流 行 程 度 排 名） 宣 布 为“ 2009 年 年 度 语 言” 后， 引 起 各 界 很 大 的 反 响。 目 前 Go 语 言 在 这 项 排 名 中 的 最 高 记 录 是 在 2010 年 2 月 创 下 的 第 13 名， 流 行 程 度 1778%。

目前截至至18-12-12日，Go语言排名如下

为什么Go语言是这样的

正 如“ 21 世 纪 的 C 语 言” 这 句 话 所 说， Go 语 言 并 不 是 凭 空 而 造 的， 而 是 和 C + +、 Java 和 C# 一 样 属 于 C 系。 不 仅 如 此， 设 计 者 们 还 汲 取 了 其 它 编 程 语 言 的 精 粹 部 分 融 入 到 Go 语 言 当 中。

在 声 明 和 包 的 设 计 方 面， Go 语 言 受 到 Pascal、 Modula 和 Oberon 系 语 言 的 影 响；

在 并 发 原 理 的 设 计 上， Go 语 言 从 同 样 受 到 Tony Hoare 的 CSP（ 通 信 序 列 进 程 Communicating Squential Processes） 理 论 影 响 的 Limbo 和 Newsqueak 的 实 践 中 借 鉴 了 一 些 经 验， 并 使 用 了 和 Erlang 类 似 的 机 制。

这 是 一 门 完 全 开 源 的 编 程 语 言， 因 为 它 使 用 BSD 授 权 许 可， 所 以 任 何 人 都 可 以 进 行 商 业 软 件 的 开 发 而 不 需 要 支 付 任 何 费 用。

尽 管 为 了 能 够 让 目 前 主 流 的 开 发 者 们 能 够 对 Go 语 言 中 的 类 C 语 言 的 语 法 感 到 非 常 亲 切 而 易 于 转 型， 但 是 它 在 极 大 程 度 上 简 化 了 这 些 语 法， 使 得 它 们 比 C/ C + + 的 语 法 更 加 简 洁 和 干 净。

同 时， Go 语 言 也 拥 有 一 些 动 态 语 言 的 特 性， 这 使 得 使 用 Python 和 Ruby 的 开 发 者 们 在 使 用 Go 语 言 的 时 候 感 觉 非 常 容 易 上 手。

为什么要有Go语言

C/ C + + 的 发 展 速 度 无 法 跟 上 计 算 机 发 展 的 脚 步， 十 多 年 来 也 没 有 出 现 一 门 与 时 代 相 符 的 主 流 系 统 编 程 语 言， 因 此 人 们 需 要 一 门 新 的 系 统 编 程 语 言 来 弥 补 这 个 空 缺， 尤 其 是 在 计 算 机 信 息 时 代。

对 比 计 算 机 性 能 的 提 升， 软 件 开 发 领 域 不 被 认 为 发 展 地 足 够 快 或 者 比 硬 件 发 展 更 加 成 功（ 有 许 多 项 目 均 以 失 败 告 终）， 同 时 应 用 程 序 的 体 积 始 终 在 不 断 地 扩 大， 这 就 迫 切 地 需 要 一 门 具 备 更 高 层 次 概 念 的 低 级 语 言 来 突 破 现 状。 

在 Go 语 言 出 现 之 前， 开 发 者 们 总 是 面 临 非 常 艰 难 的 抉 择， 究 竟 是 使 用 执 行 速 度 快 但 是 编 译 速 度 并 不 理 想 的 语 言（ 如： C + +）， 还 是 使 用 编 译 速 度 较 快 但 执 行 效 率 不 佳 的 语 言（ 如：. NET、 Java）， 或 者 说 开 发 难 度 较 低 但 执 行 速 度 一 般 的 动 态 语 言 呢？ 显 然， Go 语 言 在 这 3 个 条 件 之 间 做 到 了 最 佳 的 平 衡： 快 速 编 译， 高 效 执 行， 易 于 开 发。

Go语言的设计原则

Go 语 言 通 过 减 少 关 键 字 的 数 量（ 25 个） 来 简 化 编 码 过 程 中 的 混 乱 和 复 杂 度。 干 净、 整 齐 和 简 洁 的 语 法 也 能 够 提 高 程 序 的 编 译 速 度， 因 为 这 些 关 键 字 在 编 译 过 程 中 少 到 甚 至 不 需 要 符 号 表 来 协 助 解 析。 这 些 方 面 的 工 作 都 是 为 了 减 少 编 码 的 工 作 量， 甚 至 可 以 与 Java 的 简 化 程 度 相 比 较。

Go 语 言 有 一 种 极 简 抽 象 艺 术 家 的 感 觉， 因 为 它 只 提 供 了 一 到 两 种 方 法 来 解 决 某 个 问 题， 这 使 得 开 发 者 们 的 代 码 都 非 常 容 易 阅 读 和 理 解。 众 所 周 知， 代 码 的 可 读 性 是 软 件 工 程 里 最 重 要 的 一 部 分（ 译 者 注： 代 码 是 写 给 人 看 的， 不 是 写 给 机 器 看 的 ）。 这 些 设 计 理 念 没 有 建 立 其 它 概 念 之 上， 所 以 并 不 会 因 为 牵 扯 到 一 些 概 念 而 将 某 个 概 念 复 杂 化， 他 们 之 间 是 相 互 独 立 的。

Go语言的特征

Go 语 言 从 本 质 上（ 程 序 和 结 构 方 面） 来 实 现 并 发 编 程。 因 为 Go 语 言 没 有 类 和 继 承 的 概 念， 所 以 它 和 Java 或 C + + 看 起 来 并 不 相 同。 但 是 它 通 过 接 口（ interface） 的 概 念 来 实 现 多 态 性。

Go 语 言 有 一 个 清 晰 易 懂 的 轻 量 级 类 型 系 统， 在 类 型 之 间 也 没 有 层 级 之 说。 因 此 可 以 说 这 是 一 门 混 合 型 的 语 言。 在 传 统 的 面 向 对 象 语 言 中， 使 用 面 向 对 象 编 程 技 术 显 得 非 常 的 臃 肿， 它 们 总 是 通 过 复 杂 的 模 式 来 构 建 庞 大 的 类 型 层 级， 这 违 背 了 编 程 语 言 应 该 提 升 生 产 力 的 宗 旨。

函 数 是 Go 语 言 中 的 基 本 构 件， 它 们 的 使 用 方 法 非 常 灵 活。 在 第 六 章， 我 们 会 看 到 Go 语 言 在 函 数 式 编 程 方 面 的 基 本 概 念。 Go 语 言 使 用 静 态 类 型， 所 以 它 是 类 型 安 全 的 一 门 语 言， 加 上 通 过 构 建 到 本 地 代 码， 程 序 的 执 行 速 度 也 非 常 快。

作 为 强 类 型 语 言， 隐 式 的 类 型 转 换 是 不 被 允 许 的， 记 住 一 条 原 则： 让 所 有 的 东 西 都 是 显 式 的。 Go 语 言 其 实 也 有 一 些 动 态 语 言 的 特 性（ 通 过 关键 字 var）， 所 以 它 对 那 些 逃 离 Java 和 .Net 世 界 而 使 用 Python、 Ruby、 PHP 和 Javascript 的 开 发 者 们 也 具 有 很 大 的 吸 引 力。

Go 语 言 支 持 交 叉 编 译， 比 如 说 你 可 以 在 运 行 Linux 系 统 的 计 算 机 上 开 发 运 行 下 Windows 下 运 行 的 应 用 程 序。 这 是 第 一 门 完 全 支 持 UTF-8 的 编 程 语 言， 这 不 仅 体 现 在 它 可 以 处 理 使 用 UTF-8 编 码 的 字 符 串， 就 连 它 的 源 码 文 件 格 式 都 是 使 用 的 UTF-8 编 码。 Go 语 言 做 到 了 真 正 的 国 际 化！

Go语言的用途

Go 语 言 被 设 计 成 一 门 应 用 于 搭 载 Web 服 务 器， 存 储 集 群 或 类 似 用 途 的 巨 型 中 央 服 务 器 的 系 统 编 程 语 言。 对 于 高 性 能 分 布 式 系 统 领 域 而 言， Go 语 言 无 疑 比 大 多 数 其 它 语 言 有 着 更 高 的 开 发 效 率。 它 提 供 了 海 量 并 行 的 支 持， 这 对 于 游 戏 服 务 端 的 开 发 而 言 是 再 好 不 过 了。

Go 语 言 一 个 非 常 好 的 目 标 就 是 实 现 所 谓 的 复 杂 事 件 处 理（ CEP）， 这 项 技 术 要 求 海 量 并 行 支 持， 高 度 的 抽 象 化 和 高 性 能。 当 我 们 进 入 到 物 联 网 时 代， CEP 必 然 会 成 为 人 们 关 注 的 焦 点。

但 是 Go 语 言 同 时 也 是 一 门 可 以 用 于 实 现 一 般 目 标 的 语 言， 例 如 对 于 文 本 的 处 理， 前 端 展 现， 甚 至 像 使 用 脚 本 一 样 使 用 它。

值 得 注 意 的 是， 因 为 垃 圾 回 收 和 自 动 内 存 分 配 的 原 因， Go 语 言 不 适 合 用 来 开 发 对 实 时 性 要 求 很 高 的 软 件。

越 来 越 多 的 谷 歌 内 部 的 大 型 分 布 式 应 用 程 序 都 开 始 使 用 Go 语 言 来 开 发， 例 如 谷 歌 地 球 的 一 部 分 代 码 就 是 由 Go 语 言 完 成 的。

Go语言的强大之处

简 化 问 题， 易 于 学 习

内 存 管 理， 简 洁 语 法， 易 于 使 用

快 速 编 译， 高 效 开 发

高 效 执 行

并 发 支 持， 轻 松 驾 驭 静 态 类 型

标 准 类 库， 规 范 统 一

易 于 部 署

文 档 全 面

免 费 开 源

Go语言的性能

根 据 Go 开 发 团 队 和 基 本 的 算 法 测 试， Go 的 性 能 大 概 在 C 语 言 的 10% ~ 20% 之 间（ 译 者 注： 由 于 出 版 时 间 限 制， 该 数 据 应 为 2013 年 3 月 28 日 之 前 产 生 ）。

虽 然 没 有 官 方 的 性 能 标 准， 但 是 与 其 它 各 个 语 言 相 比 已 经 拥 有 非 常 出 色 的 表 现。 如 果 说 Go 语 言 的 执 行 效 率 大 约 比 C + + 慢 20% 也 许 更 有 实 际 意 义。

保 守 估 计 在 相 同 的 环 境 和 执 行 目 标 的 情 况 下， Go 程 序 比 Java 或 Scala 应 用 程 序 要 快 上 2 倍， 并 比 这 两 门 语 言 使 用 少 占 用 70% 的 内 存。

在 很 多 情 况 下 这 种 比 较 是 没 有 意 义 的， 因 为 像 谷 歌 这 样 拥 有 成 千 上 万 台 服 务 器 的 公 司 都 抛 弃 C + + 而 开 始 将 Go 用 于 生 产 环 境 已 经 足 够 说 明 它 本 身 所 具 有 的 优 势。

时 下 流 行 的 语 言 大 都 是 运 行 在 虚 拟 机 上， 如： Java 和 Scala 使 用 的 JVM， C# 和 VB.NET 使 用 的 .NET CLR。 尽 管 虚 拟 机 的 性 能 已 经 有 了 很 大 的 提 升， 但 任 何 使 用 JIT 编 译 器 和 脚 本 语 言 解 释 器 的 编 程 语 言（ Ruby、 Python、 Perl 和 Javascript） 在 C 和 C + + 的 绝 对 优 势 下 甚 至 都 无 法 在 性 能 上 望 其 项 背。

如 果 说 Go 比 C + + 要 慢 20%， 那 么 Go 就 要 比任 何 非 静 态 和 编 译 型 语 言 快 2 到 10 倍， 并 且 能 够 更 加 高 效 地 使 用 内 存。

其 实 比 较 多 门 语 言 之 间 的 性 能 是 一 种 非 常 猥 琐 的 行 为， 因 为 任 何 一 种 语 言 都 有 其 所 擅 长 和 薄 弱 的 方 面。 例 如 在 处 理 文 本 方 面， 那 些 只 处 理 纯 字 节 的 语 言 显 然 要 比 处 理 Unicode 这 种 更 为 复 杂 编 码 的 语 言 要 出 色 的 多。

有 些 人 可 能 认 为 使 用 两 种 不 同 的 语 言 实 现 同 一 个 目 标 能 够 得 出 正 确 的 结 论， 但 是 很 多 时 候 测 试 者 可 能 对 一 门 语 言 非 常 了 解 而 对 另 一 门 语 言 只 是 大 概 明 白， 测 试 者 对 程 序 编 写 的 手 法 在 一 定 程 度 也 会 影 响 结 果 的 公 平 性， 因 此 测 试 程 序 应 该 分 别 由 各 自 语 言 的 擅 长 者 来 编 写， 这 样 才 能 得 到 具 有 可 比 性 的 结 果。

另 外， 像 在 统 计 学 方 面， 人 们 很 难 避 免 人 为 因 素 对 结 果 的 影 响， 所 以 这 在 严 格 意 义 上 并 不 是 科 学。 还 要 注 意 的 是， 测 试 结 果 的 可 比 性 还 要 根 据 测 试 目 标 来 区 别， 例 如 很 多 发 展 十 多 年 的 语 言 已 经 针 对 各 类 问 题 拥 有 非 常 成 熟 的 类 库， 而 作 为 一 门 新 生 语 言 的 Go 语 言， 并 没 有 足 够 的 时 间 来 推 导 各 类 问 题 的 最 佳 解 决 方 案。

比 较 Go 和 Python 在 简 单 的 web 服 务 器方 面 的 性 能， 单 位 为 传 输 量 每 秒： 原 生 的 Go http 包 要 比 web.py 快 7 至 8 倍， 如 果 使 用 web.go 框 架 则 稍 微 差 点， 比 web.py 快 6 至 7 倍。 在 Python 中 被 广 泛 使 用 的 tornado 异 步 服 务 器 和 框 架 在 web 环 境 下 要 比 web.py 快 很 多， Go 大 概 只 比 它 快 1.2 至 1.5 倍

Go 和 Python 在 一 般 开 发 的 平 均 水 平 测 试 中， Go 要 比 Python 3 快 25 倍 左 右， 少 占 用 三 分 之 二 的 内 存， 但 比 Python 大 概 多 写 一 倍 的 代 码

根 据 Robert Hundt（ 2011 年 6 月） 的 文 章 对 C + +、 Java、 Go 和 Scala， 以 及 Go 开 发 团 队 的 反 应， 可 以 得 出 以 下 结 论：

　　 Go 和 Scala 之 间 具 有 更 多 的 可 比 性（ 都 使 用 更 少 的 代 码）， 而 C + + 和 Java 都 使 用 非 常 冗 长 的 代 码。

　　Go 的 编 译 速 度 要 比 绝 大 多 数 语 言 都 要 快， 比 Java 和 C + + 快 5 至 6 倍， 比 Scala 快 10 倍。

　　Go 的 二 进 制 文 件 体 积 是 最 大 的（ 每 个可 执 行 文 件 都 包 含 runtime）。

　　在 最 理 想 的 情 况 下， Go 能 够 和 C + + 一 样 快， 比 Scala 快 2 至 3 倍， 比 Java 快 5 至 10 倍。

　　Go 在 内 存 管 理 方 面 也 可 以 和 C + + 相 媲 美， 几 乎 只 需 要 Scala 所 使 用 的 一 半， 比 Java 少 4 倍 左 右。

Go语言关键字/标识符

关键字的定义我想应该不用说了，我们直接一步到位

下面粘贴出Go中的25个关键字

下面是36个标识符