w3docs logo

Lookahead and Lookbehind

  1. Introduction to Lookahead and Lookbehind Assertions
  2. Practical Applications of Lookahead and Lookbehind
  3. Conclusion
  4. Practice Your Knowledge new
  5. Related Resources

Understanding the advanced topics of JavaScript regular expressions is beneficial for any developer looking to enhance their coding skills. Among the more advanced and powerful features within this subject are lookahead and lookbehind assertions. These assertions enable developers to search for patterns in text without including those patterns in the result. This guide aims to provide an in-depth exploration of lookahead and lookbehind assertions in JavaScript, complete with numerous practical examples.

Regular expressions can be tricky, and edge cases may exist. Especially when you are using advanced concepts like Lookahead and Lookbehind. Use online regex testers or write unit tests to validate your expressions against a variety of input scenarios to ensure they behave as expected.

Introduction to Lookahead and Lookbehind Assertions

Lookahead and lookbehind assertions are zero-width assertions, meaning they match a position within the string rather than actual characters. They allow us to assert whether a given pattern exists or does not exist at a specific point in the string.

Positive Lookahead

A positive lookahead assertion checks for the existence of a certain pattern ahead of the current position in the string. It is denoted by (?=...). The following example is a positive lookahead to find the word "apple" followed by the word "pie":

Javascript regexp lookaround corresponds to characters
let text = "apple pie is delicious. apple tart is good too."; let regex = /apple(?= pie)/g; let matches = text.match(regex); console.log(matches); // Output: ["apple"]

Negative Lookahead

A negative lookahead assertion checks for the absence of a certain pattern ahead of the current position. It is denoted by (?!...). The following example is a negative lookahead to find the word "apple" not followed by the word "pie":

Javascript regexp the negative lookahead
let text = "apple pie is delicious. apple tart is good too."; let regex = /apple(?! pie)/g; let matches = text.match(regex); console.log(matches); // Output: ["apple"]

Positive Lookbehind

A positive lookbehind assertion checks for the existence of a certain pattern behind the current position in the string. It is denoted by (?<=...). Below is a code sample to find the word "pie" that is preceded by the word "apple":

Javascript regexp the negative lookbehind
let text = "apple pie is delicious. banana pie is good too."; let regex = /(?<=apple )pie/g; let matches = text.match(regex); console.log(matches); // Output: ["pie"]

Negative Lookbehind

A negative lookbehind assertion checks for the absence of a certain pattern behind the current position. It is denoted by (?<!...). Here is a sample to find the word "pie" that is not preceded by the word "apple":

Lookahead and Lookbehind
let text = "apple pie is delicious. banana pie is good too."; let regex = /(?<!apple )pie/g; let matches = text.match(regex); console.log(matches); // Output: ["pie"]

Practical Applications of Lookahead and Lookbehind

Validating Password Strength

Ensuring strong passwords is a common requirement in web applications. Lookahead assertions can be used to validate various password conditions without consuming characters.

const regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/; const password1 = "StrongPass1!"; console.log(regex.test(password1)); // Output: true const password2= "weakpass1!"; console.log(regex.test(password2)); // Output: false

In this example we validated a password that must contain at least one uppercase letter, one lowercase letter, one digit, and one special character.

Formatting and Parsing Data

Lookahead and lookbehind assertions can assist in formatting and parsing complex data structures. A good example is inserting commas into a string of numbers for readability:

let number = "1234567890"; let formattedNumber = number.replace(/\B(?=(\d{3})+(?!\d))/g, ","); console.log(formattedNumber); // Output: "1,234,567,890"

Conclusion

Mastering lookahead and lookbehind assertions in JavaScript can significantly enhance your ability to manipulate and analyze strings. These powerful tools provide the flexibility to assert patterns without consuming characters, making them invaluable for complex text processing tasks. By leveraging these assertions, developers can create more efficient and effective regular expressions, leading to cleaner and more maintainable code.

Practice Your Knowledge

Which of the following statements about lookahead and lookbehind assertions in JavaScript are correct?

Quiz Time: Test Your Skills!

Ready to challenge what you've learned? Dive into our interactive quizzes for a deeper understanding and a fun way to reinforce your knowledge.

❮ Prev Next ❯
Do you find this helpful?