you need to split the string by space

function reverseInPlace(str) {
  var words = [];
  words = str.match(/\S+/g);
  var result = "";
  for (var i = 0; i < words.length; i++) {
     result += words[i].split('').reverse().join('') + " ";
  }
  return result
}
console.log(reverseInPlace("abd fhe kdj"))

Your function has two bugs

1. Adds an extra space to the end of the string. Eg for "the cat sat on the mat" you return "eht tac tas no eht tam ". The input string is 22 characters long and the returned string is 23 characters long.

2. Related to the first. If the input string starts with a space the returned string removes it. Eg for " the cat sat on the mat" you return "eht tac tas no eht tam ".

Code style

This section will cover source code style. These points are independent of the algorithms logic.

• You are missing the semicolon for the line inside the last for statement.

• Use === or !== rather than == or !=

• You should never see for (var i If you use a var it should be declared at the top of the function or use for (let i. You can also use const in for...of and for...in loops. Eg for (const i of foo) {

• Don't scrunch up the code. Space between ) {, for (, if (, } else and else {. Also operators should be separated by space. i = strlen-1 should be i = strlen - 1

• Use const for variables that do not change.

  • The variable strlen does not change, thus it should be a constant.
  • The variable reverseStrArr holds a reference to an array. That reference never changes so the variable should be declared as a constant. const reverseStrArr = [];

• You should try to avoid adding a variable's type to its name.

  Names need only fit the context (have semantic meaning) of the scope/function they are declared in.

  • myStr better as words or sentence
  • strLen better as just length or charCount or even just len
  • reverseStr better as reversed
  • reverseStrArr maybe reversedWords

Loop variables

You don't need to declare a different variable of each loop. You need only do that if the loops are nested.

// Nested 
var i,j;
for (i = 0; i < 10; i++) {
    for (j = 0; j < 10; j++) { /*...*/ }
}
//or 
for (let i = 0; i < 10; i++) {
    for (let j = 0; j < 10; j++) { /*...*/ }
}

// Sequential
var i;
for (i = 0; i < 10; i++) { /*...*/ }
for (i = 0; i < 10; i++) { /*...*/ }

//or 
for (let i = 0; i < 10; i++) { /*...*/ }
for (let i = 0; i < 10; i++) { /*...*/ }

Algorithms Logic

This section looks at how your function solves the problem and possible ways to improve it.

Array as a stack

You are using the array reverseStrArr as a stack. An array becomes a stack only by the way you use it, it is an abstracted stack.

Stacks are first in last out. You add items one at a time to the top of the stack, then you remove items one at a time from the top.

The two array function push() and pop() provide a fast way to use JS arrays as a stack.

As a stack the final loop where you create the result string can be simplified as

while (reversedWords.length) {
    result += " " + reversedWords.pop();
}

^{(I think the rules will let us use pop.)}

Unneeded steps

1. The Last Word

In the second loop you have the statement if(j + 1 == strlen) { to push the last result to the array, then you clear result.

If you remove that statement and its content you can have result hold the last word. In the following loop result already has the first word so you can add the space then word rather than word an space (trailing space bug)

This fixes both bugs.

2. Repeated Logic

The first loop goes from last to first creating a reversed string, then the next loop indexes the string created from first to last. Its like writing backward so the when you read forward its backward... LOL

The first loop is not needed. Just read the sentence string backward as you process it.

Rewrite

Putting all the above into your function we get a much simpler source and fix the bugs at the same time.

function reverseString(words) {
    const reversed = [], len = words.length;
    var result = "", i = len;
    while (i-- > 0) {
        if (words[i] == " ") {
            reversed.push(result);
            result = "";
        } else { 
            result += words[i];
        }
    }
    while (reversed.length) { 
        result += " " + reversed.pop();
    }
    return result;
}

Alternative

The rewrite is still a little too complex .

I used two loops to first create a stack of words and then use the stack to rebuild the sentence.

You can do both within the one loop removing the need to use a stack.

function reverseWords(sentence) {
    var word = "", reversed = "", i = sentence.length;
    while (i-- > 0) {
        if (sentence[i] === " ") {
            reversed = " " + word + reversed;
            word = "";
        } else { word += sentence[i] }
    }
    return word + reversed;
}

Surrogates, Codepoints, Emoji, modifiers, sequences

I see that in the accepted answer there are comments regarding Emoji (surrogate Unicode characters)

In JavaScript strings are iteratable. The iterator handles all codepoint characters as single items.

Note: Single emoji can be created from one or more codepoints. eg is one emoji (on Chrome win10) but contains 6 codepoints or 8 Javascript string Unicode characters. See note at bottom of answer.

Using iterators to step over strings and you need not worry about character sequences.

Unfortunately iterators don't run backward. As we can not use many of the Array functions we are limited in how to solve the problem

Simplest solution.

To solve the problem of surrogate characters (within the restriction of the question) we can use a very quick hack that converts the input string to an array.

sentence = [...sentence]; // separates codepoints

The rest of the function remains unchanged because we used bracket notation to index the strings.

Example

Shows pass and failure modes when reversing surrogates via string iterator.

    function reverseWords(sentence) {
        sentence = [...sentence];
        var word = "", reversed = "", i = sentence.length;
        while (i-- > 0) {
            if (sentence[i] === " ") {
                reversed = " " + word + reversed;
                word = "";
            } else { word += sentence[i] }
        }
        return word + reversed;
    }
    
    
    const test1 = " The cat  on the mat ";
    const test2 = `  \u200D\u200D \u{1F3C4}\u200D\u2642\uFE0F`;

    log(test1);
    log("Reverse...");
    log(reverseWords(test1));
    
    log("--------------------------------------");
    log("Emoji modifiers and sequences may fail.");

    log(`${test2} Reversed is...`);
    log(`${reverseWords(test2)}`);

    
    
    function log(textContent) { 
        info.appendChild(Object.assign(document.createElement("div"),{textContent}));
    }

#info {
font-size: large;
}

<code id="info"><code>

Note: Emoji modifiers and sequences rely not only on how Javascript handles the string but also how the device OS interprets the string.

Use String.prototype.codePointAt() to locate modifiers, sequences, gruping, etc

For a full Emoji rundown Unicode Emoji Technical Standard