Как вы переворачиваете строку на месте (или на месте) в JavaScript при передаче в функцию с оператором return? Все без использования встроенных функций (.reverse(), .charAt() и т.д.)?
Как вы меняете строку на JavaScript?
Ответ 1
Пока вы имеете дело с простыми символами ASCII, и вы счастливы использовать встроенные функции, это будет работать:
function reverse(s){
return s.split("").reverse().join("");
}
Если вам нужно решение, поддерживающее UTF-16 или другие многобайтовые символы, имейте в виду, что эта функция даст недопустимые строки Unicode или правильные строки, которые выглядят забавно. Возможно, вы захотите рассмотреть этот ответ.
Ответ 2
Следующий метод (или аналогичный) обычно используется для изменения строки в JavaScript:
// Don’t use this!
var naiveReverse = function(string) {
return string.split('').reverse().join('');
}
Фактически, все ответы, опубликованные до сих пор, являются вариацией этого шаблона. Однако есть некоторые проблемы с этим решением. Например:
naiveReverse('foo 𝌆 bar');
// → 'rab �� oof'
// Where did the `𝌆` symbol go? Whoops!
Если вы задаетесь вопросом, почему это происходит, читать внутреннюю кодировку JavaScripts. (TL; DR: 𝌆 является астральным символом, а JavaScript предоставляет его как два отдельных блока кода.)
Но больше:
// 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.
Хорошая строка для проверки обратных реализаций строк следующая:
'foo 𝌆 bar mañana mañana'
Почему? Поскольку он содержит астральный символ (𝌆) (который представлен суррогатными парами в JavaScript) и комбинирующий знак (ñ в последний mañana состоит из двух символов: U + 006E LATIN SMALL LETTER N и U + 0303 COMBINING TILDE).
Порядок, в котором появляются суррогатные пары, не может быть отменен, иначе астральный символ больше не появится в "обращенной строке". Вот почему вы видели те метки �� на выходе для предыдущего примера.
Комбинированные метки всегда применяются к предыдущему символу, поэтому вы должны рассматривать как основной символ (U + 006E LATIN SMALL LETTER N) в качестве метки объединения (U + 0303 COMBINING TILDE) в целом. Если реверсировать их порядок, это приведет к соединению метки объединения с другим символом в строке. Поэтому для вывода примера был ã вместо ñ.
Надеюсь, это объясняет, почему все ответы, опубликованные до сих пор, неверны.
Чтобы ответить на ваш первоначальный вопрос - как [правильно] изменить строку в JavaScript, я написал небольшую библиотеку JavaScript, способную разворачивать строку в Unicode. У меня нет никаких проблем, о которых я только что упомянул. Библиотека называется Esrever; его код находится на GitHub, и он работает практически в любой среде JavaScript. Он поставляется с утилитой оболочки/двоичным кодом, поэтому вы можете легко отменить строки из своего терминала, если хотите.
var input = 'foo 𝌆 bar mañana mañana';
esrever.reverse(input);
// → 'anañam anañam rab 𝌆 oof'
Что касается части "на месте", см. другие ответы.
Ответ 3
String.prototype.reverse=function(){return this.split("").reverse().join("");}
или
String.prototype.reverse = function() {
var s = "";
var i = this.length;
while (i>0) {
s += this.substring(i-1,i);
i--;
}
return s;
}
Ответ 4
Подробный анализ и десять различных способов изменения строки и их характеристик производительности.
http://eddmann.com/posts/ten-ways-to-reverse-a-string-in-javascript/
Перспективность этих реализаций:
Лучшая реализация для браузера
- Хром 15 - Реализации 1 и 6
- Firefox 7 - Реализация 6
- IE 9 - Реализация 4
- Opera 12 - Реализация 9
Вот эти реализации:
Реализация 1:
function reverse(s) {
var o = '';
for (var i = s.length - 1; i >= 0; i--)
o += s[i];
return o;
}
Реализация 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('');
}
Реализация 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('');
}
Реализация 4:
function reverse(s) {
return s.split('').reverse().join('');
}
Реализация 5:
function reverse(s) {
var i = s.length,
o = '';
while (i > 0) {
o += s.substring(i - 1, i);
i--;
}
return o;
}
Реализация 6:
function reverse(s) {
for (var i = s.length - 1, o = ''; i >= 0; o += s[i--]) { }
return o;
}
Реализация 7:
function reverse(s) {
return (s === '') ? '' : reverse(s.substr(1)) + s.charAt(0);
}
Реализация 8:
function reverse(s) {
function rev(s, len, o) {
return (len === 0) ? o : rev(s, --len, (o += s[len]));
};
return rev(s, s.length, '');
}
Реализация 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('');
}
Реализация 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
Вся "обратная строка на месте" - это устаревший собеседование с программистами на языке C, и люди, которые были опрошены ими (для мести, может быть?), спросят. К сожалению, это часть "In Place", которая больше не работает, потому что строки в практически любом управляемом языке (JS, С# и т.д.) Используют неизменяемые строки, тем самым побеждая всю идею перемещения строки без выделения какой-либо новой памяти.
В то время как вышеприведенные решения действительно меняют строку, они не делают этого, не выделяя больше памяти и, таким образом, не удовлетворяют условиям. Вы должны иметь прямой доступ к строке как выделенную и иметь возможность манипулировать своим исходным местоположением памяти, чтобы иметь возможность отменить ее на месте.
Лично я действительно ненавижу подобные интервью, но, к сожалению, я уверен, что мы будем следить за ними на долгие годы.
Ответ 6
Во-первых, используйте Array.from() чтобы превратить строку в массив, затем Array.prototype.reverse() чтобы отменить массив, а затем Array.prototype.join() чтобы вернуть строку.
const reverse = str => Array.from(str).reverse().join('');
Ответ 7
В ECMAScript 6 вы можете изменить строку еще быстрее, не используя метод .split('') split, с распространителем следующим образом:
var str = [...'racecar'].reverse().join('');
Ответ 8
Похоже, я опаздываю на вечеринку на 3 года...
К сожалению, вы не можете, как было указано. См. Являются ли строки JavaScript неизменяемыми? Нужен ли мне строковый конструктор " в JavaScript?
Следующее лучшее, что вы можете сделать, это создать "представление" или "обертку", которая берет строку и восстанавливает любые части используемого API-интерфейса строки, но притворяется, что строка отменена. Например:
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
Демо:
> 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"
Кикер - на месте чистая математика, читая математику, посещая каждый символ только один раз и только при необходимости:
> 'demo: ' + S('0123456789abcdef').slice(3).reversed().slice(1,-1).toUpperCase()
"demo: EDCBA987654"
> S('0123456789ABCDEF').slice(3).reversed().slice(1,-1).toLowerCase().charAt(3)
"b"
Это дает значительную экономию, если применяется к очень большой строке, если вы используете только относительно небольшой срез.
Независимо от того, стоит ли это (по сравнению с копированием как в большинстве языков программирования), зависит от вашего варианта использования и того, насколько эффективно вы переопределяете API-интерфейс строки. Например, если все, что вы хотите, это сделать операцию индексации строк или взять небольшие slice или substr s, это сэкономит вам пространство и время. Если вы планируете печатать большие перевернутые фрагменты или подстроки, экономия может быть небольшой, даже хуже, чем полная копия. Ваша строка "reverse" также не будет иметь тип string, хотя вы можете подделать это с помощью прототипирования.
В приведенной выше демонстрационной реализации создается новый объект типа ReversedString. Он прототипирован и, следовательно, достаточно эффективен, с минимальной работой и минимальными затратами на пространство (общие определения прототипов). Это ленивая реализация, включающая отложенную нарезку. Всякий раз, когда вы выполняете функцию типа .slice или .reversed, она будет выполнять индексную математику. Наконец, когда вы извлекаете данные (путем неявного вызова .toString() или .charCodeAt(...) или что-то еще), он будет применять те, которые используются "умным" способом, касаясь наименьших данных.
Примечание: приведенный выше API-интерфейс строки является примером и не может быть реализован отлично. Вы также можете использовать только 1-2 функции, которые вам нужны.
Ответ 9
Во время собеседования меня попросили изменить строку без использования каких-либо переменных или собственных методов. Это моя любимая реализация:
function reverseString(str) {
return str === '' ? '' : reverseString(str.slice(1)) + str[0];
}
Ответ 10
Есть много способов перевернуть строку в JavaScript. Я записываю три способа, которые предпочитаю.
Подход 1: Использование обратной функции:
function reverse(str) {
return str.split('').reverse().join('');
}
Подход 2: перебирая символы:
function reverse(str) {
let reversed = '';
for (let character of str) {
reversed = character + reversed;
}
return reversed;
}
Подход 3: Использование функции снижения:
function reverse(str) {
return str.split('').reduce((rev, char) => char + rev, '');
}
Надеюсь, это поможет :)
Ответ 11
Есть несколько способов сделать это, вы можете проверить следующее:
1. Традиционный для цикла (приращение):
function reverseString(str){
let stringRev ="";
for(let i= 0; i<str.length; i++){
stringRev = str[i]+stringRev;
}
return stringRev;
}
alert(reverseString("Hello World!"));Ответ 12
Это самый простой способ, я думаю,
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 🍺'));Ответ 13
var str = 'sample string';
[].map.call(str, function(x) {
return x;
}).reverse().join('');
ИЛИ
var str = 'sample string';
console.log(str.split('').reverse().join(''));
//Вывод: 'gnirts elpmas'
Ответ 14
Я знаю, что это старый вопрос, на который хорошо ответил, но для моего собственного удовольствия я написал следующую обратную функцию и подумал, что поделюсь ею, если это будет полезно для кого-то еще. Он обрабатывает суррогатные пары и комбинирует метки:
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('');
}
Все опоры для Mathias, Punycode и различные другие ссылки для обучения меня сложностям кодирования символов в JavaScript.
Ответ 15
В ES6 у вас есть еще один вариант
function reverseString (str) {
return [...str].reverse().join('')
}
reverseString('Hello');
Ответ 16
Реальный ответ: вы не можете отменить его на месте, но вы можете создать новую строку, которая является обратной.
Как упражнение для игры с рекурсией: иногда, когда вы идете на собеседование, интервьюер может спросить вас, как это сделать, используя рекурсию, и я думаю, что "предпочтительный ответ" может быть "Я бы предпочел не делать этого в рекурсия, поскольку она может легко вызвать переполнение стека" (поскольку это O(n), а не O(log n).Если это O(log n), довольно сложно получить переполнение стека - 4 миллиарда элементов могут обрабатываться стеком уровень 32, так как 2 ** 32 - 4294967296. Но если это O(n), тогда он может легко получить переполнение стека.
Иногда интервьюер все еще спрашивает вас: "Как упражнение, почему бы вам не написать его с помощью рекурсии?" И вот он:
String.prototype.reverse = function() {
if (this.length <= 1) return this;
else return this.slice(1).reverse() + this.slice(0,1);
}
тестовый прогон:
var s = "";
for(var i = 0; i < 1000; i++) {
s += ("apple" + i);
}
console.log(s.reverse());
выход:
999elppa899elppa...2elppa1elppa0elppa
Чтобы попытаться получить переполнение стека, я изменил 1000 на 10000 в Google Chrome и сообщил:
RangeError: Maximum call stack size exceeded
Ответ 17
Строки сами по себе неизменяемы, но вы можете легко создать обратную копию со следующим кодом:
function reverseString(str) {
var strArray = str.split("");
strArray.reverse();
var strReverse = strArray.join("");
return strReverse;
}
reverseString("hello");
Ответ 18
//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
Ответ 19
Если вы не хотите использовать встроенную функцию. Попробуйте это
var string = 'abcdefg';
var newstring = '';
for(let i = 0; i < string.length; i++){
newstring = string[i] += newstring
}
console.log(newstring)
Ответ 20
function reverseString(string) {
var reversedString = "";
var stringLength = string.length - 1;
for (var i = stringLength; i >= 0; i--) {
reversedString += string[i];
}
return reversedString;
}
Ответ 21
без преобразования строки в массив;
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());
с использованием Array.reverse без преобразования символов в кодовые точки;
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());
Ответ 22
Я думаю, что String.prototype.reverse - хороший способ решить эту проблему; код ниже:
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";
Ответ 23
Использование функций массива,
String.prototype.reverse = function(){
return [].reduceRight.call(this, function(last, secLast){return last + secLast});
}
Ответ 24
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);
Ответ 25
Лучшие способы изменить строку в JavaScript
1) Array.reverse:
Вероятно, вы думаете, подождите, я думал, что мы меняем строку, почему вы используете метод Array.reverse. Используя метод String.split, мы преобразуем нашу строку в массив символов. Затем мы меняем порядок каждого значения в массиве, а затем, наконец, преобразуем массив обратно в строку, используя метод Array.join.
function reverseString(str) {
return str.split('').reverse().join('');
}
reverseString('dwayne');
2) Сокращение while-loop:
Хотя это довольно многословное решение, оно имеет свои преимущества перед решением. Вы не создаете массив, и вы просто конкатенируете строку на основе символов из исходной строки.
С точки зрения производительности, этот, вероятно, даст наилучшие результаты (хотя и не проверен). Для чрезвычайно длинных строк выигрыш в производительности может выпасть из окна.
function reverseString(str) {
var temp = '';
var i = str.length;
while (i > 0) {
temp += str.substring(i - 1, i);
i--;
}
return temp;
}
reverseString('dwayne');
3) Рекурсия
Мне нравится, насколько просто и понятно это решение. Вы можете ясно видеть, что методы String.charAt и String.substr используются для передачи другого значения, вызывая его каждый раз, пока строка не будет пустой, из которой троянец просто вернет пустую строку вместо использования рекурсии для вызова себя, Это, вероятно, даст вторую лучшую производительность после второго решения.
function reverseString(str) {
return (str === '') ? '' : reverseString(str.substr(1)) + str.charAt(0);
}
reverseString('dwayne');
Ответ 26
Моя собственная оригинальная попытка...
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"
Ответ 27
Небольшая функция, которая обрабатывает как сочетание диакритики, так и 2-байтовые символы:
(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() ); }
);
Ответ 28
Держите его сухим и простым глупым!
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
ОК, довольно просто, вы можете создать функцию с помощью простого цикла, чтобы сделать обратную строку для вас, не используя reverse(), charAt() и т.д., например:
Например, у вас есть эта строка:
var name = "StackOverflow";
Создайте такую функцию, я называю ее 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;
}
И вы можете называть его так:
reverseString(name);
И результат будет:
"wolfrevOkcatS"
Ответ 30
Вот четыре наиболее распространенных метода, которые вы можете использовать для достижения обращения строки
Если задана строка, вернуть новую строку с обратным порядком символов
Несколько решений проблемы
//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;
}, '');
}