Reverse String in JavaScript [duplicate]

The length problem is already explained. To solve it you could use:

function ReverseString(string) {
    this.str = string;
    var size = this.str.length;
    this.reverse = function () {
        while(size--) {
            console.log(this.str[size]);
        }
    }
}

Another (more simple way) to reverse a string is to split it into an array, reverse that, and join again:

somestring.split('').reverse().join('');

Applied to your method, something like this snippet:

const result = document.querySelector('#result');
const RString = stringFactory();

// constructor
const myReversed = new ReverseString('hello world');
myReversed.reverse();

// factory
result.textContent += ` | `;
RString(`Hello World`).printReversed(result);

function ReverseString(string) {
  this.str = string;
  this.reverse = function() {
    const rev = this.str.split('').reverse();
    rev.forEach(v => result.textContent += v);
    this.reversed = rev.join('');
  };
}

// factory pattern
// see also https://github.com/KooiInc/es-stringbuilder-plus
function stringFactory() {
  return str => assignHelpers(str);
  
  function assignHelpers(str) {
    return {
      get reverse() { return str.split('').reverse().join(``); },
      printReversed(elem) {
        str.split('').reverse().forEach( l => 
          elem.textContent += l );
      }
    };
  }
}

#result {
  letter-spacing: 0.5rem;
  font-size: 1.3rem;
  font-weight: bold;
}

<div id="result"></div>

To circumvent the problem @Mark Baijens commented on (combined Unicode characters, aka surrogate pairs), a modern solution (es20xx) could be:

const str = `foo 𝌆 bar mañaña`;
document.querySelector(`#result`)
  .textContent = [...str].reverse().join(``);

#result {
  letter-spacing: 0.5rem;
  font-size: 1.3rem;
  font-weight: bold;
}

<div id="result"></div>

What about this easy step

"hello world".split(' ').map(word=>word.split('').reverse().join('')).join(' ')

it will reverse every word in its place

"olleh dlrow"

Try as altenrative

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

In your solution size at beginning should be length -1. You mix string reversing with string printing, but you can separate it as follows

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

At the beginning, size is going to be 3 (the length). There is nothing at index 3, hence undefined. You need to initiate it at length-1.

var size = this.str.length - 1;

Here are three ways to reverse a string in JavaScript.

Iterate through string in reverse order and push letters to array, then join the array:

function reverse1(str) {
  if(!str || str.length < 2 || typeof str !== "string") {
    return new Error("Not a valid input");
  }
  const backwards = [];
  for (let i = str.length; i > -1; i--) {
    backwards.push(str[i]);
  }
  return backwards.join('');
}

Use split, reverse, and join methods:

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

Use ES6 arrow function and spread operator to copy as well as convert the string to array and then reverse and join:

reverse3 = str => [...str].reverse().join('');

Call the three functions:

console.log(reverse1("Hello World!"));
console.log(reverse2("Hello World!"));
console.log(reverse3("Hello World!"));

Output

!dlroW olleH
Hello World!
!dlroW olleH

User recusrsivity, easiest way to do it

function reverse(str){
     if (str.length == 0){ 
        return '';
     }
     return reverse(str.slice(1)) + charAt(0);
}

I would use reduceRight:

function sum(arr) {
    return arr.reduceRight(function(result, chr) {
        return result += chr;
    });
}

Now I have a handy routine I can also use to sum up sequences of numbers (in reverse order, but that doesn't matter).. For string:

function reverse_string(str) {
    return sum(str.split(''));
}

In here you have get the size of the 'string' constructor parameter and you decrese the length of the given word('size' variable).

function ReverseString(string)     { 
    this.str = string; 
    var size = this.str.length;
    this.reverse = function () {
        for(size; size >= 0; --size){ //loop from index value 3 to 0 
          console.log(this.str[size]);
        } 
    }
}

But the problem is when you input word 'asd', the length of that string is 3. So, when you access the index of str[3] should be undefined. Because,

    index[0] --> a
    index[1] --> s
    index[2] --> d
    index[3] --> undfined

So, your code should change,

function ReverseString(string)   { 
    this.str = string; 
    var size = this.str.length; 
    this.reverse = function () {
        for(size; size > 0; --size) { //loop from index value 2 to 0 
            console.log(this.str[size - 1]);
        } 
    }
}

So, output should be like this,

    index[0] --> a
    index[1] --> s
    index[2] --> d