How do you check if a string ends with a substring?

To determine if a string ends with a specific substring in JavaScript, there are several methods available. The most straightforward approach is to use the built-in `String.prototype.endsWith()` method, which provides a clean and efficient way to perform this check. Below, I will outline the method, provide practical examples, discuss best practices, and highlight common mistakes developers might encounter.

Using the endsWith Method

The `endsWith()` method is part of the ECMAScript 6 (ES6) specification and allows you to check if a string ends with a given substring. It returns a boolean value: `true` if the string ends with the specified substring, and `false` otherwise.

Syntax

string.endsWith(searchString[, length])

The `length` parameter is optional and allows you to specify a length of the string to consider. If omitted, the entire string is used.

Example

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

Alternative Methods

While `endsWith()` is the most modern and recommended approach, there are alternative methods for older browsers or specific use cases.

Using Substring and Length

You can manually check if a string ends with a substring by using the `substring()` method combined with the `length` property:

const str = "Hello, world!";
const substring = "world!";
const result = str.substring(str.length - substring.length) === substring;
console.log(result); // true

Using Regular Expressions

Another method is to use regular expressions, which can be more powerful but also more complex:

const str = "Hello, world!";
const regex = /world!$/;
console.log(regex.test(str)); // true

Best Practices

• Prefer using `endsWith()` for readability and performance, especially in modern applications.
• Always consider the case sensitivity of the substring. If needed, convert both strings to the same case using `toLowerCase()` or `toUpperCase()`.
• Be cautious with the optional `length` parameter; ensure it does not exceed the actual string length to avoid unexpected results.

Common Mistakes

• Forgetting that `endsWith()` is case-sensitive, which can lead to incorrect results.
• Using the wrong substring length when utilizing the `length` parameter, which can cause false negatives.
• Not checking for `null` or `undefined` values before calling `endsWith()`, which can result in runtime errors.

In conclusion, checking if a string ends with a substring can be efficiently achieved using the `endsWith()` method, with alternative methods available for specific scenarios. By following best practices and being aware of common pitfalls, developers can ensure robust and error-free string manipulations in their applications.