Wie kehrt man in JavaScript eine Zeichenkette an Ort und Stelle um?

Question

Wie kehrt man eine Zeichenkette in JavaScript an Ort und Stelle um, wenn sie an eine Funktion mit einer Rückgabeanweisung übergeben wird, ohne integrierte Funktionen zu verwenden ( .reverse() , .charAt() usw.)?

Answer 1

Hier ein einfaches ES6-Beispiel für unveränderliche Elemente, ohne Array.prototype.reverse zu verwenden:

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

Answer 2

Beste Möglichkeiten zur Umkehrung einer Zeichenkette in JavaScript

1) Array.reverse:

Sie denken jetzt wahrscheinlich: Moment, ich dachte, wir kehren eine Zeichenkette um, warum verwenden Sie die Methode Array.reverse? Mit der Methode String.split konvertieren wir unsere Zeichenkette in ein Array von Zeichen. Dann kehren wir die Reihenfolge der einzelnen Werte im Array um und schließlich konvertieren wir das Array mit der Methode Array.join zurück in einen String.

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

2) Dekrementierende while-Schleife:

Diese Lösung ist zwar ziemlich umständlich, hat aber Vorteile gegenüber der ersten Lösung. Sie erstellen kein Array und verketten lediglich eine Zeichenkette auf der Grundlage von Zeichen aus der Quellzeichenkette.

Vom Standpunkt der Leistung aus betrachtet, würde dieser wahrscheinlich die besten Ergebnisse liefern (obwohl er nicht getestet wurde). Bei extrem langen Zeichenketten könnten die Leistungsgewinne allerdings verpuffen.

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

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

    return temp;
}
reverseString('dwayne');

3) Rekursion

Ich finde es toll, wie einfach und klar diese Lösung ist. Sie können deutlich sehen, dass die Methoden String.charAt und String.substr verwendet werden, um einen anderen Wert durchlaufen zu lassen, indem sie sich selbst jedes Mal aufrufen, bis die Zeichenfolge leer ist, woraufhin die Ternäre einfach eine leere Zeichenfolge zurückgeben würde, anstatt eine Rekursion zu verwenden, um sich selbst aufzurufen. Dies würde wahrscheinlich die zweitbeste Leistung nach der zweiten Lösung bringen.

function reverseString(str) {
    return (str === '') ? '' : reverseString(str.substr(1)) + str.charAt(0);
}
reverseString('dwayne');

Answer 3

function reverseWords(str) {
  // Go for it
  const invertirPalabra = palabra => palabra.split('').reverse().join('')
  return str.split(' ').map(invertirPalabra).join(' ')
  // con split convierto string en array de palabras, le paso ' ' 
  // que es que me lo separe por espacios
  // luego invierto cada palabra...
  // y luego con join las uno separando por espacios
}

Answer 4

So etwas sollte nach den besten Praktiken durchgeführt werden:

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

})();

Answer 5

Eine Möglichkeit wäre auch die Verwendung der Reduktionsmethode, um nach der Split-Methode eine Umkehrung vorzunehmen.

function reverse(str) {
    return str.split('').reduce((rev, currentChar) => currentChar + rev, '');
}
  console.log(reverse('apple'));
  console.log(reverse('hello'));
  console.log(reverse('Greetings!'));