前情提要

在前两期实验中，我们对比了C、C++、Python、Java、JavaScript(Node.js)、Go、CommonLisp、仓颉、Python2输出一百万个数字的速度。
第1期
第2期

本期实验将本着认真严谨、公平公正的原则， 系统地评判各种语言的性能。

运行任务

和以前一样，输出一百万个数字，每个数字后换行。

语言版本

Common LISP : Steel Bank Common Lisp
C/C++ 编译器 : MinGW 13.10
Python : 2.7.15和3.13
Java : JDK 17.0.7.7
Node.js : 22.14.0
D 编译器 : dmd

代码

Common LISP

1

(setq start (get-internal-real-time))
(loop for i from 0 to 999999
 do (print i))
(setq end (get-internal-real-time))
(setq spent (- end start))
(print spent)

2

(defun main ()
    (defvar start (get-internal-real-time))
    (loop for i from 0 to 999999
     do (print i))
    (defvar end (get-internal-real-time))
    (defvar spent (- end start))
    (print spent)
    (sb-ext:quit))
(sb-ext:save-lisp-and-die "cl.exe" :toplevel #'main :executable t)

C

#include<stdio.h>
#include<time.h>
int main(int argc,char **argv){
	clock_t start=clock();
	int i=0;
	for(;i<1000000;i++){
		printf("%d\n",i);
	}
	clock_t end=clock();
	double spent=(double)(end-start)/CLOCKS_PER_SEC;
	printf("%lfs\n",spent);
}

C++

1

#include<stdio.h>
#include<time.h>
int main(int argc,char *argv[]){
	clock_t start=clock();
	for(int i=0;i<1000000;i++){
		printf("%d\n",i);
	}
	clock_t end=clock();
	double spent=(double)(end-start)/CLOCKS_PER_SEC;
	printf("%lfs\n",spent);
}

2

#include<iostream>
#include<time.h>
using std::cout;
int main(int argc,char *argv[]){
	clock_t start=clock();
	for(int i=0;i<1000000;i++){
		cout<<i<<'\n';
	}
	clock_t end=clock();
	double spent=(double)(end-start)/CLOCKS_PER_SEC;
	cout<<spent<<"s\n";
}

Python2

import time
start=time.time()
for i in xrange(1000000):
    print i 
end=time.time()
spent=end-start
print spent

Python3

import time
start=time.time()
for i in range(1000000):
    print(i)
end=time.time()
spent=end-start
print(spent,'s')

Java

public class JavaCompetition{
    public static void main(String[] args){
        long start=System.currentTimeMillis();
        for(int i=0;i<1000000;i++){
            System.out.println(i);
        }
        long end=System.currentTimeMillis();
        long spent=end-start;
        System.out.println(spent/1000+'s');
    }
}

JavaScript + Node.js

const start=new Date().getTime()
for(let i=0;i<1000000;i++){
    console.log(i)
}
const end=new Date().getTime()
const spent=end-start
console.log(spent/1000,'s')

Golang

package main
import (
	"fmt"
	"time"
)
func main() {
	start := time.Now()
	for i := 0; i < 1000000; i++ {
		fmt.Println(i)
	}
	end := time.Now()
	spent := end.Sub(start)
	fmt.Printf("%s\n", spent)
}

仓颉

main() {
    for(i in 0..1000000){
        println(i)
    }
}

@echo off
call main.exe
echo %time%

D

void main(){
    import std.stdio;
    import core.time;
    auto start = MonoTime.currTime;
    for(int i=0;i<1000000;i++){
        writeln(i);
    }
    auto end = MonoTime.currTime;
    auto duration = end - start;
    writeln(duration.total!"msecs", " ms");
}

Rust

use std::time::Instant;

fn main() {
    let start = Instant::now();
    let mut i=0;
    while i<1000000 {
        println!("{}",i);
        i+=1;
    }
    let duration = start.elapsed();
    println!("{}s", duration.as_millis());
}

MoonBit

fn main {
  for i in 0..<1000000 {
    println("\{i}")
  }
}

@echo off
call moon run Moon.mbt
echo time

编译

sbcl --script Lisp2.lisp
gcc C.c -o c.exe
g++ C++1.cpp -o cpp.exe
g++ C++2.cpp -o cpp2.exe
javac Java.java
rustc Rust.rs
go build Go.go
pyinstaller -F Python.py
cjc CangJie.cj

运行

运行同时打开MemReader.

c.exe
cpp.exe
cl.exe
sbcl --script Lisp.lisp
cpp2
python2 Python2.py
python Python.py
Python.exe
java Java
node JS.js
Go.exe
runcj.cmd
runmbt.cmd

结果

运行结果类似这样：(C语言)

今天不知为何运行格外慢。
时间：351.708s

统计结果

由于C/C++编译器出了问题，故不记录。

语言	时间	程序大小
Python2	111.703000069 s	–
Python	35.495373487472534 s	–
Java	29 s	540B(.class文件)
Node.js	59.337 s	–
Go	31.4393614 s	–
仓颉	371 s	810768B
Common Lisp 1	53.661216 s	–
D	139.560 s	382946B
Rust	73.7 s	5313690B
MoonBit	61 s

不知为啥，今天编译性语言普遍比正常情况慢很多。但是我们应该尊重实验数据。