Рекурсивная функция разворота строк в javascript?

Ответ 1

Что-то вроде:

function reverse (str) {
    if (str === "") {
        return "";
    } else {
        return reverse(str.substr(1)) + str.charAt(0);
    }
}

Таким образом, функция рекурсивна, поскольку она вызывает себя для выполнения работы.

Ответ 2

Рекурсивная версия с хвостом, только для ударов (хотя JavaScript не выполняет удаление хвостового вызова):

function reverse(str) {
  function r(s, acc) {
    return (s.length == 0) ? acc : r(s.substr(1), s.charAt(0) + acc);
  };
  return r(str, '');
};

Ответ 3

Одна строка кода, использующая тернарные операторы, вы можете легко отменить ее.

Объяснение: если строка существует (если не null), тогда возвращайте рекурсию, иначе остановите рекурсию.

  function reverseString(str) {
    return (str ? reverseString(str.substring(1)) + str.charAt(0) : str);
  }

Вызов функции:

console.log(reverseString('hello'));

Ответ 4

Функция ускорения на 25%: jsperf.com

function Reverse(str) {
  if (str === null) {
    return null;
  }
  if (str.length <= 1) {
    return str;
  }
  var first = str[0];
  var last = str[str.length - 1];
  var str1 = Reverse(str.substring(1, str.length - 1));
  return last + str1 + first;
}

var result = Reverse("a really serious string of nothingness making call stack to explode");

Ответ 5

function reverse(str) {
  if(str.charAt(0) === ''){
    return "";
  }
  return str.charAt(str.length -1) + reverse(str.substring(0,str.length-1));
}

Ответ 6

//вызываем эту функцию со строкой в качестве параметра

function strrev(str) {
    return str.length !== 1 ? strrev(str.slice(1))+str[0] : str;
}

Ответ 7

Согласно веб-документам MDN, вы должны использовать substring() вместо substr():

Предупреждение. Хотя String.prototype.substr(…) не является строго устаревшим (как в "удаленных из веб-стандартов"), он считается устаревшей функцией и его следует избегать, когда это возможно. Он не является частью основного языка JavaScript и может быть удален в будущем. Если это вообще возможно, используйте метод substring().

Кроме того, если в качестве параметра charAt() не указан индекс, по умолчанию используется значение 0.

Следовательно, мы можем написать рекурсивную однострочную строку для обращения строки, используя троичный оператор и применив логику, описанную выше:

const reverse_string = s => s === '' ? '' : reverse_string(s.substring(1)) + s.charAt();

console.log(reverse_string('Hello, world!')); // !dlrow ,olleH

Ответ 8

Попробуйте следующее:

function recurse(s) {  
  if (s.length == 0) {  
    return '' // stopping condition  
  } else {  // return last char + result of function called with chars up to last char  
    return s.substring(s.length, s.length -1) + recurse(s.substring(0, s.length -1))  
  }
}  

Ответ 9

Пока лучшее, что я думаю:

function reverse(s) {
    if (s.length===1) return s;
    return reverse(s.slice(1)) + s[0];
}

Ответ 10

Это довольно простая реализация С# для алгоритма, который вы просили. Я думаю, что это можно было бы легко переписать в javascript.

/*
C#: The Complete Reference 
by Herbert Schildt 

Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/


// Display a string in reverse by using recursion. 

using System; 

class RevStr { 

  // Display a string backwards. 
  public void displayRev(string str) { 
    if(str.Length > 0)  
      displayRev(str.Substring(1, str.Length-1)); 
    else  
      return; 

    Console.Write(str[0]); 
  } 
} 

public class RevStrDemo { 
  public static void Main() {   
    string s = "this is a test"; 
    RevStr rsOb = new RevStr(); 

    Console.WriteLine("Original string: " + s); 

    Console.Write("Reversed string: "); 
    rsOb.displayRev(s); 

    Console.WriteLine(); 
  } 
}

Ответ 11

Это многословие, но мне нравится облегчать понимание в логических шагах:

function rev(soFar, count){
   console.log("asString: " + soFar );
   console.log("count: " + count);
   var len = soFar.length;
   var ret = soFar;//ret needs to be a reference to soFar
   if(len > count){
      var subd = soFar.substring(1,len);
      var first = soFar[0];
      //we want to inject the first letter at the index position one back from the length, minus what the count is at this point
      var indexOfInsert = len-1 - count;//so if count is 0 and length is 5, we want 4 (4 -0)
      var asArray = subd.split("");
      asArray.splice(indexOfInsert,0,first);
      count++;//need to increment count for the next round
      var asString = "";
    //recreate as string, not array - the default toString() makes this a comma delimited string. It is best toi just recreate it in a loop
    for(var i = 0; i<len; i++){
        asString+=asArray[i];
    }
    ret = rev(asString,count);//ret always needs to be reassigned
}
//only get here when count is greater than the length of the original string
return ret;//will always be a reference to soFar, which is being reassigned in the recursive loop

}

Затем назовите его так:

var reversed = rev("Hello",0);
console.log("result",reversed);