String Polyfills and Common Interview Questions in JavaScript

In Javascript, strings are used everywhere, but many developers do not know how they actually work behind the scenes.

When you call a method like .toUpperCase() on a string primitive, JavaScript creates a temporary wrapper object (using the String constructor) so the method can be executed. Once the operation is done, that object is immediately discarded, and the result is returned as a primitive.

What Are String Methods?

String methods are the built-in functions that are used to manipulate and update the string.

Here are some of the string methods:

• toUpperCase()

• toLowerCase()

• slice()

• substring()

• includes()

• split()

• trim()

These methods don’t modify the original string (because strings are immutable). Instead, they return a new string.

How string method work internally?

Let's take an example toUpperCase and understand how it works.

When you call string.toUpperCase()

const str = 'Hello';

str.toUpperCase();

1. Javascript iterate over each character

2. Convert that character into uppercase

3. Build a new string

Think of execution like this

Input String → Process Each Character → Apply Logic → Return New String

What are polyfills?

Polyfills are a custom implementation of the built-in functions. It is mostly used to create the same functionality that built-in functions offer.

Why Developers Write Polyfills?

• Provide support for new methods in older browsers

• Understanding internal logic

• To practice the built-in methods logic by creating them of their own

Polyfill Examples

Let's implement some polyfills for string methods

1. string.toLowerCase()
   Here I will be writing a custom polyfill for toLowerCase.

   if(!String.prototype.toLowerCase){
       String.prototype.toLowerCase = function () {
           let result = "";
   
           // this refer to string on which method is called
           for (let char of this) {
               const code = char.charCodeAt(0);
   
               // a-z → A-Z
               if (code >= 97 && code <= 122) {
                   result += String.fromCharCode(code - 32);
               } else {
                   result += char;
               }
           }
   
           return result;
       };
   }
   

   This will only work if the browser doesn't support string.toLowerCase, it will use the polyfill toLowerCase

2. string.includes

   if(!String.prototype.includes){
       String.prototype.myIncludes = function(searchString) {
           return this.indexOf(searchString) !== -1;
       };
   }
   

Common String Interview Questions

If you're preparing for interviews, these are must-practice:

1. Reverse a String function without using built-in methods
   Logic: Iterate over the string and append the new string with each character in an order so that the last character comes first.

2. Check Palindrome
   Logic: Reverse and create a new string. Check if both strings are equal or not.

3. Count Characters
   Logic: Use a "Map" or an object to store counts as you iterate through the string.

4. Anagram Detection: Do two strings contain the same characters?
   Logic: Sort both strings and compare them.

Why Understanding Built-in Behavior Matters

Most developers stop at using methods. But in an interview, the interviewer tests:

• How things work internally

• Your problem-solving ability

• Your understanding of edge cases

Understanding internals helps you in writing better code, debugging faster, and performing well in interviews.

Example questions:

1. How does slice() differ from substring()?

2. Why are strings immutable?

3. How would you optimize a string search?

Conclusion

If you want to stand out as a developer:

Don’t just use methods — understand them, practice writing polyfills, and solve real interview problems.

That’s where real growth happens.

Follow the series to learn more about Javascript.