Lazy developers, Stack concept, and the fastest, unobtrusive, JavaScript StringBuilder

Fast Web, and lazy developers

About 1 month ago, I have posted a little piece of code that, in some way, could be a little revolution for JavaScript 3rd edition, and every kind of library.
I explained how to use native Array methods with an object, to extend Array itself, or simply create a Stack behaviour, compatible with every used browser.
Few comments a part, in both Ajaxian and this site, it seems that nobody had enough fantasy to use that tricky piece of code to create every kind of Stack based constructor, library, or Iterator, without destroying the native Array.prototype. So, here I am, with another little piece of code that uses the same Stack concept to create a StringBuilder constructor.

The Fastest Unobtrusive JavaScript StringBuilder

A common problem with JavaScript and, specially, Internet Explorer, is string concatenation.
You can find every kind of benchmark, even in IEBlog, about string concatenation problems.
IE Team seems to suggest the usage of an Array, because it is much faster than plus operator, i.e.

"a" + "b" + "c"
// slower than
["a", "b", "c"].join("")

Different libraries, and different developers, use daily a StringBuilder like constructor, to perform string concatenation and finally create resulted string.

You can find different implementation, and someone is better for some feature than another one, but every implementation is not using the Stack constructor trick:

function StringBuilder(){
    // (C) Andrea Giammarchi - Mit Style License
    if(arguments.length)
        this.append.apply(this, arguments);
};
StringBuilder.prototype = function(){
    var join = Array.prototype.join,
        slice = Array.prototype.slice,
        RegExp = /\{(\d+)\}/g,
        toString = function(){return join.call(this, "")};
    return {
        constructor:StringBuilder,
        length:0,
        append:Array.prototype.push,
        appendFormat:function(String){
            var i = 0, args = slice.call(arguments, 1);
            this.append(RegExp.test(String) ?
                String.replace(RegExp, function(String, i){return args[i]}):
                String.replace(/\?/g, function(){return args[i++]})
            );
            return  this;
        },
        size:function(){return this.toString().length},
        toString:toString,
        valueOf:toString
    }
}();

Above constructor is fast as is Array one, when you use them to push values inside the stack. In few words, there's nothing faster to do this simple task, than a native method as push is.

var str = new StringBuilder("a", "b", "c");
str.append("de", "f");
alert(str.length); // 5
alert(str.size()); // 6, the length of the string
alert(str); // abcdef

You can use a StringBuilder instance inside append method without problems, as you can use plus operator to simply create a String, even if it does not make sense

alert(new StringBuilder("abc") + new StringBuilder("def"));
(str = new StringBuilder("abc")).append(new StringBuilder("def"));
alert(str);

Finally, you can use a simplified version of the appendFormat method too:

alert(
    new StringBuilder("a", "b", "c").
    appendFormat("{0}{1}{0}", 0, 1).
    appendFormat("???", 1, 2, 3)
);
// abc010123

What's next?

We can use Stack and/or ArrayObject constructors, or concepts, to literally create every kind of FILO/LIFO/LILO/FIFO based constructor, and without modifying the native Array.prototype.
It is simply up to you, but what I am already working over is:

• a generic Collection constructor, with predefined Type (new Collection(Person), to have a Collection of Persons, for example)


• a Matrix manager, which aim is to become the fastest one, with JavaScript


• something else ... so please, stay tuned ;)