Array Metotlarını Parçalamak: Koleksiyon Üzerinde Adım Adım Simülasyon

Yüzeyde Basit, İçeride Akış

JavaScript’te bir array metodu çağırdığında, genellikle birkaç satırda sonucu elde edersin. Bu durum, işlemin basit olduğu izlenimini oluşturabilir.

Ancak gerçekte bu metotlar, tek bir işlemden ibaret değildir. Her biri, veri üzerinde çalışan adım adım ilerleyen bir işlem zinciridir.

Bir array metodu, veriyi olduğu gibi bırakmaz. Elemanları tek tek ele alır, her biri üzerinde belirli kurallara göre işlem yapar ve bu işlemlerin sonucunu yeni bir yapı haline getirir.

Örneğin bir dönüşüm işlemi, tek bir adım değildir; her elemanın sırayla işlendiği, yeni değerlerin üretildiği bir süreçtir.

Bu süreçte sistem, her adımda bir karar verir: bu eleman değiştirilecek mi, filtrelenecek mi, yoksa olduğu gibi bırakılacak mı?

Simülasyon Perspektifi

Bu bölümde yapacağın şey, hazır metotları kullanmak değil; onların veri üzerinde nasıl çalıştığını adım adım yeniden inşa etmektir.

Yani sadece sonucu görmek yerine, verinin nasıl işlendiğini ve nasıl dönüştürüldüğünü takip edeceksin.

Bu yaklaşım seni pasif bir kullanıcı olmaktan çıkarır ve sistemi yöneten bir bakış açısı kazandırır.

Artık bir metodu sadece kullanmazsın; onun veri üzerindeki etkisini, davranışını ve sınırlarını da analiz edebilirsin.

Unutma: Bir array metodunu anlamak, sonucu görmek değil; verinin nasıl işlendiğini açıklayabilmektir.

Tek Satırın Arkasındaki Döngü

Bir array metodu çağırdığında, genellikle tek bir fonksiyon ile sonucu elde edersin. Ancak bu tek satırın arkasında, çoğu zaman gizli bir döngü çalışır.

Sistem, array içerisindeki elemanları tek tek dolaşır ve her eleman üzerinde belirli bir işlem uygular.

Bu işlem bazen bir dönüşüm, bazen bir filtreleme, bazen de bir biriktirme olabilir.

Yani bir array metodu aslında, kontrol edilen bir döngü ve bu döngü içerisinde çalışan bir işlem mantığıdır.

Temel İşleyiş Mantığı

Bir array metodu çalıştığında, sistem öncelikle boş bir yapı oluşturur. Bu yapı, yapılacak işleme göre değişebilir: yeni bir array, tek bir değer ya da farklı bir sonuç olabilir.

Ardından sistem, array’in ilk elemanından başlayarak sırayla ilerler.

Her eleman için belirli bir işlem uygulanır ve elde edilen sonuç, oluşturulan yeni yapıya eklenir ya da işlenir.

Bu süreç, tüm elemanlar işlenene kadar devam eder.

Sonuç olarak, başlangıçtaki veriden farklı, işlenmiş ve yeniden oluşturulmuş bir yapı elde edilir.

Neden Bu Önemli?

Array metotlarını anlamak, yalnızca bu metotları kullanabilmek değildir. Asıl önemli olan, bu metotların arkasındaki döngü ve işlem mantığını kavrayabilmektir.

Çünkü bu mantık, sadece hazır fonksiyonlarda değil; kendi yazacağın algoritmalarda da karşına çıkar.

Bu bakış açısı sayesinde, karmaşık görünen işlemleri küçük ve yönetilebilir adımlara bölebilirsin.

Unutma: Array metotlarını öğrenmek, fonksiyon ezberlemek değil; veri üzerinde nasıl işlem yapılacağını öğrenmektir.

Hepsi Aynı Değil

Array metotları yüzeyde benzer görünse de, aslında farklı amaçlara hizmet eden yapılardır.

Bazı metotlar veriyi dönüştürür, bazıları belirli elemanları seçer, bazıları ise tüm veriyi tek bir sonuca indirger.

Bu farkları anlamadan metotları kullanmak, doğru aracı yanlış problemde kullanmaya neden olabilir.

Bu nedenle array metotlarını, yaptıkları iş türüne göre sınıflandırmak öğrenme sürecini çok daha net hale getirir.

3 Temel Kategori

Array metotlarını genel olarak üç ana kategori altında inceleyebiliriz: dönüşüm, filtreleme ve biriktirme.

Bu kategoriler, verinin nasıl işlendiğini anlamak için temel bir çerçeve sunar.

Her kategori, veri üzerinde farklı bir işlem türünü temsil eder ve farklı sonuçlar üretir.

1. Dönüşüm (Transformation)

Bu tür metotlar, her elemanı alır ve onu yeni bir değere dönüştürür.

Eleman sayısı değişmez; ancak her elemanın içeriği farklı hale gelir.

Yani sistem, aynı yapı üzerinde yeni bir versiyon üretir.

Bu kategori, veriyi yeniden şekillendirmek için kullanılır.

2. Filtreleme (Filtering)

Bu tür metotlar, her elemanı kontrol eder ve belirli koşullara göre seçim yapar.

Koşulu sağlayan elemanlar alınır, diğerleri dışarıda bırakılır.

Bu nedenle sonuç, başlangıçtaki array’den daha küçük olabilir.

Sistem burada, veriyi azaltarak daha anlamlı hale getirir.

3. Biriktirme (Reduction)

Bu tür metotlar, tüm elemanları işleyerek tek bir sonuç üretir.

Bu sonuç bir sayı, string ya da farklı bir veri türü olabilir.

Sistem burada, tüm veriyi tek bir değerde toplar.

Bu yaklaşım, veri özetleme ve sonuç üretme işlemlerinde kullanılır.

Neden Bu Ayrım Önemli?

Bu kategorileri anlamak, doğru problemi doğru yöntemle çözmeni sağlar.

Artık bir metot gördüğünde, onun ne yaptığını tahmin edebilirsin: veri mi değişiyor, eleman mı seçiliyor, yoksa sonuç mu üretiliyor?

Bu bakış açısı, sadece mevcut metotları anlamanı değil; kendi algoritmalarını tasarlamanı da kolaylaştırır.

Tek Tek İşleme

map metodu, array içerisindeki her elemanı tek tek ele alır ve üzerinde belirli bir işlem uygular.

Bu işlem sonucunda her eleman yeni bir değere dönüşür ve bu değerler bir araya getirilerek yeni bir array oluşturulur.

Bu süreçte dikkat edilmesi gereken nokta, eleman sayısının değişmemesidir. Yani map, veriyi azaltmaz veya çoğaltmaz; sadece dönüştürür.

Bu nedenle map, veri üzerinde sistematik bir dönüşüm uygulayan bir yapı olarak düşünülebilir.

Simülasyon Mantığı

Simülasyon sürecinde sistem, boş bir array oluşturarak başlar.

Ardından mevcut array’in ilk elemanından başlayarak sırayla ilerler.

Her eleman için bir işlem uygulanır ve elde edilen yeni değer, oluşturulan array’e eklenir.

Bu işlem tüm elemanlar için tekrar edilir ve sonunda tamamen yeni bir array elde edilir.

Orijinal array bu süreçte değişmez; sistem yalnızca yeni bir yapı üretir.

Mantıksal Kazanım

map metodunu anlamak, veri üzerinde toplu dönüşüm yapabilmeyi öğrenmektir.

Bu yaklaşım sayesinde, manuel döngüler yazmadan daha okunabilir ve düzenli kodlar oluşturabilirsin.

map, modern JavaScript'te veri işleme süreçlerinin en temel yapı taşlarından biridir.

// Amaç: Her elemanı dönüştürerek yeni bir array oluşturmak

function mapSim(arr, callback) {

  if (!arr) return [];
  let result = [];

  for (let i = 0; i < arr.length; i++) {

    const newValue = callback(arr[i], i);
    result.push(newValue);
  }
  return result;
}


// Test
const numbers = [1, 2, 3];
const doubled = mapSim(numbers, (num) => num * 2);
console.log(doubled);
// [2, 4, 6]

Seçim Mantığı

filter metodu, array içerisindeki elemanları tek tek kontrol eder ve belirli bir koşula göre seçim yapar.

Her eleman için bir test uygulanır ve bu testin sonucu, elemanın yeni array’e dahil edilip edilmeyeceğini belirler.

Bu süreçte bazı elemanlar alınır, bazıları ise tamamen dışarıda bırakılır.

Bu nedenle filter, veriyi azaltarak daha anlamlı bir alt küme oluşturur.

Simülasyon Mantığı

Sistem, boş bir array oluşturarak başlar.

Ardından mevcut array’in elemanları üzerinde sırayla ilerler.

Her eleman için bir koşul kontrol edilir.

Eğer eleman bu koşulu sağlıyorsa, yeni array’e eklenir; sağlamıyorsa tamamen atlanır.

Bu işlem tüm elemanlar için tekrar edilir ve sonuç olarak filtrelenmiş yeni bir array elde edilir.

Mantıksal Kazanım

filter metodunu anlamak, veri üzerinde seçim yapmayı öğrenmektir.

Bu yaklaşım sayesinde, gereksiz verileri ayıklayabilir ve sadece ihtiyacın olan kısmı işleyebilirsin.

filter, veri temizleme ve veri seçme süreçlerinde en temel araçlardan biridir.

                            // Amaç: Koşula uyan elemanları seçerek yeni bir array oluşturmak

function filterSim(arr, callback) {

  if (!arr) return [];
  let result = [];
  for (let i = 0; i < arr.length; i++) {

    if (callback(arr[i], i)) {
      result.push(arr[i]);
    }
  }

  return result;
}


// Test
const numbers = [1, 2, 3, 4, 5];
const evenNumbers = filterSim(numbers, (num) => num % 2 === 0);
console.log(evenNumbers);
// [2, 4]

Tek Sonuca İndirgeme

reduce metodu, array içerisindeki tüm elemanları işleyerek tek bir sonuç üretir.

Bu sonuç bir sayı, string ya da farklı bir veri yapısı olabilir. Önemli olan nokta, çok sayıda verinin tek bir değere indirgenmesidir.

Bu işlem sırasında sistem, bir “biriktirici” (accumulator) kullanır.

Her adımda mevcut değer ile biriktirilen sonuç birleştirilir ve yeni bir birikim oluşturulur.

Bu nedenle reduce, veriyi tek bir noktada toplayan ve anlamlandıran bir yapı olarak düşünülebilir.

Simülasyon Mantığı

Sistem başlangıçta bir başlangıç değeri (initial value) belirler.

Ardından array’in elemanları üzerinde sırayla ilerler.

Her adımda, mevcut eleman ile biriktirilen değer bir araya getirilir ve yeni bir sonuç elde edilir.

Bu yeni sonuç, bir sonraki adımda tekrar kullanılır.

Süreç tüm elemanlar işlenene kadar devam eder ve sonunda tek bir değer elde edilir.

Mantıksal Kazanım

reduce metodunu anlamak, veri üzerinde biriktirme ve sonuç üretme mantığını kavramaktır.

Bu yaklaşım sayesinde, toplam alma, sayma, gruplayarak toplama gibi birçok işlem tek bir yapı ile gerçekleştirilebilir.

reduce, veri işleme süreçlerinde en esnek ve güçlü araçlardan biridir.

// Amaç: Tüm elemanları birleştirerek tek bir sonuç üretmek

function reduceSim(arr, callback, initialValue) {

  if (!arr) return initialValue;
  let accumulator = initialValue;

  for (let i = 0; i < arr.length; i++) {
    accumulator = callback(accumulator, arr[i], i);
  }
  return accumulator;
}


// Test
const numbers = [1, 2, 3, 4];
const sum = reduceSim(numbers, (acc, num) => acc + num, 0);
console.log(sum);
// 10

Tek Eleman Odaklı Arama

find metodu, array içerisindeki elemanları sırayla kontrol eder ve belirli bir koşula uyan ilk elemanı bulur.

Bu metot, tüm elemanları toplamak yerine yalnızca ilk eşleşmeyi hedefler.

Bu nedenle find, arama işlemini erken sonlandıran bir yapı olarak düşünülebilir.

Eğer uygun bir eleman bulunursa, sistem işlemi durdurur ve sonucu döner. Hiçbir eşleşme bulunamazsa undefined sonucu elde edilir.

Simülasyon Mantığı

Sistem, array’in başından başlayarak elemanları sırayla inceler.

Her eleman için bir koşul kontrol edilir.

Eğer eleman koşulu sağlıyorsa, bu eleman sonuç olarak döndürülür ve işlem sona erer.

Eğer koşul sağlanmazsa, sistem bir sonraki elemana geçer.

Bu süreç, eşleşme bulunana kadar devam eder.

Hiçbir eşleşme yoksa, sistem tüm array’i taradıktan sonra undefined döner.

Mantıksal Kazanım

find metodunu anlamak, veri üzerinde hedefli arama yapabilmeyi öğrenmektir.

Bu yaklaşım sayesinde, gereksiz kontrollerden kaçınabilir ve işlemi daha verimli hale getirebilirsin.

find, özellikle tek bir sonuç arandığında kullanılan en temel metotlardan biridir.

                            // Amaç: Koşula uyan ilk elemanı bulmak

function findSim(arr, callback) {

  if (!arr) return undefined;
  for (let i = 0; i < arr.length; i++) {

    if (callback(arr[i], i)) {
      return arr[i];
    }
  }

  return undefined;
}


// Test
const numbers = [1, 3, 5, 8, 10];
const result = findSim(numbers, (num) => num % 2 === 0);
console.log(result);
// 8

Karar Mekanizması

some ve every metotları, array içerisindeki elemanları kontrol ederek bir karar üretir.

Bu metotlar, veri üretmek yerine doğru ya da yanlış (true / false) sonucu döndürür.

Bu nedenle bu metotlar, veri işlemekten çok veri hakkında karar vermek için kullanılır.

some(): En Az Bir Eleman Yeterli

some metodu, array içerisinde en az bir elemanın verilen koşulu sağlayıp sağlamadığını kontrol eder.

Eğer herhangi bir eleman koşulu sağlıyorsa, sistem işlemi hemen durdurur ve true döner.

Hiçbir eleman koşulu sağlamıyorsa, sonuç false olur.

every(): Tüm Elemanlar Gerekli

every metodu ise, tüm elemanların verilen koşulu sağlayıp sağlamadığını kontrol eder.

Eğer herhangi bir eleman koşulu sağlamazsa, sistem işlemi durdurur ve false döner.

Tüm elemanlar koşulu sağlıyorsa, sonuç true olur.

Mantıksal Fark

some ve every arasındaki temel fark, kararın nasıl verildiğidir.

some, tek bir olumlu durum ararken; every, tüm elemanların doğru olmasını bekler.

Bu fark, veri kontrolü ve doğrulama işlemlerinde kritik bir rol oynar.

// some → en az bir true
function someSim(arr, callback) {
  for (let i = 0; i < arr.length; i++) {
    if (callback(arr[i], i)) {
      return true;
    }
  }
  return false;
}


// every → hepsi true
function everySim(arr, callback) {

  for (let i = 0; i < arr.length; i++) {
    if (!callback(arr[i], i)) {
      return false;
    }
  }
  return true;
}

// Test
const numbers = [2, 4, 6];
console.log(someSim(numbers, (n) => n > 5));   // true
console.log(everySim(numbers, (n) => n % 2 === 0)); // true

Tek Adım Değil, Süreç

Şimdiye kadar her array metodunu tek başına inceledik. Ancak gerçek dünyada veri işlemleri, genellikle tek bir adımda gerçekleşmez.

Bir veri önce dönüştürülür, ardından belirli kriterlere göre seçilir ve son olarak bir sonuç üretilir.

Bu yaklaşım, pipeline (işlem zinciri) mantığı olarak adlandırılır.

Yani veri, bir işlemden geçerek diğerine aktarılır ve her adımda yeni bir forma dönüşür.

3 Aşamalı İş Akışı

Array pipeline genellikle üç temel adımdan oluşur: dönüşüm, filtreleme ve sonuç üretme.

İlk aşamada veri dönüştürülür. Her eleman yeni bir değere çevrilir.

İkinci aşamada, bu yeni değerler belirli kurallara göre filtrelenir.

Son aşamada ise kalan veriler işlenerek tek bir sonuç elde edilir.

Akış Mantığı

Bu süreçte her metot, bir öncekinin çıktısını girdi olarak alır.

Yani veri, adım adım işlenerek ilerler ve her aşamada daha anlamlı hale gelir.

Bu yapı sayesinde, karmaşık işlemler bile küçük ve yönetilebilir adımlara bölünebilir.

Neden Bu Güçlü?

Pipeline yaklaşımı, kodu daha okunabilir ve anlaşılır hale getirir.

Her adımın görevi bellidir ve bu sayede hata ayıklamak daha kolay olur.

Ayrıca bu yapı, veri işleme süreçlerini standartlaştırır ve tekrar kullanılabilir hale getirir.

Bu nedenle modern JavaScript'te veri işlemleri çoğunlukla bu model üzerine kuruludur.

// Amaç: Simüle edilmiş metotlarla pipeline mantığını görmek

function mapSim(arr, callback) {
  let result = [];
  for (let i = 0; i < arr.length; i++) {
    result.push(callback(arr[i], i));
  }
  return result;
}

function filterSim(arr, callback) {
  let result = [];
  for (let i = 0; i < arr.length; i++) {
    if (callback(arr[i], i)) {
      result.push(arr[i]);
    }
  }
  return result;
}

function reduceSim(arr, callback, initialValue) {
  let acc = initialValue;
  for (let i = 0; i < arr.length; i++) {
    acc = callback(acc, arr[i], i);
  }
  return acc;
}

// Pipeline (SIM)
const numbers = [1, 2, 3, 4, 5];

const step1 = mapSim(numbers, n => n * 2);
// [2, 4, 6, 8, 10]

const step2 = filterSim(step1, n => n > 5);
// [6, 8, 10]

const result = reduceSim(step2, (acc, n) => acc + n, 0);
// 24

console.log(result);