numero - reverse javascript

¿Cómo se invierte una cadena en JavaScript?

Question

¿Cómo se invierte una cadena en lugar (o en lugar) en JavaScript cuando se pasa a una función con una declaración de retorno? ¿Todo sin usar las funciones incorporadas? .reverse() , .charAt() , etc.

Answer 1

Análisis detallado y diez formas diferentes de revertir una cadena y sus detalles de rendimiento.

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

Perfomance de estas implementaciones:

Mejor implementación (s) por navegador

• Chrome 15 - Implicaciones 1 y 6
• Firefox 7 - Implementación 6
• IE 9 - Implementación 4
• Opera 12 - Implementación 9

Aquí están esas implementaciones:

Implementación 1:

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

Implementación 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('''');
}

Implementación 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('''');
}

Implementación 4:

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

Implementación 5:

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

Implementación 6:

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

Implementación 7:

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

Implementación 8:

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

Implementación 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('''');
    }

Implementación 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));
}

Answer 2

Creo que String.prototype.reverse es una buena manera de resolver este problema; el código como abajo;

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 3

Durante una entrevista, me pidieron que invirtiera una cadena sin usar ninguna variable o método nativo. Esta es mi implementación favorita:

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

Answer 4

En ECMAScript 6, puede revertir una cadena aún más rápido sin usar el método de división .split('''') , con el operador de difusión así:

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

Answer 5

En ES6, tienes una opción más.

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

reverseString(''Hello'');

Answer 6

Esta es la forma más fácil que pienso

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 7

Hay varias formas de hacerlo, puede verificar lo siguiente,

1. Tradicional para bucle (incrementando):

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

2. Tradicional para loop (decremento):

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. Usando el bucle for-of

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

4. Usando el método de matriz forEach / high order:

function reverseString(str){

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

5. ES6 estándar:

function reverseString(str){

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

6. La última forma:

function reverseString(str){

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

alert(reverseString("Learning JavaScript"));

7. También puede obtener el resultado utilizando lo siguiente,

function reverseString(str){

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

Answer 8

La respuesta real es: no puede revertirlo en su lugar, pero puede crear una nueva cadena que sea lo contrario.

Solo como un ejercicio para jugar con recursión: a veces, cuando va a una entrevista, el entrevistador puede preguntarle cómo hacerlo utilizando la recursión, y creo que la "respuesta preferida" podría ser "Preferiría no hacer esto en forma recursiva, ya que puede provocar fácilmente un desbordamiento de pila "(porque es O(n) lugar de O(log n) . Si es O(log n) , es bastante difícil obtener un desbordamiento de pila: 4 mil millones de elementos pueden ser manejados por un nivel de pila de 32, ya que 2 ** 32 es 4294967296. Pero si es O(n) , entonces puede obtener un desbordamiento de pila fácilmente.

A veces el entrevistador todavía te pregunta: "solo como un ejercicio, ¿por qué no lo escribes usando la recursión?" Y aquí está:

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

prueba de funcionamiento:

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

salida:

999elppa899elppa...2elppa1elppa0elppa

Para intentar obtener un desbordamiento de pila, cambié de 1000 a 10000 en Google Chrome, y se informó:

RangeError: Maximum call stack size exceeded

Answer 9

La siguiente técnica (o similar) se usa comúnmente para revertir una cadena en JavaScript:

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

De hecho, todas las respuestas publicadas hasta ahora son una variación de este patrón. Sin embargo, hay algunos problemas con esta solución. Por ejemplo:

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

Si se está preguntando por qué sucede esto, lea la codificación de caracteres interna de JavaScript . (TL; DR: 𝌆 es un símbolo astral, y JavaScript lo expone como dos unidades de código separadas).

Pero hay más:

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

Una buena cadena para probar implementaciones de cadena inversa es la siguiente :

''foo 𝌆 bar mañana mañana''

¿Por qué? Porque contiene un símbolo astral ( 𝌆 ) (que está representado por pares sustitutos en JavaScript ) y una marca combinada (la ñ en la última mañana realidad consiste en dos símbolos: U + 006E LATINA PEQUEÑA LATINA N y U + 0303 COMBINANDO TILDE) .

El orden en el que aparecen los pares sustitutos no se puede invertir, de lo contrario, el símbolo astral no aparecerá más en la cadena "invertida". Es por eso que vio esas marcas en la salida del ejemplo anterior.

Las marcas combinadas siempre se aplican al símbolo anterior, por lo que debe tratar tanto el símbolo principal (U + 006E LATIN SMALL LETTER N) como la marca combinada (U + 0303 COMBINANDO TILDE) como un todo. Si se invierte su orden, la marca de combinación se emparejará con otro símbolo en la cadena. Es por eso que la salida de ejemplo tuvo ã lugar de ñ .

Afortunadamente, esto explica por qué todas las respuestas publicadas hasta ahora están equivocadas .

Para responder a su pregunta inicial: cómo revertir [correctamente] una cadena en JavaScript -, he escrito una pequeña biblioteca de JavaScript que es capaz de revertir cadenas de caracteres conscientes de Unicode. No tiene ninguno de los problemas que acabo de mencionar. La biblioteca se llama Esrever ; su código está en GitHub, y funciona en casi cualquier entorno de JavaScript. Viene con una utilidad de shell / binario, por lo que puede revertir fácilmente cadenas desde su terminal si lo desea.

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

En cuanto a la parte “en el lugar”, vea las otras respuestas.

Answer 10

Las cadenas en sí mismas son inmutables, pero puede crear fácilmente una copia invertida con el siguiente código:

function reverseString(str) {

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

  var strReverse = strArray.join("");

  return strReverse;
}

reverseString("hello");

Answer 11

Mantenlo seco y simple tonto!

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

Answer 12

Mi propio intento original ...

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

Answer 13

Parece que llego 3 años tarde a la fiesta ...

Lamentablemente no se puede, como se ha señalado. Ver ¿Son inmutables las cadenas de JavaScript? ¿Necesito un "generador de cadenas" en JavaScript?

Lo siguiente que puede hacer es crear una "vista" o "envoltorio", que toma una cadena y reimplementa las partes de la API de la cadena que está utilizando, pero fingiendo que la cadena está invertida. Por ejemplo:

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

Manifestación:

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

El kicker: lo siguiente se hace en su lugar con matemáticas puras, visitando cada personaje solo una vez, y solo si es necesario:

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

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

Esto produce ahorros significativos si se aplica a una cadena muy grande, si solo está tomando una porción relativamente pequeña de la misma.

Si esto vale la pena (revertir como copia en la mayoría de los lenguajes de programación) depende en gran medida de su caso de uso y de la eficiencia con la que vuelva a implementar la API de cadena. Por ejemplo, si todo lo que desea es hacer manipulación de índice de cadena, o tomar pequeñas substr o substr , esto le ahorrará espacio y tiempo. Sin embargo, si planea imprimir grandes rebanadas invertidas o subcadenas, el ahorro puede ser pequeño, incluso peor que haber hecho una copia completa. Su cadena "invertida" tampoco tendrá la string tipo, aunque es posible que pueda falsificar esto con prototipos.

La implementación de demostración anterior crea un nuevo objeto de tipo ReversedString. Es un prototipo y, por lo tanto, bastante eficiente, con un trabajo casi mínimo y una sobrecarga de espacio mínima (se comparten las definiciones del prototipo). Es una implementación perezosa que implica rebanado diferido. Cada vez que realice una función como .slice o .reversed , realizará las matemáticas de índice. Finalmente, cuando extraiga datos (al llamar implícitamente a .toString() o .charCodeAt(...) o algo así), los aplicará de manera "inteligente", tocando la menor cantidad de datos posible.

Nota: la API de cadena anterior es un ejemplo y puede no implementarse perfectamente. También puedes usar solo 1-2 funciones que necesites.

Answer 14

Primero, use Array.from() para convertir una cadena en una matriz, luego Array.prototype.reverse() para revertir la matriz, y luego Array.prototype.join() para hacer que vuelva a ser una cadena.

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

Answer 15

Sé que esta es una vieja pregunta que ha sido bien respondida, pero para mi propia diversión escribí la siguiente función inversa y pensé en compartirla en caso de que fuera útil para alguien más. Maneja ambos pares sustitutos y marcas de combinación:

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

Todos los apoyos a Mathias, Punycode y varias otras referencias para enseñarme las complejidades de la codificación de caracteres en JavaScript.

Answer 16

Si no quieres usar ninguna función incorporada. Prueba esto

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

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

        console.log(newstring)

Answer 17

Siempre y cuando estés tratando con caracteres ASCII simples y estés feliz de usar las funciones integradas, esto funcionará:

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

Si necesita una solución que admita UTF-16 u otros caracteres de múltiples bytes, tenga en cuenta que esta función proporcionará cadenas de Unicode no válidas, o cadenas válidas que parecen divertidas. Es posible que desee considerar esta respuesta en su lugar .

Answer 18

Todo el "revertir una cadena en su lugar" es una entrevista anticuada que los programadores de la pregunta C, y las personas que entrevistaron por ellos (¿por venganza, tal vez?), Preguntarán. Desafortunadamente, es la parte "In Place" que ya no funciona porque las cadenas en casi cualquier lenguaje administrado (JS, C #, etc.) usan cadenas inmutables, lo que anula la idea de mover una cadena sin asignar ninguna memoria nueva.

Si bien las soluciones anteriores realmente invierten una cadena, no lo hacen sin asignar más memoria y, por lo tanto, no satisfacen las condiciones. Debe tener acceso directo a la cadena asignada y poder manipular su ubicación de memoria original para poder revertirla en su lugar.

Personalmente, realmente odio este tipo de preguntas de la entrevista, pero, lamentablemente, estoy seguro de que seguiremos viéndolos en los próximos años.

Answer 19

Una pequeña función que maneja tanto la combinación de caracteres diacríticos como los de 2 bytes:

(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://.com/a/1732454/1509264
].forEach(
  function(str){ console.log( str + " -> " + str.reverse() ); }
);
  

Answer 20

Usando funciones de Array,

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

Answer 21

sin convertir la cadena a la matriz;

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

usando Array.reverse sin convertir caracteres en puntos de código;

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

Answer 22

Las mejores formas de revertir una cadena en JavaScript

1) Array.reverse

Probablemente estés pensando, espera, pensé que estábamos invirtiendo una cadena, ¿por qué estás usando el método Array.reverse? Usando el método String.split estamos convirtiendo nuestra cadena en una matriz de caracteres. Luego estamos invirtiendo el orden de cada valor en la matriz y, finalmente, volvemos a convertir la matriz en una cadena utilizando el método Array.join.

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

2) Disminución del bucle while:

Aunque bastante detallado, esta solución tiene sus ventajas sobre la solución uno. No está creando una matriz y solo está concatenando una cadena basada en caracteres de la cadena fuente.

Desde una perspectiva de rendimiento, este probablemente arrojaría los mejores resultados (aunque no se haya probado). Sin embargo, para cadenas extremadamente largas, las mejoras en el rendimiento podrían abandonar la ventana.

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

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


    return temp;
}
reverseString(''dwayne'');

3) Recursion

Me encanta lo simple y clara que es esta solución. Puede ver claramente que los métodos String.charAt y String.substr se utilizan para pasar por un valor diferente llamándose a sí mismo cada vez hasta que la cadena esté vacía, de lo que el ternario solo devolvería una cadena vacía en lugar de usar la recursión . Esto probablemente daría el segundo mejor desempeño después de la segunda solución.

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

Answer 23

OK, bastante simple, puedes crear una función con un simple bucle para hacer la cadena inversa por ti sin usar reverse() , charAt() etc.

Por ejemplo tienes esta cadena:

var name = "";

Crear una función como esta, la llamo 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;
}

Y puedes llamarlo como:

reverseString(name);

Y el resultado será:

"wolfrevOkcatS"

Answer 24

Otra variación (¿funciona con IE?):

String.prototype.reverse = function() {
    for (i=1,s=""; i<=this.length; s+=this.substr(-i++,1)) {}
    return s;
}

EDITAR:

Esto es sin el uso de funciones incorporadas:

String.prototype.reverse = function() {
    for (i=this[-1],s=""; i>=0; s+=this[i--]) {}
    return s;
}

Nota: este [-1] tiene una longitud de la cadena.

Sin embargo, no es posible revertir la cadena en su lugar, ya que la asignación a elementos individuales de la matriz no funciona con el objeto String (¿está protegido?). Es decir, puedes hacer asignaciones, pero la cadena resultante no cambia.

Answer 25

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

Answer 26

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

o

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

Answer 27

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

Answer 28

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

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 = ''sample string'';
[].map.call(str, function(x) {
  return x;
}).reverse().join('''');

O

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

// Salida: ''gnirts elpmas''