Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
Feature Requests
FAQ
Register
Log In
TESTSort
(version: 0)
Benchmark.js
Comparing performance of:
JS vs Typed
Created:
2 years ago
by:
Guest
Go to the latest result
Script Preparation code:
var nums = Array.from({length: 40}, () => Math.random() * 100 |0) var unums = new Uint16Array(nums);
Tests:
JS
nums.sort((x,y) => x-y)
Typed
unums.sort((x,y) => x-y)
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (2)
Previous results
Fork
Test case name
Result
JS
Typed
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
2 years ago
)
User agent:
Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:126.0) Gecko/20100101 Firefox/126.0
Browser/OS:
Firefox 126 on Mac OS X 10.15
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=515169" width="100%" height="500px"></iframe>
JS
5.1M/s
Typed
1.8M/s
View exact numbers
Test name
Executions per second
✓
JS
5,119,982 Ops/sec
Typed
1,811,647 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's break down the benchmark and explain what's being tested. **Benchmark Overview** The benchmark, named "TESTSort", tests the performance of sorting algorithms on two types of arrays: regular JavaScript arrays (`nums`) and Typed Arrays (`unums`). In this case, we're comparing the performance of a simple bubble sort algorithm implemented using a compare function. **Script Preparation Code** The script preparation code generates an array of random numbers between 0 and 100 for the `nums` variable. It then creates a new instance of `Uint16Array`, which is a typed array, from the generated numbers in `nums`. **HTML Preparation Code** There's no HTML preparation code provided, so we'll skip that part. **Individual Test Cases** We have two test cases: 1. **JS**: This test case uses a regular JavaScript array (`nums`) and tests the performance of the sorting algorithm implemented using a compare function. 2. **Typed**: This test case uses a Typed Array (`unums`) and also tests the same sorting algorithm as before. **Library and Purpose** In this benchmark, we're not explicitly using any external libraries or frameworks. However, we are using JavaScript's built-in `Array` and `Uint16Array` constructors, which are part of the standard library. **Special JS Features/Syntax** There doesn't seem to be any special JavaScript features or syntax being used in this benchmark. It's a straightforward implementation of bubble sort using compare functions. **Pros and Cons of Different Approaches** In general, comparing performance between regular JavaScript arrays and Typed Arrays can help developers understand the benefits of using typed arrays for certain types of data. Here are some pros and cons: * **Regular JavaScript Arrays:** + Pros: - Easier to work with, as they're more versatile and flexible. - More memory-efficient for smaller datasets. + Cons: - Slower performance due to the overhead of dynamic typing. * **Typed Arrays:** + Pros: - Faster performance, especially for larger datasets or numerically-intensive operations. - More memory-efficient, as they're designed specifically for storing numeric data. + Cons: - Less flexible and less suitable for storing non-numerical data. **Other Alternatives** If we were to explore other alternatives, we might consider testing: * Other sorting algorithms (e.g., quicksort, mergesort) to see which one performs best in this specific scenario. * Different data types or structures (e.g., objects, sets) to understand how they affect performance. * External libraries or frameworks that provide optimized implementations of common operations (e.g., caching, parallelization). * Other browsers or environments to see if the results hold up across different platforms and devices. I hope this explanation helps! Let me know if you have any further questions.
Related benchmarks
array vs int32array without conversion
Comments
Confirm delete:
Do you really want to delete benchmark?