String Metotlarını Parçalamak: Adım Adım Simülasyon

Yüzeyde Basit, İçeride Süreç

JavaScript’te bir string metodu çağırdığında, genellikle tek bir satırda sonucu alırsın. Bu durum, işlemin oldukça basit olduğu izlenimini yaratır.

Ancak bu görünüm aldatıcıdır. Çünkü arka planda çalışan süreç, tek bir işlem değil; birden fazla adımın ardışık olarak yürütüldüğü bir akıştır.

Bir string metodu, veriyi olduğu gibi kabul edip sonucu üretmez. Onu analiz eder, parçalara ayırır ve her parçayı belirli kurallara göre işler.

Örneğin bir karşılaştırma işlemi, tek bir kontrol değildir; her karakterin sırayla incelendiği, eşleşme mantığına göre ilerleyen bir süreçtir.

Bu süreçte sistem, her adımda bir karar verir: devam mı etmeli, yoksa işlemi sonlandırmalı mı? İşte bu karar mekanizması, metotların gerçek davranışını belirler.

Simülasyon Perspektifi

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

Yani bir fonksiyonun sonucunu almak yerine, o sonuca nasıl ulaşıldığını adım adım takip edeceksin.

Bu yaklaşım, seni kullanıcı konumundan çıkarıp sistemin içine yerleştirir. Artık dışarıdan bakan biri değil, süreci yöneten biri gibi düşünmeye başlarsın.

Bu sayede bir metodu sadece kullanmakla kalmaz, onun sınırlarını, davranışlarını ve olası durumlarını da anlayabilirsin.

Unutma: Bir metodu gerçekten anlamak, onu çağırabilmek değil; nasıl çalıştığını açıklayabilmektir.

StartsWith Neyi Kontrol Eder?

JavaScript’te startsWith() metodu, bir string ifadenin belirli bir karakter dizisi ile başlayıp başlamadığını kontrol eder.

Yüzeyde bu işlem oldukça basit görünür: bir metin verilir, bir başlangıç değeri kontrol edilir ve sonuç olarak true veya false elde edilir.

Ancak bu sonuç, tek bir karşılaştırma ile değil; karakterler üzerinde ilerleyen adım adım bir süreç ile üretilir.

Simülasyon İçin Gerekenler

Bu metodu simüle edebilmek için, sistemin ihtiyaç duyduğu temel bileşenleri belirlememiz gerekir.

İlk olarak elimizde bir ana metin (string) bulunur. Bu metin, üzerinde işlem yapılacak olan veri kaynağıdır.

İkinci olarak kontrol edilecek ifade, yani başlangıçta aranacak karakter dizisi tanımlanır.

Bunun yanında, sistemin ilerleyebilmesi için bir takip mekanizmasına ihtiyacımız vardır. Bu mekanizma genellikle bir indeks üzerinden ilerler ve karakterleri sırayla karşılaştırır.

Son olarak, sistemin ne zaman duracağını belirleyen bir karar yapısı bulunur. Bu yapı, eşleşme başarısız olduğunda işlemi sonlandırır veya tüm karakterler eşleştiğinde sonucu üretir.

Adım Adım Çalışma Mantığı

Simülasyon süreci, başlangıç karakterinden itibaren ilerleyen bir karşılaştırma akışı ile başlar.

Sistem, ana metnin ilk karakteri ile aranan ifadenin ilk karakterini karşılaştırır.

Eğer bu iki karakter eşleşirse, sistem bir sonraki karaktere geçer ve aynı işlemi tekrar eder.

Bu süreç, iki durumdan biri gerçekleşene kadar devam eder:

Eğer herhangi bir adımda karakterler eşleşmezse, sistem işlemi durdurur ve sonuç olarak false üretir.

Eğer tüm karakterler sırasıyla eşleşirse, bu durumda sistem true sonucunu üretir.

Simülasyonun Temel Mantığı

Bu süreci simüle ederken, aslında bir döngü ve karşılaştırma mekanizması kurmuş oluruz.

Sistem, indeks üzerinden ilerler, her adımda karakterleri kontrol eder ve bir eşleşme durumuna göre karar verir.

Bu yapı, basit görünmesine rağmen birçok string metodunun temelini oluşturur.

Bu nedenle startsWith simülasyonu, sadece tek bir metodu anlamak değil; karakter tabanlı işlem mantığını kavramak için önemli bir adımdır.

// Amaç: Bir string ifadenin belirli bir değer ile başlayıp başlamadığını kontrol etmek

function startsWithSim(str, search) {

  // 1. Geçersiz veri kontrolü
  if (!str || !search) {
    return false;
  }

  // 2. Eğer aranan ifade, ana metinden uzunsa → imkansız
  if (search.length > str.length) {
    return false;
  }

  // 3. Karakter karakter karşılaştırma başlat
  for (let i = 0; i < search.length; i++) {

    // 4. Her adımda ilgili karakterleri al
    const mainChar = str[i];
    const searchChar = search[i];

    // 5. Eğer herhangi bir karakter eşleşmezse → direkt false
    if (mainChar !== searchChar) {
      return false;
    }
  }

  // 6. Tüm karakterler eşleştiyse → true
  return true;
}


// Test edelim
const sonuc1 = startsWithSim("hello", "he");
const sonuc2 = startsWithSim("hello", "hi");

console.log(sonuc1); // true
console.log(sonuc2); // false

startsWith'ten Daha İleri Bir Adım

startsWith metodunda, karşılaştırma yalnızca string’in başlangıcından yapılır. Bu nedenle sistem sabit bir noktadan ilerler ve kontrol alanı sınırlıdır.

Ancak gerçek arama işlemleri çoğu zaman bu kadar basit değildir. Aranan ifade, string’in herhangi bir noktasında bulunabilir.

includes metodu tam olarak bu ihtiyacı karşılar ve aranan değerin string içerisinde herhangi bir konumda bulunup bulunmadığını kontrol eder.

Bu durum, tek bir karşılaştırma yerine sistemin tüm olası başlangıç noktalarını sırayla denemesini gerektirir.

Yani sistem sadece bir noktaya bakmaz; her karakteri potansiyel bir başlangıç olarak ele alır.

Simülasyon Mantığı

Simülasyon sürecinde sistem, ana string üzerinde soldan sağa doğru ilerler.

Her adımda bulunduğu pozisyonu yeni bir başlangıç noktası olarak kabul eder ve aranan ifade ile karşılaştırma sürecini başlatır.

Bu noktada sistem, aslında iki katmanlı bir süreç yürütür: biri başlangıç noktalarını değiştiren dış akış, diğeri ise karakterleri karşılaştıran iç akıştır.

Eğer herhangi bir başlangıç noktasında tüm karakterler eşleşirse, sistem işlemi anında durdurur ve sonucu üretir.

Ancak eşleşme sağlanamazsa, sistem bir sonraki pozisyona kayar ve aynı süreci tekrar eder.

Bu döngü, tüm olası konumlar denenene kadar devam eder. Eğer hiçbir eşleşme bulunamazsa, sistem arama sürecini tamamlayarak false sonucunu üretir.

// Amaç: Bir string içinde belirli bir ifadenin herhangi bir yerde olup olmadığını bulmak

function includesSim(str, search) {

  // 1. Geçersiz veri kontrolü
  if (!str || !search) {
    return false;
  }

  // 2. Eğer aranan ifade daha uzunsa → bulunamaz
  if (search.length > str.length) {
    return false;
  }

  // 3. Ana string üzerinde ilerle (her karakter başlangıç noktası olabilir)
  for (let i = 0; i <= str.length - search.length; i++) {

    let bulundu = true; // başlangıçta eşleşiyor varsay

    // 4. Aranan ifadeyi karakter karakter kontrol et
    for (let j = 0; j < search.length; j++) {

      const mainChar = str[i + j];
      const searchChar = search[j];

      // 5. Eğer herhangi bir karakter eşleşmezse → bu başlangıç geçersiz
      if (mainChar !== searchChar) {
        bulundu = false;
        break;
      }
    }

    // 6. Eğer tüm karakterler eşleştiyse → bulundu
    if (bulundu) {
      return true;
    }
  }

  // 7. Hiçbir yerde bulunamadı
  return false;
}


// Test edelim
console.log(includesSim("hello world", "wor")); // true
console.log(includesSim("hello world", "abc")); // false

Bulmak Yetmez, Yerini Bilmek Gerekir

includes metodunda, aranan ifadenin string içerisinde bulunup bulunmadığını kontrol ederiz. Bu yaklaşım bize yalnızca bir cevap verir: var ya da yok.

Ancak birçok durumda bu bilgi yeterli değildir. Bir ifadenin sadece var olduğunu bilmek yerine, string içerisinde tam olarak nerede bulunduğunu bilmemiz gerekir.

İşte indexOf metodu, bu noktada devreye girer ve aranan değerin string içerisindeki ilk konumunu tespit eder.

Eğer eşleşme bulunursa, sistem bu eşleşmenin başladığı indeks değerini döndürür. Eğer hiçbir eşleşme yoksa, sistemin özel bir durum değeri olan -1 sonucu üretilir.

Simülasyon Mantığı

indexOf simülasyonu, includes metoduna oldukça benzer bir yapı üzerine kuruludur. Sistem yine ana string üzerinde ilerler ve her karakteri olası bir başlangıç noktası olarak değerlendirir.

Her başlangıç noktasında, aranan ifade ile karakter karakter karşılaştırma yapılır. Bu süreç, eşleşme bulunana kadar devam eder.

Ancak burada önemli bir fark vardır: sistem yalnızca eşleşmenin varlığını değil, eşleşmenin başladığı pozisyonu belirlemeye çalışır.

Bu nedenle, ilk tam eşleşme yakalandığı anda sistem durur ve o anki başlangıç indeksini sonuç olarak döndürür.

Eğer hiçbir başlangıç noktasında eşleşme sağlanamazsa, sistem tüm olasılıkları denedikten sonra sonucu -1 olarak belirler.

Mantıksal Fark

Bu metodu anlamanın en iyi yolu, includes ile arasındaki farkı net bir şekilde kavramaktır.

includes metodu bir doğrulama yapar: “Bu ifade var mı?”

indexOf metodu ise bir konumlandırma yapar: “Bu ifade nerede başlıyor?”

Bu fark küçük gibi görünse de, veri işleme ve algoritma tasarımında çok önemli bir rol oynar.

                            // Amaç: Bir string içinde aranan ifadenin ilk geçtiği konumu bulmak

function indexOfSim(str, search) {

  // 1. Geçersiz veri kontrolü
  if (!str || !search) {
    return -1;
  }

  // 2. Eğer aranan ifade daha uzunsa → bulunamaz
  if (search.length > str.length) {
    return -1;
  }

  // 3. Ana string üzerinde ilerle (her karakter başlangıç olabilir)
  for (let i = 0; i <= str.length - search.length; i++) {

    let bulundu = true;

    // 4. Aranan ifadeyi karakter karakter karşılaştır
    for (let j = 0; j < search.length; j++) {

      const mainChar = str[i + j];
      const searchChar = search[j];

      // 5. Eşleşme bozulursa → bu başlangıç geçersiz
      if (mainChar !== searchChar) {
        bulundu = false;
        break;
      }
    }

    // 6. Eğer tam eşleşme varsa → başlangıç indexini döndür
    if (bulundu) {
      return i;
    }
  }

  // 7. Hiçbir yerde bulunamazsa
  return -1;
}


// Test edelim
console.log(indexOfSim("hello world", "wor")); // 6
console.log(indexOfSim("hello world", "abc")); // -1
                        

Yön Değiştir: Sondan Başla

Şimdiye kadar incelediğimiz string metotlarında, karşılaştırmalar genellikle string’in başlangıcından itibaren yapılır. Sistem soldan sağa ilerler ve karakterleri bu yönde değerlendirir.

Ancak bazı durumlarda kontrolün başlangıç noktası farklıdır. Özellikle bir ifadenin string’in sonunda yer alıp almadığını belirlemek istediğimizde, karşılaştırma yönünü değiştirmemiz gerekir.

endsWith metodu, tam olarak bu ihtiyaca cevap verir ve aranan ifadenin string’in sonunda bulunup bulunmadığını kontrol eder.

Bu yaklaşımda sistem, başlangıçtan değil; string’in sonundan geriye doğru hizalanmış bir karşılaştırma noktası üzerinden çalışır.

Simülasyon Mantığı

Simülasyon sürecinde sistem, aranan ifadenin uzunluğunu dikkate alarak ana string üzerinde sabit bir başlangıç noktası belirler.

Bu başlangıç noktası, string’in son kısmı ile aranan ifadenin birebir hizalanmasını sağlar.

Ardından sistem, bu hizalanmış bölümde karakterleri sırayla karşılaştırır.

Eğer herhangi bir karakter eşleşmezse, sistem işlemi hemen durdurur ve false sonucunu üretir.

Eğer tüm karakterler sırasıyla eşleşirse, bu durumda string’in sonu ile aranan ifade birebir uyumludur ve sonuç true olarak belirlenir.

Mantıksal Fark

startsWith metodu başlangıçtan itibaren kontrol yaparken, endsWith metodu aynı mantığı string’in sonuna uygular.

Bu nedenle algoritma yapısı benzerdir, ancak başlangıç noktası ve indeks hesaplaması farklıdır.

Bu küçük fark, sistemin çalışma yönünü tamamen değiştirir ve geliştiriciye farklı bir bakış açısı kazandırır.

endsWith metodunu anlamak, yalnızca bir metodu öğrenmek değil; aynı problemi farklı bir yönden çözebilmeyi öğrenmektir.

// Amaç: Bir string ifadenin belirli bir değer ile bitip bitmediğini kontrol etmek

function endsWithSim(str, search) {

  // 1. Geçersiz veri kontrolü
  if (!str || !search) {
    return false;
  }

  // 2. Aranan ifade daha uzunsa → imkansız
  if (search.length > str.length) {
    return false;
  }

  // 3. Karşılaştırma başlangıç noktası (sona hizala)
  const startIndex = str.length - search.length;

  // 4. Karakter karakter karşılaştır
  for (let i = 0; i < search.length; i++) {

    const mainChar = str[startIndex + i];
    const searchChar = search[i];

    // 5. Eşleşme bozulursa → false
    if (mainChar !== searchChar) {
      return false;
    }
  }

  // 6. Tüm karakterler eşleştiyse → true
  return true;
}


// Test edelim
console.log(endsWithSim("hello", "lo")); // true
console.log(endsWithSim("hello", "he")); // false

Aramadan Üretime Geçiş

Şimdiye kadar incelediğimiz metotlarda, string üzerinde bir kontrol işlemi gerçekleştiriyorduk. Yani sistem, belirli bir değerin var olup olmadığını ya da nerede bulunduğunu analiz ediyordu.

slice metodu ile birlikte bu yaklaşım değişir. Artık amaç bir şeyi bulmak değil; string içerisinden yeni bir parça üretmektir.

Bu durum, sistemi pasif bir kontrol mekanizmasından çıkarıp aktif bir veri üretim sürecine dönüştürür.

Simülasyon Mantığı

slice simülasyonunda sistem, başlangıç ve bitiş indekslerini kullanarak belirli bir aralığı tanımlar.

Bu aralık, ana string içerisinden hangi karakterlerin alınacağını belirler.

Sistem, başlangıç indeksinden itibaren ilerler ve her karakteri yeni bir string yapısına ekler.

Bu süreç, bitiş indeksine ulaşılana kadar devam eder. Dikkat edilmesi gereken nokta, bitiş indeksinin dahil edilmemesidir.

Yani sistem, belirli bir aralığı kopyalar ve bu aralıktan yeni bir veri üretir.

Mantıksal Fark

Önceki metotlar, string üzerinde bir doğrulama veya arama işlemi yapıyordu. slice ise bu yapıyı tamamen değiştirir.

Artık sistem, var olan veriyi incelemek yerine o veriden yeni bir çıktı üretir.

Bu yaklaşım, veri işleme süreçlerinde çok daha güçlü ve esnek çözümler üretmemizi sağlar.

slice metodunu anlamak, sadece bir string işlemi öğrenmek değil; veri parçalama ve yeniden oluşturma mantığını kavramaktır.

// Amaç: Bir string içerisinden belirli bir aralığı alarak yeni bir string oluşturmak

function sliceSim(str, start, end) {

  // 1. Geçersiz veri kontrolü
  if (!str) {
    return "";
  }

  // 2. Eğer end verilmezse → string sonuna kadar al
  if (end === undefined) {
    end = str.length;
  }

  // 3. Negatif indeks desteği (opsiyonel ama öğretici)
  if (start < 0) {
    start = str.length + start;
  }

  if (end < 0) {
    end = str.length + end;
  }

  // 4. Sınırları düzelt
  start = Math.max(0, start);
  end = Math.min(str.length, end);

  // 5. Yeni string oluştur
  let result = "";

  // 6. Belirlenen aralıkta ilerle
  for (let i = start; i < end; i++) {

    // 7. Karakterleri yeni string’e ekle
    result += str[i];
  }

  // 8. Oluşturulan yeni string’i döndür
  return result;
}


// Test edelim
console.log(sliceSim("hello world", 0, 5)); // hello
console.log(sliceSim("hello world", 6)); // world
console.log(sliceSim("hello world", -5)); // world

Üretimden Dönüşüme

slice metodunda, belirli bir aralığı alarak yeni bir string oluşturuyorduk. Ancak bu yaklaşım yalnızca veri seçmeye dayanıyordu.

replace metodu ile birlikte bu süreç daha da gelişir. Artık sadece veri seçmekle kalmaz, mevcut veriyi dönüştürerek yeni bir çıktı üretiriz.

Bu metot, belirli bir ifadeyi bulur ve onun yerine yeni bir değer yerleştirir.

Böylece sistem, hem arama yapar hem de bu aramanın sonucunu değiştirerek yeni bir string üretir.

Simülasyon Mantığı

Simülasyon sürecinde sistem, ana string üzerinde ilerler ve aranan ifadeyi tespit etmeye çalışır.

Eşleşme bulunana kadar karakterler olduğu gibi korunur ve yeni string’e eklenir.

Eşleşme bulunduğu anda, sistem orijinal karakterleri eklemek yerine yerine konulacak yeni değeri ekler.

Ardından sistem, eşleşmenin bittiği noktadan devam ederek kalan karakterleri eklemeye devam eder.

Bu süreç sonunda, değiştirilmiş yeni bir string elde edilir.

Mantıksal Yapı

replace metodu, önceki metotların birleşimi gibi düşünülebilir.

Bir yandan arama yapar (includes gibi), bir yandan konum belirler (indexOf gibi), ve sonunda yeni bir değer üretir (slice gibi).

Bu nedenle replace, string işlemleri içerisinde en kapsamlı ve güçlü metotlardan biridir.

// Amaç: Belirli bir ifadeyi bulup yerine yeni bir değer koymak

function replaceSim(str, search, replacement) {

  if (!str || !search) {
    return str;
  }

  let result = "";
  let replaced = false;

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

    // eşleşme kontrolü
    if (!replaced && str.slice(i, i + search.length) === search) {

      result += replacement;
      i += search.length - 1;
      replaced = true;

    } else {
      result += str[i];
    }
  }

  return result;
}


// Test
console.log(replaceSim("hello world", "world", "JS"));
// hello JS

String’den Yapıya Geçiş

Şimdiye kadar string üzerinde yaptığımız işlemlerde, genellikle tek bir değer üretmeye odaklandık. Ancak bu yaklaşım, veriyi daha küçük parçalara ayırmak gerektiğinde yeterli olmaz.

split metodu ile birlikte, string’i tek parça olarak ele almak yerine belirli kurallara göre bölerek yeni bir yapı oluştururuz.

Bu metot, bir ayırıcı (delimiter) kullanarak string içerisindeki bölünme noktalarını belirler ve her parçayı ayrı bir eleman olarak saklar.

Böylece sistem, tek bir string yerine birden fazla parçadan oluşan bir liste (array) üretir.

Simülasyon Mantığı

Simülasyon sürecinde sistem, string üzerinde soldan sağa doğru ilerler.

Her karakter incelenir ve ayırıcı ile eşleşip eşleşmediği kontrol edilir.

Eğer karakter ayırıcı değilse, geçici bir yapı içerisinde biriktirilir.

Ayırıcı ile karşılaşıldığında ise, o ana kadar biriktirilen değer bir parça olarak kaydedilir ve yeni bir biriktirme süreci başlatılır.

Bu işlem string’in sonuna kadar devam eder ve sonunda tüm parçalar bir liste halinde elde edilir.

Mantıksal Fark

Önceki metotlar, string üzerinde işlem yaparak tek bir sonuç üretirken, split metodu birden fazla sonuç üretir.

Bu nedenle split, string işlemlerinden veri yapısı oluşturma sürecine geçiş sağlar.

Bu yaklaşım sayesinde, metin verilerini analiz etmek ve işlemek çok daha esnek hale gelir.

// Amaç: String'i belirli bir ayırıcıya göre parçalara ayırmak

function splitSim(str, delimiter) {

  if (!str) return [];

  let result = [];
  let current = "";

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

    const char = str[i];

    if (char === delimiter) {
      result.push(current);
      current = "";
    } else {
      current += char;
    }
  }

  // son parçayı ekle
  result.push(current);

  return result;
}


// Test
console.log(splitSim("a,b,c", ",")); 
// ["a", "b", "c"]

Parçalamadan Yeniden Oluşturmaya

split metodunda, tek bir string’i parçalara ayırarak bir liste (array) oluşturmuştuk.

join metodu ise bu sürecin tersini gerçekleştirir ve parçalardan yeni bir string oluşturur.

Bu metot, bir liste içerisindeki elemanları belirli bir ayırıcı kullanarak birleştirir ve tek bir string haline getirir.

Böylece sistem, parçalanmış veriyi tekrar bir araya getirerek yeni ve düzenlenmiş bir çıktı üretir.

Simülasyon Mantığı

Simülasyon sürecinde sistem, bir dizi (array) içerisindeki elemanlar üzerinde sırayla ilerler.

Her eleman, oluşturulacak yeni string’e eklenir.

Elemanlar arasında, belirlenen ayırıcı (delimiter) yerleştirilir.

Ancak son elemandan sonra ayırıcı eklenmez; bu, simülasyonun doğru çalışması için kritik bir detaydır.

Bu süreç tamamlandığında, tüm elemanlar birleştirilmiş ve yeni bir string oluşturulmuş olur.

Mantıksal Fark

split metodu veriyi parçalayarak çoğaltırken, join metodu bu parçaları birleştirerek tek bir yapı haline getirir.

Bu iki metot birlikte kullanıldığında, veri üzerinde güçlü dönüşümler yapmak mümkün hale gelir.

join metodunu anlamak, sadece string oluşturmayı değil; veri parçalarını kontrol ederek yeniden yapılandırmayı öğrenmektir.

// Amaç: Array elemanlarını belirli bir ayırıcı ile birleştirerek string oluşturmak

function joinSim(arr, delimiter) {

  if (!arr || arr.length === 0) return "";

  let result = "";

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

    result += arr[i];

    // son eleman değilse delimiter ekle
    if (i < arr.length - 1) {
      result += delimiter;
    }
  }

  return result;
}


// Test
console.log(joinSim(["a", "b", "c"], "-"));
// a-b-c

Temizleme Mantığı

Şimdiye kadar string üzerinde arama, parçalama ve birleştirme işlemleri gerçekleştirdik. Ancak bazı durumlarda asıl ihtiyaç, veriyi değiştirmek değil; gereksiz kısımlardan arındırmaktır.

trim metodu, string’in başında ve sonunda bulunan boşluk karakterlerini kaldırarak daha temiz bir veri üretir.

Bu işlem sırasında string’in ortasında bulunan karakterlere dokunulmaz. Yani sistem yalnızca sınırları hedef alır.

Bu yaklaşım, veri temizleme ve standartlaştırma işlemlerinin temelini oluşturur.

Simülasyon Mantığı

Simülasyon sürecinde sistem, string’in başından başlayarak boşluk karakterlerini kontrol eder.

İlk boşluk olmayan karaktere ulaştığında, bu nokta başlangıç olarak kabul edilir.

Aynı işlem string’in sonu için de uygulanır ve sondan geriye doğru ilerlenerek son boşluk olmayan karakter tespit edilir.

Bu iki sınır belirlendikten sonra, sistem bu aralık içerisindeki karakterleri alarak yeni bir string oluşturur.

Mantıksal Fark

Diğer metotlar string üzerinde aktif işlemler yaparken, trim metodu daha pasif bir yaklaşım izler ve yalnızca gereksiz karakterleri ortadan kaldırır.

Bu nedenle trim, veri işleme süreçlerinde ilk adım olarak sıkça kullanılır.

trim metodunu anlamak, veriyi analiz etmeden önce temizleme alışkanlığı kazanmaktır.

// Amaç: String'in başındaki ve sonundaki boşlukları kaldırmak

function trimSim(str) {

  if (!str) return "";

  let start = 0;
  let end = str.length - 1;

  // baştan boşlukları atla
  while (str[start] === " ") {
    start++;
  }

  // sondan boşlukları atla
  while (str[end] === " ") {
    end--;
  }

  let result = "";

  for (let i = start; i <= end; i++) {
    result += str[i];
  }

  return result;
}


// Test
console.log(trimSim("   hello world   "));
// "hello world"

Toplu Dönüşüm

Önceki metotlarda genellikle belirli bir bölüm üzerinde işlem yaptık. Ancak bazı durumlarda tüm string üzerinde aynı işlemi uygulamak gerekir.

toLowerCase metodu, string içerisindeki tüm karakterleri küçük harfe dönüştürerek tek tip bir yapı oluşturur.

Bu işlem sırasında herhangi bir karakter seçilmez; sistem tüm string’i kapsayan bir dönüşüm gerçekleştirir.

Bu yaklaşım, veri standardizasyonu ve karşılaştırma işlemleri için kritik bir rol oynar.

Simülasyon Mantığı

Simülasyon sürecinde sistem, string üzerinde soldan sağa doğru ilerler.

Her karakter alınır ve küçük harf karşılığına dönüştürülür.

Dönüştürülen karakter, yeni oluşturulan string’e eklenir.

Bu işlem tüm karakterler için tekrar edilir ve sonuç olarak tamamen dönüştürülmüş bir string elde edilir.

Mantıksal Fark

replace metodu belirli bir kısmı değiştirirken, toLowerCase metodu tüm string üzerinde tek tip bir dönüşüm uygular.

Bu nedenle toLowerCase, veri temizleme ve karşılaştırma işlemlerinde sıkça kullanılır.

Bu metodu anlamak, veri üzerinde toplu dönüşüm (mapping) mantığını kavramaktır.

// Amaç: String içerisindeki tüm karakterleri küçük harfe dönüştürmek

function toLowerCaseSim(str) {

  if (!str) return "";

  let result = "";

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

    const char = str[i];

    result += char.toLowerCase();
  }

  return result;
}


// Test
console.log(toLowerCaseSim("HELLO WORLD"));
// hello world