❮ Previous

Advanced String Concepts

  • This lesson covers advanced string handling and manipulation techniques.

  • Introduction to Advanced String Concepts

    Strings are one of the most commonly used data types in JavaScript.
    In real-world applications, we often need to:

    • Search text inside strings

    • Replace specific words or characters

    • Compare strings for validation, sorting, or logic

    In this lesson, we will focus on two important advanced string topics:

    1. String Searching and Replacing

    2. String Comparison

    String Searching & Replacing

    Why String Searching Is Important

    String searching is used when:

    • Validating user input

    • Finding keywords

    • Filtering data

    • Processing text

    • Implementing search functionality

    Common String Searching Methods in JavaScript

    JavaScript provides several built-in methods for searching strings:

    • indexOf()

    • lastIndexOf()

    • includes()

    • search()

    • match()

      indexOf() Method

      What It Does

      Finds the first occurrence of a substring and returns its index.

      Syntax

      string.indexOf(searchValue, startIndex)

    Finding Substring Position Using indexOf()

    Returns the index of the first occurrence of a specified substring 

    let text = "JavaScript is powerful";

console.log(text.indexOf("is")); // position of "is"

    • If the value is not found, it returns -1.

      lastIndexOf() Method

      What it Does

      Finds the last occurrence of a substring.

    Find Last Occurrence Using lastIndexOf()

    Returns the index of the last occurrence of a specified substring 

    let text = "apple banana apple";

console.log(text.lastIndexOf("apple")); // position of last "apple"

    • includes() Method

      What It Does

      Checks whether a string contains a specified value and returns true or false.

      Syntax

      string.includes(searchValue)

    Check Substring Existence Using includes()

    Returns true or false based on whether a string contains a given value 

    let message = "Welcome to JavaScript";

console.log(message.includes("JavaScript")); // true

    • search() Method

      What It Does

      Searches a string using a regular expression and returns the index of the match.

    Search Substring Using search() Method

    Finds the position of a match in a string using a pattern 

    let text = "Learning JavaScript";

console.log(text.search("JavaScript")); // index of match

    • Replacing Strings in JavaScript

      Replacing strings is commonly used to:

      • Modify user input

      • Clean data

      • Replace sensitive information

      • Format text

      replace() Method

      What It Does

      Replaces a specified value with another value.

      Syntax

      string.replace(oldValue, newValue)

    Replace Text in Strings Using replace()

    Substitutes a specific part of a string with a new value 

    let sentence = "I love JavaScript";

let newSentence = sentence.replace("JavaScript", "Programming");

console.log(newSentence); // "I love Programming"

    • Important About replace()

      By default:

      Only the first occurrence is replaced

    replace() Only Changes First Occurrence

    Shows that replace() modifies only the first matching value by default 

    let text = "JS is easy. JS is powerful.";

console.log(text.replace("JS", "JavaScript")); 
// "JavaScript is easy. JS is powerful."
    • Replacing All Occurrences

    Replace All Matches Using Regular Expression

    Uses global flag to replace every occurrence in a string 

    let text = "JS is easy. JS is powerful.";

console.log(text.replace(/JS/g, "JavaScript")); 
// "JavaScript is easy. JavaScript is powerful."
    • Case-Insensitive Replace

    Case-Insensitive Replacement Using Regex

    Replaces text without considering letter case using the i flag 

    let text = "Javascript is popular";

console.log(text.replace(/javascript/i, "JavaScript")); 
// "JavaScript is popular"

    • String Comparison

      What is String Comparison ?

      String comparison is used to:

      • Check equality

      • Validate passwords

      • Compare usernames

      • Sort text data

      JavaScript compares strings character by character, based on Unicode values.

    Comparing Values Using == and ===

    Shows difference between loose equality and strict equality 

    let str1 = "Hello";
let str2 = "Hello";

console.log(str1 == str2);  // true
console.log(str1 === str2); // true
    • Case Sensitivity in String Comparison

    Case Sensitivity in String Comparison

    Demonstrates that string comparison depends on exact letter casing 

    console.log("Hello" === "hello"); // false
    • Comparing User Input

    Normalize Case Before String Comparison

    Converts input to a consistent case to avoid comparison errors 

    let userInput = "Admin";

if (userInput.toLowerCase() === "admin") {
  console.log("Access granted");
}

    • localeCompare() Method

      What It Does

      Compares two strings based on language rules.

      Syntax

      string1.localeCompare(string2)

      Return Values

      • 0 → strings are equal

      • -1 → string1 comes before string2

      • 1 → string1 comes after string2

    Compare Strings Using localeCompare()

    Compares strings based on alphabetical and language-specific rules 

    // Using localeCompare()
let a = "apple";
let b = "banana";

console.log(a.localeCompare(b)); // -1

// Comparing alphabetically
let name1 = "Rahul";
let name2 = "Rohan";

if (name1 < name2) {
  console.log(name1 + " comes first");
}

    • Real-Life Use Cases

      • Login validation

      • Search filters

      • Sorting names

      • Replacing forbidden words

      • Text formatting

      Common Mistakes

      • Forgetting strings are case-sensitive

      • Expecting replace() to change all occurrences

      • Using == instead of ===

      • Not handling user input properly

      Best Practices for String Searching & Comparison

      • Use includes() for simple checks

      • Use indexOf() when position matters

      • Normalize strings using toLowerCase()

      • Avoid complex nested conditions

      • Prefer readability over short code

    ❮ Previous