---
title: 'Dosya Dahil Etme'
source: 'https://academia.sh/tr/kurslar/php-temelleri/dosya-dahil-etme'
course: 'PHP Temelleri'
language: tr
updated: '2026-10-21T05:03:34+00:00'
license: 'CC BY-SA 4.0'
objectives:
    - 'Bulunamayan bir dosyanın include ve require ile hangi kanaldan duyulduğunu ölçer'
    - 'include_once ile aynı dosyanın ikinci kez çalıştırılmadığını gözlemler'
    - 'Dahil edilen dosyadaki sözdizim hatasının include için de yürütmeyi durdurduğunu gösterir'
    - 'Kursun on dört dersini ölçü sınıflarına göre tek tabloda karşılaştırır'
---

# Dosya Dahil Etme

Bulunamayan bir dosyanın dahil edilmesinin include, require ve include_once ile hangi kanaldan duyulduğu; ardından on dört dersin ölçümünü bir tabloda toplayan kurs kapanışı.

Dosya Yükleme dersi, istekle gelen bir dosyanın `false` döndüren bir fonksiyona verilmesiyle bitti. Bir betiğin başka bir dosyayı kendi içine çekmesi aynı soruyu başka bir düzenekte sorar: çekilecek dosya yoksa bu hangi kanaldan duyulur? Yanıt, dahil etmenin hangi biçimiyle yapıldığına göre değişir. Ders, çekirdeğin on dördüncü gözlemini ve onun karşıtlarını ölçer; ardından kursun tamamını tek tabloda toplar.

Ölçüm yine kursun çekirdeğindeki `kanal.php` dosyasını kullanır. Her ders kendi çalışma dizininde koştuğu için dosya burada da birebir verilir.

```php
<?php
// kanal.php — bir sorunun hangi kanaldan duyuldugunu siniflandiran yardimcilar

// Yakalanan uyarilarin seviye adlari burada birikir; ileti metni tutulmaz.
$GLOBALS['duyulan_uyarilar'] = [];

set_error_handler(function (int $seviye): bool {
    $adlar = [E_WARNING => 'E_WARNING', E_NOTICE => 'E_NOTICE', E_DEPRECATED => 'E_DEPRECATED'];
    $GLOBALS['duyulan_uyarilar'][] = $adlar[$seviye] ?? 'E_' . $seviye;
    return true;
});

// Degeri tipiyle birlikte kisa bir metne cevirir.
function yaz(mixed $deger): string
{
    return match (true) {
        $deger === null => 'null',
        is_bool($deger) => $deger ? 'true' : 'false',
        is_array($deger) => 'dizi(' . count($deger) . ')',
        default => get_debug_type($deger) . ' ' . $deger,
    };
}

// Isi calistirir ve sorunun hangi kanaldan duyuldugunu sirayla sorar:
// once firlatma, sonra uyari, sonra false/null donus; hicbiri yoksa sessiz.
function dinle(callable $is): array
{
    $GLOBALS['duyulan_uyarilar'] = [];
    try {
        $sonuc = $is();
    } catch (Throwable $hata) {
        return ['durdurur', get_class($hata)];
    }
    if ($GLOBALS['duyulan_uyarilar']) {
        $seviyeler = implode(',', array_unique($GLOBALS['duyulan_uyarilar']));
        return ['uyari', $seviyeler . ', sonuc ' . yaz($sonuc)];
    }
    if ($sonuc === false || $sonuc === null) {
        return ['donus', 'sonuc ' . yaz($sonuc)];
    }
    return ['sessiz', 'sonuc ' . yaz($sonuc)];
}

// Kodu ayri bir PHP yurutmesinde calistirir; cikis kodu 255 ise yurutme durmustur.
function ayri_yurut(string $kod): array
{
    exec('php -d display_errors=0 -r ' . escapeshellarg($kod) . ' 2>&1', $satirlar, $cikis);
    $sinif = $cikis === 255 ? 'durdurur' : 'sessiz';
    return [$sinif, 'cikti ' . count($satirlar) . ' satir, cikis ' . $cikis];
}
```

## Eksik Dosya `include` ile Uyarı Verir

İlk betik dört şeyi ölçer: var olmayan bir dosyanın `include` ile çekilmesi, var olan bir dosyanın `include_once` ile iki kez çekilmesi ve o dosyanın kaç kez çalıştığı. Var olan dosyayı betik kendisi yazar; böylece ölçüm bir önceki koşumdan kalan dosyaya bağlı olmaz.

```php
<?php
// dahil.php — eksik dosya ve include_once hangi kanaldan duyulur
require 'kanal.php';

file_put_contents('parca.php', "<?php\n\$GLOBALS['yuklenme'] = (\$GLOBALS['yuklenme'] ?? 0) + 1;\nreturn 7;\n");

$olcumler = [
    'eksik dahil dosyasi' => fn() => include 'yok.php',
    'ilk include_once'    => fn() => include_once 'parca.php',
    'ikinci include_once' => fn() => include_once 'parca.php',
];

foreach ($olcumler as $ad => $olcum) {
    [$sinif, $kanit] = dinle($olcum);
    printf("%-24s%-10s%s\n", $ad, $sinif, $kanit);
}
echo 'parca.php calisma sayisi ', $GLOBALS['yuklenme'], "\n";
```

```
eksik dahil dosyasi     uyari     E_WARNING, sonuc false
ilk include_once        sessiz    sonuc int 7
ikinci include_once     sessiz    sonuc true
parca.php calisma sayisi 1
```

İlk satır çekirdeğin `eksik dahil dosyasi` gözlemidir: `include` bulamadığı dosya için `E_WARNING` bildirdi, `false` döndürdü ve yürütme sürdü. Bu **uyarı** sınıfıdır ve bu dersin ölçü sınıfıdır. **IY21.** Döndürülen `false` da vardır, ama sınıfı `dinle()`'nin sorduğu sıra belirler: uyarı dönüşten önce sorulur. Bu yüzden satır **dönüş** değil, **uyarı** yazar.

Sonraki iki satır `include_once` içindir. İlk çağrı dosyayı çalıştırır ve dosyanın `return` ettiği `7` değerini verir. İkinci çağrı dosyayı bir daha çalıştırmaz ve yalnız `true` döndürür; son satır dosyanın toplam bir kez çalıştığını doğrular. **IY22.** Bu, `include_once` ile `require_once` için aynı davranıştır ve aynı fonksiyonun iki kez tanımlanması gibi çakışmaları önler. Ama ikinci çağrının `7` değil `true` vermesi sessiz bir farktır: dosyanın dönüş değerini kullanan kod, ikinci çağrıda başka bir değer alır.

## Require Uyarının Ardından Durdurur

`require` aynı eksikliği daha sert karşılar. Yürütmeyi sürdürmesi için bir `false` bırakmaz; dosya bulunamazsa durur. Bunun hangi biçimde olduğu ölçülür, varsayılmaz. İki ölçüm yapılır: aynı işlemde bir `try` ile ve ayrı bir yürütmede çıkış koduyla.

```php
<?php
// zorunlu.php — require ile eksik dosya hangi kanaldan duyulur
require 'kanal.php';

[$sinif, $kanit] = dinle(fn() => require 'yok.php');
printf("%-24s%-10s%s\n", 'eksik require', $sinif, $kanit);
echo 'once duyulan uyari: ', implode(',', $GLOBALS['duyulan_uyarilar']), "\n";

[$sinif, $kanit] = ayri_yurut('echo "once\n"; require "yok.php"; echo "sonra\n";');
printf("%-24s%-10s%s\n", 'ayri yurutme', $sinif, $kanit);
```

```
eksik require           durdurur  Error
once duyulan uyari: E_WARNING
ayri yurutme            durdurur  cikti 1 satir, cikis 255
```

**IY23.** Sınıf **durdurur**dur: `require` bir `Throwable` fırlattı ve ayrı yürütme 255 koduyla çıktı, `sonra` satırı basılmadı. Kanal birden fazla sinyal verdi: `require` önce `E_WARNING` bildirdi, ardından yürütmeyi kesti. Çekirdeğin sorusu en güçlü kanalı seçer, bu yüzden satırın sınıfı uyarı değil durdurur'dur. Kursun ortak kuralı budur: aynı olayda iki kanal konuşuyorsa ölçü, yürütmeyi kesen kanaldır.

## Yol Çalışma Dizinine Mi Bağlı

Göreli bir yol, betiğin kendi dizinine değil, o anki çalışma dizinine bağlı olabilir. Aynı dosya `__DIR__` ile verilince bu bağımlılık kalkar. `__DIR__`, çalışan dosyanın bulunduğu dizinin yoludur; değeri ortama bağlıdır ve bu derste basılmaz, yalnız onunla kurulan yolun çalışıp çalışmadığı basılır.

```php
<?php
// yol.php — dahil edilen yolun calisma dizinine baglanip baglanmadigi
require 'kanal.php';

file_put_contents('parca.php', "<?php\nreturn 7;\n");
chdir('/');

$olcumler = [
    'goreli ./ yolu'  => fn() => include './parca.php',
    '__DIR__ ile yol' => fn() => include __DIR__ . '/parca.php',
];

foreach ($olcumler as $ad => $olcum) {
    [$sinif, $kanit] = dinle($olcum);
    printf("%-24s%-10s%s\n", $ad, $sinif, $kanit);
}
```

```
goreli ./ yolu          uyari     E_WARNING, sonuc false
__DIR__ ile yol         sessiz    sonuc int 7
```

**IY24.** Çalışma dizini değiştikten sonra `./` ile başlayan yol dosyayı bulamadı ve uyarı verdi; `__DIR__` ile kurulan yol bulundu ve dosyanın `7` değeri döndü. Yol dahil edilen dosyanın yerini betiğin konumuna bağlıyorsa `__DIR__` kullanılır. Bu, hatanın kanalını değiştirmez; yalnız hatanın çıkma olasılığını azaltır.

## Sınırlayıcı Ölçüm

`include`'un uyarı kanalı bir koşula bağlıdır: dosya **bulunamazsa** geçerlidir. Dosya bulunur ve sözdizimi bozuksa durum değişir. Aşağıdaki betik bozuk bir dosyayı `include` ile çeker.

```php
<?php
// bozuk.php — bulunan ama sozdizimi bozuk dosyanin include ile duyulusu
require 'kanal.php';

file_put_contents('bozuk_parca.php', "<?php\n\$x = ;\n");

[$sinif, $kanit] = dinle(fn() => include 'bozuk_parca.php');
printf("%-24s%-10s%s\n", 'bozuk dahil dosya', $sinif, $kanit);
```

```
bozuk dahil dosya       durdurur  ParseError
```

**IY25.** `include` bu kez `ParseError` fırlattı ve sınıf **durdurur**dur. Dosyanın bulunması, kanalı uyarıdan durdurura çevirdi. Bu, Sözdizim ve Etiketler dersindeki özetin ölçülmüş biçimidir: dahil edilen dosyadaki sözdizim hatası ana dosya çalıştıktan sonra yakalanabilir bir `ParseError` olarak fırlar. Sonuç olarak `include` için "hata yürütmeyi kesmez" cümlesi doğru değildir; doğru cümle "eksik dosya yürütmeyi kesmez"dir.

## Özet

- Bulunamayan bir dosya `include` ile `E_WARNING` bildirir ve `false` döndürür; yürütme sürer. Bu dersin ölçü sınıfı **uyarı**dır (`eksik dahil dosyasi`).
- `require` aynı eksiklikte önce uyarı bildirir, sonra yürütmeyi keser; sınıfı **durdurur**dur.
- `include_once` ikinci çağrıda dosyayı çalıştırmaz ve `true` döndürür; ilk çağrıdaki dönüş değeri kaybolur.
- `./` ile başlayan yol çalışma dizinine bağlıdır; `__DIR__` ile kurulan yol betiğin konumuna bağlıdır.
- Dosya bulunur ama sözdizimi bozuksa `include` da `ParseError` fırlatır ve durdurur.

## Kurs Kapanışı

Kurs boyunca tek soru soruldu: bu sorun hangi kanaldan duyuluyor? On dört ders, her biri bir düzeneği ölçtü ve her biri kendi sınıfını bu dört addan biriyle adlandırdı. Tablo, her satırda dersin ölçtüğü düzeneği, kanalını ve o kanalın bittiği yeri gösterir.

| Ders | Ölçülen düzenek | Kanal | Sınırlayıcı ölçüm |
|---|---|---|---|
| Yürütme Modeli | on dört gözlemli çekirdek | durdurur | sunucuda her istek baştan başlar |
| Sözdizim ve Etiketler | ayrıştırma ile yürütme hatası | durdurur | sözdizim hatası yürütmeyi başlamadan keser |
| Değişkenler ve Veri Tipleri | tip değere bağlı | sessiz | `strict_types` çağıranın dosyasını bağlar |
| İşleçler | sayı önekli dizgi | uyarı | `??` uyarıyı susturur |
| Denetim Akışı | karşılıksız `match` | durdurur | `default` kolu durdurmayı sessize çevirir |
| Fonksiyonlar | fazla argüman | sessiz | yerleşik fonksiyon `ArgumentCountError` verir |
| İndeksli ve İlişkisel Diziler | anahtar normalleşmesi | sessiz | ondalık anahtar `E_DEPRECATED` verir |
| Çok Boyutlu Diziler | eksik iç anahtar | uyarı | `??` yolun tamamını sessize çevirir |
| Dizi Fonksiyonları | `array_search` bulamaz | dönüş | `0` gevşek karşılaştırmada `false` olur |
| Dizgi İşleme | bozuk JSON | dönüş | `JSON_THROW_ON_ERROR` durdurur |
| Süper Küresel Değişkenler | eksik sorgu anahtarı | uyarı | dizi gelince `TypeError`, durum kodu değişir |
| Form İşleme | geçersiz form sayısı | dönüş | geçerli `0` başarısızlıkla aynı görünür |
| Dosya Yükleme | yüklenmemiş dosya | dönüş | `post_max_size` aşımı iki diziyi de boşaltır |
| Dosya Dahil Etme | eksik dahil dosya | uyarı | bozuk sözdizimi `ParseError` verir |

On dört dersin dağılımı 3 sessiz · 4 dönüş · 4 uyarı · 3 durdurur'dur; çekirdek her ders için bir gözlem taşıdığından çekirdeğin dağılımı da aynıdır. Dört sınıf aynı aksaklığın dört farklı bedelidir. Sessiz sınıfta bedeli yanlış sonuç öder, dönüşte çağıranın dikkati, uyarıda bildirimi okuyan göz, durdurur sınıfında ise çalışan yürütme.

Tablonun ikinci bir okuması vardır: her satırın son sütunu, o kanalın bir koşula bağlı olduğunu gösterir. `??` uyarıyı sessize çevirir, `JSON_THROW_ON_ERROR` dönüşü durdurur sınıfına taşır, `default` kolu durdurmayı sessize çevirir. Kanal, düzeneğin sabit bir özelliği değil, çağıranın yazdığı koda göre kayan bir özelliğidir. Bu nedenle kanalı varsaymak yerine her yeni düzenekte aynı soru sorulur.

Kurs bu soruyla PHP'nin sorunlarını duyma biçimlerini ayırdı; sınıflandırmaların güvenlik sonuçları M24 ve M25'in konusudur. Sıradaki kurs PHP'de sınıfları, arayüzleri ve ad alanlarını ele alır.
