Имеет ли JavaScript встроенный класс stringbuilder?

Я только что перепроверил производительность на http://jsperf.com/javascript-concat-vs-join/2. Тестовые случаи объединяются или присоединяются к алфавиту 1000 раз.

в текущих браузерах (FF, Opera, IE11, Chrome) "concat" примерно в 4-10 раз быстрее, чем "join".

в IE8 оба возвращают примерно равные результаты.

в IE7, "присоединиться" примерно в 100 раз быстрее, к сожалению.

нет, нет встроенной поддержки для построения строк. Вместо этого вы должны использовать конкатенацию.

вы можете, конечно, сделать массив из разных частей вашей строки, а затем вызвать join() на этом массиве, но это зависит от того, как соединение реализуется в интерпретаторе JavaScript, который вы используете.

я провел эксперимент, чтобы сравнить скорость str1+str2 метод против array.push(str1, str2).join() метод. Код был прост:

var iIterations =800000;
var d1 = (new Date()).valueOf();
str1 = "";
for (var i = 0; i<iIterations; i++)
    str1 = str1 + Math.random().toString();
var d2 = (new Date()).valueOf();
log("Time (strings): " + (d2-d1));

var d3 = (new Date()).valueOf();
arr1 = [];
for (var i = 0; i<iIterations; i++)
    arr1.push(Math.random().toString());
var str2 = arr1.join("");
var d4 = (new Date()).valueOf();
log("Time (arrays): " + (d4-d3));

Я проверил его в Internet Explorer 8 и Firefox 3.5.5, оба на Windows 7 x64.

вначале я тестировал на небольшом количестве итераций (несколько сотен, несколько тысяч элементов). Результаты были непредсказуемы (иногда конкатенация строк занимала 0 миллисекунд, иногда-16 миллисекунд, то же самое для объединения массивов).

когда я увеличил количество до 50 000, результаты были разными в разных браузерах - в Internet Explorer конкатенация строк была быстрее (94 миллисекунды) и соединение было медленнее(125 миллисекунд), в то время как в Firefox соединение массива было быстрее (113 миллисекунд), чем соединение строк (117 миллисекунд).

затем я увеличил счет до 500 ' 000. Теперь array.join() был медленнее, чем конкатенация строк в обоих браузерах: конкатенация строк была 937 МС в Internet Explorer, 1155 МС в Firefox, array join 1265 в Internet Explorer и 1207 МС в Firefox.

максимальное количество итераций, которое я мог бы проверить в Internet Explorer без "сценарий занимает слишком много времени для выполнения" было 850,000. Затем Internet Explorer был 1593 для конкатенации строк и 2046 массива присоединиться, и Firefox была 2101 для конкатенации строк и 2249 присоединяйтесь к массиву.

результаты - если количество итераций мало, вы можете попробовать использовать array.join(), как это может быть быстрее в Firefox. Когда число увеличивается, то string1+string2 метод быстрее.

обновление

I выполнил тест в Internet Explorer 6 (Windows XP). Процесс останавливался, чтобы ответить немедленно и никогда не заканчивался, если я пробовал тест на более чем 100 000 итераций. На 40 000 итераций результаты были

Time (strings): 59175 ms
Time (arrays): 220 ms

это означает - если вам нужно поддерживать Internet Explorer 6, Выберите array.join() что намного быстрее, чем конкатенация строк.

этот код выглядит как маршрут, который вы хотите взять с несколькими изменениями.

вы хотите изменить метод append, чтобы выглядеть так. Я изменил его, чтобы принять число 0, и заставить его вернуться this таким образом, вы можете связать свои приложения.

StringBuilder.prototype.append = function (value) {
    if (value || value === 0) {
        this.strings.push(value);
    }
    return this;
}

В C# вы можете сделать что-то вроде

 String.Format("hello {0}, your age is {1}.",  "John",  29) 

в JavaScript, вы могли бы сделать что-то вроде

 var x = "hello {0}, your age is {1}";
 x = x.replace(/\{0\}/g, "John");
 x = x.replace(/\{1\}/g, 29);

версия ECMAScript 6 (aka ECMAScript 2015) JavaScript представила строковые литералы.

var classType = "stringbuilder";
var q = `Does JavaScript have a built-in ${classType} class?`;

обратите внимание, что обратные тики вместо одинарных кавычек заключают строку.

для тех, кто заинтересован, вот альтернатива вызова массива.присоединяйтесь:

var arrayOfStrings = ['foo', 'bar'];
var result = String.concat.apply(null, arrayOfStrings);
console.log(result);

выход, как и ожидалось, является строкой 'foobar'. В Firefox этот подход превосходит Array.присоединиться, но превосходит по + конкатенации. Начиная Со Строки.concat требует, чтобы каждый сегмент был указан в качестве отдельного аргумента, вызывающий объект ограничен любым ограничением количества аргументов, наложенным исполняющим механизмом JavaScript. Взгляните на документация функции.прототип.применить() за дополнительной информацией.

Я определил эту функцию:

function format() {
        var args = arguments;
        if (args.length <= 1) { 
            return args;
        }
        var result = args[0];
        for (var i = 1; i < args.length; i++) {
            result = result.replace(new RegExp("\{" + (i - 1) + "\}", "g"), args[i]);
        }
        return result;
    }

и может называться как c#:

 var text = format("hello {0}, your age is {1}.",  "John",  29);

результат:

Привет Джон, тебе 29 лет.

когда я делаю много конкатенации строк в JavaScript, я начинаю искать шаблоны. Рули.js работает довольно хорошо, сохраняя HTML и JavaScript более читабельными. http://handlebarsjs.com

как о sys.StringBuilder() попробуйте следующую статью.

https://msdn.microsoft.com/en-us/library/bb310852.aspx