Laravel ਕਿਹੜੀ caching ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ?

Question

IT Interview Practice · Accepted Answer

Laravel ਇੱਕ ਯੁਨੀਫਾਈਡ, ਇਕਸਪ੍ਰੇਸਿਵ **caching system** ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਮਲਟੀਪਲ ਬੈਕਐਂਡਸ (Redis, Memcached, file, database, array) ਹੁੰਦੇ ਹਨ ਜੋ ਇੱਕ ਸਿੰਗਲ API ਦੇ ਪਿੱਛੇ ਹੁੰਦੇ ਹਨ। Caching ਮਹਿੰਗੇ ਨਤੀਜਿਆਂ ਨੂੰ ਸਟੋਰ ਕਰਦੀ ਹੈ ਤਾਂ ਜੋ ਉਹਨਾਂ ਨੂੰ ਦੁਬਾਰਾ ਕੰਪਿਊਟ ਨਾ ਕਰਨਾ ਪਵੇ — ਇਹ ਸਭ ਤੋਂ ਵੱਧ ਪ੍ਰਭਾਵਸ਼ਾਲੀ performance optimizations ਵਿੱਚੋਂ ਇੱਕ ਹੈ।

## cache API

```php
use Illuminate\Support\Facades\Cache;

Cache::put('key', $value, 3600);          // store for 1 hour (seconds)
Cache::get('key');                         // retrieve (null if missing)
Cache::get('key', 'default');              // with a default
Cache::has('key');
Cache::forget('key');                      // delete (invalidate)
Cache::forever('key', $value);             // store with no expiry
```

## remember() — get-or-compute pattern (ਸਭ ਤੋਂ ਉਪਯੋਗੀ)

```php
// if cached, return it; otherwise run the closure, cache the result, and return it
$users = Cache::remember('active_users', 3600, function () {
    return User::where('active', true)->get();   // expensive query — cached for 1 hour
});
```

`Cache::remember()` ਇੱਕ ਸੁੰਦਰ, ਆਮ pattern ਹੈ: ਇਹ cached value ਰਿਟਰਨ ਕਰਦਾ ਹੈ ਜੇ ਉਸ ਨੂੰ ਹੋਵੇ, ਜਾਂ ਇਸਨੂੰ compute ਕਰਦਾ ਹੈ (closure ਚਲਾ ਕੇ), ਇਸਨੂੰ cache ਕਰਦਾ ਹੈ, ਅਤੇ ਇਸਨੂੰ ਰਿਟਰਨ ਕਰਦਾ ਹੈ — ਇੱਕ ਕਾਲ ਵਿੱਚ। Expensive query results ਨੂੰ cache ਕਰਨ ਲਈ ਪਰਫੈਕਟ।

## Configurable backends (production ਲਈ Redis)

```text
config/cache.php → choose the driver:
  redis     → fast, SHARED across servers (production standard for multi-server apps)
  memcached → fast, shared
  file/database → simpler, for smaller/single-server setups
  array     → in-memory, for testing
The SAME Cache API works regardless of backend → easy to switch.
```

Unified API ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇੱਕੋ ਜਿਹਾ code ਕਿਸੇ ਵੀ backend ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ — ਅਤੇ **Redis** production ਲਈ standard ਹੈ (ਮਲਟੀਪਲ server instances ਦੇ ਪਾਰ ਇੱਕ ਸਾਂਝਾ cache)।

## Cache invalidation (ਔਖਾ ਹਿੱਸਾ)

```php
// when data changes, clear the affected cache or it serves stale data
public function updateUser($user, $data) {
    $user->update($data);
    Cache::forget('active_users');     // INVALIDATE so the next read recomputes
}
// strategies: TTL (accept brief staleness), explicit forget on writes, cache tags
Cache::tags(['users'])->flush();        // tagged invalidation (Redis/Memcached)
```

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

Caching Laravel applications ਲਈ ਸਭ ਤੋਂ ਵੱਧ ਪ੍ਰਭਾਵਸ਼ਾਲੀ performance optimizations ਵਿੱਚੋਂ ਇੱਕ ਹੈ, ਅਤੇ ਫਰੇਮਵਰਕ ਦਾ unified, expressive caching system ਇਸਨੂੰ ਪਹੁੰਚ ਯੋਗ ਬਣਾਦਾ ਹੈ — ਇਸ ਲਈ ਇਸਨੂੰ ਸਮਝਣਾ ਤੇਜ਼, scalable applications ਬਣਾਉਣ ਲਈ ਮੁੱਲਵਾਨ ਹੈ।

ਮੂਲ ਮੁੱਲ ਦੁਹਰਾਏ ਗਏ ਮਹਿੰਗੇ ਕੰਮ ਤੋਂ ਬਚਣਾ ਹੈ: slow database queries, complex computations, ਜਾਂ external API calls ਦੇ ਨਤੀਜਿਆਂ ਨੂੰ cache ਕਰਨਾ ਮਤਲਬ ਹੈ ਕਿ ਬਾਅਦ ਵਾਲੀਆਂ requests ਤੇਜ਼ੀ ਨਾਲ serve ਹੁੰਦੀਆਂ ਹਨ, latency ਅਤੇ load ਨੂੰ ਨਾਟਕੀ ਢੰਗ ਨਾਲ ਘਟਾਉਂਦਾ ਹੈ।

Laravel ਦੀ caching ਸੁੰਦਰ ਹੈ, ਖਾਸ ਕਰ ਕੇ **`Cache::remember()` get-or-compute pattern** (cached data ਰਿਟਰਨ ਕਰਨਾ ਜੇ ਮਾਜੂਦ ਹੋਵੇ, ਜਾਂ compute, cache, ਅਤੇ ਇੱਕ ਸਾਫ਼ ਕਾਲ ਵਿੱਚ ਰਿਟਰਨ ਕਰਨਾ — query results ਨੂੰ cache ਕਰਨ ਲਈ ਆਦਰਸ਼), ਅਤੇ ਇਸ ਦਾ **backends ਦੇ ਪਾਰ unified API** ਮਤਲਬ ਹੈ ਕਿ ਇੱਕੋ ਜਿਹਾ code ਕਿਸੇ ਵੀ driver ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ।

**Redis** ਨੂੰ production ਲਈ ਵਰਤਣਾ ਜਾਣਦਾ ਹੋਣਾ (ਮਲਟੀਪਲ server instances ਦੇ ਪਾਰ ਇੱਕ ਸਾਂਝਾ cache — ਮਹੱਤਵਪੂਰਨ ਕਿਉਂਕਿ ਸਰਲ per-server caches ਸਾਂਝਾ ਨਹੀਂ ਹੁੰਦੇ ਜਦੋਂ horizontally ਸਕੇਲ ਕਰਦੇ ਹੋ) ਇੱਕ ਮਹੱਤਵਪੂਰਨ architectural point ਹੈ।

ਬਰਾਬਰ ਮਹੱਤਵਪੂਰਨ ਹੈ caching ਦੀ ਕੇਂਦਰੀ ਮੁਸ਼ਕਲ ਨੂੰ ਸਮਝਣਾ — **invalidation** (cached data ਨੂੰ ਸਾਫ਼ ਕਰਨਾ ਜਾਂ refresh ਕਰਨਾ ਜਦੋਂ ਅੰਡਰਲਾਇੰਗ data ਬਦਲਦਾ ਹੈ, TTLs, explicit `forget` on writes, ਜਾਂ cache tags ਦੁਆਰਾ, stale data ਨੂੰ serve ਕਰਨ ਤੋਂ ਬਚਣ ਲਈ) — ਕਿਉਂਕਿ ਇਸ ਵਿੱਚ ਗਲਤ ਹੋਣਾ ਕਲਾਸਿਕ caching ਫੇਲਯੁਰ ਹੈ ਜੋ users ਨੂੰ outdated information ਦਿਖਾਉਂਦਾ ਹੈ।

Laravel ਦੇ caching system ਨੂੰ ਸਮਝਣਾ — API, `remember` pattern, backend selection (scale ਲਈ Redis), ਅਤੇ ਖਾਸ ਕਰ ਕੇ invalidation strategies — performant, scalable Laravel applications ਬਣਾਉਣ ਲਈ ਮਹੱਤਵਪੂਰਨ senior-level knowledge ਹੈ, ਕਿਉਂਕਿ caching ਵੱਡੇ performance gains deliver ਕਰਦੀ ਹੈ ਪਰ ਸਹੀ ਰਹਿਣ ਲਈ careful invalidation ਦੀ ਲੋੜ ਹੈ।

cache API

remember() — get-or-compute pattern (ਸਭ ਤੋਂ ਉਪਯੋਗੀ)

Configurable backends (production ਲਈ Redis)

Cache invalidation (ਔਖਾ ਹਿੱਸਾ)

ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

ਸੰਬੰਧਿਤ ਸਵਾਲ