Laravel’s property is one of those quiet conveniences that shapes how you handle data without drawing much attention. Dr

Laravel ನ $casts ಪ್ರಾಪರ್ಟಿ ಎಂಬುದು ನೀವು ಡೇಟಾವನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತೀರಿ ಎಂಬುದನ್ನು ಗಮನಕ್ಕೆ ಬರದೇ ರೂಪಿಸುವ ಒಂದು ಸೌಲಭ್ಯವಾಗಿದೆ. ಅರೇ (array) ನಲ್ಲಿ boolean ಅಥವಾ datetime ನಂತಹ ಬಿಲ್ಟ್-ಇನ್ ಟೈಪ್ ಅನ್ನು ಬಳಸಿದರೆ, Eloquent ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಡೇಟಾಬೇಸ್‌ನ ರ ಕಲ್ಮ (raw strings) ಅನ್ನು ನಿಮ್ಮ ಕಂಟ್ರೋಲರ್‌ಗಳು ಅಥವಾ ವ್ಯೂಸ್‌ಗಳಿಗೆ ತಲುಪುವ ಮೊದಲೇ ಹೆಚ್ಚು ಸುಲಭವಾಗುವ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತದೆ. ಇದು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಅಚ್ಚುಕಟ್ಟಾಗಿಡುತ್ತದೆ. ಆದರೆ ನೀವು ಆ ಅರೇ ಒಳಗೇ ನೇರವಾಗಿ ನಿಮ್ಮ ಸ್ವಂತ ಹೆಲ್ಪರ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಕರೆಯಲು ಪ್ರಯತ್ನಿಸಿದರೆ, ಫ್ರೇಮ್‌ವರ್ಕ್ ಅದನ್ನು ಒಪ್ಪುವುದಿಲ್ಲ. 'username' => 'encrypt_data()' ಎಂಬಂತಹ ಸಾಲುಗಳು ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ. Laravel ಒಂದು ನೇтив ಕ್ಯಾಸ್ಟ್ ಕೀವರ್ಡ್ ಅಥವಾ CastsAttributes ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಇಂಪ್ಲಿಮೆಂಟ್ ಮಾಡುವ ಕ್ಲಾಸ್ ಅನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತದೆ. ಈ ಅಗತ್ಯತೆಯು Eloquent ನ ಹೈಡ್ರೇಶನ್ (hydration) ಮತ್ತು ಸೀರಿಯಲೈಸೇಶನ್ (serialization) ಸೈಕಲ್‌ನ ಆಳದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದರಿಂದ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ; ಅದಕ್ಕೆ ರನ್-ಟೈಮ್‌ನಲ್ಲಿ ಇರದೇ ಇರಬಹುದಾದ ಯಾವುದೋ ಒಂದು ಅನಿರ್ದಿಷ್ಟ ಫಂಕ್ಷನ್ ಸ್ಟ್ರಿಂಗ್‌ಗಿಂತ, ಸ್ಪಷ್ಟವಾದ ಒಪ್ಪಂದವಿರುವ (clear contract) ಮುನ್ಸೂಚನೆ ನೀಡಬಲ್ಲ ಆಬ್ಜೆಕ್ಟ್ ಬೇಕಾಗುತ್ತದೆ.

$casts ಅರೇನಲ್ಲಿ ಹೆಲ್ಪರ್ ಫಂಕ್ಷನ್‌ಗಳು ಏಕೆ ವಿಫಲವಾಗುತ್ತವೆ?

Eloquent ಒಂದು ಮಾಡೆಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಿದಾಗ, ಪ್ರತಿ ಕಾಲಂ ಅನ್ನು ಹೇಗೆ ಪರಿವರ್ತಿಸಬೇಕೆಂದು ನಿರ್ಧರಿಸಲು ಅದು $casts ಅರೇ ಅನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡುತ್ತದೆ. ಫ್ರೇಮ್‌ವರ್ಕ್ string, integer, array, encrypted ಮುಂತಾದ ನಿರ್ದಿಷ್ಟ ಪ್ರಿಮಿಟಿವ್‌ಗಳನ್ನು ಮತ್ತು CastsAttributes ಅನ್ನು ಇಂಪ್ಲಿಮೆಂಟ್ ಮಾಡುವ ಫುಲ್ಲಿ-ಕ್ವಾಲಿಫೈಡ್ ಕ್ಲಾಸ್ ಹೆಸರುಗಳನ್ನು ಗುರುತಿಸುತ್ತದೆ. ಇದು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಕೋಡ್ ಆಗಿ ಎವ್ಯಾಲ್ಯೂಯೇಟ್ ಮಾಡುವುದಿಲ್ಲ. ಆದ್ದರಿಂದ 'encrypt_data()' ಅನ್ನು ಅನ್-ನೋನ್ (unknown) ಕ್ಯಾಸ್ಟ್ ಟೈಪ್ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ, ಇದು ಎರರ್ (error) ಉಂಟುಮಾಡುತ್ತದೆ. ಒಂದು ವೇಳೆ Laravel ಇದನ್ನು ಪಾರ್ಸ್ ಮಾಡಿದರೂ ಸಹ, ಮಾಡೆಲ್ ಇನ್‌ಸ್ಟೆನ್ಸ್, ಅಟ್ರಿಬ್ಯೂಟ್ ಕೀ, ಪ್ರಸ್ತುತ ಮೌಲ್ಯ ಮತ್ತು ಸುತ್ತಮುತ್ತಲಿನ ಅಟ್ರಿಬ್ಯೂಟ್‌ಗಳನ್ನು ಸರಿಯಾದ ಕ್ರಮದಲ್ಲಿ ನಿಮ್ಮ ಫಂಕ್ಷನ್‌ಗೆ ಕಳುಹಿಸಲು ಯಾವುದೇ ವಿಶ್ವಾಸಾರ್ಹ ಮಾರ್ಗವಿರುವುದಿಲ್ಲ. ನಿಮ್ಮ ಕಸ್ಟಮ್ ಲಾಜಿಕ್ ಮತ್ತು Eloquent ನ ಇಂಟರ್ನಲ್ಸ್ ನಡುವಿನ ಆ ಹ್ಯಾಂಡ್‌ಶೇಕ್ ಅನ್ನು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಮಾಡಲು ಈ ಇಂಟರ್ಫೇಸ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

ಈ ಅಂತರವನ್ನು ತುಂಬಲು ನಿಮ್ಮ ಬಳಿ ಎರಡು ದೃಢವಾದ ಮಾರ್ಗಗಳಿವೆ. ಒಂದು ದೀರ್ಘಕಾಲದ ಮರುಬಳಕೆಗೆ (reuse) ಪೂರಕವಾಗಿದೆ. ಇನ್ನೊಂದು ಕೇವಲ ಒಂದೇ ಮಾಡೆಲ್‌ನಲ್ಲಿ ವೇಗವಾಗಿ ಪ್ಯಾಚ್ ಮಾಡಲು ಬಯಸುವವರಿಗೆ ಸೂಕ್ತವಾಗಿದೆ.

ವಿಧಾನ 1: ಕಸ್ಟಮ್ ಕ್ಯಾಸ್ಟ್ ಕ್ಲಾಸ್ ಬರೆಯಿರಿ

ಒಂದೇ ರೀತಿಯ ಪರಿವರ್ತನೆಯು ಹಲವಾರು ಫೀಲ್ಡ್‌ಗಳಿಗೆ ಅಥವಾ ಹಲವಾರು ಮಾಡೆಲ್‌ಗಳಿಗೆ ಅನ್ವಯವಾಗುತ್ತಿದ್ದರೆ, ಪ್ರತ್ಯೇಕ ಕ್ಯಾಸ್ಟ್ ಕ್ಲಾಸ್ ಬಳಸುವುದು ಉತ್ತಮ ಆಯ್ಕೆಯಾಗಿದೆ. ಇದು ತನ್ನದೇ ಆದ ಫೈಲ್‌ನಲ್ಲಿ ಇರುತ್ತದೆ, ಪ್ರತ್ಯೇಕವಾಗಿ ಯೂನಿಟ್-ಟೆಸ್ಟ್ ಮಾಡಬಹುದು ಮತ್ತು ನಿಮ್ಮ ಮಾಡೆಲ್‌ಗಳನ್ನು ಪುನರಾವರ್ತಿತ ಬಾಯ್ಲರ್‌ಪ್ಲೇಟ್‌ನಿಂದ ಮುಕ್ತವಾಗಿಡುತ್ತದೆ.

ಮೊದಲು app/Casts/CustomEncrypt.php ಅನ್ನು ರಚಿಸುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸಿ. ನೇಮ್‌ಸ್ಪೇಸ್ (namespace) ನಿಮ್ಮ ಆಟೋಲೋಡಿಂಗ್ ಸೆಟಪ್‌ಗೆ ಹೊಂದಿಕೆಯಾಗಬೇಕು, ಸಾಮಾನ್ಯವಾಗಿ App\Casts. ಕ್ಲಾಸ್ ಕಡ್ಡಾಯವಾಗಿ Illuminate\Contracts\Database\Eloquent\CastsAttributes ಅನ್ನು ಇಂಪ್ಲಿಮೆಂಟ್ ಮಾಡಬೇಕು, ಇದು ನೀವು get ಮತ್ತು set ಎಂಬ ಎರಡು ಮೆಥಡ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದನ್ನು ಕಡ್ಡಾಯಗೊಳಿಸುತ್ತದೆ.

<?php

namespace App\Casts;

use Illuminate\Contracts\Database\Eloquent\CastsAttributes;
use Illuminate\Database\Eloquent\Model;

class CustomEncrypt implements CastsAttributes
{
    public function get(Model $model, string $key, mixed $value, array $attributes): mixed
    {
        return decrypt_data($value);
    }

    public function set(Model $model, string $key, mixed $value, array $attributes): mixed
    {
        return encrypt_data($value);
    }
}

ಸಿಗ್ನೇಚರ್‌ಗಳು (signatures) ಮುಖ್ಯವಾಗಿವೆ. Eloquent ಪ್ರತಿ ಮೆಥಡ್‌ಗೆ ನಾಲ್ಕು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ. $model ಎಂಬುದು ಪೋಪ್ಯುಲೇಟ್ ಆಗುತ್ತಿರುವ ಅಥವಾ ಸೇವ್ ಆಗುತ್ತಿರುವ ಇನ್‌ಸ್ಟೆನ್ಸ್ ಆಗಿದೆ, ಇದು ನಿಮ್ಮ ಲಾಜಿಕ್ ಇತರ ಫೀಲ್ಡ್‌ಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದ್ದರೆ ಅವುಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. $key ಎಂಬುದು ಪ್ರಸ್ತುತ ಕ್ಯಾಸ್ಟ್ ಆಗುತ್ತಿರುವ ಕಾಲಂ ಹೆಸರು. $value ಎಂಬುದು get ಮಾಡುವಾಗ ಡೇಟಾಬೇಸ್‌ನಿಂದ ಬರುವ ರ ಸ್ಟ್ರಿಂಗ್ ಅಥವಾ null ಆಗಿರುತ್ತದೆ, ಅಥವಾ set ಮಾಡುವಾಗ ಬಳಕೆದಾರರು ನೀಡಿದ ಮೌಲ್ಯವಾಗಿರುತ್ತದೆ. $attributes ಎಂಬುದು ಆ ರೋ (row) ನ ಎಲ್ಲಾ ಕಾಲಂಗಳ ರ ಅರೇ ಆಗಿದೆ. ನೀವು ಪ್ರತಿ ಬಾರಿಯೂ ನಾಲ್ಕೂ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಬಳಸಬೇಕಾಗಿಲ್ಲ, ಆದರೆ ಇಂಟರ್ಫೇಸ್ ಅವುಗಳನ್ನು ಬಯಸುತ್ತದೆ.

ಮೇಲಿನ get ಮೆಥಡ್‌ನಲ್ಲಿ, Eloquent ಡೇಟಾಬೇಸ್‌ನಿಂದ ರೋ ಅನ್ನು ಪಡೆದ ನಂತರ ಮತ್ತು ಮೌಲ್ಯವು ನಿಮ್ಮ ಮಾಡೆಲ್‌ಗೆ ತಲುಪುವ ಮೊದಲು decrypt_data($value) ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. set ಮೆಥಡ್‌ನಲ್ಲಿ, encrypt_data($value) ಎಂಬುದು INSERT ಅಥವಾ UPDATE ನಡೆಯುವ ಮೊದಲು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಇದರಿಂದ ಡೇಟಾಬೇಸ್ ಎಂದಿಗೂ ಪ್ಲೇನ್‌ಟೆಕ್ಸ್ಟ್ (plaintext) ಅನ್ನು ನೋಡುವುದಿಲ್ಲ.

ಇದನ್ನು ಜೋಡಿಸಲು, ನಿಮ್ಮ ಮಾಡೆಲ್‌ನ $casts ಅರೇ ಒಳಗಡೆ ಕ್ಲಾಸ್ ಅನ್ನು ಉಲ್ಲೇಖಿಸಿ:

protected $casts = [
    'username' => CustomEncrypt::class,
    'password' => CustomEncrypt::class,
];

ನೀವು ಕ್ಲಾಸ್ ಕಾನ್ಸ್ಟಂಟ್ ಅನ್ನು ಬಳಸುತ್ತಿರುವುದರಿಂದ, ಆಟೋಲೋಡರ್ ಉಳಿದ ಕೆಲಸವನ್ನು ಮಾಡುತ್ತದೆ. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ನಂತರ ಎನ್‌ಕ್ರಿಪ್ಶನ್ ಸ್ಕೀಮ್ ಬದಲಾಯಿಸಬೇಕಾದಲ್ಲಿ, ನೀವು ಕೇವಲ ಒಂದು ಫೈಲ್ ಅನ್ನು ಎಡಿಟ್ ಮಾಡಿದರೆ ಸಾಕು, ಮ್ಯಾಪ್ ಮಾಡಲಾದ ಎಲ್ಲಾ ಫೀಲ್ಡ್‌ಗಳ ವರ್ತನೆಯು ತಕ್ಷಣವೇ ಬದಲಾಗುತ್ತದೆ. ಅನೇಕ ಟೇಬಲ್‌ಗಳಲ್ಲಿ ಸೂಕ್ಷ್ಮ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಈ ಕೇಂದ್ರೀಕರಣವು ಅತ್ಯುತ್ತಮವಾಗಿದೆ.

ವಿಧಾನ 2: ಅಕ್ಸೆಸರ್ (Accessor) ಮತ್ತು ಮ್ಯುಟೇಟರ್ (Mutator) ಬಳಸಿ

ಕೆಲವೊಮ್ಮೆ ಕೇವಲ ಒಂದು ಕಡೆ ಮಾತ್ರ ಅಗತ್ಯವಿರುವ ಪರಿವರ್ತನೆಗಾಗಿ ನೀವು ಹೊಸ ಫೈಲ್ ಅನ್ನು ರಚಿಸಲು ಬಯಸುವುದಿಲ್ಲ. Laravel ನ Attribute ಕ್ಲಾಸ್ ಬಳಸಿ ನೀವು PHP 8+ closure ಸಿಂಟ್ಯಾಕ್ಸ್ ಮೂಲಕ ಮಾಡೆಲ್‌ನಲ್ಲಿ ನೇರವಾಗಿ get ಮತ್ತು set ಲಾಜಿಕ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು.

use Illuminate\Database\Eloquent\Casts\Attribute;

protected function username(): Attribute
{
    return Attribute::make(
        get: fn ($value) => decrypt_data($value),
        set: fn ($value) => encrypt_data($value),
    );
}

ಇಲ್ಲಿ ಮೆಥಡ್ ಹೆಸರು ನೀವು ಗುರಿಯಾಗಿಸಿಕೊಂಡಿರುವ ಕಾಲಂ ಅಥವಾ ಅಟ್ರಿಬ್ಯೂಟ್‌ಗೆ ಹೊಂದಿಕೆಯಾಗಬೇಕು. Eloquent ಡೇಟಾಬೇಸ್‌ನಿಂದ username ಅನ್ನು ಓದಿದಾಗ, ಅದು ರ ಮೌಲ್ಯವನ್ನು get closure ಮೂಲಕ ಕಳುಹಿಸುತ್ತದೆ. ನೀವು ಮಾಡೆಲ್‌ನ username ಪ್ರಾಪರ್ಟಿಗೆ ಹೊಸ ಮೌಲ್ಯವನ್ನು ನೀಡಿದಾಗ, Eloquent ಕ್ವೇರಿಯನ್ನು ನಿರ್ಮಿಸುವ ಮೊದಲು set closure ಅದನ್ನು ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡುತ್ತದೆ.

ಪೈಲಟ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ ಅಥವಾ ಪೂರ್ಣ ಪ್ರಮಾಣದ ಕ್ಯಾಸ್ಟ್ ಕ್ಲಾಸ್‌ಗಳ ಡೈರೆಕ್ಟರಿಯ ಅಗತ್ಯವಿಲ್ಲದ ಹಳೆಯ (legacy) ಮಾಡೆಲ್‌ಗಳಲ್ಲಿ ಈ ವಿಧಾನವು ಹೆಚ್ಚು ಉಪಯುಕ್ತವಾಗಿದೆ. ಇದರ ಅನಾನುಕೂಲವೆಂದರೆ ಪುನರಾವರ್ತನೆ (repetition). ಒಂದು ವೇಳೆ ನೀವು ನಂತರ email, phone, ಮತ್ತು backup_code ಗೆ ಅದೇ ಟ್ರೀಟ್‌ಮೆಂಟ್ ಬೇಕೆಂದು ನಿರ್ಧರಿಸಿದರೆ, ನೀವು ಆ closure ಗಳನ್ನು ಹಲವಾರು ಮೆಥಡ್‌ಗಳು ಅಥವಾ ಮಾಡೆಲ್‌ಗಳಾದ್ಯಂತ ಕಾಪಿ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಇದು ಕೋಡ್‌ನಲ್ಲಿ ಅನಗತ್ಯ ಗೊಂದಲವನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ. ಅಲ್ಲದೆ, ಇಡೀ ಮಾಡೆಲ್ ಅನ್ನು ಬೂಟ್ ಮಾಡದೆ ಯೂನಿಟ್ ಟೆಸ್ಟ್‌ನಲ್ಲಿ ಈ ಲಾಜಿಕ್ ಅನ್ನು ಮರುಬಳಕೆ ಮಾಡಲು ಇದು ಅಡ್ಡಿಯಾಗುತ್ತದೆ.

ಇವೆ两ರ ನಡುವೆ ಆಯ್ಕೆ ಮಾಡುವುದು

ನೀವು ಮರುಬಳಕೆ, ಪರೀಕ್ಷೆ ಮತ್ತು ಮಾಡೆಲ್‌ಗಳನ್ನು ಸರಳವಾಗಿ ಇಟ್ಟುಕೊಳ್ಳುವುದಕ್ಕೆ ಆದ್ಯತೆ ನೀಡಿದಾಗ custom cast class ಅನ್ನು ಬಳಸಿ. ಈ ಪರಿವರ್ತನೆಯು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಒಂದು ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ ಹೊರತು ಕೇವಲ ಒಂದು ತಾತ್ಕಾಲಿಕ ಪರಿಹಾರವಲ್ಲ ಎಂದು ಇದು ಇತರ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಸೂಚಿಸುತ್ತದೆ.

ಲಾಜಿಕ್ ಸಂಪೂರ್ಣವಾಗಿ ಸ್ಥಳೀಯವಾಗಿದ್ದಾಗ, ಪ್ರಾಯೋಗಿಕವಾಗಿದ್ದಾಗ ಅಥವಾ ಪ್ರಸ್ತುತ ಸ್ಪ್ರಿಂಟ್‌ನಿಂದ ಹೆಚ್ಚು ಕಾಲ ಉಳಿಯುವ ಸಾಧ್ಯತೆ ಇಲ್ಲದಿದ್ದಾಗ accessor ಅನ್ನು ಬಳಸಿ. ಇದು ಕೋಡ್‌ಬೇಸ್‌ನಾದ್ಯಂತ ಸಣ್ಣ ಫೈಲ್‌ಗಳನ್ನು ಹರಡದೆ ವೇಗವಾಗಿ ಕೆಲಸ ಮಾಡಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಅದೇ ಮಾದರಿಯು ಎರಡನೇ ಅಥವಾ ಮೂರನೇ ಬಾರಿ ಕಂಡುಬಂದ ತಕ್ಷಣ ಅದನ್ನು cast class ಆಗಿ ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡಲು ಸಿದ್ಧರಿರಿ.

ಗಮನದಲ್ಲಿಡಬೇಕಾದ ಪ್ರಾಯೋಗಿಕ ವಿವರಗಳು

Custom casts ಶಕ್ತಿಯುತವಾಗಿವೆ, ಆದರೆ ನೀವು ಗಮನಿಸದಿದ್ದರೆ ಅವು ಅಚ್ಚರಿ ಉಂಟುಮಾಡುವಂತಹ ವರ್ತನೆಯನ್ನು ತರಬಹುದು. ಮೊದಲನೆಯದಾಗಿ, get ಎಂಬುದು ಡೇಟಾಬೇಸ್‌ನಿಂದ ಬಂದಿದ್ದನ್ನು (null ಸೇರಿದಂತೆ) ಸ್ವೀಕರಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ. ಒಂದು ವೇಳೆ decrypt_data null ಇನ್‌ಪುಟ್ ಅನ್ನು ಸ್ವೀಕರಿಸದಿದ್ದರೆ, ಅದಕ್ಕೆ ಎಚ್ಚರಿಕೆ ವಹಿಸಿ:

public function get(Model $model, string $key, mixed $value, array $attributes): mixed
{
    return is_null($value) ? null : decrypt_data($value);
}

ಎರಡನೆಯದಾಗಿ, casts ಎಂಬುದು array ಮತ್ತು JSON serialization ಸಮಯದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ನೀವು ಮಾಡೆಲ್ ಅನ್ನು API resource ಆಗಿ ನೀಡಿದಾಗ ಅಥವಾ toArray() ಅನ್ನು ಕರೆದಾಗ, cast get ಲಾಜಿಕ್ ಇನ್ನೂ ಅನ್ವಯಿಸುತ್ತದೆ. ಸಾಮಾನ್ಯವಾಗಿ ಇದು ನೀವು ಬಯಸುವಂತೆಯೇ ಇರುತ್ತದೆ, ಆದರೆ ನೀವು ಡೀಕ್ರಿಪ್ಟ್ ಮಾಡಿದ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತಿದ್ದರೆ ಮತ್ತು ಅದರ ಮೇಲೆ ಹೆಚ್ಚುವರಿ ವಿಸಿಬಿಲಿಟಿ ಕಂಟ್ರೋಲ್‌ಗಳನ್ನು (visibility controls) ಅನ್ವಯಿಸಬೇಕಿದ್ದರೆ ಇದನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವುದು ಮುಖ್ಯ.

ಮೂರನೆಯದಾಗಿ, ಮತ್ತು ಅತ್ಯಂತ ಮುಖ್ಯವಾಗಿ, casting ಎಂಬುದು ಡೇಟಾವನ್ನು ಪಡೆದ ನಂತರ ನಡೆಯುತ್ತದೆ. ನೀವು ಪರಿವರ್ತಿತ ಮೌಲ್ಯದ ವಿರುದ್ಧ ಕ್ವೇರಿ (query) ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ. User::where('username', 'john_doe')->first() ನಂತಹ ಕ್ವೇರಿಯು john_doe ಎಂಬ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ನೇರವಾಗಿ ಡೇಟಾಬೇಸ್‌ಗೆ ಕಳುಹಿಸುತ್ತದೆ. ಇದು ನಿಮ್ಮ decrypt ಲಾಜಿಕ್ ಮೂಲಕ ಎಂದಿಗೂ ಹಾದುಹೋಗುವುದಿಲ್ಲ. ಒಂದು ವೇಳೆ ಕಾಲಂ ಎನ್‌ಕ್ರಿಪ್ಟ್ ಆಗಿದ್ದರೆ, ನೀವು ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡಲಾದ ciphertext ವಿರುದ್ಧವೇ ಹುಡುಕದ ಹೊರತು ಆ ಕ್ವೇರಿಯು ಏನನ್ನೂ ಕಂಡುಹಿಡಿಯುವುದಿಲ್ಲ. ನಿಮ್ಮ ಡೇಟಾಬೇಸ್ ಅಕ್ಸೆಸ್ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು (access patterns) ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಯೋಜಿಸಿ, ಏಕೆಂದರೆ casts ಎಂಬುದು ನೇಟಿವ್ ಡೇಟಾಬೇಸ್ ಫಂಕ್ಷನ್‌ಗಳಿಗೆ ಅಥವಾ ಇಂಡೆಕ್ಸ್ ಮಾಡಿದ ಪ್ಲೇನ್‌ಟೆಕ್ಸ್ ಕಾಲಂಗಳಿಗೆ ಪರ್ಯಾಯವಲ್ಲ.

Custom cast class ಗಳು ಸಣ್ಣ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳಿಗೂ ಉತ್ತಮವಾದ ಸ್ಥಳಗಳಾಗಿವೆ. ನಿಮಗೆ constructor arguments ಬೇಕಾದಲ್ಲಿ—ಬಹುಶಃ ಒಂದು cipher mode ಅಥವಾ format string ಅನ್ನು ಕಳುಹಿಸಬೇಕಾದಲ್ಲಿ—Laravel ಅದನ್ನು $casts ಅರೇ ಮೂಲಕ 'field' => CustomEncrypt::class . ':arg' ಎಂಬ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಬಳಸಿ ಬೆಂಬಲಿಸುತ್ತದೆ, ಆದರೆ ಇದು ಇಲ್ಲಿ ವಿವರಿಸಲಾದ ಮೂಲಭೂತ ಸೆಟಪ್‌ಗಿಂತ ಒಂದು ಹಂತದ ಮುಂದಿದೆ.

ನಿಜವಾದ ಸಾರಾಂಶ

$casts ಗೆ ನೇರವಾಗಿ ಹೆಲ್ಪರ್ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಸೇರಿಸದಂತೆ ಇರುವ ನಿರ್ಬಂಧವು ಕೇವಲ ಅನಗತ್ಯ ಕಟ್ಟುಪಾಡಲ್ಲ. ಇದು ನಿಮ್ಮನ್ನು ಸ್ಪಷ್ಟವಾದ, ಪರೀಕ್ಷಿಸಬಹುದಾದ ಮತ್ತು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಕೋಡ್ ಕಡೆಗೆ ಪ್ರೇರೇಪಿಸುತ್ತದೆ. Custom cast class ಗಳು ಚದುರಿಹೋಗಿರುವ ಇನ್‌ಲೈನ್ ಲಾಜಿಕ್ ಅನ್ನು ಪುನರಾವರ್ತನೆಯಿಲ್ಲದೆ ನೀವು ಮಾಡೆಲ್‌ಗಳಾದ್ಯಂತ ಹಂಚಿಕೊಳ್ಳಬಹುದಾದ ವಿಶ್ವಾಸಾರ್ಹ ಘಟಕಗಳನ್ನಾಗಿ (dependable components) ಬದಲಾಯಿಸುತ್ತವೆ. ಪ್ರತ್ಯೇಕ ಫೈಲ್ ರಚಿಸುವುದು ಅನಗತ್ಯ ಪ್ರಕ್ರಿಯೆ ಎಂದು ಅನಿಸಿದಾಗ, Accessors ವೇಗವಾದ ಮತ್ತು ಸ್ಥಳೀಯ ಪರಿಹಾರಗಳಿಗೆ ಅವಕಾಶ ನೀಡುತ್ತವೆ. ಎರಡನ್ನೂ ಕಲಿಯಿರಿ, ಸಮಸ್ಯೆಯ ವ್ಯಾಪ್ತಿಯ ಆಧಾರದ ಮೇಲೆ ಆಯ್ಕೆ ಮಾಡಿ, ಆಗ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಬೆಳೆದ ನಂತರವೂ ನಿಮ್ಮ Eloquent layer ಓದಲು ಸುಲಭವಾಗಿರುತ್ತದೆ.