Der große Performance-Vergleich: JavaScript, Python, Java, Ruby, PHP, C++, C und Bash

Habt ihr euch schon einmal gefragt, welche der populärsten Programmiersprache eigentlich die schnellste bzw. performanteste ist? Um das zu testen, habe ich mir ein kurzes Skript/Programm überlegt, das die Summe aller Zahlen von 0 bis 100000000 in einer Schleife errechnen muss. Das lässt sich als Konsolenausgabe in allen Sprachen umsetzen und braucht einiges an Rechenleistung – also perfekt für einen Vergleich geeignet. Das Ergebnis ist zum Großteil wie erwartet, überrascht aber auch bei manchen Sprachen.

Die Reihenfolge der Ergebnisse ergibt sich übrigens aus populärsten Sprachen aus GitHub.

JavaScript (Node.js 6.11)

View Code JAVASCRIPT
var sum = 0
for (var i = 0; i < 100000000; i++) {
    sum +=i
}
console.log(sum);
$ time node time.js
4999999950000000
 
real	0m0.247s
user	0m0.226s
sys	0m0.017s

Python 3.6

View Code PYTHON
sum = 0
for i in range(100000000):
    sum += i
print(sum)
$ time python time.py
4999999950000000
 
real	0m18.588s
user	0m18.558s
sys	0m0.019s

Java 1.8

public class Time {
        public static void main(String[] args) {
                long sum = 0;
                for(long i = 0; i < 100000000; i++) {
                        sum += i;
                }
                System.out.println(sum);
        }
}
$ time java Time
4999999950000000
 
real	0m0.177s
user	0m0.145s
sys	0m0.025s

Ruby 2.4

#!/usr/bin/ruby
 
sum = 0
for i in 0..99999999
        sum += i
end
puts sum
$ time ruby time.rb
4999999950000000
 
real	0m5.385s
user	0m5.338s
sys	0m0.026s

PHP 7

#!/usr/bin/php
<?php
$sum = 0;
for ($i = 1; $i < 100000000; $i++)
{
        $sum += $i;
}
echo $sum . PHP_EOL;
?>
$ time php time.php
4999999950000000
 
real	0m2.298s
user	0m2.273s
sys	0m0.014s

C++

#include <iostream>
 
using namespace std;
 
int main() {
        long sum = 0;
        for(long i = 0; i < 100000000; i++) {
                sum = sum + i;
        }
        cout << sum << endl;
        return 0;
}
$ time ./time
4999999950000000
 
real	0m0.220s
user	0m0.216s
sys	0m0.002s

C

#include <stdio.h>
 
int main() {
        long sum = 0;
        for(long i = 0; i < 100000000; i++) {
                sum = sum + i;
        }
        printf("%ld\n", sum);
        return 0;
}
$ time ./time
4999999950000000
 
real	0m0.212s
user	0m0.208s
sys	0m0.002s

Bash

Hinweis: Bash ist mit den großen Zahlen leider überfordert. Das Skript arbeitet daher mit einer geringeren Gesamtsumme, kommt aber selbst dort auf eine Laufzeit, die weit über dem Durchschnitt liegt.

#!/bin/bash
sum=0
for i in {0..9999999}; do
    let sum=$sum+$i
done
echo $sum
$ time ./time.sh
49999995000000
 
real	1m59.923s
user	1m55.809s
sys	0m3.687s

Balkendiagramm

Fazit

Dass C, C++ und Java das Feld anführen, ist wenig überraschend.

Allerdings steht mit JavaScript die erste Skriptsprache unmittelbar dahinter und macht damit deutlich, warum sie sich als meistgenutzte Sprache bei GitHub durchgesetzt hat.

PHP schlägt in puncto Performance seine direkten Konkurrenten Python und Ruby mit ordentlichem Abstand.

Bash musste ich wegen des miserablen Ergebnisses sogar aus dem Balkendiagramm herausnehmen.

5 Kommentare zu “Der große Performance-Vergleich: JavaScript, Python, Java, Ruby, PHP, C++, C und Bash

  1. Hat mich erstaunt – Java bei diesem Test schneller als C. Hab das mit Optimierung getestet:

    gcc -O3 time.c -o time
    time ./time
    4999999950000000

    real 0m0.002s
    user 0m0.000s
    sys 0m0.000s

    und die Python Version mit zwei verschiedenen Interpretern (CPython 3.5 und PyPy 2.7)

    time python3 time.py
    4999999950000000

    real 0m12.918s
    user 0m12.760s
    sys 0m0.156s

    time pypy time.py
    4999999950000000

    real 0m0.375s
    user 0m0.368s
    sys 0m0.004s

  2. ca. 2 Millisekunden für C – hat mir keine Ruhe gelassen:
    100 Millionen Loops in 2 ms – entspricht 50 Milliarden in einer Sekunde.
    Das kann nicht sein bei einem Prozessor mit ca. 3 GHz Takt.

    Der Compiler optimiert mit -O3 soweit, dass er schon das Endergebnis berechnet.

    Den For-Loop um Faktor 50 vergrößert verhindert diese Optimierung:

    time ./time
    -5946744076209551616

    real 0m1.812s
    user 0m1.808s
    sys 0m0.000s

    -5946744076209551616 ist nicht falsch, es gibt hier nur einen Überlauf weil sum vorzeichenbehaftet ist, entspricht (12499999997500000000 – 2**64). Die 1812 Millisekunden entsprechen geteilt durch 50 ca.

    30 Millisekunden.

  3. Yezzz Python ist langsam. Mit Numba ein wenig schneller …

    ####
    from numba import jit

    @jit
    def time():
    sum = 0
    for i in range(100000000):
    sum += i
    return sum
    print(time())
    ####

    time python time.py
    4999999950000000

    real 0m0.463s
    user 0m0.393s
    sys 0m0.066s

  4. @Manfred

    obigen Numba Code mit

    5000000000
    =>
    time python time.py
    -5946744076209551616

    real 0m0.474s
    user 0m0.401s
    sys 0m0.068s

    bzw.: * 1000000 … ?!
    500000000000000
    =>
    time python time.py
    634368033788157952

    real 0m0.477s
    user 0m0.404s
    sys 0m0.068s

    ;^)

  5. Habe C/C++ mit Assembler verglichen: Assembler ist 6x schneller als C/C++.

    section .text
    global _start
    _start:
    mov rax, 99999999
    mov rbx, 0
    .loop:
    add rbx, rax
    sub rax, 1
    jne .loop
    mov rax, 60
    mov rdi, 0
    syscall

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.