如何就地反转字符串？

Question

当字符串传递给带有 return 语句的函数时，如何在 JavaScript 中就地反转字符串，而不使用内置函数（.reverse()、.charAt()< /代码>等）？

Answer 1

只要您处理简单的 ASCII 字符，并且您乐于使用内置函数，这就会起作用：

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

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

数组扩展运算符支持 Unicode：

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

另一个使用 split() 的 Unicode 感知解决方案，如 MDN 是使用正则表达式，并将 u (Unicode) 标志设置为分隔符。

function reverse(s){
    return s.split(/(?:)/u).reverse().join("");
}

Answer 2

以下技术（或类似技术）通常用于反转 JavaScript 中的字符串：

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

事实上，到目前为止发布的所有答案都是此模式的变体。 然而，这个解决方案存在一些问题。 例如：

naiveReverse('foo 

Answer 3

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

Answer 4

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

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')

Answer 5

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

虽然上面的解决方案确实反转了字符串，但它们在不分配更多内存的情况下不会这样做，因此不满足条件。 您需要直接访问分配的字符串，并且能够操作其原始内存位置以便能够将其反转。

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

Answer 6

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

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

Answer 7

在 ECMAScript 6 中，您可以更快地反转字符串，而无需使用 .split('') split 方法，使用 传播运算符 像这样：

var str = [...'racecar'].reverse().join('');

Answer 8

看来我迟到了三年……

不幸的是你不能，正如已经指出的那样。 请参阅 JavaScript 字符串是不可变的吗？ 我需要 JavaScript 中的“字符串构建器”吗？

您可以做的下一个最好的事情是创建一个“视图”或“包装器”，它接受一个字符串并重新实现您正在使用的字符串 API 的任何部分，但假装字符串颠倒了。 例如：

var identity = function(x){return x};

function LazyString(s) {
    this.original = s;

    this.length = s.length;
    this.start = 0; this.stop = this.length; this.dir = 1; // "virtual" slicing
    // (dir=-1 if reversed)

    this._caseTransform = identity;
}

// syntactic sugar to create new object:
function S(s) {
    return new LazyString(s);
}

//We now implement a `"...".reversed` which toggles a flag which will change our math:

(function(){ // begin anonymous scope
    var x = LazyString.prototype;

    // Addition to the String API
    x.reversed = function() {
        var s = new LazyString(this.original);

        s.start = this.stop - this.dir;
        s.stop = this.start - this.dir;
        s.dir = -1*this.dir;
        s.length = this.length;

        s._caseTransform = this._caseTransform;
        return s;
    }

//We also override string coercion for some extra versatility (not really necessary):

    // OVERRIDE STRING COERCION
    //   - for string concatenation e.g. "abc"+reversed("abc")
    x.toString = function() {
        if (typeof this._realized == 'undefined') {  // cached, to avoid recalculation
            this._realized = this.dir==1 ?
                this.original.slice(this.start,this.stop) : 
                this.original.slice(this.stop+1,this.start+1).split("").reverse().join("");

            this._realized = this._caseTransform.call(this._realized, this._realized);
        }
        return this._realized;
    }

//Now we reimplement the String API by doing some math:

    // String API:

    // Do some math to figure out which character we really want

    x.charAt = function(i) {
        return this.slice(i, i+1).toString();
    }
    x.charCodeAt = function(i) {
        return this.slice(i, i+1).toString().charCodeAt(0);
    }

// Slicing functions:

    x.slice = function(start,stop) {
        // lazy chaining version of https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/slice

        if (stop===undefined)
            stop = this.length;

        var relativeStart = start<0 ? this.length+start : start;
        var relativeStop = stop<0 ? this.length+stop : stop;

        if (relativeStart >= this.length)
            relativeStart = this.length;
        if (relativeStart < 0)
            relativeStart = 0;

        if (relativeStop > this.length)
            relativeStop = this.length;
        if (relativeStop < 0)
            relativeStop = 0;

        if (relativeStop < relativeStart)
            relativeStop = relativeStart;

        var s = new LazyString(this.original);
        s.length = relativeStop - relativeStart;
        s.start = this.start + this.dir*relativeStart;
        s.stop = s.start + this.dir*s.length;
        s.dir = this.dir;

        //console.log([this.start,this.stop,this.dir,this.length], [s.start,s.stop,s.dir,s.length])

        s._caseTransform = this._caseTransform;
        return s;
    }
    x.substring = function() {
        // ...
    }
    x.substr = function() {
        // ...
    }

//Miscellaneous functions:

    // Iterative search

    x.indexOf = function(value) {
        for(var i=0; i<this.length; i++)
            if (value==this.charAt(i))
                return i;
        return -1;
    }
    x.lastIndexOf = function() {
        for(var i=this.length-1; i>=0; i--)
            if (value==this.charAt(i))
                return i;
        return -1;
    }

    // The following functions are too complicated to reimplement easily.
    // Instead just realize the slice and do it the usual non-in-place way.

    x.match = function() {
        var s = this.toString();
        return s.apply(s, arguments);
    }
    x.replace = function() {
        var s = this.toString();
        return s.apply(s, arguments);
    }
    x.search = function() {
        var s = this.toString();
        return s.apply(s, arguments);
    }
    x.split = function() {
        var s = this.toString();
        return s.apply(s, arguments);
    }

// Case transforms:

    x.toLowerCase = function() {
        var s = new LazyString(this.original);
        s._caseTransform = ''.toLowerCase;

        s.start=this.start; s.stop=this.stop; s.dir=this.dir; s.length=this.length;

        return s;
    }
    x.toUpperCase = function() {
        var s = new LazyString(this.original);
        s._caseTransform = ''.toUpperCase;

        s.start=this.start; s.stop=this.stop; s.dir=this.dir; s.length=this.length;

        return s;
    }

})() // end anonymous scope

演示：

> r = S('abcABC')
LazyString
  original: "abcABC"
  __proto__: LazyString

> r.charAt(1);       // doesn't reverse string!!! (good if very long)
"B"

> r.toLowerCase()    // must reverse string, so does so
"cbacba"

> r.toUpperCase()    // string already reversed: no extra work
"CBACBA"

> r + '-demo-' + r   // natural coercion, string already reversed: no extra work
"CBAcba-demo-CBAcba"

踢球者 - 以下是通过纯数学就地完成的，仅访问每个字符一次，并且仅在必要时才访问：

> 'demo: ' + S('0123456789abcdef').slice(3).reversed().slice(1,-1).toUpperCase()
"demo: EDCBA987654"

> S('0123456789ABCDEF').slice(3).reversed().slice(1,-1).toLowerCase().charAt(3)
"b"

如果应用于非常大的字符串，如果您只采用相对较大的字符串，则这会产生显着的节省。一小片。

这是否值得（而不是像大多数编程语言那样以副本形式反转）在很大程度上取决于您的用例以及重新实现字符串 API 的效率。 例如，如果您只想进行字符串索引操作，或者采用小切片或子字符串，这将节省您的空间和时间。 然而，如果您计划打印大的反向切片或子字符串，节省的成本可能确实很小，甚至比完成完整副本还要糟糕。 您的“反转”字符串也不会具有 string 类型，尽管您可以通过原型设计来伪造它。

上面的演示实现创建了一个 ReversedString 类型的新对象。 它是原型化的，因​​此相当高效，几乎只需最少的工作和最小的空间开销（原型定义是共享的）。 这是一个涉及延迟切片的惰性实现。 每当您执行 .slice 或 .reversed 等函数时，它都会执行索引数学运算。 最后，当您提取数据时（通过隐式调用 .toString() 或 .charCodeAt(...) 等），它将以“智能”方式应用这些数据，尽可能少地接触数据。

注意：上面的字符串API只是一个示例，可能无法完美实现。 您也可以只使用您需要的 1-2 个功能。

Answer 9

使用扩展语法的清晰方式：

const reverseString = str => [...str].reverse().join('');

console.log(reverseString('ABC'));

Answer 10

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

方法1：使用reverse函数：

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

我希望这会有所帮助:)

Answer 11

有多种方法可以做到这一点，您可以检查以下内容，

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

Answer 12

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

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

Answer 13

在 ES6 中，你多了一种选择

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

reverseString('Hello');

Answer 14

这是我认为最简单的方法

var reverse = function(str) {

    var arr = [];

    for (var i = 0, len = str.length; i <= len; i++) {

        arr.push(str.charAt(len - i))

    }
    return arr.join('');

}
console.log(reverse('I want a 

Answer 15

var str = 'sample string';
[].map.call(str, function(x) {
  return x;
}).reverse().join('');

或

var str = 'sample string';
console.log(str.split('').reverse().join(''));

// 输出：'gnirts elpmas'

Answer 16

如果您不想使用任何内置函数。 尝试这个

var string = 'abcdefg';
var newstring = '';

for(let i = 0; i < string.length; i++){
    newstring = string[i] += newstring;
}

console.log(newstring);

Answer 17

正如其他人指出的那样，字符串是不可变的，因此您无法就地反转它。 您需要生成一个新字符串。 执行此操作的一个新选项是使用 Intl .Segmenter 允许您分割视觉字素（即：用户感知的字符单元，例如表情符号、字符等）。 Intl.Segmenter 目前是第 4 阶段提案，并且如果您想使用它，则可以使用 polyfill 。 目前它的浏览器支持有限，您可以找到有关 此处。

如果您使用 Intl.Segmenter，reverse() 方法可能如下所示：

const reverse = str => {

  const segmenter = new Intl.Segmenter("en", {granularity: 'grapheme'});

  const segitr = segmenter.segment(str);

  const segarr = Array.from(segitr, ({segment}) => segment).reverse();

  return segarr.join('');

}

console.log(reverse('foo 

Answer 18

我知道这是一个已经得到很好回答的老问题，但为了我自己的娱乐，我编写了以下反向函数，并认为我会分享它，以防它对其他人有用。 它处理代理对和组合标记：

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 中字符编码的复杂性。

Answer 19

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

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

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

Answer 20

您无法就地反转 string 但您可以使用以下命令：

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

var s = "ABCD";
s = s.reverse();
console.log(s);

Answer 21

UTF-8 字符串可以有：

• 组合变音符号，例如由 b 字符和由 unicode 转义序列生成的后续 ~ 变音符号组成的 b̃ \u0303;
• 多字节字符，例如


Answer 22

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

Answer 23

我认为 String.prototype.reverse 是解决这个问题的好方法；
代码如下；

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

var str = 'this is a good example for string reverse';
str.reverse();
-> "esrever gnirts rof elpmaxe doog a si siht";

Answer 24

真正的答案是：您无法就地反转它，但您可以创建一个相反的新字符串。

就像递归的练习一样：有时当你去面试时，面试官可能会问你如何使用递归来做到这一点，我认为“首选答案”可能是“我宁愿不在递归中这样做，因为它”很容易导致堆栈溢出”（因为它是O(n)而不是O(log n)。如果是O(log n) code>，堆栈溢出是相当困难的——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

Answer 25

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

function reverseString(str) {

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

  var strReverse = strArray.join("");

  return strReverse;
}

reverseString("hello");

Answer 26

//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

"

Answer 27

使用内置函数反转字符串

function reverse(str) {
  // Use the split() method to return a new array
  //  Use the reverse() method to reverse the new created array
  // Use the join() method to join all elements of the array into a string
  return str.split("").reverse().join("");
}
console.log(reverse('hello'));

---

在没有助手的情况下反转字符串

function reversedOf(str) {
  let newStr = '';
  for (let char of str) {
    newStr = char + newStr
    // 1st round: "h" + "" = h, 2nd round: "e" + "h" = "eh" ... etc. 
    // console.log(newStr);
  }
  return newStr;
}
console.log(reversedOf('hello'));

Answer 28

使用数组函数，

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

Answer 29

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

Answer 30

我自己最初的尝试...

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/编辑？js，控制台，输出