Weave Code
Comparison Laravel Package
php-standard-library/comparison
Small PHP comparison utilities that provide consistent, reusable ways to compare values. Useful for sorting, equality checks, and custom comparator functions without rewriting boilerplate across your projects.
Interfaces and functions for type-safe, consistent value comparison
Frequently asked questions about Comparison
- How can I use this package to standardize sorting in Laravel Collections?
- Replace `Collection::sortBy()` with the package’s comparator methods. For example, use `Comparison::sort($collection, 'price', 'desc')` for consistent, reusable sorting logic. Works seamlessly with Laravel’s built-in collections and avoids repetitive closures. Benchmark critical paths first—method calls may introduce minor overhead compared to native PHP operators.
- Does this package support Laravel Eloquent queries (e.g., `orderBy` or `where`)?
- No direct Eloquent integration exists, but you can create custom query scopes or global macros to adapt comparators to SQL. For example, define `DB::macro('orderByComparator', fn($field, $direction) => ...)` to bridge the gap. This requires manual setup but centralizes comparison logic in your application.
- Will this package work with Laravel’s Blade templates for conditional rendering?
- Not natively, but you can wrap comparators in Blade helpers or directives. For example, create a helper like `{{ comparison('yesNo', $user->isActive) }}` to replace ternary checks. This keeps your views clean while leveraging the package’s standardized logic.
- What Laravel versions and PHP versions does php-standard-library/comparison support?
- The package targets PHP 8.1+ and is framework-agnostic, so it works with Laravel 9.x, 10.x, and 11.x. No Laravel-specific dependencies mean it won’t conflict with your existing setup. Always check the [repository’s requirements](https://github.com/php-standard-library/comparison) for updates.
- How do I handle null values or custom domain objects (e.g., Money, DateRange) with this package?
- The package doesn’t include null safety by default, so you’ll need to extend it or wrap values in adapters. For custom objects like `Money`, implement a `Comparable` interface or create a factory method (e.g., `Comparison::compareMoney($amount1, $amount2)`). This ensures type safety while keeping comparisons consistent.
- Can I use this package to replace Laravel’s built-in Collection methods like `sortBy()` or `where()`?
- Yes, but selectively. The package excels at complex or domain-specific comparisons (e.g., fuzzy matching, custom hierarchies) where Laravel’s methods fall short. For simple cases, stick with built-ins for performance. Use the package to standardize logic across your app, reducing duplication in services, controllers, and API responses.
- Are there performance concerns when using comparators in high-traffic Laravel APIs?
- Method calls introduce minimal overhead, but benchmark critical paths (e.g., API rate limits) to compare against native PHP operators. For hot paths, cache comparator results or use inline logic. The package’s lightweight design ensures it won’t bloat your application, but always test under load.
- How does this package integrate with Laravel’s testing (e.g., unit or feature tests)?
- Deterministic comparisons simplify testing by replacing flaky or context-dependent logic. Mock comparators in unit tests to isolate business rules, and use the package’s methods in assertions (e.g., `assertTrue(Comparison::is($user->role, 'admin'))`). Integration tests benefit from consistent comparison logic across your app.
- What alternatives exist for type-safe comparisons in Laravel, and when should I choose this package?
- Laravel’s built-in `Collection` methods suffice for basic cases, while Spatie’s query builder extensions handle SQL comparisons. Choose this package if you need reusable, domain-specific comparators (e.g., pricing tiers, custom objects) or want to enforce clean code standards. It’s ideal for projects prioritizing maintainability over minimalism.
- How do I migrate from ad-hoc comparisons (e.g., `if ($a > $b)`) to this package incrementally?
- Start by replacing repetitive comparisons in services or controllers (Phase 1). Use IDE refactoring tools to find and replace patterns like `===`, `>`, or `<`. For collections, add global helpers (Phase 2) before tackling domain objects (Phase 3). Write tests to validate correctness during each phase, ensuring no regressions in business logic.
Weaver
How can I help you explore Laravel packages today?