Fonksiyonlar

Çoğu zaman kod yazarken belirli bölümleri tekrarlama ihtiyacı duyulur.

Örneğin kullanıcı hesabına giriş yaptığında veya çıktığında güzel görünümlü bir mesaj göstermek istenebilir.

Fonksiyonlar programın “yapı taşıdır”. Birçok defa bu fonksiyonlar çağırılarak tekrardan bu kodları yazmaktan kurtulunur.

Aslında var olan alert(mesaj), prompt(mesaj,varsayilan) ve confirm(soru) gibi fonksiyonları gördük. Fakat artık bunları yazmanın zamanı geldi.

Fonksiyon Tanımlama

Fonksiyon tanımlamak için function tanım kullanılır.

Aşağıdaki gibi görünür:

function mesajGoster() {
  alert( 'Merhaba millet!' );
}

function kelimesi önce yazılır, ardından fonksiyonun adı ve sonra parametrelerin yazılacağı parantez açılır ve ihtiyaç duyulan parametreler yazılır, sonrasında ise kapatılıp süslü parantez ile fonksiyon gövdesine baÅŸlanır.

Yeni fonksyion ismiyle ÅŸu ÅŸekilde çağırılır: mesajGoster().

Örneğin:

function mesajGoster() {
  alert( 'Merhaba millet' );
}

mesajGoster();
mesajGoster();

mesajGoster() fonksiyonu kodu çalıştırır. Bu kod sonrasında Merhaba millet uyarısını iki defa göreceksiniz.

Bu örnek açıkça fonksiyonların ana amacını gösteriyor: Kod tekrarından kaçınma.

Eğer mesajı değiştirmek istersek bir yerde değiştirdiğimizde bu fonksiyonu kullanan her yerde değişiklik olacaktır.

Yerel deÄŸiÅŸkenler

Fonksiyon içinde tanımlanan değişkene sadece o fonksiyon içerisinde erişilebilir.

Örneğin:

function mesajGoster() {
  let mesaj = "Merhaba! Ben Javascript"; // Yerel DeÄŸiÅŸken

  alert( mesaj );
}

mesajGoster(); // Merhaba! Ben Javascript

alert( mesaj ); // <-- Hata! Bu deÄŸiÅŸken `mesajGoster` fonksiyonuna aittir.

Dış Değişkenler

Fonksiyon, kendi dışında oluşturulmuş değişkenlere erişebilir. Örneğin:

let kullaniciAdi = 'Adem';

function mesajGoster() {
  let mesaj = 'Hello, ' + kullaniciAdi;
  alert(mesaj);
}

mesajGoster(); // Merhaba, Adem

Fonksiyon dışarıda bulunan değişkenlere tam kontrol sağlar. Hatta modifiye edebilir.

Örneğin:

let kullaniciAdi = 'Adem';

function mesajGoster() {
  kullaniciAdi = "Yusuf"; // (1) dışarıda bulunan değişkenin değeri değişti.

  let mesaj = 'Merhaba, ' + kullaniciAdi;
  alert(mesaj);
}

alert( kullaniciAdi ); // Fonksiyon çağırılmadan  Adem

mesajGoster();

alert( kullaniciAdi ); // fonksiyon çağırıldıktan sonra Yusuf,

Dışarıda bulunan deÄŸiÅŸkenler eÄŸer yerel deÄŸiÅŸken yoksa kullanılırlar. Bazen eÄŸer let ile deÄŸiÅŸken oluÅŸturulmazsa karışıklık olabilir.

Eğer aynı isim ile fonksiyon içerisinde bir değişken oluşturulmuş ise, fonksiyon içerisindeki değişkenin değeri düzenlenebilir. Örneğin aşağıda yerel bir değişken dıştaki değişken ile aynı isimdedir. Dolayısıyla yerel değişken düzenlenecektir. Dıştaki değişken bundan etkilenmeyecektir.

let kullaniciAdi = 'Adem';

function mesajGoster() {
  let kullaniciAdi = "Yusuf"; // yerel değişken tanımla

  let mesaj = 'Merhaba, ' + kullaniciAdi; // Yusuf
  alert(mesaj);
}

// buradaki fonksiyon kendi deÄŸiÅŸkenini yaratacak ve onu kullanacak.
mesajGoster();

alert( kullaniciAdi ); // Adem, değişmedi!!!, fonksiyon dışarıda bulunan değişkene erişmedi.

Parametreler

Parametrelere isteğe bağlı olarak veri paslanabilir. Bunlara fonksiyon argümanları da denir.

AÅŸağıdaki fonksiyon iki tane parametreye sahiptir. gonderen ve metin

function mesajGoster(gonderen, metin) { // argümanlar: gonderen, metin
  alert(gonderen + ': ' + metin);
}

mesajGoster('Ahmet', 'Merhaba!'); // Ahmet: Merhaba! (*)
mesajGoster('Mehmet', "Naber?"); // Mehmet: Naber? (**)

EÄŸer fonksiyonlar (*) ve (**) deki gibi yazılırsa doÄŸrudan fonksiyonda gonderen ve metin yerel deÄŸiÅŸkenlerine atanırlar. Sonrasında fonksiyon bunları kullanabilir.

AÅŸağıda gonderen deÄŸiÅŸkeni fonksiyona paslanmakta. Dikkat ederseniz fonksiyon içerisinde gonderen deÄŸiÅŸse bile bu dışarıda bulunan deÄŸiÅŸkeni etkilememekte. Çünkü fonksiyon bu deÄŸiÅŸkenin her zaman kopyasını kullanır:

function mesajGoster(gonderen,metin) {

  gonderen = '*' + gonderen + '*'; // "gonderen" biraz daha güzel hale getirildi.

  alert( gonderen + ': ' + metin );
}

let gonderen = "Mahmut";

mesajGoster(gonderen, "Merhaba"); // *Mahmut*: Merhaba

// "gonderen" değişkeninin değeri sadece fonksiyon içerisinde değişti. Çünkü bu değişken paslandığında fonksiyon yerel bir kopyası üzerinde çalışır
alert( gonderen ); // Mahmut

Varsayılan Değerler

EÄŸer fonksiyon argümanına bir deÄŸer gönderilmemiÅŸse fonksiyon içerisinde bu deÄŸiÅŸken undefined olur.

ÖrneÄŸin mesajGoster(gonderen,metin) fonksiyonu tek argüman ile de çağırılabilir.

mesajGoster("Mahmut");

Bu bir hata deÄŸildir. Fonksiyon eÄŸer bu ÅŸekilde çağırılırsa, yani metin yoksa, metin == undefined varsayılır. Yukarıdaki fonksiyon çağırıldığında sonuç “Mahmut: undefined” olacaktır.

EÄŸer “varsayılan” olarak metin deÄŸeri atamak istiyorsanız, = iÅŸareti ile tanımlamanız gerekmekte.

function mesajGoster(gonderen, metin = "metin gönderilmedi") {
  alert(gonderen + ": " + metin );
}

mesajGoster("Mahmut"); // Mahmut: metin gönderilmedi

EÄŸer metin deÄŸeri paslanmazsa, "metin gönderilmedi" çıktısı alınır.

"metin gönderilmedi" ÅŸu anda karakter dizisidir. Fakat daha karmaşık yapılar olabilir. Sadece parametre gönderilmez ise bu deÄŸer atanır. AÅŸağıdaki kullanım da pekala doÄŸrudur.

function mesajGoster(gonderen, metin = digerFonksiyon()) {
  // eğer metin gönderilmez ise digerFonksiyon çalışır ve sonucu "metin" değişkenine atanır.
}

function mesajGoster(gonderen, metin) {
  if (metin === undefined) {
    text = 'metin gönderilmedi';
  }

  alert( gonderen + ": " + metin );
}

function mesajGoster(gonderen, metin) {
  // eğer metin yanlış değer ise( bu durumda undefined yanlış değerdir hatırlarsanız ) 'metin gönderilmedi' ata.
  text = text || 'metin gönderilmedi';
  ...
}

Değer döndürme

Fonksiyon çağırıldığı yere değer döndürebilir.

En basit örnek iki değeri toplayan bir fonksiyon olabilir.

function toplam(a, b) {
  return a + b;
}

let sonuc = toplam(1, 2);
alert( sonuc ); // 3

return fonksiyon içerisinde her yerde kullanılabilir. Kod return satırına eriÅŸtiÄŸinde fonksiyon durur ve deÄŸer fonksiyonun çağırıldığı yere geri gönderilir.

Bir fonksiyon içerisinde birden fazla return fonksiyonu da olabilir.

function yasKontrolu(yas) {
  if (yas > 18) {
    return true;
  } else {
    return confirm('Ebevenylerinin izni var mı?');
  }
}

let yas = prompt('Kaç yaşındasın?', 18);

if ( yasKontrolu(yas) ) {
  alert( 'Ä°zin verildi' );
} else {
  alert( 'Reddedildi' );
}

return deÄŸer döndürmek zorunda deÄŸildir. Bu fonksiyondan anında çıkmayı saÄŸlar.

Örneğin:

function filmGoster(age) {
  if ( !yasKontrolu(yas) ) {
    return;
  }

  alert( "Filmleri izleyebilirsin" ); // (*)
  // ...
}

Yukarıdaki kodda eÄŸer yasKontrolu(yas) false döndürür ise filmGoster fonksiyonu alerte eriÅŸemeyecektir.

function biseyYapma() { /* boÅŸ */ }

alert( biseyYapma() === undefined ); // true

function biseyYapma() {
  return;
}

alert( biseyYapma() === undefined ); // true

return
 (bazı + uzun + ifade + veya + baska + birsey  * f(a) + f(b))

return;
  (bazı + uzun + ifade + veya + baska + birsey  * f(a) + f(b))

Fonksiyonu isimlendirme

Fonksiyonlar eylemdir. Bundan dolayı isimleri yüklem olmalıdır. Net olmalı ve fonksiyonun ne işe yaradığını ifade edebilmelidir. Böylece kim ki kodu okur, ne yazıldığına dair bir fikri olur.

Genel itibari ile eylemi tanımlayan ön ek kullanmak iyi bir yöntemdir. Bu ön ekler ile ilgili birlikte kod yazdığınız kişiler ile uyum içerisinde olmalısınız.

ÖrneÄŸin "show" fonksiyonu her zaman bir ÅŸeyleri gösterir.

Fonksiyonlar şöyle başlayabilir.

• "get…" – deÄŸer döndürür,
• "calc…" – bir ÅŸeyler hesaplar,
• "create…" – bir ÅŸeyler yaratır,
• "check…" – bir ÅŸeyleri kontrol eder ve boolean döndürür.

Böyle isimlere örnek:

Not: İngilizce’de bu daha kolay önce eylemi yazıyorlar. Türkçe’de fiil genelde sonda olduğundan dolayı sıkıntı yaşanmaktadır. Fonksiyonlarınızı adlandırırken İngilizce adlandırırsanız okunması daha kolay olacaktır.

sendMessage(..)     // mesaj gönderir
getAge(..)          // yaşı döndürür
calcSum(..)         // toplamı hesaplar ve geri döndürür.
createForm(..)      // form oluşturur ve genelde geri döndürür.
checkPermission(..) // izni kontor eder. true/false

Ön ek ile fonksiyonlar bir anlamda ipucu verir ve ne tür değerler dönmesi gerektiğini anlatır.

Fonksiyonlar == Yorumlar

Fonksiyonlar kısa olmalı ve sadece bir şeyi yapmalıdırlar. Eğer uzun ise bu durumda ayırıp yeni bir fonksiyon yapmanız daha iyi olabilir. Bazen bu kuralı takip etmek zor olabilir. Fakat kesinlikle iyi bir şeydir.

Farklı fonksiyon daha kolay bir şekilde çalışması kontrol edilebilir. Varlığı harika bir yorumdur.

ÖrneÄŸin, aÅŸağıdaki iki asalGoster(n) fonksiyonunu karşılaÅŸtırın. Asal Sayı

İlk tanım label kullanıyor:

function asalGoster(n) {
  sonrakiAsal: for (let i = 2; i < n; i++) {

    for (let j = 2; j < i; j++) {
      if (i % j == 0) continue sonrakiAsal;
    }

    alert( i ); // asal sayı
  }
}

Ä°kinci tip ise asalMi(n) adında ikinci bir fonksiyon ile asal olup olmama durumunu kontrol ediyor.

function asalGoster(n) {

  for (let i = 2; i < n; i++) {
    if (!asalMi(i)) continue;

    alert(i);  // asal sayı
  }
}

function asalMi(n) {
  for (let i = 2; i < n; i++) {
    if ( n % i == 0) return false;
  }
  return true;
}

Ä°kinci örnek anlaşılması daha kolay deÄŸil mi? asalMi gibi fonksiyon isimleri yerine bazıları buna kendi kendini açıklayan demektedir.

Fonksiyonlar eğer tekrar kullanmayacağımızı bilsek bile oluşturulabilir. Kodu daha okunabilir yaparlar.

Özet

Bir fonksiyonun tanımı aşağıdaki gibidir.

function fonksiyon ismi(parametreler, virgül , ile, ayrilirlar) {
  /* code */
}

• Fonksiyona paslanan parametreler yerel deÄŸiÅŸken olarak fonksiyon içerisinde kopyalanırlar.
• Fonksiyon dışarıdaki deÄŸiÅŸkene eriÅŸebilir. Fakat içeride yaratılmış bir deÄŸiÅŸken dışarıda kullanılamaz.
• Fonksiyon deÄŸer döndürebilir. EÄŸer döndürmezse undefinedolarak tanımlanır.

Kodun daha anlaşılır ve okunabilir olması için, fonksiyonlar içerisinde yerel değişken kullanılması önerilir. Dış değişkenler kullanılması önerilmez.

Eğer fonksiyon parametre ile değer alır ve bu değer üzerinde çalışıp değer geri döndürürse anlaşılırlığı artar. Fakat eğer fonksiyon hiçbir parametre almadan sadece dışarıdaki değişkenleri değiştiriyor ise kodun anlaşılırlığı büyük ölçüde azalır.

Fonksiyon isimlendirme:

• Bir isim fonksiyonun ne iÅŸe yaradığını açıklayabiliyor olmalıdır. Ä°yi bir isim fonksiyonun okunmadan ne iÅŸ yaptığına dair fikir verir.
• Fonksiyon bir fiili yerine getirdiÄŸinden, fonksiyon isimleri yüklem olmalıdır.
• Bunlar için ön ek kullanabilirsiniz. Türkçe sondan eklemeli bir dil olduÄŸundan dolayı fonksiyon ekleri sona gelmektedir. ÖrneÄŸin asalGoster, bu tip kullanım aslında okunurluk açısından pekte iyi deÄŸil benim kanaatimce. Çünkü okurken önce ne yaptığını anlaşılmıyor. Fakat Ä°ngilizce örneÄŸine bakarsanız showPrime, burada önce ne yaptığını söylüyor. Farzedin ki birçok fonksiyonunuz var ve okuduÄŸunuzda önce ne iÅŸ yaptığını bilmek bunları filtrelemenizde size yardımcı olacaktır.
• Örnek kaç tane ek , create... , show..., get..., check... vs.

Fonksiyonlar kod yazarken kullanılan ana yapılardır. Artık temellerini anlaşıldığına göre kullanılmaya başlanabilir. Fakat sadece temellerinin gösterildiğini bilmekte fayda var. İleride defalarca fonksiyonlar konusuna geri dönülecektir.