The constraint "without reversing" is pushing you toward the two-pointer technique — which is actually the better solution anyway (no extra allocation).

Two-pointer approach

function isPalindrome(str) {
  let left = 0;
  let right = str.length - 1;
  while (left < right) {
    if (str[left] !== str[right]) return false;
    left++;
    right--;
  }
  return true;
}

• Compare the outermost pair, move inward. First mismatch → not a palindrome.
• Loop ends when the pointers meet (odd length: middle char ignored, correctly).
• O(n) time (really n/2 comparisons), O(1) space — beats the reverse-and-compare approach which allocates a whole new string.

Clarify the requirements first

Always ask: "raw characters, or normalized?" Common variant — ignore case, spaces, and punctuation ("A man, a plan, a canal: Panama"):

function isPalindrome(str) {
  const s = str.toLowerCase().replace(/[^a-z0-9]/g, "");
  let left = 0, right = s.length - 1;
  while (left < right) {
    if (s[left++] !== s[right--]) return false;
  }
  return true;
}

Recursive variant (if they ask)

const isPal = (s, l = 0, r = s.length - 1) =>
  l >= r ? true : s[l] !== s[r] ? false : isPal(s, l + 1, r - 1);

Same O(n) time but O(n) call stack — worse than the loop for large inputs.

Edge cases

• Empty string / single char → true (vacuously a palindrome).
• Unicode — str[i] indexes UTF-16 code units, so emoji/surrogate pairs break it; use [...str] to split into code points if Unicode matters.
• Whitespace/case — depends entirely on the spec; ask.

What interviewers want

Reach for two pointers immediately, state O(n)/O(1), and ask the normalization question before coding — that clarification is itself a signal.