Create a new string and add all the chars from the original string to it backwards:

function reverse1(str){
  var r = "";
  for(var i = str.length - 1; i >= 0; i--){
    r += str.charAt(i);
  }
  return r;
}

Then just say:

str = reverse1(str);

The following technique (or similar) is commonly used to reverse a string in JavaScript:

// Don’t use this!
var naiveReverse = function(string) {
    return string.split('').reverse().join('');
}

In fact, all the answers posted so far are a variation of this pattern. However, there are some problems with this solution. For example:

naiveReverse('foo 𝌆 bar');
// → 'rab �� oof'
// Where did the `𝌆` symbol go? Whoops!

If you’re wondering why this happens, read up on JavaScript’s internal character encoding. (TL;DR: 𝌆 is an astral symbol, and JavaScript exposes it as two separate code units.)

But there’s more:

// To see which symbols are being used here, check:
// http://mothereff.in/js-escapes#1ma%C3%B1ana%20man%CC%83ana
naiveReverse('mañana mañana');
// → 'anãnam anañam'
// Wait, so now the tilde is applied to the `a` instead of the `n`? WAT.

A good string to test string reverse implementations is the following:

'foo 𝌆 bar mañana mañana'

Why? Because it contains an astral symbol (𝌆) (which are represented by surrogate pairs in JavaScript) and a combining mark (the ñ in the last mañana actually consists of two symbols: U+006E LATIN SMALL LETTER N and U+0303 COMBINING TILDE).

The order in which surrogate pairs appear cannot be reversed, else the astral symbol won’t show up anymore in the ‘reversed’ string. That’s why you saw those �� marks in the output for the previous example.

Combining marks always get applied to the previous symbol, so you have to treat both the main symbol (U+006E LATIN SMALL LETTER N) as the combining mark (U+0303 COMBINING TILDE) as a whole. Reversing their order will cause the combining mark to be paired with another symbol in the string. That’s why the example output had ã instead of ñ.

Hopefully, this explains why all the answers posted so far are wrong.

To answer your initial question — how to [properly] reverse a string in JavaScript —, I’ve written a small JavaScript library that is capable of Unicode-aware string reversal. It doesn’t have any of the issues I just mentioned. The library is called Esrever; its code is on GitHub, and it works in pretty much any JavaScript environment. It comes with a shell utility/binary, so you can easily reverse strings from your terminal if you want.

var input = 'foo 𝌆 bar mañana mañana';
esrever.reverse(input);
// → 'anañam anañam rab 𝌆 oof'

As for the “in-place” part, see the other answers.

I was wondering if there's a need to split at all, because characters are accessible directly using String#charAt.

This implementation (which is almost the same as yours - only with the split) should be among the fastest.

function reverse(str) {
  var result = [];
  for (var i = str.length - 1; i >= 0; i--) {
    result.push(str.charAt(i));
  }
  return result.join("");
}

console.log(reverse("abcde"));

According to some benchmark, String concatenation is better optimized than Array.join, it also makes the code cleaner:

function reverse(str) {
  var result = "";
  for (var i = str.length - 1; i >= 0; i--) {
    result += str.charAt(i);
  }
  return result;
}

console.log(reverse("abcde"));

As a side-note, you can get creative by using Array.prototype.reduce and allow JavaScript duck-type the String as an Array.

function reverse(str) {
  return Array.prototype.reduce.call(str, function(result, c) {
    return c + result;
  }, "");
}

console.log(reverse("Hello world!"));

And going further you can make an ES6 one-liner:

let reverse = str => Array.prototype.reduce.call(str, (result, c) => c + result, "");

console.log(reverse("Hello world!"));

JSFiddle forked from @Andreas: https://jsfiddle.net/kazenorin/6shbv6hs/2/

Another idea for reversing the words in a String is using a Stack data structure. Like so:

var newString = "";
var theString = prompt("Enter a Phrase that you would like to reverse (Ex. Hello world)");

var word = "";
var c;
var stack = [];
for (var i = 0, len = theString.length; i < len; i++) {
  c = theString[i];
  word += c;

  if (c == " " || i == (len-1)) {
      word = word.trim();
      stack.push(word);
      word = "";
  }  
}

while (s = stack.pop()) {    
    newString += s + " ";
}

console.log(newString);

Here is a recursive way of doing it:

const rev = s => s.length>1 ? s.at(-1)+rev(s.slice(0,-1)) : s;

console.log(rev("This is a test string."))