---
title: 'Kod Çalıştırma Yolları'
source: 'https://academia.sh/tr/kurslar/javascript-temelleri/kod-calistirma-yollari'
course: 'JavaScript Temelleri'
language: tr
updated: '2026-08-17T18:09:47+00:00'
license: 'CC BY-SA 4.0'
---

# Kod Çalıştırma Yolları

Dosyadan çalıştırma, etkileşimli kabuk, tarayıcı konsolu ve betik etiketi; betik ile modül ayrımı ve hata iletisinin okunması.

Önceki ders, bir betiğin hangi adları görebildiğinin barındıran ortama bağlı olduğunu
gösterdi. Bu ders, o ortamlara kodun nasıl verildiğini ele alır: komut satırından bir
dosya, etkileşimli bir kabuk oturumu, tarayıcı konsolu ve sayfaya bağlanan bir betik
etiketi. Dört yol yalnızca "kodu başlatma" biçimi değildir; her biri kodun hangi kurallar
altında yorumlanacağını da belirler.

Aynı ölçüm betiği bu yolların hepsinde çalıştırılacak. Sonuçların örtüştüğü ve
ayrıştığı noktalar, dilin çekirdeği ile ortamın katkısı arasındaki sınırı ikinci kez
çizer.

## Komut Satırından Bir Dosya Çalıştırmak

Sunucu tarafı çalışma zamanı, kaynağı bir dosyadan alır. Kurstaki örnekler `node`
komutuyla çalıştırılmıştır; dosyaya verilen ad ve uzantı, kaynağın nasıl yorumlanacağını
belirler.

`olcum.mjs` adlı dosya:

```js
const sicakliklar = [21.5, 19.75, 23, 18.25];
let toplam = 0;
for (const deger of sicakliklar) {
  toplam += deger;
}
console.log("okuma sayisi:", sicakliklar.length);
console.log("ortalama:", toplam / sicakliklar.length);
```

```sh
node olcum.mjs
```

```
okuma sayisi: 4
ortalama: 20.625
```

Dosya baştan sona okunur, ayrıştırılır ve yürütülür. Süreç, kodun son satırı bittikten
sonra bekleyen bir iş kalmadıysa sona erer.

Tek satırlık denemeler için dosya açmak gerekmez; kaynak doğrudan argüman olarak
verilebilir:

```sh
node -e 'console.log(Math.max(21.5, 19.75, 23))'
```

```
23
```

## Etkileşimli Kabuk

Argümansız çağrıldığında çalışma zamanı bir **etkileşimli kabuk (REPL)** açar. Bu
kabuk her satırı okur, değerlendirir, sonucu yazar ve döngüye döner. Adı bu dört adımdan
gelir.

```
> const sicakliklar = [21.5, 19.75, 23, 18.25];
undefined
> sicakliklar.length
4
> Math.max(...sicakliklar)
23
> typeof sicakliklar
'object'
```

İki gözlem bu kabuğu anlamak için yeterlidir.

Birincisi: kabuk, her satırın **değerini** yazar. Bir bildirim deyimi değer üretmez;
bu yüzden ilk satırın karşılığı `undefined` olmuştur. Bu, bildirimin başarısız olduğu
anlamına gelmez — sonraki satır değişkeni sorunsuz okuyor. Programlama Temelleri
kursundaki deyim–ifade ayrımı burada gözle görülür hale gelir: `const` bir deyimdir,
`sicakliklar.length` bir ifadedir.

İkincisi: kabuğun yazdığı biçim ile `console.log` biçimi aynı değildir. `typeof`
sonucu kabukta `'object'` olarak, tırnaklarla yazıldı; aynı değer `console.log` ile
yazılsaydı tırnaksız `object` görünürdü. Kabuk değeri **inceleme biçiminde** yazar:
metinler tırnaklanır, böylece `4` sayısı ile `'4'` metni ayırt edilebilir. Bu biçimin
ayrıntıları çalışma zamanına özgüdür ve standartta tanımlı değildir.

Aynı fark nesnelerde de görülür:

```js
const kayit = { istasyon: "A1", sicaklik: 21.5 };
console.log(kayit);
console.log(String(kayit));
```

```
{ istasyon: 'A1', sicaklik: 21.5 }
[object Object]
```

İlk satırdaki okunabilir gösterim, ortamın inceleme biçimidir. İkinci satır ise dilin
kendi metne çevirme kuralının sonucudur ve her ortamda aynıdır. Tarayıcı konsolu ilk
satır için katlanıp açılabilen bir ağaç gösterir; ikinci satır orada da `[object Object]`
üretir.

## Tarayıcı Konsolu ve Betik Etiketi

Belge tabanlı ortamda kod iki yoldan girer. **Konsol**, sayfanın bağlamında açılmış bir
etkileşimli kabuktur; yukarıdaki kuralların aynısı geçerlidir. **Betik etiketi** ise
kodu sayfanın yüklenme sürecine bağlar:

```html
<script src="olcum.js"></script>
```

Etiketin konumu ve nitelikleri yürütme anını belirler. Nitelik verilmezse belge
çözümlemesi durur, kaynak indirilir ve çalıştırılır, sonra çözümleme sürer. `defer`
niteliği yürütmeyi belge çözümlemesinin sonuna erteler; `type="module"` niteliği hem
aynı ertelemeyi uygular hem de kaynağı betik değil modül olarak yükler.

Bu kursun örnekleri konsolda ve komut satırında doğrulanabilir; belge nesnelerine
dokunmadıkları için sayfa bağlamı gerektirmezler. Belgeye erişen kod, dilin değil
barındıran ortamın konusudur.

## Betik mi, Modül mü

ECMAScript, bir kaynak metni iki farklı hedefe göre ayrıştırır: **betik (script)** ve
**modül (module)**. Bu, dosya uzantısından ya da etiket niteliğinden çıkarılan bir
karardır ve üç somut fark üretir.

Birinci fark **katı kiptir (strict mode)**. Modül olarak yüklenen kaynak her zaman katı
kipte çalışır; betik olarak yüklenen kaynak, ayrıca istenmedikçe çalışmaz. Katı kip,
sessizce yanlış sonuç üreten birkaç davranışı hataya çevirir. En görünür örneği,
bildirilmemiş bir ada atama yapmaktır:

```js
try {
  bildirilmemis = 5;
} catch (hata) {
  console.log(hata.name + ": " + hata.message);
}
```

Modül olarak (`.mjs` uzantısıyla) çalıştırıldığında:

```
ReferenceError: bildirilmemis is not defined
```

Aynı atama katı kipte olmayan bir betikte hata vermez; sessizce genel bir ad yaratır.
Yazım hatasıyla oluşmuş bir adın program boyunca yaşaması bu yüzden mümkündür.

İkinci fark **en dış kapsamdaki `this` değeridir**. Modülde bu değer `undefined`'dır;
betikte ise ortamın seçtiği bir nesnedir.

Üçüncü fark, en dış kapsamda bildirilen adların **genel nesneye yazılıp
yazılmadığıdır**. Modülde en dış kapsam modüle özeldir; orada bildirilen hiçbir ad genel
nesnenin özelliği olmaz:

```js
var x = 1;
console.log(typeof this);
console.log(typeof globalThis.x);
```

Modül olarak çalıştırıldığında:

```
undefined
undefined
```

Klasik betik olarak yüklenen bir kaynakta ise `var` ile bildirilen en dış kapsam adları
genel nesnenin özelliği olur. İki dosyanın birbirinin adlarını kazara ezmesi bu
davranışın sonucudur; modül modeli bu paylaşımı ortadan kaldırır.

Kurs boyunca örnekler modül olarak çalıştırılmıştır. Bir örnek yalnızca betik kipinde
farklı davranıyorsa, bu metinde ayrıca belirtilecektir.

## Hata İletisini Okumak

Yakalanmamış bir hata üç parça bilgi taşır: hatanın **adı**, **iletisi** ve **yığıt
izi**. Üçü ayrı ayrı okunabilir:

```js
const kayitlar = [{ istasyon: "A1", sicaklik: 21.5 }];
try {
  console.log(kayitlar[1].sicaklik);
} catch (hata) {
  console.log("ad   :", hata.name);
  console.log("ileti:", hata.message);
}
```

```
ad   : TypeError
ileti: Cannot read properties of undefined (reading 'sicaklik')
```

**Ad**, hatanın sınıfını verir. `TypeError` bir değerin beklenen türde olmadığını,
`ReferenceError` bir adın bulunamadığını, `SyntaxError` kaynağın ayrıştırılamadığını
bildirir.

**İleti**, olayın ayrıntısıdır. Yukarıdaki iletiyi adım adım okumak, hatanın nerede
olduğunu doğrudan söyler: `kayitlar[1]` değeri `undefined` çıkmıştır ve `undefined`
üzerinde `sicaklik` özelliği aranmıştır. Yani asıl sorun, dizinin ikinci elemanının
bulunmamasıdır — özelliğin adı değil. Hata iletisi, hatanın **belirtisini** gösterir;
nedeni genellikle bir üst satırdadır.

**Yığın izi**, hatanın hangi çağrı zincirinden geçtiğini `at` ile başlayan satırlarda
listeler. En üstteki satır hatanın oluştuğu yerdir; alt satırlar oraya kimin çağırdığını
verir. Yığın izinin biçimi, dosya yolları ve çalışma zamanının iç çerçeveleri makineye
göre değiştiği için bu kursta yalnızca ad ve ileti bölümleri gösterilecektir.

Yakalanmamış bir hata, sunucu tarafı çalışma zamanında süreci sıfırdan farklı bir çıkış
koduyla sonlandırır. Tarayıcıda ise sayfa çalışmaya devam eder; hata yalnızca konsola
yazılır. Aynı hatanın iki ortamdaki sonucu farklıdır, ama iletisi aynıdır.

## Özet

- Kod dört yoldan girer: dosya, komut satırı argümanı, etkileşimli kabuk ve belge
  bağlamındaki betik etiketi.
- Etkileşimli kabuk her satırın değerini inceleme biçiminde yazar; bildirimler değer
  üretmediği için `undefined` görünür. Bu biçim standarttan değil ortamdan gelir.
- ECMAScript bir kaynağı betik ya da modül olarak ayrıştırır; modül her zaman katı
  kiptedir, en dış `this` değeri `undefined`'dır ve adları genel nesneye yazılmaz.
- Katı kip, bildirilmemiş ada atamayı sessiz bir genel ad yaratmak yerine
  `ReferenceError`'a çevirir.
- Hata iletisi ad, ileti ve yığıt izinden oluşur; ileti belirtiyi anlatır, neden çoğu
  zaman bir önceki adımdadır.

## Sonraki Adım

Betiğin modül olarak yüklenmesi, `const` ve `let` bildirimlerinin varlığı, `for...of`
döngüsü — bunların hepsi dilin belirli bir noktada kazandığı yeteneklerdir. Sonraki ders,
bir özelliğin dile nasıl girdiğini ele alacak: standardın sürümlenme biçimi, önerilerin
geçtiği aşamalar ve "bu özellik burada var mı" sorusunun sürüm adına bakmadan nasıl
yanıtlanacağı.