ideas

[Uzlopak]

I think there is still some performance to gain.

e.g. currently you have to create a variable lastIndex.

Some ideas.

const empty = "";
function join(output, separator = ",") {
  const length = output.length
  if (length === 0) {
    return empty;
  }

  let str = empty;
  let i = 1
  while (i < length) {
    // It is faster not to use a template string here
    str += separator;
    str += output[i++];
  }
  return output[0] + str
}

function join(array, separator) {
  const length = array.length
  if (length === 0) {
    return "";
  } else if (length === 1) {
    return array[0];
  } else {
    let str = "";
    let i = 1;
    while (i < length) {
      // It is faster not to use a template string here
      str += separator;
      str += array[i++];
    }
    return array[0] + str;
  }
}

Or something with a switch.

[Uzlopak]

The first performance hit is done when getting the length of the Array.

Something like this actually improves perf maybe:

function generateJoin(length, separator = ',') {

  const fnBody = []
  fnBody.push(`const separator = '${separator}';`)
  fnBody.push('const length = array.length;')
  fnBody.push('switch (length) {')
  fnBody.push('case 0: return "";')
  for (let i = 1; i < length; ++i) {
    fnBody.push(buildCase(i, separator))
  }
  fnBody.push(`
  default:
  let str = "";
  let i = 1;
  while (i < length) {
    // It is faster not to use a template string here
    str += separator;
    str += array[i++];
  }
  return array[0] + str;`)

  fnBody.push('}')
  return new Function('array', fnBody.join(''))
}

function buildCase (length) {
  let str = `\n case ${length}: return "" + array[0]`
  let i = 1
  while (i < length) {
    // It is faster not to use a template string here
    str += ` + separator + array[${i++}]`;
  }
  return str + ';'
}

const defaultJoin = generateJoin(5)

native: empty  x 188,335,148 ops/sec ±0.20% (194 runs sampled)
fast-array-join: empty  x 238,342,115 ops/sec ±0.08% (192 runs sampled)
native: single x 42,023,228 ops/sec ±2.16% (186 runs sampled)
fast-array-join: single x 241,588,348 ops/sec ±0.07% (194 runs sampled)
native: small  x 15,078,461 ops/sec ±1.64% (177 runs sampled)
fast-array-join: small  x 231,394,381 ops/sec ±0.09% (196 runs sampled)
native: large  x 88,531 ops/sec ±0.50% (187 runs sampled)
fast-array-join: large  x 140,427 ops/sec ±3.38% (178 runs sampled)

Maybe find a good balance between short and long arrays.