¿Cómo se puede invertir una cadena en lugar de JavaScript?

¿Cómo se puede invertir una cadena en lugar de (o en lugar) en JavaScript cuando se pasa a una función con una instrucción return, sin utilizar las funciones integradas (.reverse(), .charAt() etc.)?

  • así, usted no está autorizado para utilizar .charAt() para obtener los caracteres de la cadena?
  • Usted no puede. JavaScript cadenas son inmutables, es decir, la memoria asignada a cada uno no puede ser escrito, haciendo realidad «en lugar de» reversiones imposible.
  • Re: crescentfresh comentario consulte stackoverflow.com/questions/51185/…
  • usted debe publicar que como una nueva respuesta.
  • su 2015 y charAt() todavía no es totalmente compatible. donde se apoya el proceso es lento.
  • Invertir una cadena de 3 maneras en Javascript
  • var reverse = (str, rev = '') => str.length == 0 ? console.log(rev) : reverse((str.substr(0,str.length -1)), (rev + str.substr(str.length -1 , 1)));

InformationsquelleAutor | 2009-06-06

46 Kommentare

  1. 710

    Mientras que usted está tratando con simples caracteres ASCII, y que está feliz a utilizar las funciones integradas, esto va a funcionar:

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

    Si usted necesita una solución que es compatible con UTF-16 o de otros caracteres multi-byte, ser conscientes de que esta función va a dar no válido cadenas unicode, o cadenas válidas que mira divertido. Usted puede ser que desee considerar esta respuesta, en lugar.

    • Este es roto para UTF-16 cadenas que contienen los pares suplentes, es decir, caracteres fuera del plano multilingüe básico. También se le dará divertido resultados para cadenas de caracteres que contengan la combinación de caracteres, por ejemplo, una diéresis puede aparecer el siguiente carácter. El primer tema que se va a llevar a no válida cadenas unicode, el segundo a cadenas válidas que mira divertido.
    • Bebedor «sin el uso de la incorporada en las funciones? .reverse()» Esto no sería aceptado la solución, ya que no encaja dentro de los confines de la cuestión, a pesar de ser una solución viable para invertir una cadena en JS.
    • Sí, mirando hacia atrás en este casi cuatro años más tarde, es difícil ver cómo me tan a fondo perdido el punto de la cuestión. Parece que debería haber sólo esperó dos minutos y upvoted crescentfresh comentario en el post original!
    • Mi respuesta proporciona un soporte para Unicode solución para el problema que se ocupa de los pares suplentes y combinando correctamente las marcas: stackoverflow.com/a/16776380/96656
    • perfecto para una cadena hexadecimal
    • Para UTF-16 return [...s].reverse().join(""); puede trabajar.
    • Y es que no se en-lugar string inversión, lo cual no es posible.

  2. 401

    La siguiente técnica (o similar) es comúnmente utilizado para invertir una cadena en JavaScript:

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

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

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

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

    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 prueba de la cadena de la cadena inversa de las implementaciones se el siguiente:

    'foo 𝌆 bar mañana mañana'

    ¿Por qué? Debido a que contiene un símbolo astral (𝌆) (que son representado por los pares suplentes en JavaScript) y una combinación de marca (el en los últimos mañana consta en realidad de dos símbolos: U+006E LATINA PEQUEÑO LETRA N y U+0303 que COMBINA la TILDE).

    El orden en el que los pares suplentes aparecen no se puede invertir, de lo contrario el símbolo astral no aparecen más en la ‘invertidos’ cadena. Es por eso que usted vio los �� marcas en la salida para el ejemplo anterior.

    De la combinación de marcas siempre se aplica el símbolo anterior, así que tienes que tratar tanto el principal símbolo (U+006E LATINA PEQUEÑO LETRA N) como la combinación de interrogación (U+0303 que COMBINA la TILDE) como un todo. Invertir su orden hará que la combinación de la marca para ser emparejado con otro símbolo en la cadena. Por eso el ejemplo de la salida había en lugar de ñ.

    Esperemos que esto explica por qué todas las respuestas publicadas hasta el momento son mal.


    Para responder a su pregunta inicial — cómo [correctamente] invertir una cadena en JavaScript —, he escrito una pequeña biblioteca JavaScript que es capaz de soporte Unicode cadena de reversión. 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 fácilmente pueden revertir las cadenas de tu terminal, si quieres.

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

    Como para el «en lugar de» parte, ver las otras respuestas.

    • Usted debe incluir la parte principal del código de Esrever en su respuesta.
    • Si un mal enfoque utilizado ( es decir, split().reverse().join() ) – la longitud de la cadena ser siempre el mismo después de dar marcha atrás?
    • Con ese enfoque específico, sí.
    • Hola, he comprobado que está utilizando replace método de la cadena de prototipo que devuelve una nueva cadena, el no hacerlo en el lugar en el que yo creo. Pls quiero saber si me estoy perdiendo algo.
    • Véase el último párrafo de mi respuesta.
    • El problema, fuera del campo, es que «invertir una cadena» sonidos de ambigüedad, pero no está en la cara de los problemas que se mencionan aquí. Es la inversión de una cadena de devolución de la cadena que cuando se imprime sería mostrar el grafema clusters en la cadena en orden inverso? Por un lado, que los sonidos probable. En el otro, ¿por qué querríamos hacer eso? Esta definición depende de lo que se imprime, y la impresión de una inversión de la cadena rara vez es útil. Como parte de un algoritmo, sus requisitos puede ser diferente.
    • Mientras este hace un gran de trabajo de explicar el problema, el respuesta es en otro castillo. Como @r0estir0bbe dijo hace más de un año, el código debe ser en la respuesta, no vinculados.
    • «Esperamos que esto explica por qué todas las respuestas publicado hasta el momento están equivocados» – Esta afirmación es demasiado contundente de la omi. Muchos de los casos de uso no requieren soporte UTF-16 (simple ejemplo; trabajar con URL y URL de componentes o parámetros). La solución no es «malo» simplemente porque no se manejar un no-escenario requerido. En particular, la parte superior de votación de respuesta explícitamente declara que sólo funciona con los caracteres ASCII y por lo tanto no es, definitivamente, incluso un poco mal.
    • La nota que se refieren a la era añadir mucho tiempo después de que esto fue publicado. Mencionar que «no se requiere escenario» OP pero no especifica esta limitación, a todos. Generalmente, cuando alguien pregunta «cómo hacer X?», en ASÍ, no es suficiente para decir «aquí es una solución parcial al problema, en algunos casos», sin explicar cómo resolverlo completamente. P. S. el uso de la frase «soporte UTF-16», sugiere que usted está mezclando Unicode con las codificaciones de caracteres.
    • Como la mayoría de la gente que visita esta página, solo puedo ver las respuestas como lo son ahora. No me entra en la edición de la historia para ver que nota llegó primero. Es irrelevante, la verdad. La parte superior de votación de respuesta explícitamente renuncia a la ayuda para la codificación UTF-16 o de otros caracteres multi-byte». No es «malo» para cualquier persona que no necesita esas cosas. Si quieres argumentar en contra de las soluciones parciales, que está bien, pero luego su respuesta es incorrecta porque el OP pregunta acerca de la inversión de una cadena de en lugar de. La única «correcta» respuesta a eso es «no se puede debido a que las cadenas son inmutables en JS».
    • De nuevo, podría publicar los fundamentos de cómo invertir una cadena de que contiene caracteres extraños en su respuesta a sí misma?
    • La función no está publicado esto en la Pila y la función que vincula no es un reutilizables de la función.

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

    o

    String.prototype.reverse_string = function() {
        var s = "";
        var i = this.length;
        while (i>0) {
            s += this.substring(i-1,i);
            i--;
        }
        return s;
    }
    • Definitivamente estoy de acuerdo con la Cadena de prototipo.
    • la concatenación de cadenas es caro. Mejor para construir una matriz y unirse a ella o uso concat().
    • #1 es el mejor, #2 podría ser horriblemente lento
    • Sin embargo, ni la solución de trabajo cuando Unicode compuesto personajes están presentes.
    • eww, usted está utilizando el construido-en la separación de las funciones, a la inversa, de combinación y de la subcadena. 🙂
    • el uso de este[i] en lugar de la subcadena, el autor de la pregunta no desea utilizar las funciones integradas 😛
    • La concatenación de cadenas no es tan caro, ver mis pruebas de rendimiento aquí stackoverflow.com/questions/51185/… jsperf.com/string-concat-without-sringbuilder/3
    • He dejado este comentario en 2009, las cosas han cambiado en los últimos 4 años. 😛
    • Mi respuesta proporciona un soporte para Unicode solución para el problema que se ocupa de los pares suplentes y combinando correctamente las marcas: stackoverflow.com/a/16776380/96656

  4. 56

    Análisis detallado y diez maneras diferentes para invertir una cadena y sus detalles de rendimiento.

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

    Perfomance de estas implementaciones:

    Mejor desempeño de la aplicación(s) por navegador

    • Chrome 15 – Implemations 1 y 6
    • Firefox 7 – Aplicación 6
    • IE 9 – Implementación 4
    • Opera 12 – Implementación 9

    Aquí son las implementaciones:

    Aplicación 1:

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

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

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

    Aplicación 4:

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

    Aplicación 5:

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

    Ejecución 6:

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

    La aplicación 7:

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

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

    Aplicació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));
    }
  5. 51

    Toda la inversa de una cadena en lugar de» es una antigua pregunta de la entrevista programadores de C, y las personas que fueron entrevistadas por ellos (por venganza, tal vez?), le va a preguntar. Lamentablemente, es el «En Lugar de» la parte que ya no funciona porque las cadenas en casi cualquier lenguaje administrado (JS, C#, etc) utiliza inmutable de las cuerdas, y así derrotar a la idea de mover una cadena sin asignar cualquier memoria nueva.

    Mientras que las soluciones anteriores, de hecho invertir una cadena, no lo hacen sin asignar más memoria, y por lo tanto no cumplen las condiciones. Usted necesita tener acceso directo a la cadena asignada, y ser capaz de manipular su original ubicación de memoria para ser capaz de revertir en su lugar.

    Personalmente, yo realmente odio a estos tipos de preguntas de la entrevista, pero por desgracia, estoy seguro de que vamos a seguir viendo por años para venir.

    • Por lo menos puedo decir que he tenido un entrevistador hace un tiempo atrás ser bastante impresionado cuando me preguntó cómo invertir una cadena «en el lugar» en JS y me explicó el por qué de su imposible, ya que las cadenas en JS son inmutables. No sé si esa era la respuesta que él esperaba o si yo educo un poco. De cualquier manera, no funcionó muy bien 😉
    • Tal vez él se refiere a «administrado» por un recolector de basura, al menos eso es lo que normalmente se entiende por «lenguaje administrado» o la presencia de una Máquina Virtual / Virtual Entorno de tiempo de ejecución? @torazaburo
  6. 38

    Primer lugar, el uso Array.a partir de() para convertir una cadena en una matriz, entonces Array.el prototipo.reverse() a la inversa de la matriz y, a continuación, Array.el prototipo.join() a hacer de nuevo una cadena.

    const reverse = str => Array.from(str).reverse().join('');
    • Tiene una sobrecarga, pero esta es una solución elegante! No hay una reescritura de la pre-existentes reverse lógica.
    • string.split('') también trabajará en lugar de Array.from()
    • No, string.split('') no funciona. Consulte esta respuesta para más explicación.
    • Esto debe ser aceptado respuesta, porque también funciona con unicode. Por ejemplo, en el ejemplo anterior: Array.from('foo 𝌆 bar mañana mañana').reverse().join('') == 'anãnam anañam rab 𝌆 oof'
    • No exactamente, una tilde todavía se aplica a la ‘a’ en lugar de ‘n’.
  7. 25

    En ECMAScript 6, usted puede invertir en un string, incluso más rápido sin el uso .split('') método split, con el la propagación del operador así:

    var str = [...'racecar'].reverse().join('');
    • ES6 también permite el uso de dos comillas simples inclinadas ` en lugar de ('')
    • no hay ninguna razón para utilizar dos comillas simples inclinadas en este caso
    • A menos que usted es el código de golf que usted debe evitar de esta. Escrito string.split('') es más claro para la mayoría de las personas que [...string].
  8. 19

    Parece que tengo 3 años tarde a la fiesta…

    Lamentablemente no se puede, como se ha señalado. Ver Son cadenas JavaScript inmutable? Necesito un «generador de cadenas» en JavaScript?

    La siguiente mejor cosa que puedes hacer es crear una «vista» o «contenedor», que toma una cadena y reimplemente cualesquiera partes de la cadena de la API que se usa, pero pretendiendo que la cadena se invierte. 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

    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"

    El trampolín — el siguiente es hecho en el lugar por pura matemática, visitando cada personaje sólo una vez, y sólo 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 un ahorro significativo si se aplica a una gran cadena, si usted sólo va a tomar una relativamente pequeña porción de la misma.

    Si esto es digno de él (más de revertir-como-una-copia como en la mayoría de los lenguajes de programación) depende altamente de su caso de uso y la eficiencia de la reimplementar la cadena de la API. Por ejemplo, si lo que quieres es hacer una cadena de índice de la manipulación, o tomar pequeñas slices o substrs, esto te ahorrará espacio y el tiempo. Si usted está pensando en la impresión de grandes invertido rodajas o subcadenas sin embargo, el ahorro puede ser pequeña, de hecho, incluso peor que haber hecho una copia completa. Su «invertido» cadena también no tienen el tipo string, a pesar de que usted podría ser capaz de falsificar esto con la creación de prototipos.

    La anterior demo de la aplicación crea un nuevo objeto de tipo ReversedString. Es un prototipo, y por lo tanto bastante eficiente, con casi un trabajo mínimo y un mínimo de espacio de cabeza (prototipo definiciones son compartidos). Es un perezoso que implican la aplicación diferida de rebanar. Cuando se realiza una función como .slice o .reversed, se llevará a cabo el índice de matemáticas. Finalmente, al extraer los datos (por implícitamente de llamada .toString() o .charCodeAt(...) o algo), se aplicará a aquellos en una «smart» que manera de tocar los menos datos posibles.

    Nota: la cadena anterior de la API es un ejemplo, y no puede llevarse a cabo perfectamente. Usted también puede utilizar sólo 1-2 funciones que usted necesita.

  9. 13

    Hay muchas maneras que usted puede invertir una cadena en JavaScript. Me voy a anotar de tres maneras prefiero.

    Método 1: Utilizando la inversa de la función:

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

    Enfoque 2: Bucle a través de los personajes:

    function reverse(str) {
      let reversed = '';
    
      for (let character of str) {
        reversed = character + reversed;
      }
    
      return reversed;
    }

    Enfoque 3: reducir el Uso de la función:

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

    Espero que esta ayuda 🙂

  10. 10

    Durante una entrevista, le preguntaron a invertir una cadena sin usar ninguna de las variables o métodos nativos. Esta es mi favorita de aplicación:

    function reverseString(str) {
        return str === '' ? '' : reverseString(str.slice(1)) + str[0];
    }
    • Corto, sencillo, pero lento como el infierno 😉
    • Cero métodos nativos? ¿Qué acerca de slice? :-/
    • Interesante uso de la recursividad. Irónico que es en de Desbordamiento de Pila. stackoverflow.com/q/2805172/265877
    • usted hace un buen punto. En algunos casos, el entrevistador le rogamos que no utilice Array.prototype.reverse().
  11. 10

    Hay Varias formas de hacerlo, puede consultar el siguiente,

    1. Tradicional bucle for(incremento):

    JS:

    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 bucle for(decremento):

    JS:

    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. El uso de de bucle

    JS:

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

    4. El uso de forEach/alto orden método de la matriz:

    JS:

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

    5. ES6 estándar:

    JS:

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

    6. La última manera:

    JS:

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

    7. Usted también puede obtener el resultado utilizando el siguiente,

    JS:

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

  12. 6

    Esta es la manera más fácil creo

    JS:

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

    • Es bueno que haya incluido un emoji en tu ejemplo. Así que rápidamente ver que esto claramente no funciona para emojis y un montón de otros caracteres unicode.
    • La fe, mientras que su respuesta es correcta, no estoy de acuerdo que es la forma más fácil. Varias de las primeras respuestas de hacer uso de Array.prototype.reverse() que sería la manera más fácil, por tanto, la respuesta más popular. Por supuesto, sería requieren de un buen conocimiento previo de JavaScript.
  13. 6
    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’

    • Toda su «mapa» puede ser escrito como [...str].
  14. 5

    Sé que esta es una vieja cuestión que ha sido bien contestadas, pero para mi propia diversión escribí la siguiente función de marcha atrás y pensé en compartirlo en caso de que fuera útil para cualquier otra persona. Se encarga tanto de los pares suplentes y de la combinación de marcas:

    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 la escolarización de mí en la complejidad de la codificación de caracteres en JavaScript.

  15. 5

    En ES6, usted tiene una opción más

    function reverseString (str) {
      return [...str].reverse().join('')
    }
    
    reverseString('Hello');
  16. 4

    Que no puede porque JS cadenas son inmutables. Corto no en lugar de la solución de

    [...str].reverse().join``

    JS:

    let str = "Hello World!";
    let r = [...str].reverse().join``;
    console.log(r);

  17. 2

    La verdadera respuesta es: no se puede revertir en su lugar, pero usted puede crear una nueva cadena que es a la inversa.

    Sólo como un ejercicio para jugar con recursividad: a veces cuando vas a una entrevista, el entrevistador puede preguntar cómo hacer esto mediante la recursividad, y creo que el «preferido responder que» podría ser «preferiría no hacerlo en la recursividad como fácilmente puede causar un desbordamiento de pila» (porque es O(n) en lugar de O(log n). Si es O(log n), es muy difícil conseguir un desbordamiento de pila — 4 millones de artículos podría ser manejado por un nivel de pila de 32, como 2 ** 32 es 4294967296. Pero si es O(n), a continuación, se puede conseguir fácilmente un desbordamiento de pila.

    A veces, el entrevistador le pide aún, «solo como un ejercicio, ¿por qué no escribir usando recursividad?» Y aquí está:

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

    la ejecución de la prueba:

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

    de salida:

    999elppa899elppa...2elppa1elppa0elppa

    Para intentar llegar a un desbordamiento de pila, he cambiado 1000 a 10000 en Google Chrome, y se informó:

    RangeError: Maximum call stack size exceeded
  18. 2

    Los Strings son inmutables, pero usted puede crear fácilmente una inversión de la copia con el siguiente código:

    function reverseString(str) {
    
      var strArray = str.split("");
      strArray.reverse();
    
      var strReverse = strArray.join("");
    
      return strReverse;
    }
    
    reverseString("hello");
  19. 2

    Una pequeña función que se encarga tanto de la combinación de los signos diacríticos y caracteres de 2 bytes:

    JS:

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

  20. 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
    • Esto tiene la ventaja de que trata complementario de avión correctamente los caracteres.
  21. 2

    Si usted no desea utilizar cualquier función integrada. Pruebe este

            var string = 'abcdefg';
            var newstring = '';
    
            for(let i = 0; i < string.length; i++){
                newstring = string[i] += newstring
            }
    
            console.log(newstring)
  22. 1
    function reverseString(string) {
        var reversedString = "";
        var stringLength = string.length - 1;
        for (var i = stringLength; i >= 0; i--) {
            reversedString += string[i];
        }
        return reversedString;
    }
  23. 1

    sin la conversión de cadena a un array;

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

    el uso de la Matriz.invertir sin la conversión de caracteres para el código de puntos;

    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());
    • Para la segunda versión: var c = array[i-1]; array[i-1] = array[i]; array[i] = c; no requiere la concatenación del código de par. También, el bucle debe empezar en 1.
    • La segunda versión no funciona con '\ud83c\ud83c\udfa5'.reverse() – que es la salida la misma que la de entrada. La adición de ++i; dentro de la if declaración debe solucionar este problema.
    • En la segunda pensamientos – esto no manejar la combinación de los signos diacríticos: 'a\u0303bc'.reverse() === 'cba\u0303' debe devolver true.
  24. 1

    Creo Cadena.el prototipo.invertir es una buena forma de resolver este problema;
    el código de la siguiente manera;

    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";
  25. 1

    El uso de las funciones de Matriz,

    String.prototype.reverse = function(){
        return [].reduceRight.call(this, function(last, secLast){return last + secLast});
    }
  26. 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);
    • Cómo es este «lugar»??
  27. 1

    Mi propia tentativa 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,consola de salida

  28. 1

    Mantenerlo 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;
    }
  29. 1

    OK, bastante simple, usted puede crear una función con un simple bucle para hacer la cadena inversa para usted sin necesidad de utilizar reverse(), charAt() etc como esta:

    Por ejemplo, usted tiene esta cadena:

    var name = "StackOverflow";

    Crear una función como esta, yo lo 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 que se le puede llamar como:

    reverseString(name);

    Y el resultado será:

    "wolfrevOkcatS"
  30. 1

    Mejores maneras de invertir una cadena en JavaScript

    1) de la Matriz.reverso:

    Que usted está pensando probablemente, esperar pensaba que íbamos a invertir una cadena, ¿por qué está usted utilizando la Matriz.inversa método. El uso de la Cadena.método split estamos convirtiendo nuestra cadena en una Matriz de caracteres. Entonces estamos invirtiendo el orden de cada valor de la matriz y, finalmente, convertir la Matriz en una Cadena mediante la Matriz.método de combinación.

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

    2) Disminuir el bucle while:

    Aunque bastante detallado, esta solución tiene sus ventajas con respecto a la solución de uno. No está la creación de una matriz y usted está a solo concatenar una cadena de caracteres de la cadena de origen.

    Desde una perspectiva de rendimiento, esto probablemente se produzcan los mejores resultados (aunque no probado). Extremadamente largas cadenas, las mejoras de rendimiento que podría caer por la ventana, aunque.

    function reverseString(str) {
        var temp = '';
        var i = str.length;
    
        while (i > 0) {
            temp += str.substring(i - 1, i);
            i--;
        }
    
    
        return temp;
    }
    reverseString('dwayne');

    3) la Recursividad

    Me encanta lo simple y claro esta solución es. Se puede ver claramente que la Cadena.charAt y Cadena.substr métodos están siendo utilizados para pasar a través de un valor diferente se llama a sí mismo cada vez, hasta que la cadena está vacía de que el ternario sólo devuelve una cadena vacía en lugar de utilizar la recursividad se llame a sí mismo. Esto sería, probablemente, el rendimiento de la segunda mejor rendimiento después de la segunda solución.

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

    Aquí están los cuatro métodos más comunes que puede utilizar para lograr una cadena de reversión

    Dada una cadena, devuelve una nueva cadena con la inversa de
    orden de los caracteres

    Múltiples Soluciones para el problema

    //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;  
        }, '');
    }
  32. 0

    Otra variación (funciona con IE?):

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

    EDICIÓN:

    Esto es, sin el uso de las funciones integradas:

    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, dado que la asignación a
    elementos individuales de la matriz no funciona con objeto String protegida (?). I. e. usted puede hacer cesionarios, pero la cadena resultante no cambia.

  33. 0
    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(''));
  34. 0
    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");

    //salidas: gnirts desrever si sihT

  35. 0
    function reverse(str){
    var s = "";
    for (var i = str.length - 1; i >= 0; i--){
        s += str[i];
    }
    return s;
    };
    reverse("your string comes here")
  36. 0

    El siguiente podría ayudar a cualquier persona que está mirando para invertir una cadena de forma recursiva. Pidió hacer esto en una reciente entrevista de trabajo utilizando el estilo de programación funcional:

    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
  37. 0

    Añadiendo a la Cadena de prototipo ideal (sólo en caso de que se agrega en el núcleo de la JS idioma), pero primero tiene que comprobar si existe, y añade que si no existe, así:

    String.prototype.reverse = String.prototype.reverse || function () {
        return this.split('').reverse().join('');
    };
  38. 0

    Supongo que esto funcionará para usted

    function reverse(str){
        str = str.split("").reverse().join("").split(" ").reverse().join(" ");
        console.log(str)
    }
  39. 0

    Aquí tenemos un ES6 inmutable ejemplo, sin el uso de la Matriz.el prototipo.reverso:

    JS:

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

    • Proporciona una explicación sobre la forma en que la solución resuelve el problema será ayudar a los lectores a aprender.
  40. 0

    Usted podría intentar algo como esto. Estoy seguro de que hay algo de espacio para la refactorización. No podía desplazarse utilizando la función split. Tal vez alguien sabe de alguna manera de hacerlo sin dividir.

    Código para configurar, puede poner esto en tu .js biblioteca

    Código a utilizar es (ha de código del lado del cliente, sólo porque fue probado en un navegador):

    var sentence = "My Stack is Overflowing."
    document.write(sentence.reverseLetters() + '<br />');
    document.write(sentence.reverseWords() + '<br />');

    Fragmento:

    JS:

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

  41. 0

    Algo como esto debe hacerse siguiendo las mejores prácticas:

    JS:

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

  42. 0
    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('');
    }
  43. 0

    No integrado en los métodos? Esta es la mejor manera:

    function ReverseString(str) {
        var len = str.length;
        var newString = '';
    
        while (len--) {
            newString += str[len];
        }
    
        return newString;
    }
    
    console.log(ReverseString('amgod'))
  44. -1
    <body>
            <label>Enter any string: </label>
            <input type="text" name="str" id="str"><br><br>
            <button value = "Reverse" onclick=myFunction()>Reverse</button><br>
            <p id="result"></p>
            <script>
                function myFunction(){
                    var str1 = document.getElementById("str").value;
    //Step 1. take value from text box and stored it into a new variable str1.
    //Step 2. Use the split() method to return a new array.
     //Step 3. Use the reverse() method to reverse the new created array
    //Step 4. Use the join() method to join all elements of the array into a string
                    var res = str1.split("").reverse().join("");
                    document.getElementById("result").innerHTML = res;
                }   
            </script>
        </body>
    • Utiliza las funciones integradas.
    • Esto no es muy útil, ya que utiliza tres funciones integradas de donde no se puede utilizar.

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea