PHP માં વર્ગો અને ઑબ્જેક્ટ્સ કેવી રીતે કામ કરે છે?

Question

Accepted Answer

PHP માં સંપૂર્ણ **ઑબ્જેક્ટ-ઓરિયન્ટેડ પ્રોગ્રામિંગ** સપોર્ટ છે: વર્ગો માળખું અને વર્તણૂક વ્યાખ્યાયિત કરે છે, ઑબ્જેક્ટ્સ ઉદાહરણો છે. આધુનિક PHP OOP સ્વચ્છ અને સુવિધાથી સમૃદ્ધ છે, જેમાં દૃશ્યમાનતા સંશોધકો, નિર્માણકર્તા અને કન્સ્ટ્રક્ટર પ્રોપર્ટી પ્રમોશન જેવી સુવિધાઓ છે.

## વર્ગ વ્યાખ્યાયિત કરવું

```php
<?php
class User {
    public string $name;            // typed property
    private int $age;                // visibility: public / private / protected

public function __construct(string $name, int $age) {   // constructor
        $this->name = $name;          // $this refers to the instance; -> accesses members
        $this->age = $age;
    }

public function greet(): string {
        return "Hi, I'm {$this->name}";
    }
}

$user = new User("Ann", 30);     // create an instance
echo $user->name;                 // access a property
echo $user->greet();              // call a method
```

વર્ગોમાં **ટાઇપ કરેલ પ્રોપર્ટીઝ**, `__construct` પદ્ધતિ અને પદ્ધતિઓ છે. `$this` વર્તમાન ઑબ્જેક્ટનો સંદર્ભ આપે છે, અને `->` પ્રોપર્ટીઝ/પદ્ધતિઓને ઍક્સેસ કરે છે (PHP `->` નો ઉપયોગ કરે છે, `.` નહીં).

## દૃશ્યમાનતા સંશોધકો (encapsulation)

```php
public    // accessible everywhere
private   // only within THIS class
protected // this class and subclasses
```

## કન્સ્ટ્રક્ટર પ્રોપર્ટી પ્રમોશન (PHP 8 — ઓછું boilerplate)

```php
class User {
    // declare AND assign properties directly in the constructor signature
    public function __construct(
        public string $name,
        private int $age = 0,
    ) {}
    // equivalent to declaring the properties + assigning them — much less code
}
```

PHP 8 ની **કન્સ્ટ્રક્ટર પ્રોપર્ટી પ્રમોશન** પુનરાવર્તક ઘોષણા-પછી-અસાઇન boilerplate નું સંપાદન કરે છે — એક મોટી આધુનિક સુવિધા.

## સ્ટેટિક સભ્યો અને સ્થિરાંકો

```php
class Counter {
    public static int $count = 0;      // belongs to the CLASS, not instances
    const MAX = 100;                    // class constant

public static function increment(): void {
        self::$count++;                  // access static via self::
    }
}
Counter::increment();                    // call via ClassName::
Counter::MAX;
```

સ્ટેટિક સભ્યો (`::` સિન્ટેક્સ) વર્ગનાં જ છે; સ્થિરાંકો `const` નો ઉપયોગ કરે છે.

## કેમ આ મહત્વપૂર્ણ છે

ઑબ્જેક્ટ-ઓરિયન્ટેડ પ્રોગ્રામિંગ આધુનિક PHP માટે કેન્દ્રીય છે — ફ્રેમવર્ક્સ (Laravel, Symfony) અને વ્યાવસાયિક કોડબેસ વર્ગોની આસપાસ બાંધવામાં આવે છે, તેથી PHP OOP સમજવું કોઈપણ ગંભીર PHP ડેવલપમેન્ટ માટે મૂળભૂત છે.

ટાઇપ કરેલ પ્રોપર્ટીઝ, કન્સ્ટ્રક્ટર્સ અને પદ્ધતિઓ સાથે વર્ગો કેવી રીતે વ્યાખ્યાયિત કરવા, **દૃશ્યમાનતા સંશોધકો** (`public`/`private`/`protected`) જે encapsulation લાગુ કરે છે, `$this`/`->`/`::` સિન્ટેક્સ અને સ્ટેટિક સભ્યો/સ્થિરાંકો એ આવશ્યક રોજની જાણકારી છે.

આધુનિક સુવિધાઓ ખાસ કરીને જાણવી યોગ્ય છે — **કન્સ્ટ્રક્ટર પ્રોપર્ટી પ્રમોશન** (PHP 8) boilerplate ને નાટકીય રીતે ઘટાવે છે અને વર્તમાન કોડમાં વ્યાપક રીતે ઉપયોગમાં છે, અને **ટાઇપ કરેલ પ્રોપર્ટીઝ** વર્ગોને વધુ મજબૂત બનાવે છે.

આધુનિક PHP OOP સ્વચ્છ અને સક્ષમ છે (PHP ની પ્રારંભિક પ્રક્રિયાત્મક પ્રતિષ્ઠાથી દૂર), અને બધા આધુનિક PHP ફ્રેમવર્ક્સ અને અપ્લિકેશનો ઑબ્જેક્ટ-ઓરિયન્ટેડ હોવાથી, વર્ગો અને ઑબ્જેક્ટ્સમાં માસ્ટર થવું — PHP-સ્પેસિફિક સિન્ટેક્સ અને આધુનિક સુવિધાઓ સહ — વ્યાવસાયિક PHP લખવા માટે મૂળભૂત, જ્ઞાન-હોવું જોઈએ તેવી સામગ્રી છે.