Benchmark: eval vs new Function vs mathjs (evaluate) vs mathjs (chain)

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/mathjs/6.6.1/math.min.js"></script>

Script Preparation code:

var func = new Function("return 2 * 3");

Tests:

eval
let x = eval("2 * 3");
new Function
let x = func();
mathjs
let x = math.evaluate("2 * 3");
mathjs-chain
let x = math.chain(2).multiply(3)
native multiply
let x = 2 * 3

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
eval
new Function
mathjs
mathjs-chain
native multiply

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):

LLMs can make mistakes. Check important info.

To understand the provided benchmark, let's break down each test case.

**Benchmark Overview**

The `MeasureThat.net` website hosts JavaScript microbenchmarks, allowing users to create and run custom benchmarks. The current benchmark compares the performance of four approaches:

1. `eval`
2. Creating a new `Function` object
3. Using the `mathjs` library for arithmetic operations (both standalone and chained)
4. Native multiplication (using the `*` operator directly)

**Test Cases**

Here's an explanation of each test case:

### 1. `eval`

The first test case uses the built-in `eval` function to evaluate the expression `"2 * 3"`. This approach is generally considered insecure and slow due to its dynamic nature.

Pros: None

Cons:
- Insecure (allows arbitrary code execution)
- Slow compared to other approaches
- Not recommended for production use

### 2. `new Function`

The second test case creates a new `Function` object using the syntax `var func = new Function("return 2 * 3");`. This approach is often used as a workaround for security concerns, but it's still slower than native code.

Pros:
- Less insecure than `eval`
- Still slower than native code

Cons:
- Inefficient (creates an extra function object)
- May introduce additional overhead due to the function creation process

### 3. `mathjs` (evaluate)

The third test case uses the `mathjs` library for arithmetic operations, specifically with the `evaluate()` method. This approach leverages a dedicated math library.

Pros:
- Fast and efficient
- Uses a specialized math library optimized for performance

Cons:
- Requires an external dependency (the `mathjs` library)
- May have additional overhead due to the library's initialization process

### 4. `mathjs-chain`

The fourth test case uses the `mathjs` library, but this time with the `chain()` method, which allows for more efficient and expressive math operations.

Pros:
- Faster than standalone `evaluate()`
- More flexible and expressive (using a chaining syntax)

Cons:
- Still requires an external dependency (the `mathjs` library)
- May have additional overhead due to the library's initialization process

### 5. Native Multiply (`2 * 3`)

The final test case uses native multiplication, which is the most straightforward and efficient way to perform arithmetic operations.

Pros:
- Fastest option
- Requires no external dependencies or setup
- Most straightforward syntax

Cons:
- Limited to simple arithmetic operations (no built-in functions like `sqrt()`)
- May not be as expressive as other options (e.g., `mathjs-chain`)

**Library: Math.js**

The `mathjs` library is a JavaScript port of the popular Python math library, NumPy. It provides an extensive set of mathematical functions and operations, including support for matrix calculations, statistics, and more.

Pros:
- Provides a wide range of mathematical functions and operations
- Optimized for performance

Cons:
- Requires additional setup and initialization (loading the library)
- May have overhead due to the library's complexity

**Special JavaScript Feature/ Syntax**

There is no special JavaScript feature or syntax mentioned in this benchmark. However, it's worth noting that some modern JavaScript features, such as `async/await` and `class` expressions, are not included in this benchmark.

**Alternatives**

If you're interested in exploring alternative approaches for similar benchmarks, here are a few options:

* Using the `ArithmeticError` library: This is another popular math library for JavaScript that provides a range of mathematical functions and operations.
* Implementing custom arithmetic operations using WebAssembly (WASM): If you want to optimize your performance further, you could consider implementing custom arithmetic operations using WASM, which allows for native code execution in the browser.

Keep in mind that each approach has its own trade-offs, and the choice ultimately depends on your specific use case and requirements.

Latest run results:

Run details: (Test run date: 11 days ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36

Browser/OS: Chrome 130 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
eval	4652781.5 Ops/sec
new Function	20829394.0 Ops/sec
mathjs	816201.7 Ops/sec
mathjs-chain	6604167.0 Ops/sec
native multiply	126167640.0 Ops/sec

Related benchmarks:

eval vs new Function vs mathjs (evaluate) vs mathjs (chain) (version: 0)

Comparing performance of: eval vs new Function vs mathjs vs mathjs-chain vs native multiply

Created: 2 years ago by: Guest

Jump to the latest result

eval

new Function

mathjs

mathjs-chain

native multiply

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):