Javascript 我不知道'；我不知道为什么会有'；在我的例子中，JS和Go之间没有太大的性能差异

我刚刚解决了Euler项目中关于除数和三角形数的问题，一次在Go中，一次在JavaScript中。我认为Go中的代码比JS中的代码快得多，因为JS在运行时运行代码，Go构建代码。我知道构建代码并不直接意味着良好的性能，但结果是，即使是JS中的代码有时在不同的条件下也会更快

我使用的代码如下所示

我在我的macbook上测试了它们，规格如下

处理器：2.6 GHz Intel Core i5
内存：8 GB 1600 MHz DDR3

我用下面的命令运行它们

$#js
$node euler12.js

$#开始
$go构建euler12.go
美元/欧盟12

---

我做错什么了吗？如果没有，为什么它们之间没有区别？我还使用Python进行了测试，Go和Python之间有很大的差距。提前感谢。

非常有趣，在我的机器上（macbookpro 2013年底，i7 2.3ghz），JS代码比Go代码快得多：

JS:

去：

但是，在快速优化Go代码之后：

去：

我所说的快速优化（非常幼稚）：并行化计算：

package main

import (
        "fmt"
        "os"
        "runtime"
)

func numberOfDevisor(n int64) int64 {
        var result int64

        var i int64 = 1
        for true {
                if n%i == 0 {
                        opposite := n / i
                        if opposite == i {
                                result++
                                return result
                        } else if opposite > i {
                                result += 2
                        } else {
                                return result
                        }
                }
                i++
        }
        return result
}

func main() {
        var acc int64
        var i int64 = 1

        maxRoutines := runtime.NumCPU()
        c := make(chan struct{}, maxRoutines)
        for i := 0; i < maxRoutines; i++ {
                c <- struct{}{}
        }
        for true {
                <-c
                acc += i
                go func(acc int64) {
                        defer func() { c <- struct{}{} }()
                        if numberOfDevisor(acc) > 1000 {
                                fmt.Println(acc)
                                os.Exit(0)
                        }
                }(acc)
                i++
        }
}

主程序包
进口(
“fmt”
“操作系统”
“运行时”
)
func numberOfDevisor（n int64）int64{
var结果int64
变量i int64=1
真的{
如果n%i==0{
相反：=n/i
如果相反==i{
结果++
返回结果
}否则，如果相反>i{
结果+=2
}否则{
返回结果
}
}
我++
}
返回结果
}
func main（）{
var acc int64
变量i int64=1
maxRoutines:=runtime.numpu（）
c:=make（chan结构{}，maxRoutines）
对于i:=0；ic这是完全相同的代码，一个由Go编译器编译，另一个由Javascript VM的JIT编译。那么：为什么你认为合成的、人工的代码会有很大的不同呢？非常正确，感谢你提到JIT，因为我没有注意到。不过，与Javascript相比，Go是一种低级的静态类型语言，我认为这可能有一些性能优势。另外，我认为Go可能不需要解释过程，这使我期望Go更快。我是否想错了？并且它不是相同的代码，不管代码的形状如何。具体来说：类型不同。一个是在JavaSc中隐式处理浮点双精度例如，Go代码使用的是
int64
s。由于数字类型在JavaScript中是隐式的，因此当一些求值器可以判断它可以使用更便宜的表示形式时，会在表面下切换类型表示形式。例如，V8在知道数字没有那么大时会使用31位小整数。
time GOMAXPROCS=8 ./test
842161320

real    0m7.345s
user    0m7.470s
sys     0m0.010s

time GOMAXPROCS=8 ./test
842161320

real    0m1.760s
user    0m11.610s
sys     0m0.230s

package main

import (
        "fmt"
        "os"
        "runtime"
)

func numberOfDevisor(n int64) int64 {
        var result int64

        var i int64 = 1
        for true {
                if n%i == 0 {
                        opposite := n / i
                        if opposite == i {
                                result++
                                return result
                        } else if opposite > i {
                                result += 2
                        } else {
                                return result
                        }
                }
                i++
        }
        return result
}

func main() {
        var acc int64
        var i int64 = 1

        maxRoutines := runtime.NumCPU()
        c := make(chan struct{}, maxRoutines)
        for i := 0; i < maxRoutines; i++ {
                c <- struct{}{}
        }
        for true {
                <-c
                acc += i
                go func(acc int64) {
                        defer func() { c <- struct{}{} }()
                        if numberOfDevisor(acc) > 1000 {
                                fmt.Println(acc)
                                os.Exit(0)
                        }
                }(acc)
                i++
        }
}