İşlevsel programlama, daha modüler, yeniden kullanılabilir ve bakımı yapılabilir kod yazma yeteneği nedeniyle son yıllarda popülerlik kazanan bir paradigmadır. Çok yönlü bir programlama dili olan JavaScript, işlevsel programlama için de çok uygundur. Bu makalede, JavaScript ile işlevsel programlamadaki temel kavramları ve bunların daha iyi kod yazmanıza nasıl yardımcı olabileceğini keşfedeceğiz:

1. Birinci Sınıf Vatandaş Olarak İşlevler
2. Üst Düzey İşlevler
3. Saf Fonksiyonlar
4. Değişmezlik
5. özyineleme

İşlevsel programlamada, işlevler birinci sınıf vatandaşlar olarak ele alınır; bu, değişkenlere atanabilecekleri, diğer işlevlere argüman olarak iletilebilecekleri ve değer olarak döndürülebilecekleri anlamına gelir. Bu kavram, daha modüler ve yeniden kullanılabilir kod yazmamıza izin verdiği için işlevsel programlamada çok önemlidir.

İşte JavaScript'te işlevlerin birinci sınıf vatandaş olarak nasıl ele alındığına dair bazı örnekler:

1. Değişkenlere Fonksiyon Atama:

const add = function(x, y) {
  return x + y;
}

2. Fonksiyonları Argüman Olarak Geçirmek:

İşlevler, diğer işlevlere bağımsız değişken olarak da iletilebilir. Bu, aynı işlevi farklı giriş ve çıkışlarla yeniden kullanmamıza izin verdiği için programlamaya daha modüler bir yaklaşım sağlar. Örneğin:

function greet(name, callback) {
  const message = "Hello, " + name + "!";
  callback(message);
}

function logMessage(message) {
  console.log(message);
}

greet("Sumit", logMessage); // Logs "Hello, Sumit!"

3. Fonksiyonları Değer Olarak Döndürmek:

İşlevler, diğer işlevlerden değerler olarak da döndürülebilir. Bu, kapatma ve körleme gibi daha gelişmiş tekniklere izin verir. Örneğin:

function add(x) {
  return function(y) {
    return x + y;
  };
}

const addFive = add(5);
console.log(addFive(3)); // Logs 8

✓ Üst Düzey İşlevler

Üst düzey işlevler, diğer işlevleri bağımsız değişken olarak alan veya işlevleri değer olarak döndüren işlevlerdir. Farklı kullanım durumlarına uygulanabilecek daha soyut ve genel amaçlı kodlar yazmamıza izin veriyorlar. JavaScript'teki bazı yaygın üst düzey işlevler map(), filter() ve reduce()'tur.

JavaScript'teki üst düzey işlevlere bazı örnekler:

1. Array.prototype.map():

const numbers = [1, 2, 3, 4];
const doubled = numbers.map(function(num) {
  return num * 2;
});
console.log(doubled); // Logs [2, 4, 6, 8]

2. Array.prototype.filter():

Yöntem, filter()bir geri arama işlevini bağımsız değişken olarak alan ve yalnızca geri aramada belirtilen testi geçen öğelerle yeni bir dizi döndüren başka bir üst düzey işlevdir. Örneğin:

const numbers = [1, 2, 3, 4];
const even = numbers.filter(function(num) {
  return num % 2 === 0;
});
console.log(even); // Logs [2, 4]

3. Function.prototype.bind():

Yöntem, bind()belirli bir değere ve ilk bağımsız değişkenlere sahip yeni bir işlev döndüren üst düzey bir işlevdir this. Genellikle belirli bir bağlamla yeni bir işlev oluşturmak veya kısmen uygulanmış bir işlev oluşturmak için kullanılır. Örneğin:

const person = {
  firstName: "Sumit",
  lastName: "Saha",
  fullName: function() {
    return this.firstName + " " + this.lastName;
  }
};

const logName = function(greeting) {
  console.log(greeting + " " + this.fullName());
};

const boundLogName = logName.bind(person, "Hello");
boundLogName(); // Logs "Hello Sumit Saha"

Bunlar, JavaScript'te bulunan birçok üst düzey işlevin yalnızca birkaç örneğidir. Üst düzey işlevleri kullanarak, farklı kullanım durumlarına uygulanabilecek daha genel ve yeniden kullanılabilir kodlar yazabilirsiniz.

✓ Saf İşlevler

Saf işlevler, yan etkileri olmayan işlevlerdir, yani kapsamları dışında herhangi bir harici durumu veya değişkeni değiştirmezler. Aynı girdi için her zaman aynı çıktıyı döndürürler, bu da onları deterministik yapar. Saf fonksiyonlar, kodun öngörülebilirliğini, test edilebilirliğini ve sürdürülebilirliğini teşvik ettikleri için fonksiyonel programlamada esastır.

İşte JavaScript'teki saf işlevlere bazı örnekler:

1. Toplama işlevi:

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

function concatenateArrays(arr1, arr2) {
  return arr1.concat(arr2);
}

3. Tarih biçimlendirme işlevi:

function formatDate(date) {
  const year = date.getFullYear();
  const month = date.getMonth() + 1;
  const day = date.getDate();
  return `${year}-${month}-${day}`;
}

4. Dize büyük harf işlevi:

function capitalize(str) {
  return str.charAt(0).toUpperCase() + str.slice(1);
}

Genel olarak saf fonksiyonlar, herhangi bir yan etkisi olmayan ve aynı girdi için her zaman aynı sonucu veren fonksiyonlardır. Öngörülebilir olmaları ve akıl yürütmeleri daha kolay olup, onları sürdürülebilir ve yeniden kullanılabilir kod yazmak için ideal kılar.

✓ değişmezlik

Değiştirilemezlik, oluşturulduktan sonra veri yapılarını veya değişkenleri değiştirmekten kaçınmayı içeren bir kavramdır. Bir nesneyi veya diziyi değiştirmek yerine, istenen değişikliklerle yeni bir tane oluşturuyoruz. Bu yaklaşım, istenmeyen yan etkileri önler ve kodu daha öngörülebilir ve akıl yürütmeyi daha kolay hale getirir.

İşte JavaScript'teki bazı değişmezlik örnekleri:

1. Yeni bir dizi veya nesne oluşturmak için forma operatörünü kullanma:

const arr1 = [1, 2, 3];
const arr2 = [...arr1, 4];
// arr1 is still [1, 2, 3], arr2 is [1, 2, 3, 4]

const obj1 = { a: 1, b: 2 };
const obj2 = { ...obj1, c: 3 };
// obj1 is still { a: 1, b: 2 }, obj2 is { a: 1, b: 2, c: 3 }

const arr1 = [1, 2, 3];
const arr2 = arr1.concat(4);
// arr1 is still [1, 2, 3], arr2 is [1, 2, 3, 4]

3. Yeni bir nesne oluşturmak için kullanma :Object.assign()

const obj1 = { a: 1, b: 2 };
const obj2 = Object.assign({}, obj1, { c: 3 });
// obj1 is still { a: 1, b: 2 }, obj2 is { a: 1, b: 2, c: 3 }

4. Bir nesnenin değiştirilmesini önlemek için kullanma :Object.freeze()

const obj1 = Object.freeze({ a: 1, b: 2 });
obj1.c = 3;
// obj1 is still { a: 1, b: 2 }, the assignment is ignored

Genel olarak değişmezlik, verilerin doğrudan değiştirilmediği, bunun yerine değişiklikler yapıldığında yeni kopyaların oluşturulduğu anlamına gelir. Bu, istenmeyen yan etkilerin önlenmesine yardımcı olabilir ve kodu daha öngörülebilir ve bakımı yapılabilir hale getirebilir.

✓ Yineleme

Özyineleme, bir işlevin bir sorunu çözmek için kendisini çağırdığı bir tekniktir. Karmaşık problemleri daha küçük, daha basit problemlere bölerek çözmemize izin verdiği için fonksiyonel programlamada güçlü bir araçtır. Ancak, düzgün kullanılmadığı takdirde yığın taşma hatalarına ve performans sorunlarına yol açabileceğinden özyinelemenin kullanımı zor olabilir.

İşte JavaScript'te bazı özyineleme örnekleri:

1. Faktöriyel fonksiyon:

function factorial(n) {
  if (n === 0) {
    return 1;
  } else {
    return n * factorial(n - 1);
  }
}

factorial(5); // returns 120 (5! = 5 * 4 * 3 * 2 * 1)

function sum(arr) {
  if (arr.length === 0) {
    return 0;
  } else {
    return arr[0] + sum(arr.slice(1));
  }
}

sum([1, 2, 3, 4, 5]); // returns 15 (1 + 2 + 3 + 4 + 5)

3. Fibonacci işlevi:

function fibonacci(n) {
  if (n === 0 || n === 1) {
    return n;
  } else {
    return fibonacci(n - 1) + fibonacci(n - 2);
  }
}

fibonacci(6); // returns 8 (0, 1, 1, 2, 3, 5, 8)

Yineleme, yinelenen kalıpları veya yapıları içeren problemlerin çözümünde güçlü bir araç olabilir. Ancak, dikkatli bir şekilde uygulanmadığı takdirde performans sorunlarına ve yığın taşma hatalarına da yol açabilir. Özyineleme kavramını anlamak ve onu kodunuzda akıllıca kullanmak önemlidir.

Çözüm

Sonuç olarak, işlevsel programlama daha modüler, yeniden kullanılabilir ve bakımı yapılabilir kodlar yazmanıza yardımcı olabilecek önemli bir paradigmadır. Birinci sınıf vatandaşlar olarak işlevler, üst düzey işlevler, saf işlevler, değişmezlik ve özyineleme gibi temel kavramları anlayarak, JavaScript'te daha işlevsel kod yazmaya başlayabilirsiniz. İşlevsel programlama, iyi kod yazmanın tek yolu değildir, ancak karmaşık sorunları çözmenize ve kodunuzu daha öngörülebilir ve akıl yürütmeyi daha kolay hale getirmenize yardımcı olabilecek güçlü bir araçtır.