你如何扭转地方（或就地）在JavaScript字符串时，它被传递给用一个return语句的功能，而无需使用内置函数（.reverse()，.charAt()等等）？
如何在JavaScript中反转字符串？
第1771篇《如何在JavaScript中反转字符串？》来自Winter(https://github.com/aiyld/aiyld.github.io)的站点
共18个回答
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"
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字符串或看起来很有趣的有效字符串。您可能需要考虑此答案。
相似问题
问题类别
Keep it DRY and simple silly!!