如何在JavaScript中反转字符串？

Keep it DRY and simple silly!!

function reverse(s){
let str = s;
var reverse = '';
for (var i=str.length;i>0;i--){

    var newstr = str.substring(0,i)
    reverse += newstr.substr(-1,1)
}
return reverse;
}

My own original attempt...

var str = "The Car";

function reverseStr(str) {
  var reversed = "";
  var len = str.length;
  for (var i = 1; i < (len + 1); i++) {  
    reversed += str[len - i];      
  }

  return reversed;
}

var strReverse = reverseStr(str);    
console.log(strReverse);
// "raC ehT"

http://jsbin.com/bujiwo/19/edit?js,console,output

var str = "my name is saurabh ";
var empStr='',finalString='';
var chunk=[];
function reverse(str){
var i,j=0,n=str.length;
    for(i=0;i<n;++i){
        if(str[i]===' '){
            chunk[j]=empStr;
            empStr = '';
            j++;
        }else{
            empStr=empStr+str[i];
        }
    }
    for(var z=chunk.length-1;z>=0;z--){
        finalString = finalString +' '+ chunk[z];
        console.log(finalString);
    }
    return true;
}
reverse(str);

Using Array functions,

String.prototype.reverse = function(){
    return [].reduceRight.call(this, function(last, secLast){return last + secLast});
}

function reverseString(string) {
    var reversedString = "";
    var stringLength = string.length - 1;
    for (var i = stringLength; i >= 0; i--) {
        reversedString += string[i];
    }
    return reversedString;
}

//es6
//array.from
const reverseString = (string) => Array.from(string).reduce((a, e) => e + a);
//split
const reverseString = (string) => string.split('').reduce((a, e) => e + a); 

//split problem
"𠜎𠺢".split('')[0] === Array.from("𠜎𠺢")[0] // "�" === "𠜎" => false
"😂😹🤗".split('')[0] === Array.from("😂😹🤗")[0] // "�" === "😂" => false

字符串本身是不可变的，但是您可以使用以下代码轻松创建反向副本：

function reverseString(str) {

  var strArray = str.split("");
  strArray.reverse();

  var strReverse = strArray.join("");

  return strReverse;
}

reverseString("hello");

真正的答案是：您不能将其原地反转，但是可以创建一个新的相反的字符串。

就像进行递归练习一样：有时候，当您去面试时，面试官可能会问您如何使用递归来做到这一点，我认为“首选答案”可能是“我宁愿不递归地这样做。容易导致堆栈溢出”（因为O(n)不是O(log n)。如果是O(log n)，则很难导致堆栈溢出-堆栈级别32可以处理40亿个项目，因为2 ** 32是4294967296。但是，如果为O(n)，则很容易导致堆栈溢出。

有时候，面试官还会问你：“就像练习一样，为什么你还不使用递归来写呢？” 这里是：

String.prototype.reverse = function() {
    if (this.length <= 1) return this;
    else return this.slice(1).reverse() + this.slice(0,1);
}

测试运行：

var s = "";
for(var i = 0; i < 1000; i++) {
    s += ("apple" + i);
}
console.log(s.reverse());

输出：

999elppa899elppa...2elppa1elppa0elppa

为了尝试使堆栈溢出，我在Google Chrome中更改1000为10000，它报告：

RangeError: Maximum call stack size exceeded

您不能因为JS字符串是不可变的。简短的非就地解决方案

[...str].reverse().join``

let str = "Hello World!";
let r = [...str].reverse().join``;
console.log(r);

我知道这是一个已经解决的老问题，但是出于我的娱乐，我编写了以下反向函数，并认为如果对其他人有用的话，我会分享一下。它同时处理代理对和组合标记：

function StringReverse (str)
{
  var charArray = [];
  for (var i = 0; i < str.length; i++)
    {
      if (i+1 < str.length)
        {
          var value = str.charCodeAt(i);
          var nextValue = str.charCodeAt(i+1);
          if (   (   value >= 0xD800 && value <= 0xDBFF
                  && (nextValue & 0xFC00) == 0xDC00) // Surrogate pair)
              || (nextValue >= 0x0300 && nextValue <= 0x036F)) // Combining marks
            {
              charArray.unshift(str.substring(i, i+2));
              i++; // Skip the other half
              continue;
            }
        }

      // Otherwise we just have a rogue surrogate marker or a plain old character.
      charArray.unshift(str[i]);
    }

  return charArray.join('');
}

Mathias，Punycode和所有其他参考的所有道具，使我了解了JavaScript字符编码的复杂性。

有多种方法，您可以检查以下内容，

1.传统的for循环（递增）：

function reverseString(str){
        let stringRev ="";
        for(let i= 0; i<str.length; i++){
            stringRev = str[i]+stringRev;
        }
        return stringRev;
}
alert(reverseString("Hello World!"));

2.传统的for循环（递减）：

function reverseString(str){
    let revstr = "";
    for(let i = str.length-1; i>=0; i--){
        revstr = revstr+ str[i];
    }
    return revstr;
}
alert(reverseString("Hello World!"));

3.使用for-of循环

function reverseString(str){
    let strn ="";
    for(let char of str){
        strn = char + strn;
    }
    return strn;
}
alert(reverseString("Get well soon"));

4.使用forEach /高阶数组方法：

function reverseString(str){

  let revSrring = "";
  str.split("").forEach(function(char){
    
    revSrring = char + revSrring;
  
  });
  return revSrring;
}
alert(reverseString("Learning JavaScript"));

5. ES6标准：

function reverseString(str){

  let revSrring = "";
  str.split("").forEach(char => revSrring = char + revSrring);
  return revSrring;
}
alert(reverseString("Learning JavaScript"));

6.最新方法：

function reverseString(str){

  return str.split("").reduce(function(revString, char){
       return char + revString;
  }, "");
 
}

alert(reverseString("Learning JavaScript"));

7.您还可以使用以下方法获得结果，

function reverseString(str){

  return str.split("").reduce((revString, char)=> char + revString, "");
 
}
alert(reverseString("Learning JavaScript"));

在一次采访中，我被要求在不使用任何变量或本机方法的情况下反转字符串。这是我最喜欢的实现：

function reverseString(str) {
    return str === '' ? '' : reverseString(str.slice(1)) + str[0];
}

您可以通过多种方式来反转JavaScript中的字符串。我记下了我喜欢的三种方式。

方法1：使用反向功能：

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

方法2：遍历字符：

function reverse(str) {
  let reversed = '';

  for (let character of str) {
    reversed = character + reversed;
  }

  return reversed;
}

方法3：使用reduce函数：

function reverse(str) {
  return str.split('').reduce((rev, char) => char + rev, '');
}

我希望这有帮助 ：）

首先，使用Array.from()将字符串转换为数组，然后Array.prototype.reverse()反转数组，然后Array.prototype.join()使其返回字符串。

const reverse = str => Array.from(str).reverse().join('');

整个“在原处倒置字符串”是一个过时的面试问题，C程序员会问，被他们面试的人（也许是为了报仇）。不幸的是，“就位”部分不再起作用，因为几乎所有托管语言（JS，C＃等）中的字符串都使用不可变的字符串，从而破坏了在不分配任何新内存的情况下移动字符串的整个想法。

尽管上面的解决方案确实确实反转了字符串，但是他们没有分配更多的内存就不会这样做，因此不满足条件。您需要直接访问分配的字符串，并且能够操纵其原始存储位置，以便能够将其原地反转。

就个人而言，我真的很讨厌这些面试问题，但可悲的是，我相信我们会在未来几年内继续看到它们。

详细的分析以及十种不同的方式来反转字符串及其性能细节。

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));
}

String.prototype.reverse_string=function() {return this.split("").reverse().join("");}

要么

String.prototype.reverse_string = function() {
    var s = "";
    var i = this.length;
    while (i>0) {
        s += this.substring(i-1,i);
        i--;
    }
    return s;
}

只要您要处理简单的ASCII字符，并且很高兴使用内置函数，就可以使用：

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

如果您需要支持UTF-16或其他多字节字符的解决方案，请注意此函数将提供无效的unicode字符串或看起来很有趣的有效字符串。您可能需要考虑此答案。