Benchmark: array from vs substring to get fisr element of a string

Script Preparation code:

const s = "blablabla@mail.com"

Tests:

first
Array.from("blablabla@mail.com")[0].toUpperCase()
second
"blablabla@mail.com".substring(0,1).toUpperCase()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
first
second

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's break down what's being tested in this benchmark.

**What is being tested?**

The benchmark is testing the performance of two approaches to get the first character of a string:

1. `Array.from("blablabla@mail.com")[0].toUpperCase()`
2. `"blablabla@mail.com".substring(0,1).toUpperCase()` (also known as `slice` method)

**Options compared**

The benchmark is comparing the performance of these two approaches.

Pros and Cons:

1. **Using Array.from**: This approach uses a modern JavaScript feature called `Array.from`, which creates a new array from an iterable (in this case, a string). The pros are:
	* It's concise and easy to read.
	* It's a relatively new feature, so it might be optimized by the browser.
However, the cons are:
	* It creates a new array object, which can lead to additional memory allocation and garbage collection overhead.
2. **Using `substring` method**: This approach uses an older JavaScript method called `substring`, which returns a subset of characters from a string. The pros are:
	* It's more efficient in terms of memory allocation, since it doesn't create a new array object.
However, the cons are:
	* It's less concise and harder to read than `Array.from`.
3. **Using `slice` method**: This approach uses another older JavaScript method called `slice`, which returns a subset of characters from a string. The pros and cons are similar to those for `substring`.

**Other considerations**

1. **String encoding**: Both approaches assume that the input string is encoded in UTF-8, which is likely the case for most web content.
2. **Browser optimizations**: Modern browsers like Firefox 101 might optimize these approaches or use internal caching to improve performance.

**Library and special JS features**

There are no libraries used in this benchmark.

**Special JS feature: None**

The benchmark does not use any special JavaScript features, such as `let` or `const`, which are introduced in ECMAScript 2015 (ES6).

**Other alternatives**

If you wanted to test the performance of these approaches using a different method, you could try:

1. Using `String.prototype.charAt()` instead of `Array.from`.
2. Using `String.prototype.slice()` instead of `substring` or `slice`.
3. Creating an array from scratch and then extracting the first character.

Keep in mind that these alternatives might not provide comparable results, as they may introduce additional overhead or changes to the browser's optimization strategy.

Related benchmarks:

array from vs substring to get fisr element of a string (version: 0)

test

Comparing performance of: first vs second

Created: 3 years ago by: Guest

Jump to the latest result

first

second

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):