JavaScriptで文字列を元に戻すにはどうすればよいですか。
Return文を使って関数に渡されたときに、JavaScriptで文字列をその場で（またはその場で）反転させるにはどうすればよいですか。組み込み関数を使用せずにすべて？ .reverse()、.charAt()など.
単純なASCII文字を扱っていて、組み込み関数を使用しているのであれば、これでうまくいきます。
function reverse(s){
return s.split("").reverse().join("");
}
UTF-16や他のマルチバイト文字をサポートする解決策が必要な場合は、この関数が無効なUnicode文字列、または変に見える有効な文字列を返すことに注意してください。あなたは この答えを代わりに 考えることを望むかもしれません。
JavaScriptで文字列を逆にするには、次のようなテクニック（または類似のテクニック）がよく使用されます。
// Don’t use this!
var naiveReverse = function(string) {
return string.split('').reverse().join('');
}
実際、これまでに投稿されたすべての回答は、このパターンの変形です。ただし、この解決策にはいくつかの問題があります。例えば：
naiveReverse('foo ???? bar');
// → 'rab �� oof'
// Where did the `????` symbol go? Whoops!
なぜこれが起こるのか疑問に思うのであれば、 JavaScriptの内部文字エンコーディングについて読んでください 。 （TL; DR：????はアストラルシンボルであり、JavaScriptはそれを2つの別々のコード単位として公開しています。）
しかし、もっとあります：
// 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.
文字列の逆の実装をテストするのに良い文字列は 以下 です。
'foo ???? bar mañana mañana'
どうして？なぜならそれはアストラルシンボル（????）（これは JavaScriptではサロゲートペアで表される ）と結合マーク（最後のñのmañanaは実際には2つのシンボルから成ります： 0303チルドの組み合わせ）。
サロゲートペアが表示される順序を元に戻すことはできません。そうしないと、アストラル記号が「反転」文字列に表示されなくなります。そのため、前の例の出力にそれらの��マークが表示されました。
結合マークは常に前のシンボルに適用されるので、メインシンボル（U + 006Eラテン小文字N）を結合マーク（U + 0303 COMBINING TILDE）として扱う必要があります。順番を逆にすると、結合マークが文字列内の別のシンボルとペアになります。出力例がãの代わりにñを持っていたのはそのためです。
うまくいけば、これはこれまでに投稿されたすべての答えが 間違った である理由を説明しています。
最初の質問に答えるために、JavaScriptで文字列を[正しく]反転させる方法 - 、私はUnicode対応の文字列反転を可能にする小さなJavaScriptライブラリを書きました。今述べた問題はありません。このライブラリは Esrever と呼ばれます。そのコードはGitHub上にあり、ほとんどすべてのJavaScript環境で機能します。シェルユーティリティ/バイナリが付属しているので、必要に応じて端末から文字列を簡単に元に戻すことができます。
var input = 'foo ???? bar mañana mañana';
esrever.reverse(input);
// → 'anañam anañam rab ???? oof'
「インプレース」部分については、他の答えを見てください。
String.prototype.reverse=function(){return this.split("").reverse().join("");}
または
String.prototype.reverse = function() {
var s = "";
var i = this.length;
while (i>0) {
s += this.substring(i-1,i);
i--;
}
return s;
}
詳細な分析と、文字列を反転する10の異なる方法とそれらのパフォーマンスの詳細。
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));
}
全体の「逆さまの文字列を逆にする」というのは、Cプログラマーの時代遅れのインタビューの質問であり、彼らにインタビューを受けた人々（復讐のために、多分？）が尋ねるでしょう。残念ながら、ほとんどすべての管理言語（JS、C＃など）の文字列は不変の文字列を使用しているため、新しいメモリを割り当てずに文字列を移動するという考えを完全に破っています。
上記の解決策は確かに文字列を逆にしますが、より多くのメモリを割り当てずにそれを実行しないため、条件を満たしません。割り当てられた文字列に直接アクセスし、元のメモリ位置を操作して元の位置に戻すことができる必要があります。
個人的に、私は本当にこの種のインタビューの質問を嫌います、しかし残念ながら、私達はこれから何年もの間それらを見続けていると確信しています。
まず、 Array.from() を使用して文字列を配列に変換し、次に Array.prototype.reverse() を使用して配列を反転し、次に Array.prototype.join() を使用して文字列に戻します。
const reverse = str => Array.from(str).reverse().join('');
ECMAScript 6では、 spread演算子 を使用すると、.split('') splitメソッドを使用しなくても文字列をさらに高速に反転できます。
var str = [...'racecar'].reverse().join('');
私はパーティーに3年遅れているようです...
残念ながらあなたは指摘されたようにできません。参照 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をどれだけ効率的に再実装するかによって大きく異なります。たとえば、文字列インデックスの操作をしたり、小さなslicesやsubstrsを使用するだけでよい場合は、スペースと時間を節約できます。ただし、大きな逆のスライスや部分文字列を印刷することを計画している場合は、実際のコピーを行うよりもさらに節約量が少なくて済みます。プロトタイプを作成することでこれを偽造することができるかもしれませんが、あなたの "反転された"文字列もstring型を持ちません。
上記のデモ実装は、タイプReversedStringの新しいオブジェクトを作成します。これはプロトタイプ化されているため、ほとんど作業も最小限のスペースオーバーヘッドでプロトタイプが定義されているため、かなり効率的です。これは遅延スライスを含む遅延実装です。 .sliceや.reversedのような関数を実行するときはいつでも、インデックス数学を実行します。最後に（.toString()や.charCodeAt(...)などを暗黙的に呼び出して）データを抽出すると、可能な限り少ないデータに触れながら「スマート」な方法でデータが適用されます。
注意：上記の文字列APIは一例であり、完全には実装されていないかもしれません。あなたはあなたが必要とするちょうど1-2の機能を使うこともできます。
面接中に、変数やネイティブメソッドを使用せずに文字列を反転するように依頼されました。これは私のお気に入りの実装です。
function reverseString(str) {
return str === '' ? '' : reverseString(str.slice(1)) + str[0];
}
var str = 'sample string';
[].map.call(str, function(x) {
return x;
}).reverse().join('');
OR
var str = 'sample string';
console.log(str.split('').reverse().join(''));
//出力： 'gnirts elpmas'
これが私が考える最も簡単な方法です
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 ????'));それには複数の方法があります、あなたは以下をチェックすることができます、
1. for for Traditional（インクリメント）：
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 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('');
}
JavaScriptでの文字エンコードの複雑さについて私を教育するためのMathias、Punycode、およびその他のさまざまな参考文献へのすべての小道具。
JavaScriptで文字列を反転する方法はたくさんあります。私は私が好む3つの方法を書き留めています。
逆関数を使用したアプローチ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;
}
Reduce関数を使ったアプローチ3：
function reverse(str) {
return str.split('').reduce((rev, char) => char + rev, '');
}
これが役に立つことを願っています:)
ES6では、もう1つ選択肢があります。
function reverseString (str) {
return [...str].reverse().join('')
}
reverseString('Hello');
JS文字列は不変であるため、できません。短い非インプレースソリューション
[...str].reverse().join``
let str = "Hello World!";
let r = [...str].reverse().join``;
console.log(r);本当の答えは次のとおりです。元に戻すことはできませんが、その逆の文字列を新しく作成することはできます。
再帰を伴う運動のように：時々インタビューに行くとき、インタビュアーは再帰を使ってこれをどうやってやるかを尋ねるかもしれません、そして私はそれがむしろ再帰の中でこれをしたくない（スタックオーバーフローが発生する可能性があります）（これはO(n)ではなくO(log n)であるため、O(log n)の場合、スタックオーバーフローを発生させるのは非常に困難です。40億アイテムを処理できます。 2 ** 32は4294967296なので、スタックレベルは32です。ただし、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
//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");
組み込み関数を使いたくない場合これを試して
var string = 'abcdefg';
var newstring = '';
for(let i = 0; i < string.length; i++){
newstring = string[i] += newstring
}
console.log(newstring)
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";
それをDRYとシンプルな愚かさを保ってください！
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;
}
function reverseString(string) {
var reversedString = "";
var stringLength = string.length - 1;
for (var i = stringLength; i >= 0; i--) {
reversedString += string[i];
}
return reversedString;
}
私自身の最初の試み.
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"
文字列を配列に変換せずに。
String.prototype.reverse = function() {
var ret = "";
var size = 0;
for (var i = this.length - 1; -1 < i; i -= size) {
if (
'\uD800' <= this[i - 1] && this[i - 1] <= '\uDBFF' &&
'\uDC00' <= this[i] && this[i] <= '\uDFFF'
) {
size = 2;
ret += this[i - 1] + this[i];
} else {
size = 1;
ret += this[i];
}
}
return ret;
}
console.log('anãnam anañam' === 'mañana mañana'.reverse());
文字をコードポイントに変換せずにArray.reverseを使用する。
String.prototype.reverse = function() {
var array = this.split("").reverse();
for (var i = 0; i < this.length; ++i) {
if (
'\uD800' <= this[i - 1] && this[i - 1] <= '\uDBFF' &&
'\uDC00' <= this[i] && this[i] <= '\uDFFF'
) {
array[i - 1] = array[i - 1] + array[i];
array[i] = array[i - 1].substr(0, 1);
array[i - 1] = array[i - 1].substr(1, 1);
}
}
return array.join("");
}
console.log('anãnam anañam' === 'mañana mañana'.reverse());
JavaScriptで文字列を反転するための最良の方法
1）Array.reverse：
おそらくあなたが考えているのは、私たちが文字列を逆にしていると思ったのを待って、なぜあなたはArray.reverseメソッドを使っているのか。 String.splitメソッドを使用して、文字列を文字の配列に変換します。次に、配列内の各値の順序を逆にして、最後にArray.joinメソッドを使用して配列を文字列に変換します。
function reverseString(str) {
return str.split('').reverse().join('');
}
reverseString('dwayne');
2）while-loopを減少させる：
かなり冗長ですが、このソリューションにはソリューション1よりも優れた利点があります。配列を作成するのではなく、ソース文字列の文字に基づいて文字列を連結するだけです。
パフォーマンスの観点からは、これはおそらく最良の結果が得られます（未テストですが）。極端に長い文字列の場合は、パフォーマンスが向上してもウィンドウが表示されなくなる可能性があります。
function reverseString(str) {
var temp = '';
var i = str.length;
while (i > 0) {
temp += str.substring(i - 1, i);
i--;
}
return temp;
}
reverseString('dwayne');
3）再帰
私はこの解決策がどれほど単純で明確であるかが大好きです。 String.charAtメソッドとString.substrメソッドは、文字列が空になるまで毎回自分自身を呼び出すことで、異なる値を渡すために使用されていることがわかります。 。これはおそらく2番目の解決策に次いで2番目に良いパフォーマンスを生み出すでしょう。
function reverseString(str) {
return (str === '') ? '' : reverseString(str.substr(1)) + str.charAt(0);
}
reverseString('dwayne');
OK、 非常に単純です。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"
配列関数を使う
String.prototype.reverse = function(){
return [].reduceRight.call(this, function(last, secLast){return last + secLast});
}
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);
文字列の反転を実現するために使用できる4つの最も一般的な方法は次のとおりです
文字列を指定して、文字の逆順で新しい文字列を返す
問題に対する複数の解決策
//reverse('Apple') === 'leppa'
//reverse('hello') === 'olleh'
//reverse('Greetings!') === '!sgniteerG'
// 1. First method without using reverse function and negative for loop
function reverseFirst(str) {
if(str !== '' || str !==undefined || str !== null) {
const reversedStr = [];
for(var i=str.length; i>-1; i--) {
reversedStr.Push(str[i]);
}
return reversedStr.join("").toString();
}
}
// 2. Second method using the reverse function
function reverseSecond(str) {
return str.split('').reverse().join('');
}
// 3. Third method using the positive for loop
function reverseThird(str){
const reversedStr = [];
for(i=0; i<str.length;i++) {
reversedStr.Push(str[str.length-1-i])
}
return reversedStr.join('').toString();
}
// 4. using the modified for loop ES6
function reverseForth(str) {
const reversedStr = [];
for(let character of str) {
reversedStr = character + reversedStr;
}
return reversedStr;
}
// 5. Using Reduce function
function reverse(str) {
return str.split('').reduce((reversed, character) => {
return character + reversed;
}, '');
}
発音区別符号と2バイト文字の組み合わせの両方を処理する小さな関数。
(function(){
var isCombiningDiacritic = function( code )
{
return (0x0300 <= code && code <= 0x036F) // Comb. Diacritical Marks
|| (0x1AB0 <= code && code <= 0x1AFF) // Comb. Diacritical Marks Extended
|| (0x1DC0 <= code && code <= 0x1DFF) // Comb. Diacritical Marks Supplement
|| (0x20D0 <= code && code <= 0x20FF) // Comb. Diacritical Marks for Symbols
|| (0xFE20 <= code && code <= 0xFE2F); // Comb. Half Marks
};
String.prototype.reverse = function()
{
var output = "",
i = this.length - 1,
width;
for ( ; i >= 0; --i )
{
width = 1;
while( i > 0 && isCombiningDiacritic( this.charCodeAt(i) ) )
{
--i;
width++;
}
if (
i > 0
&& "\uDC00" <= this[i] && this[i] <= "\uDFFF"
&& "\uD800" <= this[i-1] && this[i-1] <= "\uDBFF"
)
{
--i;
width++;
}
output += this.substr( i, width );
}
return output;
}
})();
// Tests
[
'abcdefg',
'ab\u0303c',
'a\uD83C\uDFA5b',
'a\uD83C\uDFA5b\uD83C\uDFA6c',
'a\uD83C\uDFA5b\u0306c\uD83C\uDFA6d',
'TO͇̹̺ͅƝ̴ȳ̳ TH̘Ë͖́̉ ͠P̯͍̭O̚N̐Y̡' // copied from http://stackoverflow.com/a/1732454/1509264
].forEach(
function(str){ console.log( str + " -> " + str.reverse() ); }
);
以下は再帰的に文字列を反転しようとしている人を助けるかもしれません。関数型プログラミングスタイルを使用して、最近の就職の面接でこれを行うように依頼されました。
var reverseStr = function(str) {
return (str.length > 0) ? str[str.length - 1] + reverseStr(str.substr(0, str.length - 1)) : '';
};
//tests
console.log(reverseStr('setab retsam')); //master bates
var str = "IAMA JavaScript Developer";
var a=str.split(''), b = a.length;
for (var i=0; i<b; i++) {
a.unshift(a.splice(1+i,1).shift())
}
a.shift();
alert(a.join(''));
このようなことは、ベストプラクティスに従って実行する必要があります。
(function(){
'use strict';
var str = "testing";
//using array methods
var arr = new Array();
arr = str.split("");
arr.reverse();
console.log(arr);
//using custom methods
var reverseString = function(str){
if(str == null || str == undefined || str.length == 0 ){
return "";
}
if(str.length == 1){
return str;
}
var rev = [];
for(var i = 0; i < str.length; i++){
rev[i] = str[str.length - 1 - i];
}
return rev;
}
console.log(reverseString(str));
})();あなたはこのようなことを試すことができます。リファクタリングの余地があると確信しています。私は分割機能を使用して回避することができませんでした。多分誰かが分割せずにそれを行う方法を知っています。
設定するコードは、これをあなたの.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 />');Stringプロトタイプに追加することは理想的です（コアのJS言語に追加される場合に備えて）。ただし、まずそれが存在するかどうかを確認し、存在しない場合は追加する必要があります。
String.prototype.reverse = String.prototype.reverse || function () {
return this.split('').reverse().join('');
};
Word.split('').reduce((acc, curr) => curr+""+acc)
たぶん、これはあなたのために働くでしょう
function reverse(str){
str = str.split("").reverse().join("").split(" ").reverse().join(" ");
console.log(str)
}
もう一つのバリエーション（それはIEで動作しますか？）：
String.prototype.reverse = function() {
for (i=1,s=""; i<=this.length; s+=this.substr(-i++,1)) {}
return s;
}
編集：
これは組み込み関数を使用していません。
String.prototype.reverse = function() {
for (i=this[-1],s=""; i>=0; s+=this[i--]) {}
return s;
}
注：this [-1]は文字列の長さを保持します。
ただし、個々の配列要素への代入はStringオブジェクトでは機能しないため（保護された？）、文字列を元の位置に戻すことは不可能です。すなわち代入はできますが、結果の文字列は変わりません。
function reverse_string(string)
{
var string;
var len = string.length;
var stringExp = string.split('');
var i;
for (i = len-1; i >=0;i--)
{
var result = document.write(stringExp[i]);
}
return result;
}
reverse_string("This is a reversed string");
//出力：gnirtsはsi sihTを逆転させる
これは、Array.prototype.reverseを使用しない基本的なES6不変の例です。
// :: reverse = String -> String
const reverse = s => [].reduceRight.call(s, (a, b) => a + b)
console.log(reverse('foo')) // => 'oof'
console.log(reverse('bar')) // => 'rab'
console.log(reverse('foo-bar')) // => 'rab-oof'function reverse(str){
var s = "";
for (var i = str.length - 1; i >= 0; i--){
s += str[i];
}
return s;
};
reverse("your string comes here")
var reverseString = function(str){
let length = str.length - 1;
str = str.split('');
for(let i=0;i<= length;i++){
str[length + i + 1] = str[length - i];
}
return str.splice(length + 1).join('');
}