Which method is faster?
Array Join:
var str_to_split = "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z";
var myarray = str_to_split.split(",");
var output=myarray.join("");
String Concat:
var str_to_split = "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z";
var myarray = str_to_split.split(",");
var output = "";
for (var i = 0, len = myarray.length; i<len; i++){
output += myarray[i];
}
String concatenation is faster in ECMAScript. Here's a benchmark I created to show you:
join is faster. But what people are comparing is creating an array just to join it, vs. doing string concat. Different kettle of fish entirely. –
Senaidasenalda join, or using string concat. jsperf.com/yet-another-array-vs-concat Concat wins with modern engines for performance, and of course has always won for readability/maintainability/debugability. When I tried this 10 years ago, performance was slightly better with arrays. Not so anymore. –
Senaidasenalda array join (fastest!) –
Catalpa From 2011 and into the modern day ...
See the following join rewrite using string concatenation, and how much slower it is than the standard implementation.
// Number of times the standard `join` is faster, by Node.js versions:
// 0.10.44: ~2.0
// 0.11.16: ~4.6
// 0.12.13: ~4.7
// 4.4.4: ~4.66
// 5.11.0: ~4.75
// 6.1.0: Negative ~1.2 (something is wrong with 6.x at the moment)
function join(sep) {
var res = '';
if (this.length) {
res += this[0];
for (var i = 1; i < this.length; i++) {
res += sep + this[i];
}
}
return res;
}
The moral is - do not concatenate strings manually, always use the standard join.
I can definitely say that using Array.join() is faster. I've worked on a few pieces of JavaScript code and sped up performance significantly by removing string manipulation in favor of arrays.
join is way faster when the array of strings already exists. The real comparison would be comparing:
For small number of iteration and strings, it does not matter whether you use push-and-join or concatenate. However, for large number of strings, array push and join seems to be faster in both chrome and firefox.
Here is the code and the test results for 10 to 10 million strings:
Chrome:
strings 10
join-only: 0.01171875 ms
push-join: 0.137939453125 ms
concatenate: 0.01513671875 ms
strings 100
join-only: 0.01416015625 ms
push-join: 0.13427734375 ms
concatenate: 0.0830078125 ms
strings 1000
join-only: 0.048095703125 ms
push-join: 0.47216796875 ms
concatenate: 0.5517578125 ms
strings 10000
join-only: 0.465087890625 ms
push-join: 5.47314453125 ms
concatenate: 4.9619140625 ms
strings 100000
join-only: 7.6240234375 ms
push-join: 57.37109375 ms
concatenate: 67.028076171875 ms
strings 1000000
join-only: 67.666259765625 ms
push-join: 319.3837890625 ms
concatenate: 609.8369140625 ms
strings 10000000
join-only: 824.260009765625 ms
push-join: 3207.129150390625 ms
concatenate: 5959.56689453125 ms
Firefox:
strings 10
join-only: 0ms
push-join: 1ms
concatenate: 0ms
strings 100
join-only: 0ms
push-join: 0ms
concatenate: 0ms
strings 1000
join-only: 0ms
push-join: 1ms
concatenate: 0ms
strings 10000
join-only: 1ms
push-join: 2ms
concatenate: 0ms
strings 100000
join-only: 5ms
push-join: 11ms
concatenate: 8ms
strings 1000000
join-only: 39ms
push-join: 88ms
concatenate: 98ms
strings 10000000
join-only: 612ms
push-join: 1095ms
concatenate: 3249ms
Code to test:
for (var n = 10; n <= 10000000; n*=10) {
var iterations = n;
console.log("strings", iterations);
console.time("push-join");
arr = [];
for (var i = 0; i< iterations; i++) {
arr.push("a b c d e f g h i j k l m");
}
console.time("join-only");
content = arr.join(",");
console.timeEnd("join-only");
console.timeEnd("push-join");
content = "";
console.time("concatenate");
for (var i = 0; i< iterations; i++) {
content += "a b c d e f g h i j k l m";
}
console.timeEnd("concatenate");
}
See code below. Results:
Firefox: push+join is 80% slower than string concat, in regular usage.
Chrome: push+join is 140% slower than string concat, in regular usage.
function test(items = 100, rep = 1000000) {
let str
console.time('concat')
for (let r = 0; r < rep; r++) {
str = ''
for (let i = 0; i < items; i++) {
str += i
}
}
console.timeEnd('concat')
console.time('push+join')
for (let r = 0; r < rep; r++) {
const arr = []
for (let i = 0; i < items; i++) {
arr.push(i)
}
str = arr.join('')
}
console.timeEnd('push+join')
}
It depends:
Array Join is 30% slower
String Concat is 90% slower
According to this Google document titled 'Optimizing JavaScript code' string concat is slower then array join but apparently this is not true for modern Javascript engines.
I made a benchmark for the Fibonacci test example that they used in the document and it shows that concatenating (gluing) the string is almost 4x as fast as using Array join.
Manual concatenation is faster, for a numeric array of fixed length.
Here's a JSPerf test that tests these two operations:
zxy.join('/')
// versus
zxy[0] + '/' + zxy[1] + '/' + zxy[2]
// given the array
zxy = [1, 2, 3]
// resulting in the string '0/1/2'
Results: Using Chrome 64.0.3282.186, Array.join was 46% slower.
Array.join is 71% slower. –
Myosotis i think it is not only performance problem, but memory too
as string is immutable, means every time you concat a string, a extra string create in your memory
but array is mutable, mean it will keep the same memory address
of course it is also depend on languages, in general , array is a better solution
The spread operator, written with three consecutive dots ( ... ), is new in ES6 and gives you the ability to expand, or spread, iterable objects into multiple elements.
const books = ["Don Quixote", "The Hobbit", "Alice in Wonderland", "Tale of Two Cities"];
console.log(...books);Prints: Don Quixote The Hobbit Alice in Wonderland Tale of Two Cities
...rest) arguments. console.log is such an example. However, this does not always answer OP’s question because you may be using a function that only accepts 1 string parameter, in which case the spread operator would fail. –
Savoie © 2022 - 2024 — McMap. All rights reserved.