Array.join() is really slow and has array memory allocation overhead... inste...

Array.join() is really slow and has array memory allocation overhead... instead concat the 
strings similar to str += "...";

[Christian Plesner Hansen, 2009-10-02 05:47:12]

I think avoiding join is good since join comes with all sorts of overhead. 
However, the approach of adding strings together like this results in a linked
chain of string segments rather than a single flat string.  This makes concat
very cheap if you don't use the result but adds a cost to the next operation
that uses the string since it has to flatten it first.  I would suggest using a
StringBuilder instead for concatenations with more than one argument.

http://codereview.chromium.org/243053/diff/1/2
File src/string.js (right):

http://codereview.chromium.org/243053/diff/1/2#newcode91
Line 91: var this_string = ToString(this);
I would suggest using %StringAdd if len == 1 and using a StringBuilder (se
string.js) if there are more arguments.  That way the result becomes a flat
string rather than a chain of conses which we will have to flatten later.

[kenny, 2009-10-02 22:11:58]

hey thanks for the review!

I actually thought about using the StringBuilder, but because of the array
operations to do a StringBuilder (and the fact that I do not know if the concat
function is being called inside of a loop), I opted to just simply go with a
concat operation and delay the overhead of the flattening until everything is
done.

I don't know how to attach a file here, but my benchmarks show that even in the
case where there is a .concat() with like 20 arguments - probably very unlikely
but would be a really good case for a stringbuilder, because of the array
overhead, it's actually slower. which also tells me that StringBuilder could
probably be optimized somehow :)

[Christian Plesner Hansen, 2009-10-03 06:00:41]

I think waiting to flatten until everything is done sounds reasonable.  Just
note that when using StringAdd the string won't be flattened until the first
time it is used, whereas with the string builder the string is flattened when it
is returned from concat.  If your benchmarks doesn't use the string after
creating it (say by reading the last character) the results are misleading since
the cost won't include the flattening.

On the other hand if concat'ing 20 strings together and reading the last
character is faster with a StringAdd based concat than a StringBuilder then I
agree it's better to use StringAdd.

[kenny, 2009-10-03 07:30:28]

On 2009/10/03 06:00:41, Christian Plesner Hansen wrote:
> I think waiting to flatten until everything is done sounds reasonable.  Just
> note that when using StringAdd the string won't be flattened until the first
> time it is used, whereas with the string builder the string is flattened when
it
> is returned from concat.  If your benchmarks doesn't use the string after
> creating it (say by reading the last character) the results are misleading
since
> the cost won't include the flattening.
> 
> On the other hand if concat'ing 20 strings together and reading the last
> character is faster with a StringAdd based concat than a StringBuilder then I
> agree it's better to use StringAdd.

well, here's the benchmark I used:

var t1 = new Date().getTime();
lala = "hello";
for(var i = 0; i < 50000; i++) {
	lala = lala + "a" + "a" + "a" + "a" + "a" + "a" + "a" + "a" + "a" + "a" + "a" +
"a" + "a" + "a" + "a" + "a" + "a" + "a" + "a" + "a";
	lala.charAt(lala.length-1);
}

print((new Date().getTime() - t1) + 'ms');

//------------

var t1 = new Date().getTime();
lala = "hello";
for(var i = 0; i < 50000; i++) {
	lala = lala.concat("a", "a", "a", "a", "a", "a", "a", "a", "a", "a", "a", "a",
"a", "a", "a", "a", "a", "a", "a", "a");
	lala.charAt(lala.length-1);
}

print((new Date().getTime() - t1) + 'ms');


this reveals:

(1 string - not shown)
134ms (baseline)
120ms (concat using StringAdd)
807ms (concat using StringBuilder)

(20 strings - shown)
74ms (baseline - is actually faster, because it's affected by my other pending
patch)
877ms (concat using StringAdd)
35201ms (concat using StringBuilder)