详细分析和十种不同的方法来反转字符串和他们的性能细节。

http://eddmann.com/posts/ten-ways-to-reverse-a-string-in-javascript/

这些实现的性能:

每个浏览器的最佳执行实现

Chrome 15 -实现1和6 Firefox 7 -实现6 IE 9 -实现4 Opera 12 -实现9

以下是这些实现:

实现1:

function reverse(s) {
  var o = '';
  for (var i = s.length - 1; i >= 0; i--)
    o += s[i];
  return o;
}

实现2:

function reverse(s) {
  var o = [];
  for (var i = s.length - 1, j = 0; i >= 0; i--, j++)
    o[j] = s[i];
  return o.join('');
}

实现3:

function reverse(s) {
  var o = [];
  for (var i = 0, len = s.length; i <= len; i++)
    o.push(s.charAt(len - i));
  return o.join('');
}

实现4:

function reverse(s) {
  return s.split('').reverse().join('');
}

实现5:

function reverse(s) {
  var i = s.length,
      o = '';
  while (i > 0) {
    o += s.substring(i - 1, i);
    i--;
  }
  return o;
}

实现6:

function reverse(s) {
  for (var i = s.length - 1, o = ''; i >= 0; o += s[i--]) { }
  return o;
}

实现7:

function reverse(s) {
  return (s === '') ? '' : reverse(s.substr(1)) + s.charAt(0);
}

实现8:

function reverse(s) {
  function rev(s, len, o) {
    return (len === 0) ? o : rev(s, --len, (o += s[len]));
  };
  return rev(s, s.length, '');
}

实现9:

function reverse(s) {
  s = s.split('');
  var len = s.length,
      halfIndex = Math.floor(len / 2) - 1,
      tmp;
 

     for (var i = 0; i <= halfIndex; i++) {
        tmp = s[len - i - 1];
        s[len - i - 1] = s[i];
        s[i] = tmp;
      }
      return s.join('');
    }

实现10

function reverse(s) {
  if (s.length < 2)
    return s;
  var halfIndex = Math.ceil(s.length / 2);
  return reverse(s.substr(halfIndex)) +
         reverse(s.substr(0, halfIndex));
}

实现11

var reverser  = function(str){
let string = str.split('');

    for(i=0;i<string.length;i++){
        debugger;
        string.splice(i,0,string.pop());
    
    } 
    console.log(string.join())
}
reverser('abcdef')

好的，很简单，你可以创建一个简单的循环函数来为你反向字符串，而不需要使用reverse()， charAt()等，就像这样:

例如，你有这样一个字符串:

var name = "StackOverflow";

创建一个这样的函数，我称之为reverseString…

function reverseString(str) {
  if(!str.trim() || 'string' !== typeof str) {
    return;
  }
  let l=str.length, s='';
  while(l > 0) {
    l--;
    s+= str[l];
  }
  return s;
}

你可以这样称呼它:

reverseString(name);

结果是:

"wolfrevOkcatS"

如果您对性能和时间复杂度更感兴趣，可以使用此方法。在这个方法中，我将字符串分为两部分，并按照长度/2次循环迭代进行排序。

Let STR = "abcdefghijklmnopqrstuvwxyz" 函数反向(str) { Let store = "" 让store2 = "" (让我= str.length / 2, > = 0;我——){ 如果(str.length % 2 ! = = 0) { store += str.charAt(i) str.slice((str.length/2)+1, str.length).charAt(i) 其他}{ += str.charAt(i-1) str.slice((str.length/2)， str.length).charAt(i) ｝ ｝ 返回store2 +存储 ｝ console.log(反向(str))

这不是最优的，但我们可以这样想。

ES6

 function reverseString(str) {
     return [...str].reverse().join("");
 }

 console.log(reverseString("Hello")); // olleH

我们可以从字符串数组的两端开始迭代:start和end，并在每次迭代中交换。

function reverse(str) {
 let strArray = str.split("");
 let start = 0;
 let end = strArray.length - 1;

 while(start <= end) {
  let temp = strArray[start];
  strArray[start] = strArray[end];
  strArray[end] = temp;

  start++;
  end--;
 }
 return strArray.join("");
}

虽然操作次数减少了，但其时间复杂度仍为O(n) 操作的数量仍然与输入的大小成线性比例。

参考： 阿尔戈日报

你可以尝试这样做。我相信还有重构的空间。我无法使用分裂函数。也许有人知道不分裂的方法。

代码设置，可以把它放在你的。js库

使用它的代码(有客户端代码，只是因为它在浏览器中测试过):

var sentence = "My Stack is Overflowing."
document.write(sentence.reverseLetters() + '<br />');
document.write(sentence.reverseWords() + '<br />');

代码片段:

String.prototype.aggregate = function(vals, aggregateFunction) { var temp = ''; for (var i = vals.length - 1; i >= 0; i--) { temp = aggregateFunction(vals[i], temp); } return temp; } String.prototype.reverseLetters = function() { return this.aggregate(this.split(''), function(current, word) { return word + current; }) } String.prototype.reverseWords = function() { return this.aggregate(this.split(' '), function(current, word) { return word + ' ' + current; }) } var sentence = "My Stack is Overflowing." document.write(sentence.reverseLetters() + '<br />'); document.write(sentence.reverseWords() + '<br />');