PHP માં namespaces કેવી રીતે કામ કરે છે?

Question

Accepted Answer

**Namespaces** PHP કોડને સંગઠિત કરે છે અને **નામ સાથેના સંઘર્ષો** (naming collisions) ને રોકે છે — વર્ગો, ફંક્શન્સ અને સ્થિરાંકો વચ્ચે આવતા સંઘર્ષો અનિવાર્ય છે જયારે એપ્લીકેશનો વધે અને તૃતીય-પક્ષ પેકેજીસ વાપરે છે. તેઓ વર્ગ નામો માટે ડિરેક્ટરીઓ જેવી રીતે કામ કરે છે, અને Composer autoloading (PSR-4) સાથે એકીકૃત થાય છે.

## Namespaces જે સમસ્યાને હલ કરે છે

```text
Without namespaces, two classes named `User` (yours and a library's) would COLLIDE
("cannot redeclare class"). Namespaces give each a unique fully-qualified name.
```

## Namespaces ની જાહેરાત અને ઉપયોગ

```php
<?php
// declare a namespace at the top of the file (matches the directory, PSR-4)
namespace App\Models;

class User {            // fully-qualified name: App\Models\User
    // ...
}
```

```php
<?php
namespace App\Controllers;

use App\Models\User;            // IMPORT a class so you can use its short name
use App\Services\Mailer as MailService;   // import with an ALIAS

class UserController {
    public function index() {
        $user = new User();      // short name works thanks to the `use` import
        // or use the fully-qualified name: new \App\Models\User();
    }
}
```

ફાઈલ તેના `namespace` ની જાહેરાત કરે છે, અને અન્ય ફાઈલો વર્ગોને ટૂંક નામ દ્વારા સંદર્ભિત કરવા માટે `use` (import) કરે છે. સંપૂર્ણ-લાયક્ષણ નામ (`\App\Models\User`) વૈશ્વિક રીતે અનન્ય છે.

## Namespaces ડિરેક્ટરીઓને મેપ કરે છે (PSR-4)

```text
Namespace            File path
App\Models\User   →  src/Models/User.php
App\Services\Mailer → src/Services/Mailer.php
→ PSR-4 autoloading: the namespace structure mirrors the folder structure, so
  Composer can find and load each class automatically (no manual require).
```

## ફંક્શનો, સ્થિરાંકો અને વૈશ્વિક namespace ની આયાત

```php
use function App\Helpers\format;     // import a function
use const App\Config\VERSION;        // import a constant

\strlen("x");    // a leading \ = the GLOBAL namespace (built-in functions)
```

## શા માટે મહત્વપૂર્ણ છે

Namespaces આધુનિક PHP કોડને સંગઠિત કરવા માટે આવશ્યક છે અને આખો ઇકોસિસ્ટમ કેવી રીતે કામ કરે છે તેનો આધાર છે.

તેમને સમજવું મહત્વપૂર્ણ છે કારણ કે તેઓ **નામ સાથેના સંઘર્ષો**ની વિમર્શનીય સમસ્યાને હલ કરે છે — namespaces વિના, તમારી વર્ગો એક બીજા સાથે અને ઘણા તૃતીય-પક્ષ પેકેજીસ સાથે (જે વાસ્તવ એપ્લીકેશન વાપરે છે તેમની) સાથે સંઘર્ષ કરશે (બે `User` વર્ગો સહઅસ્તિત્વ ધરાવી શકતા નથી), જે મોટી એપ્લીકેશનો અને પેકેજ ઇકોસિસ્ટમોને અશક્ય બનાવે છે.

Namespaces દરેક વર્ગને અનન્ય સંપૂર્ણ-લાયક્ષણ નામ આપે છે, અને **`use` આયાતો** તમને વર્ગોને ટૂંક નામ દ્વારા સ્વચ્છતાથી સંદર્ભિત કરવા દે છે.

સૌથી મહત્વપૂર્ણ, namespaces **Composer autoloading via PSR-4** સાથે એકીકૃત થાય છે, જ્યાં namespace માળખું ડિરેક્ટરી માળખું પ્રતિબિંબિત કરે છે જેથી વર્ગો આવશ્યક રીતે સ્વચાલિત રીતે લોડ થાય — આ આધુનિક PHP પ્રકલ્પ માળખા અને અવલંબન વ્યવસ્થાપનનો આધાર છે.

જેમ કે દરેક આધુનિક PHP ફ્રેમવર્ક, પેકેજ અને એપ્લીકેશન namespaces સાથે સંગઠિત છે (અને તમે Composer પેકેજીસ વિના તેમને સમજ્યા વિના વાપર શકતા નથી), namespaces જાહેર કરવું, વર્ગોને `use` સાથે આયાત કરવું, અને તેઓ autoloading માટે ડિરેક્ટરીઓને કેવી રીતે મેપ કરે છે તે જાણવું આધુનિક PHP વિકાસ માટે કોઈપણ માટે પ્રાથમિક, રોજમર્રાનું જ્ઞાન છે.

Namespaces, Composer અને PSR-4 autoloading એક સાથે સમકાલીન PHP પ્રકલ્પોને કેવી રીતે સંગઠિત કરવામાં આવે છે તે વ્યાખ્યાયિત કરે છે.