Ага, в начале думал об этом, но тогда код был другой, "иф" состоял из двух условий. А сейчас можно попробовать.

Логика ясна, но у вас же есть границы? Иначе, зачем создавать объект 'TextNode', зачем такие длинные названия, зачем так много 'var'-ов, ведь это много лишних байтов. ;)

Все локальные переменные компрессор сожмет до одного символа:
http://developer.yahoo.com/yui/compressor/
Про них можно не беспокоиться.

Что касается глобальных, то вы, верно, сказали "есть границы". Можно не создавать объекты и все переменные держать в window с именами "a", "b", "c", "d" и т. д. Хорошая помойка получится. Пожалуй, я действительно поспешил так однозначно заявив:
Что бы ни допустить такой помойки все же приходится мириться с незначительным увеличением объема кода и уменьшением производительности (за счет обращения к свойствам объектов).
Все эти методы с правильными именами, красиво разложенные по полочкам (по объектам) будут постоянно применяться, и это применение должно быть удобным. Но должно ли быть удобно (читабельно) написано содержимое этих методов? То есть я сначала пишу функцию читабельно в ущерб производительности, для того что бы потом, когда этот внесенный мной ущерб проявится, я мог зайти, удобно ее прочитать и исправить сделав нечитабельной. Глупо на мой взгляд.

Лишних 'var'-ов на первый взгляд вроде не вижу. Каждый в своем уровне вложенности. Можно, например, вынести "f" выше к "div", но тогда DocumentFragment будет создаваться и в тех случаях, когда он не понадобится.

Кстати, потестируйте. Теоретически, это уже будет быстрее в n раз. А если ещё учесть тормознутость каждой конкретной реализации .createElement и .createDocumentFragment - ещё прибавится. Хотя, Вам решать, что оптимизировать - скорость или объём кода, я лишь предложил.

Теоретически, процентов 10 максимум. Сейчас протестирую.

Протестировал на "идеальном" случае, т. е. кол-во текстовых узлов в документе равно кол-ву подходящих для замены текстовых узлов. В таком случае разница в производительности особенно заметна.

Код срабатывает множество раз, и каждый раз в документе появляются теги "а", которые сразу нужно убирать:

var text = 'ddffdfg [url]http://www.youtube.com/watch?v=iuOcLoqo5e0[/url] dsfsdfs';
var startTime = new Date();
for (var __i = 0; __i < 1001; __i++) {
	document.getElementById('div1').innerHTML =
	document.getElementById('div2').innerHTML =
	document.getElementById('div3').innerHTML = text;
	TextNode.each(callback);
}
alert((new Date()) - startTime);

Результат:
IE +8.59%
FF +6.49%
Opera +10.56%
Chrome +13.04%

В среднем +9,67%

В реальном документе сотни, а часто и тысячи текстовых узлов (отступы/табы для форматирования html в большинстве браузеров тоже считаются текстовыми узлами), и максимум 5-10 подходящих, т. е. полученный результат можно смело делить минимум на сотню.

Получаем +0,0967%

Можно еще regexp вынести как свойство callback-а. Чтоб не создавался каждый раз.

Почти 100%.

У меня интерес всегда академический. Отрицать/не принимать очевидное - какой смысл? Есть разница - каждый раз создавать или один раз?

function test(callback) {
  callback();
}
var t1, t2;
function _callback1() {
  var div = document.createElement('div');
  var fragment = document.createDocumentFragment();
  var _div = div;
  var _fragment = fragment;
}
t1 = new Date().getTime();
for (var k = 0; k < 100000; k++) {
  test(_callback1);
}
t2 = new Date().getTime();
alert(t2 - t1);

function _callback2() {
  var _div = arguments.callee.div;
  var _fragment = arguments.callee.fragment;
}
_callback2.div = document.createElement('div');
_callback2.fragment = document.createDocumentFragment();
t1 = new Date().getTime();
for (var k = 0; k < 100000; k++) {
  test(_callback2);
}
t2 = new Date().getTime();
alert(t2 - t1);

Минимум в два раза быстрее (а где-то (IE6 на моей машине) в 5-8 раз).

Впрочем, повторю, Вы сами определяете приоритет.

Вы сравниваете обращение к свойству и вызов метода. Конечно второе медленней даже если метод пустой.
Т. е. вы удалили весь лишний шум. Но при реальном применении, этот шум будет, и его нужно учитывать.
Определитесь, что мы сравниваем два по разному написанных метода или "обращение к свойству" vs "вызов метода".

Riim, стоп. У вас операция document.createElement('div'); сколько раз вызывается? Один?

Не понял. И там - test(_callback1), и там - test(_callback2) - вызов test с своим коллбэком.

Первый коллбэк (Ваш, где Вы создаёте каждый раз div и fragment):

function _callback1() {
  var div = document.createElement('div');
  var fragment = document.createDocumentFragment();
  var _div = div;
  var _fragment = fragment;
}

Второй коллбэк (предложенный, где div и fragment создались единожды и записались свойствами в коллбэк):

function _callback2() {
  var _div = arguments.callee.div;
  var _fragment = arguments.callee.fragment;
}
_callback2.div = document.createElement('div');
_callback2.fragment = document.createDocumentFragment();

Какой ещё шум? До шума, действительно, и дела нет. Я Вам предложил заменить постоянное создание div и fragment на один раз. Другого я не касался.

О чём Вы продолжаете говорить (и отрицать?), я не понимаю? =) Какой вызов метода, какое свойство? Если Вы под "вызов метода" подразумеваете document.createElement('div'); и document.createDocumentFragment(); vs. arguments.callee.div; и arguments.callee.fragment; - так я Вам это и предложил.

P.S.: ещё раз - у Вас document.createElement('div'); и document.createDocumentFragment(); один раз вызываются? Нет? А почему? А! Вы говорите об оптимизации по объёму кода; что ж, Вам решать (я это третий раз говорю уже).