How to check if a string ends with a specific value in JavaScript

The endsWith method in JavaScript is a simpler way to determine if a string ends with a specific sequence of characters. It returns a boolean, true if the string does indeed end with the substring provided, false otherwise. This method is part of the ES6 specification and has become a staple in string operations for its clarity and simplicity.

Here’s the basic usage:

const str = "Hello, world!";
console.log(str.endsWith("world!"));  // true
console.log(str.endsWith("hello"));   // false

The method also accepts an optional second parameter, which specifies the length of the string to consider. This effectively lets you check if a substring ends at a certain position rather than the actual end of the string.

const phrase = "The quick brown fox";
console.log(phrase.endsWith("brown", 15));  // true

This can be useful when you want to test substrings without creating new strings explicitly, saving both time and memory, especially in performance-critical applications.

It’s important to note that endsWith is case-sensitive, which means “Test”.endsWith(“test”) will return false. If case insensitivity is needed, you’ll have to normalize case first.

const testStr = "JavaScript";
console.log(testStr.toLowerCase().endsWith("script"));  // true

Under the hood, endsWith performs a length check and then compares the substring from the specified position to the end of the string. This is more efficient than manually slicing and comparing because it avoids creating unnecessary intermediate strings in many JavaScript engines.

Understanding these details helps in writing cleaner and more efficient string manipulation code, especially when dealing with large datasets or in performance-sensitive environments like game loops or real-time data parsing.

Implementing custom string end checks

Sometimes, the built-in endsWith method may not meet specific needs. In such cases, implementing a custom string end check can provide greater flexibility. This can be done using a simple function that manually checks the end of a string against a given substring.

function customEndsWith(str, suffix) {
  return str.slice(-suffix.length) === suffix;
}

This function works by slicing the string from the end, matching its length to that of the suffix, and performing a comparison. The slice method is efficient and avoids the pitfalls of creating unnecessary copies of the string.

const example = "Custom implementation";
console.log(customEndsWith(example, "implementation"));  // true
console.log(customEndsWith(example, "Custom"));           // false

Additionally, you can extend this function to include case insensitivity or even support for regular expressions. This allows for a more versatile string check that can adapt to varying requirements.

function customEndsWithIgnoreCase(str, suffix) {
  return str.toLowerCase().slice(-suffix.length) === suffix.toLowerCase();
}

While this approach adds some overhead due to the case normalization, it can be beneficial when working with user-generated content where case sensitivity is not a concern.

const mixedCase = "Hello World";
console.log(customEndsWithIgnoreCase(mixedCase, "world"));  // true

Performance considerations should also be taken into account, especially when designing applications that require frequent string checks. The custom function can be optimized further by avoiding unnecessary string slices.

function optimizedEndsWith(str, suffix) {
  if (suffix.length > str.length) return false;
  for (let i = 0; i < suffix.length; i++) {
    if (str[str.length - suffix.length + i] !== suffix[i]) {
      return false;
    }
  }
  return true;
}

This optimized version checks character by character from the end of the string, which can be faster for longer strings or when the suffix is significantly shorter. Such optimizations are especially crucial in scenarios like game development, where every millisecond counts.

When considering performance, the choice between built-in methods and custom implementations should be guided by the specific use case. In scenarios where strings are frequently manipulated or checked, profiling both approaches is advisable to determine the most efficient method for your application needs.

Profiling tools can help identify bottlenecks in string operations, allowing developers to make informed decisions about which string manipulation techniques to employ. For instance, using the built-in endsWith can lead to cleaner code, while custom solutions may offer tailored performance advantages in specific contexts. Ultimately, understanding these trade-offs is key to optimizing string handling in JavaScript applications.

Performance considerations in string operations

The performance of string operations in JavaScript can vary significantly based on the methods used and the size of the strings involved. While endsWith is optimized for common use cases, it’s essential to consider the underlying implementation and how it interacts with the JavaScript engine.

When you use endsWith, the method performs a relatively simpler comparison, which is efficient for typical string lengths. However, as string lengths increase, the performance can degrade if not managed properly. Using simple profiling, you can identify which operations consume the most time in your application.

console.time("endsWith");
const longStr = "a".repeat(1000000) + "b";
console.log(longStr.endsWith("b"));  // true
console.timeEnd("endsWith");

In performance-critical applications, especially those involving large datasets or real-time processing, the way string comparisons are implemented can have a profound impact. For example, if you’re checking multiple suffixes in a loop, using the built-in method could introduce overhead that can be mitigated with a custom approach.

const suffixes = ["abc", "def", "ghi"];
const testStr = "This is a test string to check suffixes.";

console.time("multipleEndsWith");
suffixes.forEach(suffix => {
  console.log(testStr.endsWith(suffix));
});
console.timeEnd("multipleEndsWith");

In such cases, batching operations or reducing the number of checks can yield better performance. Consider caching results or using data structures that minimize repeated string checks. A trie, for instance, can help optimize checks against a prefix or suffix set.

class TrieNode {
  constructor() {
    this.children = {};
    this.isEndOfWord = false;
  }
}

class Trie {
  constructor() {
    this.root = new TrieNode();
  }

  insert(word) {
    let node = this.root;
    for (const char of word) {
      if (!node.children[char]) {
        node.children[char] = new TrieNode();
      }
      node = node.children[char];
    }
    node.isEndOfWord = true;
  }

  endsWith(suffix) {
    let node = this.root;
    for (const char of suffix) {
      if (!node.children[char]) {
        return false;
      }
      node = node.children[char];
    }
    return true;
  }
}

Using such structures can significantly improve performance when dealing with multiple suffix checks, as they reduce the amount of repeated work done within the string operations.

Another aspect to consider is memory management. Each string operation that creates new strings can lead to increased memory usage, which may impact performance in long-running applications. Reusing strings or avoiding unnecessary string manipulations can mitigate this.

function checkSuffixes(str, suffixes) {
  const results = {};
  for (const suffix of suffixes) {
    results[suffix] = str.endsWith(suffix);
  }
  return results;
}

In this approach, you avoid creating multiple intermediate strings by directly checking the suffixes against the original string. This method is efficient and reduces memory overhead.

Ultimately, understanding the performance characteristics of string operations, including the impact of different methods and data structures, very important for building robust, high-performance applications. Profiling, testing, and carefully selecting the right approach based on the specific context will lead to better outcomes in string handling.