Go对所有文件导入一次依赖项，因此导入时间不会随着项目大小呈指数增长。 更简单的语言学意味着解释它们需要更少的计算。

还有什么?

编译的基本思想实际上非常简单。原则上，递归下降解析器可以以I/O限制的速度运行。代码生成基本上是一个非常简单的过程。符号表和基本类型系统并不需要大量的计算。

然而，降低编译器的速度并不难。

如果存在一个预处理器阶段，其中包含多级包含指令、宏定义和条件编译，尽管这些东西很有用，但加载它并不难。(举个例子，我想到了Windows和MFC头文件。)这就是为什么预编译头文件是必要的。

在优化生成的代码方面，可以向该阶段添加多少处理是没有限制的。

测试编译器翻译效率的一个很好的方法是自编译:给定的编译器编译自己需要多长时间?对于c++来说，这需要很长的时间(几个小时?)相比之下，在现代机器[1]上，Pascal/Modula-2/Oberon编译器将在不到一秒钟的时间内自行编译。

Go一直受到这些语言的启发，但这种效率的一些主要原因包括:

A clearly defined syntax that is mathematically sound, for efficient scanning and parsing. A type-safe and statically-compiled language that uses separate compilation with dependency and type checking across module boundaries, to avoid unnecessary re-reading of header files and re-compiling of other modules - as opposed to independent compilation like in C/C++ where no such cross-module checks are performed by the compiler (hence the need to re-read all those header files over and over again, even for a simple one-line "hello world" program). An efficient compiler implementation (e.g. single-pass, recursive-descent top-down parsing) - which of course is greatly helped by points 1 and 2 above.

这些原则在20世纪70年代和80年代已经在Mesa、Ada、modala -2/Oberon和其他几种语言中被了解并完全实现，直到现在(在2010年代)才被应用到现代语言中，如Go(谷歌)、Swift (Apple)、c# (Microsoft)和其他几种语言中。

让我们希望这将很快成为常态，而不是例外。要实现这一目标，需要做到两件事:

First, software platform providers such as Google, Microsoft and Apple should start by encouraging application developers to use the new compilation methodology, while enabling them to re-use their existing code base. This is what Apple is now trying to do with the Swift programming language, which can co-exist with Objective-C (since it uses the same runtime environment). Second, the underlying software platforms themselves should eventually be re-written over time using these principles, while simultaneously redesigning the module hierarchy in the process to make them less monolithic. This is of course a mammoth task and may well take the better part of a decade (if they are courageous enough to actually do it - which I am not at all sure in the case of Google).

在任何情况下，是平台推动了语言的采用，而不是相反。

引用:

[1] http://www.inf.ethz.ch/personal/wirth/ProjectOberon/PO.System.pdf, page 6: "The compiler compiles itself in about 3 seconds". This quote is for a low cost Xilinx Spartan-3 FPGA development board running at a clock frequency of 25 MHz and featuring 1 MByte of main memory. From this one can easily extrapolate to "less than 1 second" for a modern processor running at a clock frequency well above 1 GHz and several GBytes of main memory (i.e. several orders of magnitude more powerful than the Xilinx Spartan-3 FPGA board), even when taking I/O speeds into account. Already back in 1990 when Oberon was run on a 25MHz NS32X32 processor with 2-4 MBytes of main memory, the compiler compiled itself in just a few seconds. The notion of actually waiting for the compiler to finish a compilation cycle was completely unknown to Oberon programmers even back then. For typical programs, it always took more time to remove the finger from the mouse button that triggered the compile command than to wait for the compiler to complete the compilation just triggered. It was truly instant gratification, with near-zero wait times. And the quality of the produced code, even though not always completely on par with the best compilers available back then, was remarkably good for most tasks and quite acceptable in general.

Go编译器比大多数C/ c++编译器快得多的原因有很多:

Top reason: Most C/C++ compilers exhibit exceptionally bad designs (from compilation speed perspective). Also, from compilation speed perspective, some parts of the C/C++ ecosystem (such as editors in which programmers are writing their code) aren't designed with speed-of-compilation in mind. Top reason: Fast compilation speed was a conscious choice in the Go compiler and also in the Go language The Go compiler has a simpler optimizer than C/C++ compilers Unlike C++, Go has no templates and no inline functions. This means that Go doesn't need to perform any template or function instantiation. The Go compiler generates low-level assembly code sooner and the optimizer works on the assembly code, while in a typical C/C++ compiler the optimization passes work on an internal representation of the original source code. The extra overhead in the C/C++ compiler comes from the fact that the internal representation needs to be generated. Final linking (5l/6l/8l) of a Go program can be slower than linking a C/C++ program, because the Go compiler is going through all of the used assembly code and maybe it is also doing other extra actions that C/C++ linkers aren't doing Some C/C++ compilers (GCC) generate instructions in text form (to be passed to the assembler), while the Go compiler generates instructions in binary form. Extra work (but not much) needs to be done in order to transform the text into binary. The Go compiler targets only a small number of CPU architectures, while the GCC compiler targets a large number of CPUs Compilers which were designed with the goal of high compilation speed, such as Jikes, are fast. On a 2GHz CPU, Jikes can compile 20000+ lines of Java code per second (and the incremental mode of compilation is even more efficient).

简单(用我自己的话说)，因为语法非常容易(分析和解析)

例如，没有类型继承意味着不需要进行有问题的分析，以确定新类型是否遵循基类型施加的规则。

例如，在这个代码示例:"interfaces"中，编译器在分析该类型时不会去检查预期的类型是否实现了给定的接口。只有在它被使用之前(如果它被使用)才会执行检查。

另一个例子，编译器会告诉你你是否声明了一个变量而没有使用它(或者如果你应该持有一个返回值而你没有)

以下代码不能编译:

package main
func main() {
    var a int 
    a = 0
}
notused.go:3: a declared and not used

这种强制和原则使生成的代码更安全，并且编译器不必执行程序员可以执行的额外验证。

总的来说，所有这些细节使语言更容易解析，从而导致快速编译。

再一次，用我自己的话来说。

编译效率是主要的设计目标:

最后，它的目的是要快:在一台计算机上构建一个大型可执行文件最多只需要几秒钟。为了实现这些目标，需要解决一些语言问题:表达性强但轻量级的类型系统;并发性和垃圾回收;刚性依赖规范;等等。常见问题解答

关于与解析相关的特定语言特性，语言常见问题解答非常有趣:

第二，该语言被设计成易于分析，并且可以在没有符号表的情况下进行解析。