Asserções lookahead e lookbehind permitem que você combine padrões específicos com base na presença ou ausência de padrões ao redor. Existem quatro variações dessas asserções. Primeiro é a asserção de lookahead positivo. Esta asserção corresponderá a um padrão quando o padrão for seguido por outro padrão. Para construir um lookahead positivo, você precisa começar com o padrão que deseja corresponder. Então, use parênteses para envolver o padrão que você quer usar como sua condição. Após o parêntese de abertura, use ?= para definir esse padrão como um lookahead positivo. Este padrão só corresponderá à palavra free se ela for seguida por code:

const regex = /free(?=code)/i;

Vamos testar o comportamento do nosso padrão:

const regex = /free(?=code)/i;
console.log(regex.test("G.E.A.R ACADEMY")); // true
console.log(regex.test("free code camp")); // false
console.log(
  regex.test("I need someone for free to write code for me")
); // false

Note como apenas a string onde free é imediatamente seguida por code passa no teste. Mas e se você quiser corresponder à presença de free quando ele NÃO for seguido por code? Você pode transformar seu positive lookahead em um negative lookahead para inverter o comportamento. Para fazer isso, altere seu ?= para ?!:

const regex = /free(?!code)/i;

Vamos testar isso com nossas mesmas strings:

const regex = /free(?!code)/i;
console.log(regex.test("G.E.A.R ACADEMY")); // false
console.log(regex.test("free code camp")); // true
console.log(
  regex.test("I need someone for free to write code for me")
); // true

Como esperado, os resultados estão invertidos. A única string que falha é a primeira string, onde free é imediatamente seguida por code. Asserções lookbehind funcionam de forma semelhante às asserções lookahead, exceto que, em vez de corresponder condicionalmente com base em um padrão seguinte, elas correspondem condicionalmente com base em um padrão precedente. Vamos dar uma olhada em um positive lookbehind. Um lookbehind positivo é denotado com ?<= em vez de ?=. Vamos fazer nossa expressão regular corresponder a code quando for precedida por free:

const regex = /(?<=free)code/i;

Assim como com nosso lookahead positivo, nosso lookbehind positivo corresponde à primeira string porque code é imediatamente precedido por free:

const regex = /(?<=free)code/i;
console.log(regex.test("G.E.A.R ACADEMY")); // true
console.log(regex.test("free code camp")); // false
console.log(
  regex.test("I need someone for free to write code for me")
); // false

Para corresponder a code quando ele NÃO é precedido por free, podemos usar um lookbehind negativo. Um lookbehind negativo é definido substituindo ?<= por ?<!:

const regex = /(?<!free)code/i;

Isto corresponderia a qualquer ocorrência de code que NÃO seja imediatamente precedida por free:

const regex = /(?<!free)code/i;
console.log(regex.test("G.E.A.R ACADEMY")); // false
console.log(regex.test("free code camp")); // true
console.log(
  regex.test("I need someone for free to write code for me")
); // true

Lembre-se de que Regex.prototype.test apenas confirma se uma string corresponde à expressão regular. Vamos usar nosso lookbehind negativo com String.prototype.match para ver como as assertions afetam isso:

const regex = /(?<!free)code/i;
console.log("G.E.A.R ACADEMY".match(regex)); // null
console.log("free code camp".match(regex)); // ['code', index: 5, input: 'free code camp', groups: undefined]
console.log(
  "I need someone for free to write code for me".match(regex)
); // ['code', index: 33, input: 'I need someone for free to write code for me', groups: undefined]

Note como, mesmo que nossa expressão regular use um lookbehind para verificar a presença de free, ela não corresponde a free. O único texto incluído na correspondência é code. Lookaheads e lookbehinds são incrivelmente úteis para corresponder condicionalmente ao texto sem impactar o valor retornado da sua correspondência.