Search for a command to run...
Master the logic behind built-in string methods, learn to write your own polyfills, and crush your next technical interview.
No comments yet. Be the first to comment.
These are the assignments or knowledge dumps I decide to write for the "Chai aur Code's web Dev Cohort 2026"
Move beyond traditional Arrays and Objects. Learn how Map and Set solve common data-handling problems and make your code infinitely more efficient.
RAG helps LLMs answer questions using your own data, but it doesn't guarantee correct answers. Here's how the pipeline works and where it commonly breaks down.
Imagine asking an AI, "Write a blog," versus "Act as an SEO expert and write a 1,000-word blog on AI safety formatted in markdown." The difference in the resulting output is night and day. A prompt is
Spotify and Apple Music make it incredibly easy to showcase your live listening habits on your website. YouTube Music? Not so much. After doing some setup you can do an API call and fetch your account
Arthur C. Clarke's famous third law: "Any sufficiently advanced technology is indistinguishable from magic" perfectly captures how the pace of human innovation works. From carrying supercomputers in o
Why HTTP is amnesiac, the difference between transport and state, and how to choose the right auth strategy for your Node.js app.
As a web developer, you work with text every single day. Whether you are formatting a user’s name, extracting a domain from a URL, or validating a password, Strings are at the heart of the operation.
Thankfully, modern JavaScript provides a rich library of built-in string methods like .includes(), .slice(), .repeat(), and .startsWith(). These methods are incredibly convenient—you just call them, and they work like magic.
But what happens when an interviewer takes that magic away?
One of the most common scenarios in a technical interview is being asked to recreate a built-in method from scratch (writing a Polyfill), or solving complex text-manipulation puzzles without using native shortcuts.
To pass these interviews, you cannot just be a consumer of JavaScript's methods; you must understand how they work under the hood. Let’s dive into the logic of string processing.
At a fundamental level, a string is just an array-like sequence of characters. When you call a built-in method like "hello".toUpperCase(), JavaScript is secretly running a loop over those characters, shifting their internal character codes, and returning a brand new string.
String methods are simply pre-written algorithms designed to save you from writing complex for loops every time you want to manipulate text.
A Polyfill is a piece of code (usually a function) that provides modern functionality on older web browsers that do not natively support it. It essentially "fills in" the missing gap in the browser's capabilities.
[ Execute String Method ]
|
v
[ Does the Browser Support It natively? ]
/ \
[ YES ] [ NO ]
| |
[ Run Native Engine ] [ Fallback to Polyfill Code ]
Why do interviewers ask you to write them? In Web Dev Cohort 2026, we don't write polyfills to support Internet Explorer 11 anymore. Interviewers ask for them because writing a polyfill tests three critical skills:
Algorithmic Thinking: Can you process an array of characters efficiently?
Edge Cases: Do you consider what happens if inputs are negative, empty, or undefined?
Core JS Knowledge: Do you understand how this and prototype work? (Check out my previous blog onthe this keyword if you need a refresher!)
Let’s step into the shoes of an interviewer and write two common string polyfills from scratch. To do this, we attach our custom functions to String.prototype so that any string in our code can use them.
String.prototype.repeat()The native .repeat(count) method takes a string and repeats it count number of times.
The Logic: We need a loop that runs count times. In each iteration, we take our original string (represented by this) and add it to an accumulator string.
// Attaching our polyfill to the String Prototype
String.prototype.customRepeat = function(count) {
// Edge Case 1: Count cannot be negative
if (count < 0) throw new RangeError("Count must be positive");
// Edge Case 2: If count is 0, return empty string
if (count === 0) return "";
let result = "";
// "this" refers to the string calling the method!
for (let i = 0; i < count; i++) {
result += this;
}
return result;
};
const text = "abc";
console.log(text.customRepeat(3)); // Output: "abcabcabc"
String.prototype.startsWith()The native .startsWith(searchString) checks if a string begins with a specific sequence of characters.
The Logic: We don't need to loop through the whole string. We only need to check if the characters in our string—starting from index 0 up to the length of the searchString—match perfectly.
String.prototype.customStartsWith = function(searchString) {
// If the search string is longer than our string, it's automatically false
if (searchString.length > this.length) return false;
// Loop only for the length of the search string
for (let i = 0; i < searchString.length; i++) {
// If any character doesn't match, return false immediately
if (this[i] !== searchString[i]) {
return false;
}
}
// If we made it through the loop without failing, it's a match!
return true;
};
console.log("JavaScript".customStartsWith("Java")); // Output: true
console.log("JavaScript".customStartsWith("Script")); // Output: false
Aside from polyfills, interviewers love to test your algorithmic thinking with string manipulation problems. Here are two classics, and the logic you need to solve them efficiently.
A palindrome is a word that reads the same backward as forward (e.g., "radar" or "racecar").
The Rookie Approach: Split the string into an array, reverse the array, join it back into a string, and check if it equals the original. Why it fails interviews: It creates multiple new arrays and strings in memory, making it highly inefficient (O(n) space).
The Senior Approach: Use two pointers. One at the beginning, one at the end. Check if they match. Move them closer to the center.
String Processing Flow Visualized:
r a d a r -> Match? Yes. Move pointers inward.
\ /
v v
r a d a r -> Match? Yes. Move pointers inward.
|
v
r a d a r -> Match? Yes. Left and Right overlap. Valid Palindrome!
The Code:
function isPalindrome(str) {
let left = 0;
let right = str.length - 1;
while (left < right) {
if (str[left] !== str[right]) {
return false; // Mismatch found, not a palindrome
}
left++;
right--;
}
return true;
}
console.log(isPalindrome("racecar")); // Output: true
Why this impresses: It uses zero extra memory (O(1) space) and stops the loop early the moment a mismatch is found.
An anagram is a word formed by rearranging the letters of a different word (e.g., "listen" -> "silent").
The Logic: Instead of complex sorting, use an Object as a "Hash Map" to count the frequency of each letter in the first word. Then, loop through the second word and subtract from the count. If all counts hit zero, it’s a valid anagram.
function isAnagram(str1, str2) {
if (str1.length !== str2.length) return false;
const charMap = {};
// Build the frequency map for str1
for (let char of str1) {
charMap[char] = (charMap[char] || 0) + 1;
}
// Check and subtract frequencies for str2
for (let char of str2) {
if (!charMap[char]) {
return false; // Character doesn't exist, or count dropped below zero
}
charMap[char]--;
}
return true;
}
console.log(isAnagram("listen", "silent")); // Output: true
It is tempting to rely entirely on methods like .split().reverse().join('') or .indexOf(). They make development fast and readable.
However, understanding built-in behavior at a granular level is what separates framework consumers from true software engineers. When you understand how .includes() parses memory, or how String.prototype behaves, you write code that is faster, safer, and infinitely more scalable.
When you walk into your next technical interview, don't just memorize the shortcuts. Understand the scenic route. If you can confidently explain the logic, handle the edge cases, and recreate the magic from scratch, you will ace the interview every single time.