``

Birinci sınıf vatandaş ne demektir?

Bir programlama dilinde bir değer aşağıdaki işlemleri destekliyorsa genellikle birinci sınıf kabul edilir:

• Bir değişkene atanabilir.
• Veri yapılarında saklanabilir.
• Fonksiyonlara parametre olarak geçirilebilir.
• Başka bir fonksiyondan döndürülebilir.

JavaScript fonksiyonları bu koşulların tamamını karşılar. Matematiksel açıdan bir fonksiyonu $f: A \rightarrow B$ biçiminde gösteririz. Bu ifade, $f$ fonksiyonunun $A$ kümesindeki bir girdiyi $B$ kümesindeki bir çıktıya dönüştürdüğünü söyler. Programlamadaki önemli fark, $f$ değerinin kendisini de taşıyabilmemizdir.

const topla = function (a, b) {
  return a + b;
};

const hesapla = topla;
console.log(hesapla(4, 6)); // 10

Burada topla fonksiyonu çalıştırılmadan hesapla değişkenine atanır. Parantez kullanılmaması kritiktir: topla fonksiyonun kendisini, topla() ise fonksiyon çağrısının sonucunu ifade eder.

Fonksiyonları parametre olarak geçirmek

Bir fonksiyona başka bir fonksiyon verilmesine callback yaklaşımı denir. Callback alan fonksiyon ise yüksek dereceli fonksiyondur. Bu yapı, davranışı veriden ayırarak tekrar kullanılabilir kod üretmemizi sağlar.

function uygula(sayi, islem) {
  return islem(sayi);
}

const ikiyleCarp = x => x * 2;
const karesiniAl = x => x ** 2;

console.log(uygula(5, ikiyleCarp)); // 10
console.log(uygula(5, karesiniAl)); // 25

uygula, hangi hesabın yapılacağını bilmez; yalnızca aldığı davranışı çalıştırır. Matematiksel olarak bunu $uygula(x, f) = f(x)$ şeklinde düşünebiliriz. Böylece aynı mekanizma, farklı fonksiyonlarla farklı sonuçlar üretir.

Fonksiyondan fonksiyon döndürmek

Fonksiyonlar sonuç olarak da üretilebilir. Bu teknik yapılandırılabilir ve özelleştirilebilir işlemler oluşturmak için kullanışlıdır.

function carpaniOlustur(carpan) {
  return sayi => sayi * carpan;
}

const ucleCarp = carpaniOlustur(3);
console.log(ucleCarp(7)); // 21

Döndürülen fonksiyon, dış fonksiyon tamamlandıktan sonra bile carpan değerini hatırlar. Bu davranışa closure denir. Adeta fonksiyon küçük bir sırt çantası taşır ve doğduğu kapsamın değişkenlerini yanında götürür.

Arrow function avantajları

Arrow function sözdizimi özellikle kısa callback ifadelerinde kodu sadeleştirir.

Tek ifadeli arrow function’larda return ve süslü parantezler çıkarılabilir:

const fiyatlar = [100, 200, 300];
const kdvliFiyatlar = fiyatlar.map(fiyat => fiyat * 1.20);

Ancak arrow function her durumda daha iyi değildir. Nesne metotlarında dinamik this gerekiyorsa klasik fonksiyon tercih edilmelidir.

const kullanici = {
  ad: "Ada",
  selamla() {
    console.log(`Merhaba, ${this.ad}!`);
  }
};

Sonuç olarak birinci sınıf fonksiyonlar; callback, closure, olay yönetimi ve fonksiyonel programlama gibi pek çok yaklaşımın temelidir. Arrow function’lar bu gücü kısa bir sözdizimiyle sunar, fakat this ve constructor farklılıkları unutulmamalıdır. Fonksiyonları yalnızca çalışan bloklar değil, taşınabilen ve birleştirilebilen değerler olarak gördüğünüzde JavaScript çok daha esnek bir oyun alanına dönüşür.

Dizi nedir?

Dizi, birden fazla değeri sıralı biçimde saklayan veri yapısıdır. JavaScript’te köşeli parantezlerle oluşturulur ve her elemanın sıfırdan başlayan bir indeksi vardır.

const diller = ["JavaScript", "Python", "Go"];

console.log(diller[0]); // JavaScript
console.log(diller.length); // 3

Bir dizide $n$ eleman varsa geçerli indeksler $0$ ile $n-1$ arasındadır. Örneğin üç elemanlı bir dizinin son elemanı diller[2] olur. Son elemana daha okunaklı biçimde diller.at(-1) kullanılarak da erişilebilir.

Diziler yalnızca metin değil; sayı, nesne ve hatta başka diziler barındırabilir. Yine de uygulamada aynı amaca hizmet eden verileri bir arada tutmak kodun anlaşılmasını kolaylaştırır.

Yüksek mertebe metot nedir?

Yüksek mertebe fonksiyon, başka bir fonksiyonu parametre olarak alabilen veya sonuç olarak fonksiyon döndürebilen fonksiyondur. Dizi metotları, her eleman için çalıştırılacak bir geri çağırma fonksiyonu alır.

Bu metotlar kaynak diziyi doğrudan değiştirmez. Böylece beklenmedik yan etkiler azalır ve veri akışı daha kolay takip edilir.

map: Her elemanı dönüştür

map, dizideki her elemanı verilen fonksiyondan geçirir. Matematiksel olarak bir $f$ fonksiyonunun tüm elemanlara uygulanması gibi düşünülebilir:

const fiyatlar = [100, 250, 80];
const kdvliFiyatlar = fiyatlar.map((fiyat) => fiyat * 1.20);

console.log(kdvliFiyatlar); // [120, 300, 96]

Burada her fiyat yüzde 20 KDV eklenerek dönüştürülür. Orijinal fiyatlar dizisi değişmez.

filter: İstenmeyenleri ele

filter, geri çağırma fonksiyonu true döndüren elemanları yeni diziye taşır. Bir sınıftaki başarılı notları seçelim:

const notlar = [45, 82, 67, 30, 91];
const basariliNotlar = notlar.filter((not) => not >= 50);

console.log(basariliNotlar); // [82, 67, 91]

Koşul bir süzgeç gibi çalışır. En kötü durumda bütün elemanlar incelendiği için zaman karmaşıklığı $O(n)$ olur.

reduce: Diziyi tek sonuca indir

reduce, biriktirici ve mevcut eleman üzerinden ilerler. İkinci argüman başlangıç değeridir; verilmesi, özellikle boş dizilerde hata riskini azaltır.

const sepet = [
  { ad: "Klavye", fiyat: 900 },
  { ad: "Fare", fiyat: 500 },
  { ad: "Kulaklık", fiyat: 1200 }
];

const toplam = sepet.reduce(
  (biriken, urun) => biriken + urun.fiyat,
  0
);

console.log(toplam); // 2600

Toplam, matematiksel olarak $\sum_{i=1}^{n} fiyat_i$ işlemidir. Biriktirici başlangıçta 0 değerini alır ve her ürünün fiyatıyla güncellenir.

Metotları zincirlemek

Asıl eğlence metotlar birleştiğinde başlar. Önce pahalı ürünleri seçip sonra adlarını dönüştürebiliriz:

const pahaliUrunAdlari = sepet
  .filter((urun) => urun.fiyat >= 800)
  .map((urun) => urun.ad.toUpperCase());

console.log(pahaliUrunAdlari); // ["KLAVYE", "KULAKLIK"]

Her zincir halkası yeni bir sonuç üretir. Ancak her metot diziyi ayrı dolaştığından devasa veri kümelerinde gereksiz zincirler maliyet yaratabilir. Günlük uygulamalarda ise okunabilirlik kazancı çoğunlukla daha değerlidir.

Kısacası map dönüştürür, filter seçer, reduce biriktirir. Hangi metodu kullanacağınıza karar verirken “Yeni bir liste mi, seçilmiş elemanlar mı, yoksa tek bir sonuç mu istiyorum?” sorusunu sormanız yeterlidir.

JavaScript nerede çalışır?

JavaScript kodunu çalıştıran temel bileşene JavaScript motoru denir. Google Chrome ve Node.js, V8 motorunu kullanır. Firefox ise SpiderMonkey adlı farklı bir motora sahiptir. Motor, yazdığımız kaynak kodunu bilgisayarın işleyebileceği komutlara dönüştürür.

Bir programın yaklaşık çalışma süresini teorik olarak şöyle düşünebiliriz:

Modern motorlar, sık kullanılan kodları çalışma sırasında optimize eden JIT (Just-in-Time) derleme yöntemlerinden yararlanır. Dolayısıyla JavaScript yalnızca “satır satır okunan basit bir betik dili” değildir.

Tarayıcı konsoluyla ilk buluşma

Chrome, Edge veya Firefox’ta F12 tuşuna basarak geliştirici araçlarını açın ve Console sekmesine geçin. Burada herhangi bir dosya oluşturmadan JavaScript çalıştırabilirsiniz:

const ad = 'Ada';
const dersSayisi = 3;

console.log(`Merhaba ${ad}! Bugün ${dersSayisi} ders var.`);
console.table({ ad, dersSayisi });

console.log değerleri görüntülerken console.table, nesneleri tablo biçiminde sunar. Konsol hızlı deneyler için harikadır; fakat yazdığınız komutlar kalıcı bir proje düzeni oluşturmaz.

Node.js kurulumu

Node.js, JavaScript’i tarayıcı dışında çalıştıran bir çalışma zamanıdır. Resmî Node.js sitesinden LTS sürümünü indirin. LTS, uzun süre desteklenen ve yeni başlayanlar için daha güvenli olan sürümdür. Kurulumla birlikte paket yöneticisi npm de gelir.

Terminalde kurulumu doğrulayın:

node --version
npm --version

Ardından merhaba.js adlı bir dosya oluşturup şu kodu yazın:

const sayilar = [4, 8, 15, 16, 23, 42];
const toplam = sayilar.reduce((sonuc, sayi) => sonuc + sayi, 0);

console.log('Toplam:', toplam);

Dosyayı terminalden node merhaba.js komutuyla çalıştırabilirsiniz. Buradaki toplam işleminin matematiksel gösterimi şöyledir:

VS Code’u hazırlamak

VS Code’u kurduktan sonra bir proje klasörü açın. Daha konforlu kod yazmak için şu eklentiler yararlıdır:

Prettier kurulduktan sonra ayarlardan Format On Save seçeneğini etkinleştirebilirsiniz. Böylece dosyayı her kaydettiğinizde girintiler ve boşluklar otomatik düzeltilir.

Canlı sunucuyla küçük proje

Proje klasöründe index.html ve app.js dosyaları oluşturun. HTML dosyanızın kapanış body etiketinden önce JavaScript’i bağlayın:

<button id="dugme">Tıkla</button>
<script src="app.js"></script>

app.js içinde düğmeye davranış kazandırın:

const dugme = document.querySelector('#dugme');
let sayac = 0;

dugme.addEventListener('click', () => {
  sayac += 1;
  dugme.textContent = `${sayac} kez tıklandı`;
});

index.html dosyasına sağ tıklayıp Open with Live Server seçeneğini kullanın. Sayfa genellikle localhost:5500 adresinde açılır ve kaydettiğiniz değişiklikler otomatik yenilenir. Artık konsol deneylerinden dosya tabanlı projelere geçmeye hazırsınız: tarayıcı arayüzü yönetir, Node.js araçları çalıştırır, VS Code ise tüm ekibi aynı masada buluşturur.

Statik ve dinamik tipleme nedir?

C++ gibi statik tipli dillerde değişkenin türü derleme aşamasında belirlenir. Örneğin int olarak tanımlanmış bir değişkene metin atamak derleme hatası üretir. JavaScript’te ise değişkenler belirli türlerde değerleri saklayan sabit kutular değil, farklı değerlere yöneltilebilen etiketler gibidir.

Teorik olarak bir değişkeni zamana bağlı bir eşleme şeklinde düşünebiliriz:

Burada $t$ çalışma zamanındaki anı temsil eder. JavaScript motoru, işlemi gerçekleştirirken değerin güncel türünü inceler.

Değişken değil, değer tür taşır

Aşağıdaki kodda veri değişkeninin kendisine kalıcı bir tür verilmez:

let veri = 42;
console.log(typeof veri); // number

veri = "Merhaba";
console.log(typeof veri); // string

veri = true;
console.log(typeof veri); // boolean

Kod geçerlidir çünkü let, yeniden atamaya izin verir. const ise türü sabitlemez; yalnızca değişkenin başka bir değere yeniden bağlanmasını engeller. Örneğin const liste = [] ile oluşturulan dizinin içeriği değiştirilebilir.

JavaScript’in temel değer türleri string, number, bigint, boolean, undefined, symbol ve null olarak sıralanır. Nesneler, diziler ve fonksiyonlar ise referans davranışı gösteren yapılardır. İlginç bir tarihsel ayrıntı olarak typeof null sonucu "object" döner. Bu, dilin ilk sürümlerinden kalan ve uyumluluk nedeniyle düzeltilemeyen ünlü bir tuzaktır.

Tip dönüşümü ve zorlaması

JavaScript bazı işlemlerde türleri otomatik olarak dönüştürür. Buna type coercion, yani tip zorlama denir:

console.log("5" + 2); // "52"
console.log("5" - 2); // 3
console.log(Number("5") + 2); // 7

İlk işlemde + operatörü metin birleştirmeyi seçer. İkinci işlemde - yalnızca sayısal anlam taşıdığı için "5" sayıya çevrilir. Genel fikir, işlemin uygulanabilmesi için değerlerin ortak bir alana dönüştürülmesidir:

Ancak dönüşüm kuralları her operatörde aynı değildir. Bu nedenle örtük dönüşüme güvenmek yerine Number(), String() ve Boolean() gibi açık dönüşümler kullanmak kodun niyetini anlaşılır kılar.

Eşitlik: == mı, === mi?

Sıkı eşitlik operatörü ===, hem türü hem değeri karşılaştırır. Beklenmeyen dönüşümleri azaltmak için modern JavaScript kodunda genellikle === ve !== tercih edilir.

Dinamik yapı kontrolsüzlük değildir

Dinamik tipleme, kuralların bulunmadığı anlamına gelmez; kontrollerin farklı bir zamanda yapıldığı anlamına gelir. Güvenilir kod için girişleri doğrulamak, typeof, Array.isArray() ve null kontrollerini kullanmak önemlidir. Daha büyük projelerde TypeScript, JavaScript’in üzerine statik analiz katmanı ekleyerek hataları çalıştırmadan önce gösterebilir.

Sonuç olarak JavaScript’in tip sistemi bir sihirbaz değil, çalışma zamanında karar veren hızlı bir hakemdir. Kurallarını öğrendiğinizde esneklik avantaja dönüşür; öğrenmediğinizde ise "5" + 2 size küçük ama unutulmaz bir şaka yapabilir.

``

İlkel ve referans tipleri

JavaScript’in ilkel veri tipleri string, number, bigint, boolean, undefined, symbol ve null değerleridir. Bunlar değiştirilemez, yani immutable değerlerdir. Örneğin bir metni büyük harfe çevirdiğimizde mevcut metin değişmez; yeni bir değer oluşturulur.

Nesneler, diziler ve fonksiyonlar ise referans tipleri olarak anılır. Teknik olarak JavaScript standardı “stack” ve “heap” kullanımını zorunlu kılmaz; bu ayrıntı motora bağlıdır. Bununla birlikte zihinsel model olarak ilkel değerlerin doğrudan, nesnelerin ise bellekteki bir nesneye erişim sağlayan referans üzerinden işlendiğini düşünebiliriz.

let puanA = 10;
let puanB = puanA;
puanB = 20;

console.log(puanA); // 10

const kullaniciA = { ad: "Ada" };
const kullaniciB = kullaniciA;
kullaniciB.ad = "Ece";

console.log(kullaniciA.ad); // "Ece"

İlk bölümde puanB, sayısal değerin bağımsız bir kopyasını alır. İkinci bölümde iki değişken aynı nesneye erişir. Kabaca $A \rightarrow O$ ve $B \rightarrow O$ şeklinde gösterebileceğimiz bu durumda nesne O üzerinde yapılan değişiklik her iki değişkenden de görülebilir.

Coercion nasıl çalışır?

Type coercion, bir değerin işlem sırasında başka bir tipe otomatik dönüştürülmesidir. JavaScript motoru operatörün beklentisine göre ToPrimitive, ToString, ToNumber ve ToBoolean gibi soyut işlemler uygular.

+ operatörü özel davranır: Operandlardan biri primitive dönüşümden sonra metinse birleştirme yapar. -, * ve / ise değerleri genellikle sayıya dönüştürür.

console.log("10" + 5);       // "105"
console.log("10" * 2);       // 20
console.log(Number("10"));   // 10
console.log(String(false));   // "false"
console.log(Boolean([]));     // true

Son üç satır açık dönüşüm yapar. Niyet görünür olduğu için üretim kodunda otomatik dönüşüme güvenmek yerine Number, String ve Boolean kullanmak çoğunlukla daha güvenlidir.

Truthy ve falsy değerler

Koşullarda değerler boolean tipe dönüştürülür. false, 0, -0, 0n, "", null, undefined ve NaN falsy’dir; diğer değerler truthy kabul edilir. Boş dizi ve boş nesnenin de truthy olması sık karşılaşılan bir sürprizdir.

if ([]) {
  console.log("Boş dizi bile truthy!");
}

console.log(Boolean("0")); // true
console.log(Boolean(0));   // false

Eşitlik tuzağı

Gevşek eşitlik operatörü ==, karşılaştırmadan önce dönüşüm yapabilir. Sıkı eşitlik === ise tipler farklıysa doğrudan false döndürür.

console.log(0 == false);  // true
console.log(0 === false); // false
console.log(null == undefined);  // true
console.log(null === undefined); // false

Özetle, referans paylaşımını anlamak beklenmedik nesne değişikliklerini; coercion kurallarını bilmek ise garip görünen işlem sonuçlarını açıklar. Varsayılan tercihi === yapmak ve dönüşümleri açıkça belirtmek, JavaScript motoruyla tahmin oyunu oynamaktan çok daha huzurludur.

Otomatlardan algoritmalara

Antik dünyada “kendi kendine çalışan” nesneler hem mühendislik hem de mitoloji konusuydu. İskenderiyeli Heron’un su, buhar ve karşı ağırlıklarla çalışan düzenekleri; tapınak kapılarını otomatik açabiliyor, küçük gösteriler sahneleyebiliyordu. Bunlar program yazmıyordu ama önemli bir düşünceyi somutlaştırıyordu: Doğru mekanizma kurulursa davranış, insan müdahalesi olmadan tekrar üretilebilir.

Bir otomatın temel mantığını şöyle düşünebiliriz:

Bu ifade modern yazılımın da kalbidir. Makine mevcut durumunu ve girdiyi alır, belirlenmiş kurallarla yeni bir duruma geçer. Antik otomat ile bilgisayar programı arasındaki fark, kuralların pirinç dişliler yerine sembollerle temsil edilmesidir.

Hesaplamayı mekanikleştirmek

1. yüzyılda Leibniz, akıl yürütmenin sembolik bir hesaplamaya dönüştürülebileceğini düşündü. Ünlü hayali kabaca şuydu: İnsanlar tartışmak yerine “hesaplayalım” diyebilmeliydi. 19. yüzyılda Charles Babbage’ın Analitik Makinesi genel amaçlı hesaplama fikrini, Ada Lovelace’ın notları ise makine için işlem dizileri tasarlama anlayışını ortaya koydu.

Bu gelişim birkaç katmanda ilerledi:

Derleyiciler bu hikâyenin sessiz kahramanlarıdır. İlk dönemlerde “makine kodu gerçekten program yazabilir mi?” kuşkusu yaşanıyordu. Grace Hopper’ın öncülük ettiği derleyiciler, insanın daha soyut ifadelerinin otomatik olarak düşük seviyeli komutlara çevrilebileceğini gösterdi.

Kod aramak mı, kod tahmin etmek mi?

Klasik program sentezi, belirli koşulları sağlayan programı bir arama uzayında bulmaya çalışır. Örneğin hedefimiz $f(x)=2x+1$ davranışını üreten ifadeyi keşfetmek olsun:

# Küçük bir program sentezleyici: aday ifadeleri test eder.
adaylar = [
    lambda x: x + 1,
    lambda x: 2 * x,
    lambda x: 2 * x + 1,
    lambda x: x * x
]

ornekler = [(0, 1), (2, 5), (5, 11)]

for aday in adaylar:
    if all(aday(girdi) == beklenen for girdi, beklenen in ornekler):
        print("Uygun program bulundu:", aday)

Bu yaklaşım doğrulanabilir örneklere dayanır. LLM ise çoğunlukla dev bir kod ve metin koleksiyonundan öğrendiği olasılık dağılımını kullanır. Bir sonraki kod parçasını yaklaşık olarak

olasılığına göre seçer. Yani LLM, geleneksel anlamda bütün seçenekleri deneyip matematiksel olarak doğru programı bulmaz; bağlama en uygun görünen devamı üretir.

Aynı rüya, yeni motor

Uzman sistemler kuralları, genetik programlama evrimi, program sentezi kısıt çözmeyi, LLM’ler ise istatistiksel öğrenmeyi kullandı. Yöntemler değişse de amaç aynı kaldı: İnsan “ne” istediğini söylesin, makine “nasıl” yapılacağını oluştursun.

Fakat akıcı kod doğruluk garantisi değildir. Üretilen program test edilmeli, güvenlik açıkları incelenmeli ve gereksinimlerle karşılaştırılmalıdır. Bugünün kod asistanı bağımsız bir yazılım tanrısından çok, inanılmaz hızlı fakat zaman zaman kendinden fazla emin bir çıraktır. Otomatik programlama rüyası gerçekleşiyor; sadece hayal edildiği gibi tek tuşla değil, insan ile makinenin birlikte düşünmesiyle.

``

Kısa bir tarih yolculuğu

JavaScript’in ilk sürümlerinde değişken tanımlamak için yalnızca var bulunuyordu. Dil başlangıçta küçük tarayıcı betikleri için tasarlandığından blok kapsamı önemli bir ihtiyaç sayılmamıştı. Uygulamalar büyüyünce var davranışları hata kaynağına dönüştü. ECMAScript 2015, yani ES6 ile let ve const eklenerek modern kapsam modeli güçlendirildi.

Fonksiyon ve blok kapsamı

Fonksiyon kapsamı, bir değişkenin tanımlandığı fonksiyonun tamamında erişilebilir olmasıdır. Blok kapsamı ise erişimi { ve } arasındaki bölgeyle sınırlar. if, for ve while gövdeleri birer blok oluşturur.

function kapsamTesti() {
  if (true) {
    var eskiDegisken = "var dışarı çıkabilir";
    let modernDegisken = "let blokta kalır";
    const sabitDegisken = "const da blokta kalır";
  }

  console.log(eskiDegisken); // Çalışır
  // console.log(modernDegisken); // ReferenceError
  // console.log(sabitDegisken);  // ReferenceError
}

Burada var, if bloğunu önemsemez ve kapsamTesti fonksiyonuna bağlanır. let ile const ise yalnızca tanımlandıkları blokta yaşar. Bu sınır, aynı değişken adının yanlışlıkla başka bir değeri ezmesini önler.

Kapsamları iç içe halkalar gibi düşünebiliriz. JavaScript bir ismi önce mevcut kapsamda, ardından dış kapsamlarda arar. İç içe kapsam sayısı $n$ ise en kötü durumda kavramsal olarak $n$ ortam kontrol edilir:

Bu ifade çoğunlukla performans hesabından ziyade sözcüksel kapsam zincirini anlamak için yararlıdır.

Hoisting ve geçici ölü bölge

Üç anahtar kelimeyle oluşturulan bildirimler de kapsamın başında kayda alınır; fakat erişim davranışları aynı değildir. var, bildirim satırından önce undefined değerini verir. let ve const ise bildirim çalıştırılana kadar Temporal Dead Zone, yani geçici ölü bölge içindedir.

console.log(puan); // undefined
var puan = 10;

// console.log(seviye); // ReferenceError
let seviye = 2;

Bu nedenle “let hoist edilmez” sözü teknik olarak eksiktir. Bildirim bilinir, fakat erken erişime izin verilmez. Böylece değer oluşturulmadan önce kullanma hataları sessizce ilerlemek yerine görünür hâle gelir.

const gerçekten sabit mi?

const, değerin tamamen değişmez olduğunu değil, değişken bağının yeniden atanamayacağını söyler. Bir nesnenin içeriği hâlâ değiştirilebilir.

const kullanici = { ad: "Ada", puan: 10 };
kullanici.puan += 5; // Geçerli: nesnenin alanı değişiyor

// kullanici = {}; // TypeError: bağ yeniden atanamaz

Gerçek değişmezlik gerekiyorsa Object.freeze() gibi ek yöntemler kullanılmalıdır. Ancak bu yöntem varsayılan olarak yalnızca yüzeysel dondurma yapar.

Hangisini seçmeliyiz?

Modern JavaScript’te güvenli başlangıç noktası const kullanmaktır. Değer daha sonra yeniden atanacaksa let tercih edilir. var ise eski kodları anlamak veya özel uyumluluk ihtiyaçları dışında genellikle kullanılmamalıdır.

const maksimum = 100;
let toplam = 0;

for (let i = 0; i < maksimum; i++) {
  toplam += i;
}

Bu yaklaşım niyeti açıkça gösterir: maksimum değişmeyecek, toplam ve sayaç ise güncellenecektir. Kısacası const varsayılanınız, let bilinçli alternatifiniz, var ise JavaScript tarih müzesindeki dikkatle incelenmesi gereken eseriniz olsun.

Nesne nedir?

Nesne, ilişkili verileri ve bazı programlama dillerinde bu veriler üzerinde çalışan davranışları bir arada tutan yapıdır. Örneğin gerçek dünyadaki bir otomobilin markası, hızı ve rengi vardır; ayrıca hızlanabilir veya fren yapabilir. Yazılım modelinde özellikler anahtar-değer çiftleriyle, davranışlar ise metotlarla temsil edilebilir.

Matematiksel açıdan basitleştirilmiş bir nesneyi, anahtarlar kümesinden değerlere yapılan bir eşleme gibi düşünebiliriz:

Burada $K$ anahtarlar kümesini, $V$ ise olası değerleri gösterir. Örneğin renk anahtarı kırmızı değerine eşlenebilir. Bir nesnedeki çiftlerin sayısı $n$ ise yapı kabaca şöyle ifade edilir:

JavaScript ile basit bir otomobil nesnesi oluşturalım:

const otomobil = {
  marka: "Volta",
  renk: "kırmızı",
  hiz: 0,
  elektrikli: true,
  hizlan(miktar) {
    this.hiz += miktar;
  }
};

otomobil.hizlan(30);
console.log(otomobil.hiz); // 30

Bu kodda marka, renk, hiz ve elektrikli birer özellik; hizlan ise nesnenin durumunu değiştiren bir metottur. this.hiz, işlemin ilgili otomobil nesnesinin hızına uygulanmasını sağlar. Böylece veri ile davranış aynı model altında buluşur.

Anahtar-değer yaklaşımının gücü

Düz değişkenler kullansaydık otomobilMarka, otomobilRenk ve otomobilHiz gibi giderek uzayan isimlere ihtiyaç duyardık. Nesne yapısı, bu bilgileri ortak bir bağlamda toplar.

Nesneler iç içe de geçebilir. Bir kullanıcının adresi başka bir nesne, siparişleri ise nesnelerden oluşan bir dizi olabilir. Bu sayede karmaşık ilişkiler, ağaç benzeri bir yapı kazanır.

const kullanici = {
  id: 42,
  ad: "Ada",
  adres: {
    sehir: "İzmir",
    postaKodu: "35000"
  },
  roller: ["editor", "yazar"]
};

console.log(kullanici.adres.sehir); // İzmir

Nokta gösterimi, iç içe geçmiş verilere okunabilir biçimde erişir. Dinamik bir anahtar kullanılacaksa kullanici[alanAdi] biçimindeki köşeli parantez gösterimi tercih edilir.

JSON ile yapısal bağ

JSON, açılımıyla JavaScript Object Notation, nesne benzeri verileri metin olarak temsil eden bağımsız bir veri formatıdır. Bir API’nin sunucudan tarayıcıya kullanıcı bilgisi göndermesi buna tipik örnektir.

{
  "id": 42,
  "ad": "Ada",
  "aktif": true,
  "roller": ["editor", "yazar"],
  "adres": {
    "sehir": "İzmir"
  }
}

JSON ile JavaScript nesnesi akrabadır fakat aynı şey değildir:

Bir nesneyi JSON metnine çevirmeye serileştirme, JSON metnini yeniden kullanılabilir nesneye dönüştürmeye ayrıştırma denir:

const jsonMetni = JSON.stringify(kullanici);
const geriDonenNesne = JSON.parse(jsonMetni);

console.log(geriDonenNesne.ad); // Ada

Bu dönüşüm sırasında fonksiyonlar ve undefined gibi JSON tarafından desteklenmeyen değerler korunmaz. Ayrıca güvenilmeyen bir kaynaktan gelen verinin biçimi mutlaka doğrulanmalıdır; geçerli JSON olması, içeriğinin güvenli veya iş kurallarına uygun olduğu anlamına gelmez.

Sonuç olarak nesneler gerçek dünya varlıklarını anlamlı özelliklerle modeller, anahtar-değer düzeni verilere isim kazandırır, JSON ise bu yapıyı farklı diller ve sistemler arasında taşınabilir hâle getirir. Kısacası nesne sahnedeki oyuncuysa JSON onun seyahat çantasıdır.

Operatörlerin Temel Mantığı

Operatör, bir veya daha fazla değer üzerinde işlem yapan semboldür. Örneğin 5 + 3 ifadesinde + operatör, 5 ve 3 ise operand olarak adlandırılır. Matematiksel açıdan bu işlem $f(a,b)=a+b$ biçiminde düşünülebilir.

Aritmetik operatörler

Aritmetik operatörler sayısal hesaplamalarda kullanılır:

Kalan operatörü özellikle bir sayının çift olup olmadığını anlamakta kullanışlıdır. Bir $n$ sayısı için $n \bmod 2=0$ ise sayı çifttir.

const sayi = 14;
const ciftMi = sayi % 2 === 0;
console.log(ciftMi); // true

Bu kod, bölme işleminin sonucuna değil kalanına bakarak sayı hakkında karar verir.

Karşılaştırma ve mantıksal operatörler

Karşılaştırma operatörleri true veya false üretir. Mantıksal operatörler ise birden fazla koşulu birleştirir.

A && B ifadesi yalnızca iki koşul da doğruysa doğrudur. A || B için tek bir doğru yeterlidir. Bu davranışlar sırasıyla matematikteki $A \land B$ ve $A \lor B$ ifadelerine karşılık gelir.

Karar Yapıları

if-else, koşula göre farklı kodların çalıştırılmasını sağlar:

const yas = 20;
const biletiVar = true;

if (yas >= 18 && biletiVar) {
  console.log("Etkinliğe girebilirsiniz.");
} else if (yas < 18) {
  console.log("Yaş sınırı karşılanmıyor.");
} else {
  console.log("Bilet gerekli.");
}

Burada koşullar yukarıdan aşağıya değerlendirilir ve ilk doğru dal çalıştırılır. Çok sayıda sabit değerin karşılaştırıldığı durumlarda switch-case daha okunaklı olabilir:

const rol = "editor";

switch (rol) {
  case "admin":
    console.log("Tam yetki verildi.");
    break;
  case "editor":
    console.log("İçerik düzenleme yetkisi verildi.");
    break;
  default:
    console.log("Salt okunur erişim verildi.");
}

break, eşleşen bölüm tamamlandıktan sonra diğer seçeneklere geçilmesini önler.

Döngü Mekanizmaları

Döngüler, bir işlemi koşul sağlandığı sürece tekrarlar. for, tekrar sayısı biliniyorsa; while, tekrarın bir koşula bağlı olduğu durumlarda tercih edilir.

let toplam = 0;

for (let i = 1; i <= 5; i++) {
  toplam += i;
}

console.log(toplam); // 15

Bu döngü $1+2+3+4+5=15$ toplamını hesaplar. Aynı fikir while ile şöyle kurulabilir:

let enerji = 3;

while (enerji > 0) {
  console.log(`Kalan enerji: ${enerji}`);
  enerji--;
}

Döngülerde koşulun bir noktada yanlış olması gerekir; aksi hâlde sonsuz döngü oluşur. break döngüyü tamamen sonlandırırken continue yalnızca mevcut turu atlar. Doğru operatörü doğru kontrol yapısıyla birleştirmek, hem okunabilir hem de hatalara karşı dayanıklı programların temelidir.

``

Sosyal temas neden teknik bir meseledir?

Programlama bireysel yapılan bir etkinlik gibi görünse de yazılım geliştirme, yoğun biçimde sosyal geri bildirime dayanır. Bir meslektaşa “Bu yaklaşım sana da garip geliyor mu?” diye sormak, yalnızca bilgi istemek değildir. Bu soru düşünceyi dışarı çıkarır, varsayımları görünür hâle getirir ve zihinsel yükü paylaşır.

Bilişsel yükü basitleştirilmiş biçimde şöyle gösterebiliriz:

Burada problem karmaşıklığı ve kullanılan araçların yükü sabit kalsa bile sosyal destek azaldığında hissedilen toplam yük artabilir. Ofiste beş dakikalık bir konuşmayla çözülebilecek belirsizlik, uzaktan çalışan bir geliştiricinin zihninde saatlerce dönebilir.

Kod yazma alışkanlıkları nasıl değişiyor?

İzolasyon her yazılımcıyı aynı biçimde etkilemez. Bazıları sessizlik sayesinde “akış” durumuna daha kolay girerken bazıları görünmez bir tekrar döngüsüne yakalanır: hata mesajını oku, aynı kodu değiştir, yeniden çalıştır ve neden ilerlenemediğini kimseye anlatma.

İzolasyon, geliştiriciyi daha bağımsız yapabilir; fakat bağımsızlık ile içe kapanma aynı şey değildir. Bağımsız geliştirici önce araştırır, sonra bulgularını paylaşır. İçe kapanan geliştirici ise yardım istemeyi başarısızlık gibi yorumlayabilir.

Problem çözme tarzındaki dönüşüm

Sosyal etkileşim azaldığında iç konuşma güçlenir. Bunun olumlu tarafı, kişinin kendi düşünme sürecini daha iyi izlemesidir. Olumsuz tarafıysa doğrulanmamış varsayımların yankı odasına dönüşmesidir. Bu nedenle “kauçuk ördek hata ayıklama” yöntemi uzaktan çalışmada şaşırtıcı derecede değerlidir: Problemi bir nesneye, not dosyasına veya boş sohbet penceresine adım adım anlatmak.

Küçük bir günlük aracı da düşünce kalıplarını görünür kılabilir:

from datetime import datetime

problem = input("Takıldığın problem nedir? ")
hypothesis = input("Şu anki hipotezin nedir? ")
next_step = input("Deneyeceğin en küçük adım nedir? ")

with open("debug-journal.md", "a", encoding="utf-8") as file:
    file.write(
        f"\n## {datetime.now():%Y-%m-%d %H:%M}\n"
        f"- Problem: {problem}\n"
        f"- Hipotez: {hypothesis}\n"
        f"- Sonraki adım: {next_step}\n"
    )

Bu kod problemi çözmez; düşünceyi yapılandırır. Günlükte aynı hipotezin tekrarlandığını görmek, yardım isteme zamanının geldiğini gösterebilir.

Zihinsel haritayı yeniden dengelemek

Sağlıklı uzaktan çalışma için iletişim yalnızca toplantı takvimine bırakılmamalıdır. Kısa eşli programlama oturumları, yazılı günlük durum paylaşımları ve gündemsiz sanal kahveler farklı ihtiyaçları karşılar. Ayrıca yardım istemek için bir eşik belirlenebilir: Örneğin 30 dakika boyunca yeni kanıt üretilmediyse problem özetlenip ekip kanalında paylaşılır.

Verimliliği yalnızca yazılan kod satırıyla ölçmek de yanıltıcıdır. Daha gerçekçi bir yaklaşım şöyledir:

Saatlerce yalnız çalışmak kısa vadede üretken görünebilir; ancak yorgunluk ve yeniden işleme arttığında gerçek verim düşer. Uzaktan çalışan yazılımcının ihtiyacı sürekli çevrim içi olmak değil, gerektiğinde erişilebilir insan bağlantıları kurmaktır. Çünkü bazen en zor hata kod tabanında değil, “Bunu tek başıma çözmeliyim” varsayımında saklanır.