Regex TypeScript Enfin Type Safe page

Le Problème

Tu utilises des groupes de capture dans tes regex ?

const pattern = /user-(\d+)-(.+)/
const match = pattern.exec(input)

if (match) {
  const id = match[1] // string | undefined
  const name = match[2] // string | undefined
}

Le problème ?

TypeScript ne sait pas si tes groupes existent vraiment.

Tu peux écrire match[99] sans erreur de compilation.

Tu découvres le bug en prod.

La Solution

ArkRegex est un remplaçant direct de new RegExp() avec typage complet.

import { regex } from 'arkregex'

const pattern = regex(/user-(\d+)-(.+)/)
const match = pattern.exec('user-123-john')

if (match) {
  const id = match.groups[0] // ✅ string
  const name = match.groups[1] // ✅ string
}

TypeScript infère automatiquement tes groupes de capture.

Les 3 Avantages

1. Erreurs détectées à la compilation

const pattern = regex(/data-(\d+)/)
const match = pattern.exec(input)

match.groups[0] // ✅ OK
match.groups[1] // ❌ Erreur TypeScript

2. Zero overhead runtime

ArkRegex n'ajoute aucun code à ton bundle.

L'amélioration est purement au niveau des types.

À l'exécution : RegExp natif. Rien d'autre.

3. Syntaxe JS native

Aucune courbe d'apprentissage.

// Avant
const pattern = /user-(\d+)/

// Après
const pattern = regex(/user-(\d+)/)

Un import. C'est tout.

Exemples Concrets

Avec groupes nommés

const pattern = regex(/(?<id>\d+)-(?<name>.+)/)
const match = pattern.exec(input)

if (match) {
  const id = match.groups.id // ✅ autocomplétion
  const name = match.groups.name // ✅ autocomplétion
}

Parsing de logs

const logPattern = regex(/\[(\d{4}-\d{2}-\d{2})\] (\w+): (.+)/)
const match = logPattern.exec('[2025-01-15] ERROR: Connection failed')

if (match) {
  const date = match.groups[0] // "2025-01-15"
  const level = match.groups[1] // "ERROR"
  const message = match.groups[2] // "Connection failed"
}

Migration Simple

Étape 1 : Ajoute l'import

import { regex } from 'arkregex'

Étape 2 : Wrap tes patterns

const pattern = regex(/ton-pattern-ici/)

C'est tout.

Pas de refactoring. Pas de changement de logique.

Comparaison

Quand l'Utiliser ?

✅ Utilise ArkRegex si :

• Tu écris des regex avec groupes de capture
• Tu veux éliminer les bugs de référence
• Tu veux zero overhead runtime
• Tu utilises TypeScript 5.9+

❌ Skip si :

• Tu n'utilises jamais de groupes (.test() suffit)
• Ton projet n'est pas en TypeScript

Conclusion

On refuse any dans notre code.

Pourquoi accepter string | undefined dans nos regex ?

ArkRegex résout ça.

Même syntaxe. Zero runtime. 100% type-safe.

Documentation : https://arktype.io/docs/blog/arkregex

Les regex type-safe, c'est maintenant. 🎯