---
title: 'Fonksiyon Bildirimi ve İfadesi'
source: 'https://academia.sh/tr/kurslar/javascript-temelleri/fonksiyon-bildirimi-ve-ifadesi'
course: 'JavaScript Temelleri'
language: tr
updated: '2026-08-17T18:09:47+00:00'
license: 'CC BY-SA 4.0'
---

# Fonksiyon Bildirimi ve İfadesi

İki tanım biçiminin yukarı taşıma farkı, adlı fonksiyon ifadeleri, fonksiyonların değer olarak kullanımı, dönüş kuralları ve otomatik noktalı virgül tuzağı.

Önceki derste denetimler ve birikeçler döngü gövdesine gömülüydü. Aynı işi ikinci kez
yapmak gerektiğinde kod kopyalanacaktı. Programlama Temelleri kursundaki Fonksiyon Tanımı
ve Çağrı dersinde bu bölmenin gerekçesi kurulmuştu.

JavaScript'te fonksiyon tanımlamanın birden çok biçimi vardır ve aralarındaki fark
sözdiziminden ibaret değildir. Bu ders iki temel biçimi karşılaştırır; üçüncü biçim olan
ok fonksiyonları bu konunun beşinci dersinde ele alınacak.

## İki Tanım Biçimi

**Fonksiyon bildirimi**, `function` anahtar sözcüğüyle başlayan ve bir ad taşıyan
deyimdir. **Fonksiyon ifadesi**, bir değer üreten ve genellikle bir değişkene atanan
biçimdir.

Adlandırma ve Kapsam Kuralları dersinde gösterilen fark burada tekrar edilir: bildirim
gövdesiyle birlikte yukarı taşınır, ifade taşınmaz.

```js
console.log(ortalamaBildirim([21.5, 19.75]));

function ortalamaBildirim(dizi) {
  let toplam = 0;
  for (const d of dizi) toplam += d;
  return toplam / dizi.length;
}

const ortalamaIfade = function (dizi) {
  let toplam = 0;
  for (const d of dizi) toplam += d;
  return toplam / dizi.length;
};
console.log(ortalamaIfade([21.5, 19.75]));
```

```
20.625
20.625
```

Bildirim, tanımından önceki satırdan çağrılabildi. İfade, atama satırından önce
çağrılsaydı zamansal ölü bölge hatası verirdi.

İki biçimin ikinci farkı, ifadenin bir **değer** olmasıdır: doğrudan bir argüman olarak
geçilebilir, bir nesnenin özelliği yapılabilir ya da bir fonksiyondan döndürülebilir.
Bildirim bunu yapamaz; önce bir ada bağlanması gerekir.

Kursun kuralı: **en dış kapsamdaki yardımcı fonksiyonlar bildirim biçiminde yazılır**,
başka bir fonksiyona geçirilen veya bir değişkende taşınan fonksiyonlar ifade biçiminde
yazılır. Gerekçe, bildirimin çağrı sırasından bağımsız olması ve dosyanın okunma sırasını
serbest bırakmasıdır.

## Adlı Fonksiyon İfadeleri

Bir fonksiyon ifadesi ad taşıyabilir. Bu ad, yalnızca fonksiyonun **kendi gövdesinde**
görülür:

```js
const topla = function toplayici(dizi, dizin = 0) {
  if (dizin >= dizi.length) return 0;
  return dizi[dizin] + toplayici(dizi, dizin + 1);
};
console.log(topla([21.5, 19.75, 23]));
console.log(topla.name);
try {
  console.log(toplayici([1]));
} catch (hata) {
  console.log(hata.name + ": " + hata.message);
}
```

```
64.25
toplayici
ReferenceError: toplayici is not defined
```

İç ad özyinelemeli çağrıyı mümkün kıldı ve `name` özelliğinde göründü, ama dışarıdan
erişilemedi. Bu, özyinelemeli bir fonksiyon ifadesinin kendisini dış değişkene bağımlı
olmadan çağırmasını sağlar; dış değişken sonradan başka bir değere bağlansa bile
özyineleme çalışmayı sürdürür.

Fonksiyonlar iki bilgilendirici özellik taşır:

```js
function esikUstu(dizi, esik) { return dizi.filter((d) => d > esik); }
const anonim = function (a, b) { return a + b; };
console.log(esikUstu.name, esikUstu.length);
console.log(anonim.name, anonim.length);
console.log(typeof esikUstu, esikUstu instanceof Object);
```

```
esikUstu 2
anonim 2
function true
```

`name`, hata iletilerinde ve yığıt izlerinde görünen addır; atandığı değişkenin adından
çıkarılabilir. `length`, beklenen parametre sayısıdır — varsayılan değerli ve kalan
parametreler sayılmaz, bu bir sonraki dersin konusudur.

Son satır bir tip gözlemidir: fonksiyonlar nesnedir. `typeof` ayrı bir sonuç verse de,
özellik taşırlar ve nesne olarak davranırlar.

## Fonksiyonlar Değerdir

Fonksiyonun değer olması, onu argüman olarak geçirmeyi ve bir fonksiyondan
döndürmeyi mümkün kılar. Programlama Temelleri kursundaki Fonksiyonel Programlamaya
Giriş dersinde tanımlanan yüksek mertebeden fonksiyon kavramı budur.

```js
const sicakliklar = [21.5, 19.75, 23, 18.25];

function esikSuzgeci(esik) {
  return function (deger) {
    return deger > esik;
  };
}

const yirmiUstu = esikSuzgeci(20);
console.log(sicakliklar.filter(yirmiUstu));
console.log(sicakliklar.filter(esikSuzgeci(22)));
```

```
[ 21.5, 23 ]
[ 23 ]
```

Döndürülen fonksiyon, yaratıldığı çağrıdaki `esik` bağlamasını taşımayı sürdürüyor. İki
ayrı çağrı iki ayrı bağlama üretti; ilki `20`, ikincisi `22` gördü. Bu davranışın adı
**kapanıştır** ve bir sonraki kursun temel konularından biridir. Burada yalnızca
kullanılıyor.

Bir fonksiyon ifadesi tanımlandığı yerde hemen çağrılabilir. Bu kalıp, bir adı dış
kapsama sızdırmadan iş yapmak için kullanılır:

```js
const rapor = (function () {
  const gizli = [21.5, 19.75];
  return { adet: gizli.length };
})();
console.log(rapor);
console.log(typeof gizli);
```

```
{ adet: 2 }
undefined
```

`gizli` adı dışarıda görünmüyor. Modül kipi bu ihtiyacın çoğunu ortadan kaldırır — Kod
Çalıştırma Yolları dersinde görüldüğü gibi modülün en dış kapsamı zaten özeldir — ama
kalıp, dar bir kapsam açmak için hâlâ kullanılır.

## Blok İçinde Bildirim

Katı kipte fonksiyon bildirimleri **blok kapsamlıdır**:

```js
if (true) {
  function blokIcinde() {
    return "blok";
  }
  console.log(blokIcinde());
}
try {
  console.log(blokIcinde());
} catch (hata) {
  console.log(hata.name + ": " + hata.message);
}
```

```
blok
ReferenceError: blokIcinde is not defined
```

Katı kipte olmayan betiklerde bu davranış farklıdır ve uyumluluk kuralları devreye
girer. Belirsizlikten kaçınmanın yolu, koşula bağlı tanımları bildirim yerine ifadeyle
yazmaktır: değişken bildiriminin kapsam kuralı her iki kipte de aynıdır.

## Dönüş Kuralları

Dönüş değeri yazılmamış bir fonksiyon `undefined` döndürür. Bu, çağıranın gördüğü
değerdir ve fonksiyonun bir iş yapıp yapmadığından bağımsızdır.

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

function erkenCikis(deger) {
  if (deger == null) return;
  return deger * 2;
}
console.log(erkenCikis(null), erkenCikis(10));
```

```
A1 21.5
donus: undefined
undefined 20
```

Programlama Temelleri kursundaki komut–sorgu ayrımı burada da geçerlidir: bir fonksiyon
ya iş yapar ya değer döndürür. `yaz` iş yapar; dönüşünü kullanmak anlamsızdır.

## Otomatik Noktalı Virgül Tuzağı

JavaScript, belirli durumlarda satır sonuna noktalı virgül ekler. Kural `return` deyiminde
sert bir sonuç doğurur: **`return` ile döndürülecek ifade arasına satır sonu
konamaz.**

```js
function hataliDonus() {
  return
    21.5;
}
function dogruDonus() {
  return 21.5;
}
console.log(hataliDonus());
console.log(dogruDonus());
```

```
undefined
21.5
```

İlk fonksiyonda `return` deyimi kendi satırında sonlandırıldı; `21.5;` satırı hiç
çalışmayan ayrı bir deyim oldu. Hata verilmedi, uyarı çıkmadı — yalnızca yanlış değer
döndü.

Aynı kural `throw`, `break`, `continue` ve artırma işleçleri için de geçerlidir.
Korunmanın yolu, döndürülecek ifadeyi `return` ile aynı satırda başlatmaktır. Uzun bir
ifade döndürülüyorsa açılış parantezi aynı satıra konur.

## Ölçüm Betiğine Uygulama

Önceki derslerdeki denetimler ve hesaplar fonksiyonlara ayrıldığında, betiğin gövdesi
akışı gösteren birkaç satıra iner:

```js
function gecerliMi(kayit) {
  return kayit.sicaklik != null && !Number.isNaN(kayit.sicaklik);
}

function ortalama(kayitlar) {
  let toplam = 0;
  let sayac = 0;
  for (const kayit of kayitlar) {
    if (!gecerliMi(kayit)) continue;
    toplam += kayit.sicaklik;
    sayac += 1;
  }
  return sayac === 0 ? null : toplam / sayac;
}

const kayitlar = [
  { istasyon: "A1", sicaklik: 21.5 },
  { istasyon: "A2", sicaklik: NaN },
  { istasyon: "B1", sicaklik: 23 },
  { istasyon: "B2", sicaklik: null },
];

console.log("gecerli:", kayitlar.filter(gecerliMi).length);
console.log("ortalama:", ortalama(kayitlar));
console.log("bos liste:", ortalama([]));
```

```
gecerli: 2
ortalama: 22.25
bos liste: null
```

`gecerliMi` hem `filter` çağrısına argüman olarak geçti hem de döngü içinde çağrıldı —
fonksiyonun değer olmasının doğrudan faydası. `ortalama` fonksiyonu boş listede `null`
döndürüyor; bölme yapılsaydı `NaN` üretirdi ve hata sessizce ilerlerdi.

## Özet

- Fonksiyon bildirimi gövdesiyle birlikte yukarı taşınır; fonksiyon ifadesi atama
  satırında oluşur ve öncesinde ölü bölgededir.
- Adlı fonksiyon ifadesinin adı yalnızca kendi gövdesinde görülür ve özyinelemeyi dış
  değişkenden bağımsız kılar.
- Fonksiyonlar değerdir: argüman olarak geçirilir, döndürülür ve nesne olarak özellik
  taşır.
- Katı kipte blok içindeki fonksiyon bildirimleri blok kapsamlıdır; koşula bağlı tanımlar
  ifadeyle yazılır.
- Dönüş değeri yazılmamış fonksiyon `undefined` verir; `return` ile ifade arasına satır
  sonu konursa deyim orada biter ve sessizce `undefined` döner.

## Sonraki Adım

Bu derste fonksiyonlar sabit sayıda parametreyle çağrıldı. Gerçek kullanımda argüman
eksik gelebilir, fazla gelebilir ya da sayısı önceden bilinmeyebilir. Sonraki ders
parametre kurallarını ele alacak: varsayılan değerlerin ne zaman devreye girdiği, kalan
parametrelerin toplanması ve eski argüman nesnesinin neden yeni yazımda kullanılmadığı.
