Validation améliorée des chaînes de caractères de Laravel avec des méthodes inverses

La validation des chaînes dans les applications Laravel implique souvent de vérifier quel contenu ne doit PAS correspondre à certains modèles. Les nouvelles méthodes de chaîne inverse de Laravel éliminent la logique de négation maladroite, créant un code de validation plus intuitif et plus facile à maintenir.

Aller au-delà de la double négation La validation traditionnelle des chaînes de caractères nécessitait souvent l’annulation des méthodes existantes, créant une surcharge mentale lors de la lecture des conditions :

use Illuminate\Support\Str;
 
if (!Str::startsWith($document, ['draft_', 'temp_', 'backup_'])) {
    $this->processPublishedDocument($document);
}
 
if (!Str::endsWith($username, ['_admin', '_system', '_test'])) {
    $this->createStandardUser($username);
}

Les méthodes inverses de Laravel transforment ces conditions en énoncés clairs et positifs :

if (Str::doesntStartWith($document, ['draft_', 'temp_', 'backup_'])) {
    $this->processPublishedDocument($document);
}
 
if (Str::doesntEndWith($username, ['_admin', '_system', '_test'])) {
    $this->createStandardUser($username);
}

Les deux méthodes acceptent des chaînes ou des tableaux uniques, conservant la même flexibilité que leurs homologues tout en améliorant la lisibilité du code.

Voici un système de gestion de contenu qui illustre ces méthodes dans des scénarios de validation pratiques :

class ContentValidationService
{
    private array $draftPrefixes = ['draft_', 'wip_', 'preview_'];
    private array $systemSuffixes = ['_config', '_admin', '_internal'];
    private array $reservedWords = ['system', 'admin', 'root', 'api'];
    private array $unsafeTags = ['<script>', '<iframe>', '<embed>'];
 
    public function validateSlugCreation(string $title): array
    {
        $slug = Str::slug($title);
        $errors = [];
 
        if (Str::doesntStartWith($slug, $this->reservedWords)) {
            // Safe slug prefix
        } else {
            $errors[] = 'Slug cannot start with reserved words';
        }
 
        if (Str::doesntEndWith($slug, $this->systemSuffixes)) {
            // Valid ending pattern
        } else {
            $errors[] = 'Slug cannot end with system suffixes';
        }
 
        return [
            'valid' => empty($errors),
            'slug' => $slug,
            'errors' => $errors
        ];
    }
 
    public function sanitizeContentInput(string $content): array
    {
        $maliciousPatterns = ['<script', 'javascript:', 'data:image'];
        $suspiciousEndings = ['.exe"', '.bat"', '.cmd"'];
 
        $validation = [
            'safe_opening' => Str::doesntStartWith(
                Str::lower($content),
                array_map('strtolower', $maliciousPatterns)
            ),
            'safe_references' => Str::doesntEndWith(
                Str::lower($content),
                $suspiciousEndings
            ),
            'content_length' => strlen($content)
        ];
 
        return array_merge($validation, [
            'is_safe' => $validation['safe_opening'] && $validation['safe_references']
        ]);
    }
 
    public function categorizeUserFiles(array $filePaths): array
    {
        $categories = [
            'published' => [],
            'drafts' => [],
            'user_content' => [],
            'restricted' => []
        ];
 
        foreach ($filePaths as $path) {
            $filename = basename($path);
 
            if (Str::doesntStartWith($filename, $this->draftPrefixes)) {
                if (Str::doesntEndWith($filename, $this->systemSuffixes)) {
                    $categories['published'][] = $path;
                } else {
                    $categories['restricted'][] = $path;
                }
            } else {
                $categories['drafts'][] = $path;
            }
        }
 
        return $categories;
    }
 
    public function validateApiEndpoint(string $endpoint): bool
    {
        $restrictedPrefixes = ['/admin/', '/system/', '/internal/'];
        $restrictedSuffixes = ['/delete', '/purge', '/reset'];
 
        return Str::doesntStartWith($endpoint, $restrictedPrefixes) &&
               Str::doesntEndWith($endpoint, $restrictedSuffixes);
    }
}
 
class PostController extends Controller
{
    public function __construct(
        private ContentValidationService $validator
    ) {}
 
    public function store(Request $request)
    {
        $title = $request->input('title');
        $content = $request->input('content');
 
        $slugValidation = $this->validator->validateSlugCreation($title);
        $contentValidation = $this->validator->sanitizeContentInput($content);
 
        if (!$slugValidation['valid'] || !$contentValidation['is_safe']) {
            return back()->withErrors([
                'title' => $slugValidation['errors'] ?? [],
                'content' => $contentValidation['is_safe'] ? [] : ['Content contains unsafe patterns']
            ]);
        }
 
        Post::create([
            'title' => $title,
            'slug' => $slugValidation['slug'],
            'content' => $content,
            'status' => 'published'
        ]);
 
        return redirect()->route('posts.index')
            ->with('success', 'Post created successfully');
    }
}

Inscrivez-vous pour lire la suite