Perbandingan Performa Python (Python 3) dengan JavaScript (NodeJS)

Sekarang banyak sekali analyst data yang menentukan python. Dengan data sebesar itu pasti memiliki kecepatan yang luar biasa. Saya mencoba untuk menjalankan kalkulasi data yang cukup besar.

saya memiliki 4 file yang isinya cukup sama. python, JavaScript dan typescript.

file python.py

# Python version
import time
import random

# Inisialisasi matriks dengan ukuran yang sama
size = 50
a = [[0] * size for _ in range(size)]
b = [[0] * size for _ in range(size)]

# Mengisi matriks dengan angka random 0-1
for i in range(size):
    for j in range(size):
        a[i][j] = random.random()
        b[i][j] = random.random()

def matmul(A, B):
    result = [[0] * size for _ in range(size)]
    for i in range(size):
        for j in range(size):
            for k in range(size):
                result[i][j] += A[i][k] * B[k][j]
    return result

# Mengukur waktu eksekusi
start = time.time()

# Melakukan perkalian matriks 200 kali
for _ in range(200):
    result = matmul(a, b)

end = time.time()
execution_time = (end - start) * 1000  # Konversi ke milliseconds
print(f"Waktu eksekusi Python: {execution_time:.2f} ms")

file javascript.js

// JavaScript version
// Inisialisasi matriks dengan ukuran yang sama
const size = 50;
const a = Array(size).fill().map(() => Array(size).fill(0));
const b = Array(size).fill().map(() => Array(size).fill(0));

// Mengisi matriks dengan angka random 0-1
for (let i = 0; i < size; i++) {
    for (let j = 0; j < size; j++) {
        a[i][j] = Math.random();
        b[i][j] = Math.random();
    }
}

function matmul(A, B) {
    const result = Array(size).fill().map(() => Array(size).fill(0));
    for (let i = 0; i < size; i++) {
        for (let j = 0; j < size; j++) {
            for (let k = 0; k < size; k++) {
                result[i][j] += A[i][k] * B[k][j];
            }
        }
    }
    return result;
}

// Mengukur waktu eksekusi
const start = performance.now();

// Melakukan perkalian matriks 200 kali
for (let i = 0; i < 200; i++) {
    const result = matmul(a, b);
}

const end = performance.now();
const executionTime = end - start; // Sudah dalam milliseconds
console.log(`Waktu eksekusi JavaScript: ${executionTime.toFixed(2)} ms`);

file typescript.ts

type Matrix = Array<Array<number>>;

const size = 50;

// Helper function untuk membuat matriks kosong dengan type safety
const createEmptyMatrix = (size: number): Matrix => {
  return Array.from({ length: size }, () =>
    Array.from({ length: size }, () => 0)
  );
};

// Helper function untuk membuat matriks random
const createRandomMatrix = (size: number): Matrix => {
  const matrix = createEmptyMatrix(size);
  for (let i = 0; i < size; i++) {
    for (let j = 0; j < size; j++) {
      matrix[i][j] = Math.random();
    }
  }
  return matrix;
};

// Inisialisasi matriks A dan B dengan nilai random
const a: Matrix = createRandomMatrix(size);
const b: Matrix = createRandomMatrix(size);

const matmul = (A: Matrix, B: Matrix, size: number): Matrix => {
  const result = createEmptyMatrix(size);

  for (let i = 0; i < size; i++) {
    for (let j = 0; j < size; j++) {
      let sum = 0;
      for (let k = 0; k < size; k++) {
        sum += A[i][k] * B[k][j];
      }
      result[i][j] = sum;
    }
  }

  return result;
};

// Fungsi untuk menjalankan benchmark
const runBenchmark = (): void => {
  const start = performance.now();

  for (let i = 0; i < 200; i++) {
    matmul(a, b, size);
  }

  const end = performance.now();
  const executionTime = end - start;
  console.log(`Waktu eksekusi TypeScript: ${executionTime.toFixed(2)} ms`);
};

// Jalankan benchmark
runBenchmark();

export { };

Ketika menjalankan python

python3 --version
Python 3.13.1
python3 python.py 
Waktu eksekusi Python: 4090.41 ms
python3 python.py 
Waktu eksekusi Python: 4013.43 ms
python3 python.py 
Waktu eksekusi Python: 3997.32 ms

Ketika menjalankan javascript

node --version
v20.11.0
node javascript.js 
Waktu eksekusi JavaScript: 305.95 ms
node javascript.js 
Waktu eksekusi JavaScript: 243.81 ms
node javascript.js 
Waktu eksekusi JavaScript: 264.08 ms

Ketika menjalankan typescript

tsx --version
tsx v4.19.2
node v20.11.0
tsx typescript.ts 
Waktu eksekusi TypeScript: 308.83 ms
tsx typescript.ts 
Waktu eksekusi TypeScript: 174.12 ms
tsx typescript.ts 
Waktu eksekusi TypeScript: 192.27 ms

Kesimpulan

dari uji coba di atas bahwa javascript 10x lebih cepat daripada python. Sedangkan typescript diawal lebih berat dikit dan kemudian lebih ringan. tp untuk menentukan mana yg paling performa untuk secara keseluruhan juga belum bisa ditentukan. python sendiri memiliki sangat banyak pengembang untuk ai dan ml yg banyak disupport oleh library-library untuk pengembangan tersebut. berbeda dengan nodejs yg sangat dikit dan sangat terbatas pada library-library yg menyediakan untuk ai dan ml.

Ada yg mau mencoba PHP?

<?php
// PHP version

// Inisialisasi matriks dengan ukuran yang sama
$size = 50;
$a = array_fill(0, $size, array_fill(0, $size, 0));
$b = array_fill(0, $size, array_fill(0, $size, 0));

// Mengisi matriks dengan angka random 0-1
for ($i = 0; $i < $size; $i++) {
    for ($j = 0; $j < $size; $j++) {
        $a[$i][$j] = (float)rand() / (float)getrandmax();
        $b[$i][$j] = (float)rand() / (float)getrandmax();
    }
}

function matmul($A, $B, $size) {
    $result = array_fill(0, $size, array_fill(0, $size, 0));
    for ($i = 0; $i < $size; $i++) {
        for ($j = 0; $j < $size; $j++) {
            for ($k = 0; $k < $size; $k++) {
                $result[$i][$j] += $A[$i][$k] * $B[$k][$j];
            }
        }
    }
    return $result;
}

// Mengukur waktu eksekusi
$start = microtime(true);

// Melakukan perkalian matriks 200 kali
for ($i = 0; $i < 200; $i++) {
    $result = matmul($a, $b, $size);
}

$end = microtime(true);
$execution_time = ($end - $start) * 1000; // Konversi ke milliseconds
printf("Waktu eksekusi PHP: %.2f ms\n", $execution_time);
?>