Benchmark: from vs split - MeasureThat.net

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

/*your preparation JavaScript code goes here
To execute async code during the script preparation, wrap it as function globalMeasureThatScriptPrepareFunction, example:*/
async function globalMeasureThatScriptPrepareFunction() {
    // This function is optional, feel free to remove it.
    // await someThing();
}

Tests:

from
Array.from('something')
split
'something'.split('')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
from
split

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 10 months ago)

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

Browser/OS: Chrome 138 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
from	27381212.0 Ops/sec
split	53762092.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 9 months ago):

LLMs can make mistakes. Check important info.

The benchmark presented compares two different methods for converting a string into an array of characters in JavaScript: `Array.from()` and the `split()` method. Each method has its own advantages and disadvantages, which can impact performance and use cases. Let's break down both approaches:

### Methods Tested

1. **`Array.from('something')`**
   - **Description**: `Array.from()` is a static method that creates a new Array instance from an array-like or iterable object. In this test, it's being used on a string, which is treated as an iterable of characters.
   - **Pros**:
     - Can take a mapping function as a second argument, allowing for transformation of elements during creation.
     - It's designed to work with a broader range of iterable objects, not just strings.
   - **Cons**:
     - Typically exhibits lower performance for simple cases, as shown in the provided benchmarks, which may be due to the additional overhead in handling its broader functionality.
  
2. **`'something'.split('')`**
   - **Description**: The `split()` method is a standard string method that splits a string into an array of substrings based on a specified separator. When an empty string is provided as the separator, it separates the string into individual characters.
   - **Pros**:
     - Generally faster than `Array.from()` for simple cases of converting a string to an array of characters, as indicated by the benchmark results.
     - Straightforward syntax for splitting strings, which may be more familiar to developers.
   - **Cons**:
     - Limited to converting strings and cannot handle other iterable objects directly like `Array.from()` can.

### Benchmark Results

In the latest benchmark results, the `split()` method exhibited a significantly higher performance, with **53,762,092 executions per second**, compared to **27,381,212 executions per second** for `Array.from()`. This suggests that in the context of simply converting a string to an array of characters, the `split()` method performs more efficiently on the tested environment.

### Other Considerations

- **Use Cases**: Developers should consider the specific requirements of their use case when choosing between these two methods. If additional functionality like transformation during array creation is needed, `Array.from()` may be more suitable despite its performance cost.
  
- **Compatibility**: Both methods are well supported in modern JavaScript environments, but if code needs to run in older browsers or environments where `Array.from()` may not be available, it's safer to stick with `split()`.

### Alternatives

There are a few alternatives to consider for converting strings to arrays:

- **Spread Syntax**: Using the spread operator, e.g., `const array = [...'something']`, is a modern and concise way to achieve the same result. Depending on the environment, performance may vary.
  
- **Map Method with `Array.prototype.slice()`**: Converting a string to an array using the `slice()` method in conjunction with `Array.prototype.map()` could also achieve similar results but would likely have similar or worse performance than both tested methods.

In conclusion, the benchmark highlights the performance differences between two commonly used methods for array conversion in JavaScript, with `split()` showing superior performance for the specific case tested. When making a decision, engineers should weigh performance against functionality and choose the approach that best fits their requirements.

Related benchmarks:

from vs split (version: 1)

Comparing performance of: from vs split

Created: 10 months ago by: Guest

Jump to the latest result

from

split

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 9 months ago):