Weave Code
Regex Laravel Package
php-standard-library/regex
Type-safe regex for PHP with typed capture groups and predictable error handling. Build expressions with confidence, get structured match results, and avoid silent failures common in preg_* functions. Part of PHP Standard Library.
Type-safe regular expressions with typed capture groups and proper error handling
Frequently asked questions about Regex
- How can I use this package in Laravel validation rules instead of preg_match?
- This package lets you define type-safe regex patterns with structured capture groups, which you can integrate into Laravel’s validation rules by extending the `RegexRule` class or creating a custom rule. For example, replace `preg_match('/pattern/', $input)` with the package’s fluent API to enforce stricter typing and catch errors early. The structured results also make validation feedback more precise for users.
- Does this work with Laravel’s Form Request validation? If so, how?
- Yes, you can use this package in Form Requests by defining regex patterns in your validation rules or by creating a custom validation method. For instance, add a rule like `'field' => ['regex:/pattern/', new CustomRegexRule($pattern)]` to leverage typed capture groups and avoid silent failures. The package’s error handling will also provide clearer feedback during validation failures.
- Will this break existing preg_match or preg_replace calls in my Laravel app?
- No, this package is a wrapper and won’t break existing `preg_*` calls. However, you’ll need to manually refactor code to adopt the new API for type safety and better error handling. Start with non-critical modules (e.g., logging or background jobs) to test compatibility before rolling out changes. Always run tests to ensure regex behavior remains consistent.
- Can I use this package in Laravel Blade templates for client-side-like pattern matching?
- While the package itself isn’t Blade-specific, you can create a custom Blade directive (e.g., `@regex`) to wrap its functionality. For example, define a directive that processes regex patterns in templates and returns structured results. This would be useful for dynamic pattern matching in views, though performance should be benchmarked for high-traffic pages.
- What Laravel versions does this package support, and are there any PHP version requirements?
- The package requires PHP 8.1+ and is designed to work with Laravel 9.x and later. Since it’s a thin wrapper around PHP’s native PCRE functions, it won’t introduce compatibility issues with Laravel’s ecosystem. Always check the package’s documentation for the latest supported versions, as they may evolve with updates.
- How do I handle PCRE errors (e.g., invalid patterns) in a Laravel application?
- This package provides proper error handling for invalid regex patterns, unlike `preg_*` functions which often fail silently. You can catch exceptions thrown by the package (e.g., `InvalidRegexException`) and map them to Laravel’s error responses or validation messages. For example, wrap regex operations in a try-catch block and return a `422 Unprocessable Entity` response for invalid patterns in API endpoints.
- Are there performance benefits over raw preg_match in Laravel’s high-traffic APIs?
- The package introduces minimal overhead since it’s a lightweight wrapper around PCRE. For performance-critical paths (e.g., API payload parsing), benchmark it against raw `preg_*` calls to confirm no regressions. The structured results and type safety may even improve maintainability, offsetting any minor performance trade-offs. Start with critical endpoints and compare execution times.
- Can I extend Laravel Collections to use this package for regex operations?
- Yes, you can create a Collection macro to integrate this package’s regex functionality. For example, add a method like `extract($pattern)` to parse strings in a collection with typed capture groups. This would enable fluent operations like `collect($strings)->extract('/pattern/')->toArray()`. Document the macro in your project to guide other developers.
- What’s the best way to migrate from preg_* to this package in a large Laravel app?
- Start with a proof-of-concept in a non-critical module (e.g., a custom validation rule or logging filter) to test the API and error handling. Use search/replace tools to identify `preg_*` calls and refactor them incrementally, ensuring tests pass at each step. For legacy code, prioritize high-risk areas (e.g., user input validation) first to catch edge cases early.
- Are there alternatives to this package for type-safe regex in Laravel?
- Alternatives include custom wrappers around `preg_*` with type hints or third-party packages like `spatie/array-to-xml` for specific use cases (e.g., XML parsing). However, this package stands out for its focus on typed capture groups and predictable error handling, which are critical for Laravel’s validation and parsing workflows. Evaluate alternatives based on your need for type safety, error handling, and integration with Laravel’s ecosystem.
Weaver
How can I help you explore Laravel packages today?