JavaScript'te bir dizeyi nasıl tersine çevirirsiniz?


435

Yerleşik işlevler ( vb.) Kullanılmadan .reverse(), return ifadesine sahip bir işleve iletildiğinde JavaScript'te bir dizeyi yerinde (veya yerinde) nasıl ters çevirirsiniz .charAt()?


yani, dizenin karakterlerini almak için .charAt () kullanmanıza izin verilmiyor mu?
Irwin

155
Yapamazsın. JavaScript dizeleri değiştirilemez, yani her birine ayrılan bellek yazılamaz, bu da "yerinde" ters dönüşleri imkansız hale getirir.
Crescent Fresh

2
Re: crescentfresh adlı kullanıcının yorumu bkz stackoverflow.com/questions/51185/…
baudtack

1
@crescentfresh bunu yeni bir yanıt olarak göndermelisiniz.
Baudtack

Yanıtlar:


736

Basit ASCII karakterleriyle uğraştığınız ve yerleşik işlevleri kullanmaktan mutluluk duyduğunuz sürece, bu işe yarayacaktır:

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

UTF-16 veya diğer çok baytlı karakterleri destekleyen bir çözüme ihtiyacınız varsa, bu işlevin geçersiz unicode dizeleri veya komik görünen geçerli dizeler vereceğini unutmayın. Bunun yerine bu yanıtı düşünmek isteyebilirsiniz .

[... s] Unicode farkında, küçük bir düzenleme verir: -

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

44
Bu, vekil çiftler içeren UTF-16 dizeleri, yani temel çok dilli düzlemin dışındaki karakterler için kırılmıştır. Ayrıca, birleştirici karakter içeren dizeler için komik sonuçlar verecektir, örneğin aşağıdaki karakterde bir diyaerez görünebilir. İlk sorun geçersiz unicode dizelerine, ikincisi ise komik görünen geçerli dizelere yol açacaktır.
Martin Probst

2
@Richeve Bebedor "Yerleşik işlevleri kullanmadan hepsi? .Reverse ()" JS'de bir dizeyi tersine çevirmek için uygulanabilir bir çözüm olmasına rağmen, sorunun sınırlarına uymadığı için bu kabul edilmiş bir çözüm olmaz.
David Starkey

1
@DavidStarkey: Evet, neredeyse dört yıl sonra geriye dönüp baktığımda, sorunun amacını nasıl bu kadar özlediğimi görmek zor. Görünüşe göre sadece iki dakika beklemeliydim ve crescentfresh'in orijinal yazıyla ilgili yorumunu iptal etmeliydim!
belacqua

14
@MartinProbst Cevabım, vekil çiftlerle ilgilenen ve işaretleri doğru bir şekilde birleştiren soruna Unicode farkında bir çözüm sunuyor: stackoverflow.com/a/16776380/96656
Mathias Bynens 27:13

1
UTF-16 için return [...s].reverse().join("");çalışabilir.
user4642212

411

JavaScript'te bir dizeyi tersine çevirmek için genellikle aşağıdaki teknik (veya benzeri) kullanılır:

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

Aslında, şimdiye kadar gönderilen tüm cevaplar bu modelin bir varyasyonudur. Ancak bu çözümde bazı sorunlar var. Örneğin:

naiveReverse('foo 𝌆 bar');
// → 'rab �� oof'
// Where did the `𝌆` symbol go? Whoops!

Bunun neden olduğunu merak ediyorsanız , JavaScript'in dahili karakter kodlamasını okuyun . (TL; DR: 𝌆astral bir semboldür ve JavaScript bunu iki ayrı kod birimi olarak gösterir.)

Ancak daha fazlası var:

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

Dize ters uygulamalarını test etmek için iyi bir dize şudur :

'foo 𝌆 bar mañana mañana'

Neden? Astral sembolü ( 𝌆) ( JavaScript'teki yedek çiftlerle temsil edilir ) ve bir birleştirme işareti içerdiğinden ( sonuncusu mañanaaslında iki simgeden oluşur: U + 006E LATIN KÜÇÜK MEKTUP N ve U + 0303 BİRLEŞİK TİLDE).

Yedek çiftlerin görünme sırası tersine çevrilemez, aksi takdirde astral sembolü artık 'ters' dizede görünmez. Bu yüzden ��önceki örnek için çıktıda bu işaretleri gördünüz .

Birleştirilen işaretler her zaman önceki sembole uygulanır, bu nedenle hem ana simgeye (U + 006E LATIN KÜÇÜK MEKTUP N) birleştirme işareti (U + 0303 BİRLEŞİK TİLDE) olarak bir bütün olarak davranmanız gerekir. Sıralarını ters çevirmek, birleştirme işaretinin dizedeki başka bir sembolle eşleştirilmesine neden olur. Bu yüzden örnek çıktı yerine ñ.

Umarım, bu şimdiye kadar gönderilen tüm cevapların neden yanlış olduğunu açıklar .


İlk sorunuzu cevaplamak için - JavaScript'te [düzgün bir şekilde bir dizeyi nasıl tersine çevirebilirsiniz - - Unicode farkında dize tersine çevirebilen küçük bir JavaScript kitaplığı yazdım. Az önce bahsettiğim sorunlardan hiçbiri yok. Kütüphaneye Esrever denir ; kodu GitHub'da ve hemen hemen her JavaScript ortamında çalışıyor. Bir kabuk yardımcı programı / ikili ile birlikte gelir, böylece isterseniz dizelerinizden dizeleri kolayca tersine çevirebilirsiniz.

var input = 'foo 𝌆 bar mañana mañana';
esrever.reverse(input);
// → 'anañam anañam rab 𝌆 oof'

“Yerinde” kısmına gelince, diğer cevaplara bakınız.


65
Cevabınıza Esrever kodunun ana bölümünü eklemelisiniz.
31.07.2014

1
@Meglio Bu özel yaklaşımla, evet.
Mathias Bynens

8
Sorun, elbette, "bir dizgeyi tersine çevir" in açık bir şekilde ses çıkarması, ancak burada belirtilen sorunların karşısında değil. Bir dizginin tersine çevrilmesi, yazdırıldığında dizgideki grafik kümelerini ters sırada görüntüleyeceği dizeyi döndürüyor mu? Bir yandan, kulağa muhtemel geliyor. Öte yandan, bunu neden yapmak istesin? Bu tanım yazdırılmaya dayanır ve ters bir dize yazdırmak nadiren yararlıdır. Bir algoritmanın parçası olarak gereksinimleriniz tamamen farklı olabilir.
Martijn

19
Bu bir yok iken büyük bir problemi açıklayan işi, gerçek cevabı olan başka kalede . @ R0estir0bbe bir yıl önce söylediği gibi, ilgili kodu olmalıdır içinde cevap, sadece bağlantılı değildir.
TJ Crowder

4
"Umarım, bu şimdiye kadar gönderilen tüm cevapların neden yanlış olduğunu açıklıyor" - Bu iddia aşırı güçlü imo. Birçok kullanım durumu UTF-16 desteği gerektirmez (basit örnek; URL'ler ve URL bileşenleri / parametreleriyle çalışma). Bir çözüm, yalnızca gerekli olmayan bir senaryoyu işlemediği için "yanlış" değildir. Özellikle, en çok oy alan cevap açıkça sadece ASCII karakterleriyle çalıştığını ve bu yüzden kesinlikle biraz yanlış olmadığını açıklıyor.
3'te 47

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

veya

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

String prototipine kesinlikle katılıyorum.
Jeff Meatball Yang

3
dize birleştirme pahalıdır. Bir dizi oluşturmak ve ona katılmak veya concat () kullanmak daha iyidir.
Bjorn

2
# 1 en iyisi, # 2 korkunç derecede yavaş olabilir
adamJLev

9
Ancak, Unicode bileşik karakterler bulunduğunda çözümlerin hiçbiri işe yaramaz.
Eric Grange

2
@JuanMendes Bu yorumu 2009'da bıraktım, son 4 yılda işler değişti. : P
Bjorn

63

Ayrıntılı analiz ve bir dizgeyi tersine çevirmenin on farklı yolu ve performans detayları

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

Bu uygulamaların performansı:

Tarayıcı başına en iyi performans gösteren uygulamalar

  • Chrome 15 - Uygulamalar 1 ve 6
  • Firefox 7 - Uygulama 6
  • IE 9 - Uygulama 4
  • Opera 12 - Uygulama 9

İşte bu uygulamalar:

Uygulama 1:

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

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

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

Uygulama 4:

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

Uygulama 5:

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

Uygulama 6:

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

Uygulama 7:

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

Uygulama 8:

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

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

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

53

Bütün "yerinde bir ipi ters çevir" eski bir röportaj soru C programcıları ve onlar tarafından röportaj insanlar (intikam, belki?), Sorar. Ne yazık ki, yönetilmeyen herhangi bir dilde (JS, C #, vb.) Dizeler değişmez dizeler kullandığından artık çalışmayan "Yerinde" bölümdür, böylece yeni bir bellek ayırmadan bir dizeyi taşıma fikrini yener.

Yukarıdaki çözümler gerçekten bir dizgiyi tersine çevirirken, daha fazla bellek ayırmadan yapmazlar ve bu nedenle koşulları karşılamazlar. Dizeye ayrılan şekilde doğrudan erişiminizin olması ve yerinde tersine çevirmek için orijinal bellek konumunu değiştirebilmeniz gerekir.

Şahsen, bu tür röportaj sorularından gerçekten nefret ediyorum, ama ne yazık ki, gelecek yıllarda onları görmeye devam edeceğimizden eminim.


7
En azından bana JS'de bir "yerinde" dizesini tersine çevirmeyi sorduğumda bir mülakatçının oldukça etkilendiğini söyleyebilirim ve JS'deki dizelerin değişmez olmasının neden imkansız olduğunu açıkladım. Beklediği cevap bu muydu yoksa onu biraz eğitmiş miydim bilmiyorum. Her iki durumda da iyi çalıştı;)
Chev

1
Belki bir çöp toplayıcı tarafından "yönetilen" anlamına gelir, en azından genellikle "yönetilen dil" veya bir Sanal Makine / Sanal Çalışma Zamanı Ortamı'nın varlığı ile kastedilmektedir? @torazaburo
AntonB

39

İlk olarak, Array.from()bir dizeyi bir diziye dönüştürmek için kullanın , sonra Array.prototype.reverse()diziyi tersine çevirmek ve sonra Array.prototype.join()dizeyi geri getirmek için kullanın.

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

Tepegöz var, ama bu zarif bir çözüm! Önceden var olan reversemantığın yeniden yazımı yoktur .
Gershom

2
@felixfbecker Hayır, string.split('')çalışmıyor. Daha fazla açıklama için bu cevaba bakınız .
Michał Perłakowski

5
Unicode ile de çalıştığı için bu kabul edilen cevap olmalıdır. Örneğin, yukarıdaki örnekten:Array.from('foo 𝌆 bar mañana mañana').reverse().join('') == 'anãnam anañam rab 𝌆 oof'
Julian TF

3
@JulianTF Tam olarak değil, bir tilde "n" yerine "a" ya hala uygulanır.
Roman Boiko

2
@RomanBoiko Doğru, ancak önce dizeyi normalleştirebilirsiniz. Array.from('foo 𝌆 bar mañana mañana'.normalize('NFC')).reverse().join('')olacak"anañam anañam rab 𝌆 oof"
Bay Lister

26

ECMAScript'e 6'da, daha da hızlı kullanmadan bir dize tersine çevirebilir .split('')ile, split yöntemi yayılmış operatörü şöyle:

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

1
ES6 ayrıca `` yerine('')

bu durumda iki backtick kullanmak için bir neden yok
Vic

1
Kod golf sürece bu önlemek gerekir. Yazmak string.split('')çoğu insan için daha açıktır [...string].
AnnanFay

1
@AnnanFay .split(''), ek düzlemlerden (UTF-16'daki vekil çiftler) karakterlerle ilgili bir soruna sahiptir, çünkü kod noktası yerine UTF-16 kod birimi ile ayrılır . Forma operatörü ve (benim tercihim) bunu yapmaz. Array.from()
Inkling

@Inkling Bunun bir sorun olduğunun farkında değildim. Gösterdiğiniz için teşekkürler. Hala netlik için bir yarar fonksiyonu yazmaya cazip olurdu.
AnnanFay

19

Partiye 3 yıl geç kaldım ...

Maalesef işaret edildiği gibi yapamazsınız. Bkz. JavaScript dizeleri değiştirilemez mi? JavaScript'te bir "dize oluşturucu" ya ihtiyacım var mı?

Yapabileceğiniz bir sonraki en iyi şey, bir dize alan ve kullandığınız dize API'sinin herhangi bir bölümünü yeniden uygulayan ancak dizeyi ters çevirmiş gibi davranan bir "görünüm" veya "sarmalayıcı" oluşturmaktır. Örneğin:

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

Demo:

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

Kicker - aşağıdakiler yerine saf matematik tarafından yapılır, her karakteri sadece bir kez ve sadece gerekirse ziyaret eder:

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

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

Bu, çok küçük bir dizeye uygulanırsa, sadece nispeten küçük bir dilim alıyorsanız, önemli tasarruflar sağlar.

Buna değip değmeyeceği (çoğu programlama dilinde olduğu gibi kopya olarak tersine çevirme) büyük ölçüde kullanım durumunuza ve dize API'sını ne kadar verimli bir şekilde yeniden uyguladığınıza bağlıdır. Örneğin, istediğiniz tek şey dizgi dizini manipülasyonu yapmak veya küçük slices veya substrs almaksa, bu size yer ve zaman kazandırır. Bununla birlikte, büyük ters çevrilmiş dilimleri veya alt dizeleri yazdırmayı planlıyorsanız, tasarruflar küçük olabilir, tam bir kopya yapmaktan bile daha kötü olabilir. "Tersine çevrilmiş" dizeniz de türüne sahip olmayacaktır string, ancak bunu prototipleme ile taklit edebilirsiniz.

Yukarıdaki demo uygulaması ReversedString türünde yeni bir nesne oluşturur. Neredeyse minimum çalışma ve minimum alan yükü ile prototip ve bu nedenle oldukça verimlidir (prototip tanımları paylaşılır). Ertelenmiş dilimlemeyi içeren tembel bir uygulamadır. .sliceVeya gibi bir işlevi .reversedgerçekleştirdiğinizde, dizin matematiği gerçekleştirir. Son olarak, veriyi (dolaylı olarak çağırarak .toString()veya bir .charCodeAt(...)şeyle) ayıkladığınızda , bu verileri mümkün olan en az veriye dokunarak "akıllı" bir şekilde uygular.

Not: Yukarıdaki dize API'si bir örnektir ve mükemmel bir şekilde uygulanamayabilir. İhtiyacınız olan sadece 1-2 işlevi de kullanabilirsiniz.


13

JavaScript'te bir dizeyi tersine çevirmenin birçok yolu vardır. Tercih ettiğim üç yolu not alıyorum.

Yaklaşım 1: Ters fonksiyonu kullanma:

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

Yaklaşım 2: Karakterler arasında geçiş yapma:

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

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

  return reversed;
}

Yaklaşım 3: Azaltma fonksiyonunu kullanma:

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

Umarım bu yardımcı olur :)


10

Bir röportaj sırasında, herhangi bir değişken veya yerel yöntem kullanmadan bir dizeyi ters çevirmem istendi. Bu benim en sevdiğim uygulama:

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

Kısa, basit, ama cehennem gibi yavaş;)
Tom

13
Sıfır yerli yöntem? Ne olmuş slice? : - /
yaprak

1
Özyinelemenin ilginç kullanımı. Stack Overflow üzerinde olması ironik. stackoverflow.com/q/2805172/265877
Alex

@Alex, iyi bir noktaya değindin. Bazı durumlarda, görüşmeci sizden kullanmamanızı isteyecektir Array.prototype.reverse().
Daniel

10

Bunu yapmanın birden fazla yolu vardır, aşağıdakileri kontrol edebilirsiniz,

1. döngü için Geleneksel (artan):

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

2. döngü için Geleneksel (azalan):

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-loop kullanarak

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

4. forEach / yüksek sıralı dizi yöntemini kullanarak:

function reverseString(str){

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

5. ES6 standardı:

function reverseString(str){

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

6. son yolu:

function reverseString(str){

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

alert(reverseString("Learning JavaScript"));

7. Aşağıdakileri kullanarak da sonuç alabilirsiniz,

function reverseString(str){

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


7

ES6'da bir seçeneğiniz daha var

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

reverseString('Hello');

6

Bence bu en kolay yol

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


3
Örneğinize bir emoji eklemeniz güzel. Böylece, bunun açıkça emojiler ve diğer birçok unicode karakter için çalışmadığını görüyoruz.
Íhor Mé

İnanç, cevabınız doğru olsa da, bunun en kolay yolu olduğuna katılmıyorum. İlk birkaç cevap Array.prototype.reverse()bundan en kolay ve dolayısıyla en popüler cevap olacaktır. Tabii ki, iyi bir JavaScript bilgisi gerektirir.
Daniel

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

VEYA

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

// Çıktı: 'gnirts elpmas'


Tüm 'harita' kısmınız olarak yazılabilir [...str].

5

Bunun iyi yanıtlanmış eski bir soru olduğunu biliyorum, ancak kendi eğlencem için aşağıdaki ters işlevi yazdım ve başka biri için yararlı olması durumunda paylaşacağımı düşündüm. Hem vekil çiftleri hem de işaretleri birleştirir:

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, karakter kodlamanın karmaşıklığı konusunda beni eğitmek için Mathias, Punycode ve diğer çeşitli referanslara yapılan tüm destekler.



3

Herhangi bir yerleşik işlev kullanmak istemiyorsanız. Bunu dene

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

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

console.log(newstring);

2

Gerçek cevap şudur: onu tersine çeviremezsiniz, ancak tersi olan yeni bir dize oluşturabilirsiniz.

Tıpkı özyineleme ile oynamak için bir alıştırma olarak: bazen röportaja gittiğinizde, görüşmeci size özyineleme kullanarak bunu nasıl yapacağınızı sorabilir ve bence "tercih edilen cevap" olabilir "Bunu özyineleme olarak yapmamayı tercih ederim bir yığın taşmasına neden olabilir "(çünkü O(n)daha doğrudur O(log n). Öyle ise O(log n), yığın taşması elde etmek oldukça zordur - 4 milyar öğe 32 yığın düzeyinde işlenebilir, çünkü 2 ** 32 4294967296. Ancak öyleyse O(n), bir yığın taşmasını kolayca alabilir.

Bazen görüşmeci hala size "tıpkı bir alıştırma olarak, neden hala özyineleme kullanarak yazmıyorsunuz?" Diye soracaktır. Ve işte burada:

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

test sürüşü:

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

çıktı:

999elppa899elppa...2elppa1elppa0elppa

Bir yığın taşması alıyorum denemek için, ben değiştim 1000için 10000Google Chrome'da ve rapor:

RangeError: Maximum call stack size exceeded

2

Dizelerin kendileri değiştirilemez, ancak aşağıdaki kodla kolayca ters çevrilmiş bir kopya oluşturabilirsiniz:

function reverseString(str) {

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

  var strReverse = strArray.join("");

  return strReverse;
}

reverseString("hello");

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

1
Bu, ek düzlem karakterlerini doğru bir şekilde ele alma avantajına sahiptir.

2

Hem aksanları hem de 2 baytlık karakterleri birleştiren küçük bir işlev:

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


Güncelleme

Aksanları birleştirmenin daha eksiksiz bir listesi:

      var isCombiningDiacritic = function( code )
      {
        return (0x0300 <= code && code <= 0x036F)
            || (0x0483 <= code && code <= 0x0489)
            || (0x0591 <= code && code <= 0x05BD)
            || (code == 0x05BF)
            || (0x05C1 <= code && code <= 0x05C2)
            || (0x05C4 <= code && code <= 0x05C5)
            || (code == 0x05C7)
            || (0x0610 <= code && code <= 0x061A)
            || (0x064B <= code && code <= 0x065F)
            || (code == 0x0670)
            || (0x06D6 <= code && code <= 0x06DC)
            || (0x06DF <= code && code <= 0x06E4)
            || (0x06E7 <= code && code <= 0x06E8)
            || (0x06EA <= code && code <= 0x06ED)
            || (code == 0x0711)
            || (0x0730 <= code && code <= 0x074A)
            || (0x07A6 <= code && code <= 0x07B0)
            || (0x07EB <= code && code <= 0x07F3)
            || (code == 0x07FD)
            || (0x0816 <= code && code <= 0x0819)
            || (0x081B <= code && code <= 0x0823)
            || (0x0825 <= code && code <= 0x0827)
            || (0x0829 <= code && code <= 0x082D)
            || (0x0859 <= code && code <= 0x085B)
            || (0x08D3 <= code && code <= 0x08E1)
            || (0x08E3 <= code && code <= 0x0902)
            || (code == 0x093A)
            || (code == 0x093C)
            || (0x0941 <= code && code <= 0x0948)
            || (code == 0x094D)
            || (0x0951 <= code && code <= 0x0957)
            || (0x0962 <= code && code <= 0x0963)
            || (code == 0x0981)
            || (code == 0x09BC)
            || (0x09C1 <= code && code <= 0x09C4)
            || (code == 0x09CD)
            || (0x09E2 <= code && code <= 0x09E3)
            || (0x09FE <= code && code <= 0x0A02)
            || (code == 0x0A3C)
            || (0x0A41 <= code && code <= 0x0A51)
            || (0x0A70 <= code && code <= 0x0A71)
            || (code == 0x0A75)
            || (0x0A81 <= code && code <= 0x0A82)
            || (code == 0x0ABC)
            || (0x0AC1 <= code && code <= 0x0AC8)
            || (code == 0x0ACD)
            || (0x0AE2 <= code && code <= 0x0AE3)
            || (0x0AFA <= code && code <= 0x0B01)
            || (code == 0x0B3C)
            || (code == 0x0B3F)
            || (0x0B41 <= code && code <= 0x0B44)
            || (0x0B4D <= code && code <= 0x0B56)
            || (0x0B62 <= code && code <= 0x0B63)
            || (code == 0x0B82)
            || (code == 0x0BC0)
            || (code == 0x0BCD)
            || (code == 0x0C00)
            || (code == 0x0C04)
            || (0x0C3E <= code && code <= 0x0C40)
            || (0x0C46 <= code && code <= 0x0C56)
            || (0x0C62 <= code && code <= 0x0C63)
            || (code == 0x0C81)
            || (code == 0x0CBC)
            || (0x0CCC <= code && code <= 0x0CCD)
            || (0x0CE2 <= code && code <= 0x0CE3)
            || (0x0D00 <= code && code <= 0x0D01)
            || (0x0D3B <= code && code <= 0x0D3C)
            || (0x0D41 <= code && code <= 0x0D44)
            || (code == 0x0D4D)
            || (0x0D62 <= code && code <= 0x0D63)
            || (code == 0x0DCA)
            || (0x0DD2 <= code && code <= 0x0DD6)
            || (code == 0x0E31)
            || (0x0E34 <= code && code <= 0x0E3A)
            || (0x0E47 <= code && code <= 0x0E4E)
            || (code == 0x0EB1)
            || (0x0EB4 <= code && code <= 0x0EBC)
            || (0x0EC8 <= code && code <= 0x0ECD)
            || (0x0F18 <= code && code <= 0x0F19)
            || (code == 0x0F35)
            || (code == 0x0F37)
            || (code == 0x0F39)
            || (0x0F71 <= code && code <= 0x0F7E)
            || (0x0F80 <= code && code <= 0x0F84)
            || (0x0F86 <= code && code <= 0x0F87)
            || (0x0F8D <= code && code <= 0x0FBC)
            || (code == 0x0FC6)
            || (0x102D <= code && code <= 0x1030)
            || (0x1032 <= code && code <= 0x1037)
            || (0x1039 <= code && code <= 0x103A)
            || (0x103D <= code && code <= 0x103E)
            || (0x1058 <= code && code <= 0x1059)
            || (0x105E <= code && code <= 0x1060)
            || (0x1071 <= code && code <= 0x1074)
            || (code == 0x1082)
            || (0x1085 <= code && code <= 0x1086)
            || (code == 0x108D)
            || (code == 0x109D)
            || (0x135D <= code && code <= 0x135F)
            || (0x1712 <= code && code <= 0x1714)
            || (0x1732 <= code && code <= 0x1734)
            || (0x1752 <= code && code <= 0x1753)
            || (0x1772 <= code && code <= 0x1773)
            || (0x17B4 <= code && code <= 0x17B5)
            || (0x17B7 <= code && code <= 0x17BD)
            || (code == 0x17C6)
            || (0x17C9 <= code && code <= 0x17D3)
            || (code == 0x17DD)
            || (0x180B <= code && code <= 0x180D)
            || (0x1885 <= code && code <= 0x1886)
            || (code == 0x18A9)
            || (0x1920 <= code && code <= 0x1922)
            || (0x1927 <= code && code <= 0x1928)
            || (code == 0x1932)
            || (0x1939 <= code && code <= 0x193B)
            || (0x1A17 <= code && code <= 0x1A18)
            || (code == 0x1A1B)
            || (code == 0x1A56)
            || (0x1A58 <= code && code <= 0x1A60)
            || (code == 0x1A62)
            || (0x1A65 <= code && code <= 0x1A6C)
            || (0x1A73 <= code && code <= 0x1A7F)
            || (0x1AB0 <= code && code <= 0x1B03)
            || (code == 0x1B34)
            || (0x1B36 <= code && code <= 0x1B3A)
            || (code == 0x1B3C)
            || (code == 0x1B42)
            || (0x1B6B <= code && code <= 0x1B73)
            || (0x1B80 <= code && code <= 0x1B81)
            || (0x1BA2 <= code && code <= 0x1BA5)
            || (0x1BA8 <= code && code <= 0x1BA9)
            || (0x1BAB <= code && code <= 0x1BAD)
            || (code == 0x1BE6)
            || (0x1BE8 <= code && code <= 0x1BE9)
            || (code == 0x1BED)
            || (0x1BEF <= code && code <= 0x1BF1)
            || (0x1C2C <= code && code <= 0x1C33)
            || (0x1C36 <= code && code <= 0x1C37)
            || (0x1CD0 <= code && code <= 0x1CD2)
            || (0x1CD4 <= code && code <= 0x1CE0)
            || (0x1CE2 <= code && code <= 0x1CE8)
            || (code == 0x1CED)
            || (code == 0x1CF4)
            || (0x1CF8 <= code && code <= 0x1CF9)
            || (0x1DC0 <= code && code <= 0x1DFF)
            || (0x20D0 <= code && code <= 0x20F0)
            || (0x2CEF <= code && code <= 0x2CF1)
            || (code == 0x2D7F)
            || (0x2DE0 <= code && code <= 0x2DFF)
            || (0x302A <= code && code <= 0x302D)
            || (0x3099 <= code && code <= 0x309A)
            || (0xA66F <= code && code <= 0xA672)
            || (0xA674 <= code && code <= 0xA67D)
            || (0xA69E <= code && code <= 0xA69F)
            || (0xA6F0 <= code && code <= 0xA6F1)
            || (code == 0xA802)
            || (code == 0xA806)
            || (code == 0xA80B)
            || (0xA825 <= code && code <= 0xA826)
            || (0xA8C4 <= code && code <= 0xA8C5)
            || (0xA8E0 <= code && code <= 0xA8F1)
            || (code == 0xA8FF)
            || (0xA926 <= code && code <= 0xA92D)
            || (0xA947 <= code && code <= 0xA951)
            || (0xA980 <= code && code <= 0xA982)
            || (code == 0xA9B3)
            || (0xA9B6 <= code && code <= 0xA9B9)
            || (0xA9BC <= code && code <= 0xA9BD)
            || (code == 0xA9E5)
            || (0xAA29 <= code && code <= 0xAA2E)
            || (0xAA31 <= code && code <= 0xAA32)
            || (0xAA35 <= code && code <= 0xAA36)
            || (code == 0xAA43)
            || (code == 0xAA4C)
            || (code == 0xAA7C)
            || (code == 0xAAB0)
            || (0xAAB2 <= code && code <= 0xAAB4)
            || (0xAAB7 <= code && code <= 0xAAB8)
            || (0xAABE <= code && code <= 0xAABF)
            || (code == 0xAAC1)
            || (0xAAEC <= code && code <= 0xAAED)
            || (code == 0xAAF6)
            || (code == 0xABE5)
            || (code == 0xABE8)
            || (code == 0xABED)
            || (code == 0xFB1E)
            || (0xFE00 <= code && code <= 0xFE0F)
            || (0xFE20 <= code && code <= 0xFE2F)
            || (code == 0x101FD)
            || (code == 0x102E0)
            || (0x10376 <= code && code <= 0x1037A)
            || (0x10A01 <= code && code <= 0x10A0F)
            || (0x10A38 <= code && code <= 0x10A3F)
            || (0x10AE5 <= code && code <= 0x10AE6)
            || (0x10D24 <= code && code <= 0x10D27)
            || (0x10F46 <= code && code <= 0x10F50)
            || (code == 0x11001)
            || (0x11038 <= code && code <= 0x11046)
            || (0x1107F <= code && code <= 0x11081)
            || (0x110B3 <= code && code <= 0x110B6)
            || (0x110B9 <= code && code <= 0x110BA)
            || (0x11100 <= code && code <= 0x11102)
            || (0x11127 <= code && code <= 0x1112B)
            || (0x1112D <= code && code <= 0x11134)
            || (code == 0x11173)
            || (0x11180 <= code && code <= 0x11181)
            || (0x111B6 <= code && code <= 0x111BE)
            || (0x111C9 <= code && code <= 0x111CC)
            || (0x1122F <= code && code <= 0x11231)
            || (code == 0x11234)
            || (0x11236 <= code && code <= 0x11237)
            || (code == 0x1123E)
            || (code == 0x112DF)
            || (0x112E3 <= code && code <= 0x112EA)
            || (0x11300 <= code && code <= 0x11301)
            || (0x1133B <= code && code <= 0x1133C)
            || (code == 0x11340)
            || (0x11366 <= code && code <= 0x11374)
            || (0x11438 <= code && code <= 0x1143F)
            || (0x11442 <= code && code <= 0x11444)
            || (code == 0x11446)
            || (code == 0x1145E)
            || (0x114B3 <= code && code <= 0x114B8)
            || (code == 0x114BA)
            || (0x114BF <= code && code <= 0x114C0)
            || (0x114C2 <= code && code <= 0x114C3)
            || (0x115B2 <= code && code <= 0x115B5)
            || (0x115BC <= code && code <= 0x115BD)
            || (0x115BF <= code && code <= 0x115C0)
            || (0x115DC <= code && code <= 0x115DD)
            || (0x11633 <= code && code <= 0x1163A)
            || (code == 0x1163D)
            || (0x1163F <= code && code <= 0x11640)
            || (code == 0x116AB)
            || (code == 0x116AD)
            || (0x116B0 <= code && code <= 0x116B5)
            || (code == 0x116B7)
            || (0x1171D <= code && code <= 0x1171F)
            || (0x11722 <= code && code <= 0x11725)
            || (0x11727 <= code && code <= 0x1172B)
            || (0x1182F <= code && code <= 0x11837)
            || (0x11839 <= code && code <= 0x1183A)
            || (0x119D4 <= code && code <= 0x119DB)
            || (code == 0x119E0)
            || (0x11A01 <= code && code <= 0x11A06)
            || (0x11A09 <= code && code <= 0x11A0A)
            || (0x11A33 <= code && code <= 0x11A38)
            || (0x11A3B <= code && code <= 0x11A3E)
            || (code == 0x11A47)
            || (0x11A51 <= code && code <= 0x11A56)
            || (0x11A59 <= code && code <= 0x11A5B)
            || (0x11A8A <= code && code <= 0x11A96)
            || (0x11A98 <= code && code <= 0x11A99)
            || (0x11C30 <= code && code <= 0x11C3D)
            || (0x11C92 <= code && code <= 0x11CA7)
            || (0x11CAA <= code && code <= 0x11CB0)
            || (0x11CB2 <= code && code <= 0x11CB3)
            || (0x11CB5 <= code && code <= 0x11CB6)
            || (0x11D31 <= code && code <= 0x11D45)
            || (code == 0x11D47)
            || (0x11D90 <= code && code <= 0x11D91)
            || (code == 0x11D95)
            || (code == 0x11D97)
            || (0x11EF3 <= code && code <= 0x11EF4)
            || (0x16AF0 <= code && code <= 0x16AF4)
            || (0x16B30 <= code && code <= 0x16B36)
            || (code == 0x16F4F)
            || (0x16F8F <= code && code <= 0x16F92)
            || (0x1BC9D <= code && code <= 0x1BC9E)
            || (0x1D167 <= code && code <= 0x1D169)
            || (0x1D17B <= code && code <= 0x1D182)
            || (0x1D185 <= code && code <= 0x1D18B)
            || (0x1D1AA <= code && code <= 0x1D1AD)
            || (0x1D242 <= code && code <= 0x1D244)
            || (0x1DA00 <= code && code <= 0x1DA36)
            || (0x1DA3B <= code && code <= 0x1DA6C)
            || (code == 0x1DA75)
            || (code == 0x1DA84)
            || (0x1DA9B <= code && code <= 0x1E02A)
            || (0x1E130 <= code && code <= 0x1E136)
            || (0x1E2EC <= code && code <= 0x1E2EF)
            || (0x1E8D0 <= code && code <= 0x1E8D6)
            || (0x1E944 <= code && code <= 0x1E94A)
            || (0xE0100 <= code && code <= 0xE01EF);
      };

Değerli bir girişim, ancak UnicodeData.txt dosyasını tarayacak olsaydınız, 5 yerine aksanları birleştiren 316 aralığın olduğunu görürdünüz.
Bay Lister

@MrLister Çözüm isCombiningDiacritic, tüm 316 aralığını içerecek şekilde işlevi düzenlemektir ; elinizde veri olduğu için bu düzenlemeyi yapmaktan çekinmeyin.
MT0

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

1

dizgiyi diziye dönüştürmeden;

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

karakterleri kod noktalarına dönüştürmeden Array.reverse kullanmak;

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

İkinci sürüm için: var c = array[i-1]; array[i-1] = array[i]; array[i] = c;kod çiftinin birleştirilmesini gerektirmez. Ayrıca, for döngüsü 1'den başlamalıdır.
MT0

İkinci sürüm çalışmaz '\ud83c\ud83c\udfa5'.reverse()- girişle aynı çıktıyı verir. İfadenin ++i;içine eklemek ifbunu düzeltmelidir.
MT0

İkinci düşüncelerde - bu aksanları birleştirmekle uğraşmaz: 'a\u0303bc'.reverse() === 'cba\u0303'doğru dönmelidir.
MT0

1

Ben String.prototype.reverse bu sorunu çözmek için iyi bir yol olduğunu düşünüyorum; kodu aşağıdaki gibi;

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

1

Dizi işlevlerini kullanma,

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

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

Bu nasıl "yerinde" ??
Sudhansu Choudhary

1

Kendi orijinal girişimim ...

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


1

KURU ve basit saçma tutmak !!

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

1

Tamam, oldukça basit, kullanmadan dizeyi tersine çevirmek için basit bir döngü ile bir işlev oluşturabilirsiniz reverse(),charAt() :

Örneğin şu dizeye sahipsiniz:

var name = "StackOverflow";

Böyle bir fonksiyon yarat, ben diyorum 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;
}

Ve şöyle diyebilirsiniz:

reverseString(name);

Ve sonuç şöyle olacak:

"wolfrevOkcatS"

1

JavaScript'te bir dizeyi tersine çevirmenin en iyi yolları

1) Dizi. Ters:

Muhtemelen düşünüyorsun, bekle bir ipi tersine çevirdiğimizi sanıyordum, neden Array.reverse yöntemini kullanıyorsun. String.split yöntemini kullanarak dizemizi bir karakter dizisine dönüştürüyoruz. Sonra dizideki her bir değerin sırasını tersine çeviriyoruz ve son olarak Array.join yöntemini kullanarak Diziyi geri bir String'e dönüştürüyoruz.

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

2) Döngü sırasında azalma:

Oldukça ayrıntılı olmasına rağmen, bu çözüm, birinci çözümden daha avantajlıdır. Bir dizi oluşturmuyorsunuz ve sadece bir dizeyi kaynak dizgideki karakterlere göre birleştiriyorsunuz.

Performans açısından bakıldığında, bu muhtemelen en iyi sonuçları verecektir (test edilmemiş olsa da). Son derece uzun dizeler için, performans kazançları pencereyi düşürebilir.

function reverseString(str) {
    var temp = '';
    var i = str.length;

    while (i > 0) {
        temp += str.substring(i - 1, i);
        i--;
    }


    return temp;
}
reverseString('dwayne');

3) Özyineleme

Bu çözümün ne kadar basit ve net olduğunu seviyorum. String.charAt ve String.substr yöntemlerinin, dize boş olana kadar her seferinde kendisini çağırarak üçlünün kendisini çağırmak için özyineleme kullanmak yerine boş bir dize döndüreceği farklı bir değerden geçmek için kullanıldığını açıkça görebilirsiniz. . Bu muhtemelen ikinci çözümden sonra ikinci en iyi performansı verecektir.

function reverseString(str) {
    return (str === '') ? '' : reverseString(str.substr(1)) + str.charAt(0);
}
reverseString('dwayne');
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.