include અને require વચ્ચે શું તફાવત છે?

Question

Accepted Answer

બંને `include` અને `require` વર્તમાન ફાઇલમાં બીજી PHP ફાઇલની સામગ્રીને આયાત (અને એક્સિક્યુટ) કરે છે. **એક માત્ર તફાવત એ છે કે તેઓ નિષ્ફળતાને કેવી રીતે સંભાળે છે**: `require` જો ફાઇલ ખૂટે તો ઘાતક ભૂલ ઉત્પન્ન કરે છે, જ્યારે `include` માત્ર એક ચેતવણી દર્શાવે છે અને આગળ વધે છે.

## મુખ્ય તફાવત: નિષ્ફળતાનું વર્તન

```php
<?php
include "config.php";    // if missing → WARNING, script CONTINUES
require "database.php";  // if missing → FATAL ERROR, script STOPS
```

```text
include → file missing → emits a Warning, execution continues (file's code skipped)
require → file missing → throws a Fatal Error, execution HALTS
```

**`require`** એવી ફાઇલો માટે વાપરો જે એપ્લીકેશન **વિના ચલાઈ શકતી નથી** (મુખ્ય ક્લાસીસ, વિશ્વાસપાત્ર કોન્ફિગ, ડેટાબેસ સેટআપ) — તમે ઈચ્છો છો કે જો તેઓ ખૂટે તો તે સખત બંધ થઈ જાય. **`include`** વૈકલ્પિક ફાઇલો માટે વાપરો (દા.ત. સાઇડબાર ટેમ્પલેટ) જ્યાં ખોવાયેલી ફાઇલ પૃષ્ઠને ક્રેશ ન કરે.

## _once ચલણો (બેવડો-સમાવેશ અટકાવો)

```php
require_once "functions.php";   // include the file ONLY if not already included
include_once "helper.php";
```

`require_once`/`include_once` ફાઇલને માત્ર આયાત કરે છે જો તે પહેલાથી સમાવિષ્ટ ન હોય — **આવશ્યક** છે "cannot redeclare function/class" ભૂલો અટકાવવા માટે જ્યારે ફાઇલ બહુ વખત સમાવિષ્ટ હોઈ શકે (દા.ત. ક્લાસ વ્યાખ્યા જે બહુ ફાઇલો દ્વારા ખેંચવામાં આવે છે).

## સમાવેશ વાસ્તવમાં શું કરે છે

```php
// included files share the SAME scope and can define functions, classes, variables
// config.php:
$dbHost = "localhost";
// main.php:
require "config.php";
echo $dbHost;   // "localhost" — the variable is available
```

## આધુનિક PHP: autoloading હાથ-ધરનું require બદલે છે

```php
// ❌ old style — manually requiring every class file
require_once "User.php";
require_once "Order.php";

// ✅ modern — Composer AUTOLOADING loads classes on demand automatically
require "vendor/autoload.php";   // one line; classes load when used (PSR-4)
$user = new User();               // User.php loaded automatically
```

આધુનિક PHP માં, તમે ક્લાસો માટે હાથ-ધરનું `require` ભાગ્યે વાપરો — **Composer's autoloader** તેમને માંગ પર લોડ કરે છે. તમે હજી પણ એક વાર `require "vendor/autoload.php"` વાપરો તેને બુટસ્ટ્રેપ કરવા માટે.

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

સમજવું `include` વિરુદ્ધ `require` એ મૂળભૂત પણ મહત્વપૂર્ણ PHP જ્ઞાન છે — તેઓ PHP ફાઇલો સમગ્રી શેર કરે છે, અને તફાવત સાચીતા માટે મહત્વપૂર્ણ છે.

મુખ્ય બિંદુ નિષ્ફળતાનું વર્તન છે: **આવશ્યક ફાઇલો માટે `require`** (તેથી એપ્લીકેશન ઝડપથી અને સ્પષ્ટતાથી નિષ્ફળ થાય જો મુખ્ય ફાઇલ ખૂટે છે) અને **વૈકલ્પિક ફાઇલો માટે `include`** (તેથી ખોવાયેલી બિન-સમીક્ષણીય ફાઇલ પૃષ્ઠને ક્રેશ ન કરે).

**`_once` ચલણો** જાણવું વ્યવહારીક રીતે આવશ્યક છે સામાન્ય "cannot redeclare" ભૂલો અટકાવવા માટે આકસ્મિક રીતે ક્લાસ અથવા કાર્ય વ્યાખ્યા બે વખત સમાવિષ્ટ કરવાથી.

સમાન રીતે મહત્વપૂર્ણ આધુનિક સંદર્ભ સમજવું છે: જ્યારે આ બાંધકામો તાત્પુર્તિક છે, **આધુનિક PHP Composer autoloading (માંગ પર ક્લાસ લોડ કરવું) પર આધાર રાખે છે** બનાવ પર મેનુઅલ require કરવાને બદલે, તેથી વર્તમાન કોડમાં તમે મોટાભાગે માત્ર એક વાર `require "vendor/autoload.php"` કરો અને autoloading ને બાકી હેન્ડલ કરવા દો.

બંને include/require મેકેનિક્સ (અને કયો નિષ્ફળતા મોડ યોગ્ય છે) અને આધુનિક autoloading કેવી રીતે મેનુઅલ સમાવેશને હટાવે છે તે જાણવું રોજિંદા જ્ઞાન છે PHP codebases (જૂના અને નવા બંને) સાથે કામ કરવા માટે.