# String Polyfills and Common Interview Methods in JavaScript

## Introduction

Strings are one of the most fundamental data types in JavaScript. Whether you're validating input, formatting data, or solving algorithmic problems, string manipulation is unavoidable.

In this article, we’ll go beyond just *using* string methods—we’ll understand how they work internally, why polyfills matter, and how this knowledge directly helps in interviews.

* * *

## What Are String Methods?

String methods are built-in functions provided by JavaScript to perform operations on strings.

### Common Examples:

```js
let str = "hello world";

str.toUpperCase();   // "HELLO WORLD"
str.includes("world"); // true
str.slice(0, 5);     // "hello"
str.split(" ");      // ["hello", "world"]
```

### Key Insight:

Strings in JavaScript are **immutable**. This means:

*   Methods don’t modify the original string
    
*   They return a **new string**
    

```js
let str = "hello";
str.toUpperCase();

console.log(str); // still "hello"
```

* * *

## Why Developers Write Polyfills

A **polyfill** is a custom implementation of a built-in method.

### Why do we need them?

1.  **Browser compatibility**
    
    *   Older browsers may not support modern methods
        
2.  **Deep understanding**
    
    *   Interviews often test *how things work internally*
        
3.  **Custom behavior**
    
    *   Sometimes you want slightly modified functionality
        

* * *

## How Built-in Methods Work Conceptually

Before coding polyfills, understand the internal logic.

### Example: `includes()`

Conceptually:

*   Iterate through the string
    
*   Check if substring matches at any position
    
*   Return true/false
    

* * *

## Implementing Simple String Polyfills

### 1\. Polyfill for `includes()`

```js
String.prototype.myIncludes = function(searchStr) {
  let mainStr = this;

  for (let i = 0; i <= mainStr.length - searchStr.length; i++) {
    let match = true;

    for (let j = 0; j < searchStr.length; j++) {
      if (mainStr[i + j] !== searchStr[j]) {
        match = false;
        break;
      }
    }

    if (match) return true;
  }

  return false;
};
```

### Key Logic:

*   Outer loop → starting index
    
*   Inner loop → match substring
    
*   Early break → optimization
    

* * *

### 2\. Polyfill for `toUpperCase()`

```js
String.prototype.myToUpperCase = function() {
  let result = "";

  for (let char of this) {
    let code = char.charCodeAt(0);

    // a-z → 97–122
    if (code >= 97 && code <= 122) {
      result += String.fromCharCode(code - 32);
    } else {
      result += char;
    }
  }

  return result;
};
```

### Key Logic:

*   ASCII manipulation
    
*   Lowercase → uppercase = -32 shift
    

* * *

### 3\. Polyfill for `split()`

```js
String.prototype.mySplit = function(separator) {
  let result = [];
  let current = "";

  for (let char of this) {
    if (char === separator) {
      result.push(current);
      current = "";
    } else {
      current += char;
    }
  }

  result.push(current);
  return result;
};
```

### Key Logic:

*   Accumulate characters
    
*   Push when separator found
    

* * *

## Common Interview String Problems

These are extremely important for placements and coding rounds.

* * *

### 1\. Reverse a String

```js
function reverseString(str) {
  let result = "";

  for (let i = str.length - 1; i >= 0; i--) {
    result += str[i];
  }

  return result;
}
```

* * *

### 2\. Check Palindrome

```js
function isPalindrome(str) {
  let reversed = str.split("").reverse().join("");
  return str === reversed;
}
```

* * *

### 3\. Count Character Frequency

```js
function charFrequency(str) {
  let map = {};

  for (let char of str) {
    map[char] = (map[char] || 0) + 1;
  }

  return map;
}
```

* * *

### 4\. Find First Non-Repeating Character

```js
function firstUniqueChar(str) {
  let map = {};

  for (let char of str) {
    map[char] = (map[char] || 0) + 1;
  }

  for (let char of str) {
    if (map[char] === 1) return char;
  }

  return null;
}
```

* * *

## Interview Insight: What Companies Actually Test

When interviewers ask string questions, they are evaluating:

### 1\. Logical Thinking

*   Can you break a problem into steps?
    

### 2\. Understanding of Internals

*   Do you know how `split`, `reverse`, etc. work internally?
    

### 3\. Edge Case Handling

*   Empty string
    
*   Single character
    
*   Case sensitivity
    

### 4\. Time Complexity Awareness

*   Nested loops → O(n²)
    
*   Hash maps → O(n)
    

* * *

## Importance of Understanding Built-in Behavior

Most candidates rely heavily on built-ins:

```js
str.split("").reverse().join("");
```

But interviews often restrict that.

### Why?

Because they want:

*   Your **problem-solving ability**
    
*   Not your ability to memorize methods
    

* * *

## Final Takeaways

*   String methods are powerful, but understanding their **internal logic** is what makes you strong.
    
*   Polyfills help you think like a JavaScript engine.
    
*   Interview problems are mostly about **patterns**, not memorization.
    
*   Practice writing logic from scratch—this is where most candidates struggle.
    

* * *

## What You Should Do Next

*   Re-implement 5–10 string methods yourself
    
*   Solve at least 20 string problems on LeetCode
    
*   Avoid built-ins initially, then optimize using them
    

* * *

Mastering strings is one of the fastest ways to improve your problem-solving skills—and it directly impacts your performance in technical interviews.