Penandaarasan dalam Node.js vs Deno: Perbandingan Komprehensif

class Benchmark {
  constructor(name, fn, options = {}) {
    this.name = name;
    this.fn = fn;
    this.options = options;
    this.results = [];
  }

  async run() {
    const { async = false, iterations = 1000 } = this.options;
    const results = [];

    // Warmup
    for (let i = 0; i < 10; i++) {
      async ? await this.fn() : this.fn();
    }

    // Main benchmark
    for (let i = 0; i < iterations; i++) {
      const start = process.hrtime.bigint();
      async ? await this.fn() : this.fn();
      const end = process.hrtime.bigint();
      results.push(Number(end - start)); // Nanoseconds
    }

    // Sort results to calculate metrics
    results.sort((a, b) => a - b);
    this.results = {
      avg: results.reduce((sum, time) => sum + time, 0) / iterations,
      min: results[0],
      max: results[results.length - 1],
      p75: results[Math.ceil(iterations * 0.75) - 1],
      p99: results[Math.ceil(iterations * 0.99) - 1],
      p995: results[Math.ceil(iterations * 0.995) - 1],
      iterPerSec: Math.round(
        1e9 / (results.reduce((sum, time) => sum + time, 0) / iterations)
      ),
    };
  }

  getReportObject() {
    const { avg, min, max, p75, p99, p995, iterPerSec } = this.results;
    return {
      Benchmark: this.name,
      "time/iter (avg)": `${(avg / 1e3).toFixed(1)} ns`,
      "iter/s": iterPerSec,
      "(min … max)": `${(min / 1e3).toFixed(1)} ns … ${(max / 1e3).toFixed(
        1
      )} ns`,
      p75: `${(p75 / 1e3).toFixed(1)} ns`,
      p99: `${(p99 / 1e3).toFixed(1)} ns`,
      p995: `${(p995 / 1e3).toFixed(1)} ns`,
    };
  }
}

class BenchmarkSuite {
  constructor() {
    this.benchmarks = [];
  }

  add(name, fn, options = {}) {
    const benchmark = new Benchmark(name, fn, options);
    this.benchmarks.push(benchmark);
  }

  async run() {
    const reports = [];

    for (const benchmark of this.benchmarks) {
      await benchmark.run();
      reports.push(benchmark.getReportObject());
    }

    console.log(`\nBenchmark Results:\n`);
    console.table(reports);

    // Optionally, add summaries for grouped benchmarks
    this.printSummary();
  }

  printSummary() {
    const groups = this.benchmarks.reduce((acc, benchmark) => {
      const group = benchmark.options.group;
      if (group) {
        if (!acc[group]) acc[group] = [];
        acc[group].push(benchmark);
      }
      return acc;
    }, {});

    for (const [group, benchmarks] of Object.entries(groups)) {
      console.log(`\nGroup Summary: ${group}`);
      const baseline = benchmarks.find((b) => b.options.baseline);
      if (baseline) {
        for (const benchmark of benchmarks) {
          if (benchmark !== baseline) {
            const factor = (
              baseline.results.avg / benchmark.results.avg
            ).toFixed(2);
            console.log(
              `  ${baseline.name} is ${factor}x faster than ${benchmark.name}`
            );
          }
        }
      }
    }
  }
}

const suite = new BenchmarkSuite();

// Add benchmarks
suite.add("URL parsing", () => new URL("https://nodejs.org"));
suite.add(
  "Async method",
  async () => await crypto.subtle.digest("SHA-256", new Uint8Array([1, 2, 3])),
  { async: true }
);
suite.add("Long form", () => new URL("https://nodejs.org"));
suite.add("Date.now()", () => Date.now(), { group: "timing", baseline: true });
suite.add("performance.now()", () => performance.now(), { group: "timing" });

// Run benchmarks
suite.run();

node bench.js

Deno.bench("URL parsing", () => {
  new URL("https://deno.land");
});
Deno.bench("Async method", async () => {
  await crypto.subtle.digest("SHA-256", new Uint8Array([1, 2, 3]));
});
Deno.bench({
  name: "Long form",
  fn: () => {
    new URL("https://deno.land");
  },
});
Deno.bench({
  name: "Date.now()",
  group: "timing",
  baseline: true,
  fn: () => {
    Date.now();
  },
});

Deno.bench({
  name: "performance.now()",
  group: "timing",
  fn: () => {
    performance.now();
  },
});

deno bench bench.ts