jt1 - (b.push()) x 28,025 ops/sec ±0.80% (58 runs sampled)
jt2 - (+= & +) x 45,956 ops/sec ±0.72% (62 runs sampled)
jt3 - (+= only) x 45,550 ops/sec ±0.76% (63 runs sampled)
jt4 - (+=, +, old attrs) x 30,269 ops/sec ±0.70% (62 runs sampled)
jt5 - (b.push(), attrs2()) x 41,582 ops/sec ±0.56% (63 runs sampled)
jt6 - (mostly +, attrs2()) x 46,342 ops/sec ±0.38% (60 runs sampled)
Fastest is jt2 - (+= & +) ,jt3 - (+= only) ,jt6 - (mostly +, attrs2())

For your attrs2 code, shouldn't there be a space added to the start (not the end) for each new key/value that gets appended? This requires more concatenations which decreases performance but it is necessary to render right.

attrs2 = function (obj, escaped) {
  var terse = obj.terse;

  delete obj.terse;
  var keys = Object.keys(obj)
    , len = keys.length;

  var s = '';
  if (len) {
    for (var i = 0; i < len; ++i) {
      var key = keys[i]
        , val = obj[key];

      if ('boolean' == typeof val || null == val) {
        if (val) {
          terse
            ? (s+= ' ' + key)
            : (s+= ' ' + key + '="' + key + '"');
        }
      } else if (0 == key.indexOf('data') && 'string' != typeof val) {
        s += ' ' + key + '="' + JSON.stringify(val) + '"';
      } else if ('class' == key && Array.isArray(val)) {
        s += ' ' + key + '="' + exports.escape(val.join(' ')) + '"';
      } else if (escaped[key]) {
        s += ' ' + key + '="' + exports.escape(val) + '"';
      } else {
        s += ' ' + key + '="' + val + '"';
      }
    }
  }

  return s;
};

Otherwise you get things like <pclass="something" > instead of <p class="something">.

You're right. A little bug introduced when modifiying the old attrs() which joins with ' ' at the end.
Fixed by setting var s=' ';
We end up with an extra space at the end, which I'm leaving right now. However, removing it with substr is (edit:probably) faster than the extra concatenations.

Performance results shouldn't change significantly with this modification.

My tests show that substr is slower. See this.

Good thing I came back to write 'probably' :)

However, do you think it's too sloppy to just leave that extra space at the end? I'll benchmark your attrs with mine to see if there's a significant difference. If not, then yours is preferable as it leaves cleaner HTML.

I thought that maybe because it possibly used the same character buffer for the new substring it would just be a matter of creating a new String object, hence it would be a fast operation. Maybe it does a copy operation to form the substring, collapsing the internal linked list.

I think you'll need to have correct html that passes all the jade tests.