Split and join function or the replace function

I ran a JSPerf to test which is faster, and as I thought, the replace function is around 40-50% faster (I tested on Chrome 66):

https://jsperf.com/replace-vs-split-join-seblor

Plus you get a memory gain, because split creates an array.

2021 edit:

Since this answer is still being read, here is a snippet so you can test the performance in your browser:

function runBenchmark() {
  console.log('Starting...');
  const string = 'Hello World';
  const replaceRegex = / /g;
  new Benchmark.Suite()
    .add('split & join', () => {
      let newString = string.split(' ').join('_');
    })
    .add('replace regex', () => {
      let newString = string.replace(replaceRegex, "_");
    })
    .add('replaceAll', () => {
      let newString = string.replaceAll(" ", "_");
    })
    .add('replaceAll with regex', () => {
      let newString = string.replaceAll(replaceRegex, "_");
    })
    .on('cycle', (event) => {
      console.log(String(event.target));
    })
    .run({ async: true });
}

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/benchmark/2.1.4/benchmark.min.js"></script>
<button onclick="runBenchmark()">Run Benchmark</button>

On chrome 94, regex replacing seem to be twice as fast as splitting and joining.

I'm seeing this answer relatively high on Google, while the other answers are right in your use case, they do not hold up in other use cases.

Regex does not scale well, just taking the example benchmark by Seblor, but replacing the string "hello world" by the book Othello by William Shakespeare (I'm not linking a code, the string is 5730 lines long, but you are welcome to follow this link that has the full document: https://shakespeare.mit.edu/othello/full.html)

The benchmark results are a 40% reduction in ops:

split & join x 1,486 ops/sec ±0.55% (12 runs sampled)
replace regex x 916 ops/sec ±0.26% (63 runs sampled)
replaceAll x 906 ops/sec ±0.71% (9 runs sampled)
replaceAll with regex x 910 ops/sec ±0.72% (63 runs sampled)

The more nuanced answer is that you need to verify those points:

• How long is your string? the longer the string, the less efficient the regex will be. Running a regex on a small string will be faster than split and join, but on a long string, split and join will almost always outperform the regex.

• How complex is your regex? Matching simple spaces is fast, but the more complicated it will be, the more expensive the regex will become. This is the basis of ReDOS attacks that slow down your server by sending strings that will hog down a poorly made regex.

And finally, how can you verify this? the tool https://regex101.com/ can help you verify the complexity and speed of a regex, by giving you the number of steps required to match your regex: more steps = slower.