Hoy estaba practicando la pregunta en FreecodeCamp, y encontré una pregunta sobre la inversión de cuerdas. Revertir una cadena es una de las preguntas de entrevista comunes en JavaScript. Tal vez el entrevistador te dé una cadena "¡Hola palabra!", Que te permitirá convertirlo en "! Drow Olleh" a través de JavaScript.
También soy un principiante. He aprobado la prueba utilizando el conocimiento relacionado con las matrices que aprendí antes y los consejos sobre las preguntas. Más tarde me pregunté, ¿hay alguna otra forma de resolver este problema? Después de buscar, todavía hay muchos métodos. Estos son algunos de estos métodos para su uso posterior.
Cosas que hacer
Cosas que queremos hacer:
Antes de mostrar la cadena proporcionada en reversa antes de la cadena inversa, debe convertir la cadena en una matriz y el resultado final sigue siendo una cadena.
A continuación, echemos un vistazo a qué métodos pueden lograr los requisitos anteriores.
Uso de funciones incorporadas
En los ejercicios, se nos solicita que podemos usar tres métodos para mostrar con éxito una cadena en reversa:
String.prototype.split () array.prototype.reverse () array.prototype.join ()
Simplemente revíselo brevemente:
El método dividido () divide cada carácter de un objeto de cadena, y trata cada cadena como cada elemento de una matriz, reversa () el método para cambiar la matriz, organiza los elementos en la matriz en orden inverso, el primer elemento de la matriz se convierte en el último, y el último se convierte en el primer método de unión () conecta todos los elementos en la matriz en una cadena de cadena en una cadena de cadena.
Echemos un vistazo a un ejemplo:
function reverseString (str) {// El primer paso es usar el método split () para devolver una nueva matriz // var splitString = "hello" .split (""); var splitString = str.split (""); // divide la cadena // devuelve una nueva matriz ["h", "e", "l", "l", "l", "o"] // El segundo paso es usar el método reverse () para crear una nueva matriz // var reversarray = ["h", "e", "l", "l", "o"]. Reverso ();; var reverseArray = SplitString.Reverse (); // Los elementos de la matriz originales se invierten en secuencia ["o", "l", "l", "e", "h"] // El tercer paso es usar el método unión () para unir cada elemento de la matriz y combinarlo en una nueva cadena // var unirarray = ["o", "l", "l", "e", "h"]. Join (""); var JoinArray = reverseArray.Join (""); // "Olleh" // El cuarto paso es devolver una nueva cadena que se invierte. regresar JoinArray; // "olleh"} reverseString ("hola"); // => ollehSimplifique el método anterior y se puede escribir así:
function reverseString (str) {return str.split (""). inverso (). Join ("");} ReverseString ("Hello"); // => ollehInvertir la cadena utilizando un recorrido de bucle decreciente
Este método utiliza un for para realizar un recorrido disminuido a la cadena original, y luego vuelva a fusionar la cadena atravesada en una nueva cadena:
function reverseString (str) {// Paso 1: cree una cadena vacía para almacenar la cadena recientemente creada var newString = ""; // Paso 2: Use el bucle for bucle // bucle comienza a disminuir la transferencia de str.length-1 hasta que i sea mayor o igual a 0, el bucle continuará // str.length-1 corresponde al último carácter de la cadena o para (var i = str.length-1; i> = 0; i--) {Newstring += str [i]; // o newstring = Newstring + Str [i]; } // Paso 3: Devuelva la cadena invertida return Newstring; } ReverseString ('Hello'); // => // "olleh"Una simple mirada al proceso de recorrido de cadena. Supongamos que necesita invertir la cadena "Hola". Todo el proceso de recorrido se muestra en la siguiente tabla:
i correspondiente De hecho, el bucle for anterior también se puede reemplazar con while :
function reverseString (str) {var newString = ''; var i = str.length; while (i> 0) {Newstring += str.substring (i - 1, i); i--; } return Newstring;} ReverseString ("Hola"); // => olleh Método substring() en while . substring() Devuelve una subcadena entre dos índices de la cadena (o al final de la cadena).
Implementar la inversión de las cadenas utilizando la recursión
Una cadena también se puede revertir utilizando String.prototype.substr() y String.prototype.charAt() .
substr() devuelve una subcadena en la cadena que comienza desde la posición especificada a la longitud especificada. Por ejemplo:
var str = "abcdefghij"; console.log ("(1,2):" + str.substr (1,2)); // (1,2): bcdefghijconsole.log ("(-3,2):" + str.substr (-3,2)); // (-3,2): hiconsole.log ("(-3):" + str.substr (-3)); // (-3): hijconsole.log ("(1):" + str.substr (1)); // (1): bcdefghijconsole.log ("(-20, 2):" + str.substr (-20, 2)); // (-20, 2): abconsole.log ("(20, 2):" + str.substr (20, 2)); // (20, 2): charAt() devuelve el carácter en la posición especificada en la cadena. Los caracteres en la cadena están indexados de izquierda a derecha, el primer carácter tiene un valor de índice de 0 y el último carácter (suponiendo que ese carácter esté en la cadena stringName ) tiene un valor de índice de stringName.length - 1 . Si el valor index especificado está fuera de este rango, se devuelve una cadena vacía.
var oyString = "Brave New World"; console.log ("El carácter en el índice 0 es '" + anystring.charat (0) + "'"); // => El carácter en el índice 0 es 'b'console.log ("El carácter en el índice 1 es'" + anystring.charat (1) + "'"); // => El carácter en el índice 1 es 'r'console.log ("El carácter en el índice 2 es'" + anystring.charat (2) + "'"); // => El carácter en el índice 2 es 'a'console.log ("El carácter en el índice 3 es'" + anystring.charat (3) + "'"); // => El carácter en el índice 3 es 'v'console.log ("El carácter en el índice 4 es'" + anystring.charat (4) + "'"); // => El carácter en el índice 4 es 'e'console.log ("El carácter en el índice 999 es'" + anystring.charat (999) + "'"); // => El carácter en el índice 999 es ''Combinado, podemos hacer esto para implementar la inversión de las cadenas:
function reverseString (str) {if (str === "") {return ""; } else {return reverseString (str.substr (1)) + str.charat (0); }} reverseString ("hola"); // => ollehLa primera parte del método recursivo. Debe recordar que no solo lo llamará una vez, tendrá varias llamadas anidadas.
Parte 2 Método recursivo.
El método anterior se puede mejorar y cambiar a un operador ternario
función reverseString (str) {return (str === '')? '': ReverseString (str.substr (1)) + str.charat (0);} reverseString ("hola"); // => ollehTambién se puede cambiar a este método
function reverseString (str) {return str && reverseString (str.substr (1)) + str [0];} reverseString ("hola"); // => ollehOtros métodos
Además de los métodos anteriores, en realidad hay otros métodos:
El código del código de copia del método 1 es el siguiente: function reverseString (str) { var newString = []; for (var i = str.length - 1, j = 0; i >= 0; i--, j++) { newString[j] = str[i]; } return newString.join('');}reverseString("hello"); // => olleh es el siguiente: function reverseString (str) { for (var i = str.length - 1, newString = ''; i >= 0; newString += str[i--] ) { } return newString;}reverseString("hello"); // => olleh es el siguiente: function reverseString (str) { function rev(str, len, newString) { return (len === 0) ? newString : rev(str, --len, (newString += str[len])); } return rev(str, str.length, '');}reverseString("hello"); // =>olleh es el siguiente: function reverseString (str) { str = str.split(''); var len = str.length, halfIndex = Math.floor(len / 2) - 1, newString; for (var i = 0; i <= halfIndex; i++) { newString = str[len - i - 1]; str[len - i - 1] = str[i]; str[i] = newString; } return str.join('');}reverseString("hello"); // => olleh es el siguiente: function reverseString (str) { if (str.length < 2) { return str; } var halfIndex = Math.ceil(str.length / 2); return reverseString(str.substr(halfIndex)) + reverseString(str.substr(0, halfIndex));}reverseString("hello"); // =>olleh es el siguiente: function reverseString(str) { return [].reduceRight.call(str, function(prev, curr) { return prev + curr; }, '');}reverseString("hello"); // =>olleh ES6
En ES6, se puede hacer más simple, como:
[...str].reverse().join('');
o [...str].reduceRight( (prev, curr) => prev + curr );
o:
const reverse = str => str && reverse(str.substr(1)) + str[0];
La inversión de la cadena es un algoritmo pequeño y simple, como se mencionó anteriormente, y a menudo se usa para entrevistar a JavaScript básico. Puede usar los métodos anteriores para resolver este problema, o incluso usar soluciones más complejas. Si tiene una mejor manera, agrégalo en los comentarios a continuación y compártelo con nosotros.