Functional Programming

 

Pengenalan Functional Programming

Seperti yang sudah disampaikan di awal, JavaScript adalah bahasa yang mendukung multiparadigm. Artinya, selain merupakan bahasa pemrograman berorientasi objek, penulisan syntax JavaScript juga menggunakan gaya functional programming.

Sebelumnya kita telah mempelajari tentang paradigma OOP, kali ini kita akan melanjutkan dengan pendekatan paradigma yang lain, yakni Functional Programming.

Kita juga telah membahas mengenai Object Composition. Di mana konsep ini cukup membantu ketika membuat sebuah kelas tanpa harus melakukan proses pewarisan. Ia akan memecah-mecah fungsi yang umum digunakan agar dapat digunakan kembali (reusable) tanpa proses pewarisan.

Nah, Functional Programming adalah pendekatan yang lebih dalam dari konsep tersebut.

Di modul kali ini, kita akan belajar banyak mengenai paradigma functional programming. Hingga di akhir modul ini Anda diharapkan dapat:

• Mengetahui Paradigma Functional Programming.
• Mengetahui konsep Pure Function, Immutability, dan Higher-Order Function.
• Menggunakan Reusable Function yang ada pada JavaScript.

Paradigma Functional Programming

Paradigma Functional Programming adalah paradigma pemrograman di mana proses komputasi didasarkan pada fungsi matematika murni. Functional Programming (selanjutnya akan kita singkat menjadi FP) ditulis dengan gaya deklaratif yang berfokus pada “what to solve” dibanding “how to solve” yang dianut oleh gaya imperatif.

Sebagai gambaran buat Anda yang belum tahu apa itu deklaratif dan imperatif lebih jauh, silakan simak contoh kode berikut.

• main.js

1

const names = ['Harry', 'Ron', 'Jeff', 'Thomas'];

2

​

3

const newNamesWithExcMark = [];

4

​

5

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

6

  newNamesWithExcMark.push(`${names[i]}!`);

7

}

8

​

9

console.log(newNamesWithExcMark);

10

​

11

/* output:

12

   [ 'Harry!', 'Ron!', 'Jeff!', 'Thomas!' ]

13

*/

 

Contoh kode di atas merupakan salah satu gaya penulisan kode imperatif. Di mana proses pengisian nilai array baru (newNames) berdasarkan array lama (names) dilakukan secara manual. Inilah maksud dari “how to solve”, di mana kita perlu memikirkan bagaimana cara melakukan perulangannya (for); kapan perulangannya harus berhenti (i < names.length); bagaimana cara memasukkan nilai baru ke dalam array (newNamesWithExcMark.push). Huft, sangat melelahkan!

Lantas bagaimana dengan gaya deklaratif? Mari kita lihat kode dengan fungsi yang sama namun dengan gaya deklaratif.

• main.js

1

const names = ['Harry', 'Ron', 'Jeff', 'Thomas'];

2

​

3

const newNamesWithExcMark = names.map((name) => `${name}!`);

4

​

5

console.log(newNamesWithExcMark);

6

​

7

/* output:

8

 * [ 'Harry!', 'Ron!', 'Jeff!', 'Thomas!' ]

9

 */

 

Kesan apa yang pertama Anda rasakan ketika melihat kode di atas? Coba bandingkan dengan kode sebelumnya, tentu ini jauh lebih mudah dibaca dan ringkas. Yap! Inilah yang disebut dengan gaya deklaratif. Kita tidak perlu pusing untuk memikirkan cara manual untuk mencapai sebuah tujuan. Tidak ada proses looping manual; Tidak perlu tahu kapan harus berhenti dari looping; Kita cukup fokus pada “what to solve” alias apa yang ingin kita selesaikan atau capai.

JavaScript sendiri merupakan bahasa pemrograman yang mendukung paradigma FP. Banyak Higher-Order Function (kita akan bahas detail tentang ini nanti) yang bisa kita manfaatkan sebagai utilitas, salah satunya fungsi array map() di atas.

Namun FP bukan hanya sekedar menggunakan High-Order Function bawaan saja. Untuk memahami paradigma FP secara mendalam, kita perlu tahu dulu konsep-konsep apa saja yang ada di dalamnya.

Konsep-Konsep Functional Programming

Setelah Anda memiliki sedikit gambaran tentang bagaimana paradigma FP dapat membuat kode yang Anda tuliskan lebih mudah dibaca dan ringkas, kini saatnya Anda ketahui, apa saja konsep-konsep dasar yang ada di dalam paradigma FP.

Di sini kita akan membahas 4 konsep besar yang ada di FP. Yakni Pure Function, Immutability, Recursive, dan High-Order Function.

Pure Function

Salah satu konsep besar dari paradigma FP adalah Pure Function. Apa artinya? Pure Function merupakan konsep dari pembuatan fungsi yang mengharuskan fungsi untuk tidak bergantung terhadap nilai yang berada di luar fungsi atau parameternya. Sehingga mau seperti apa keadaanya, fungsi yang dibuat selalu menghasilkan sesuatu yang sama, terkecuali bila fungsi tersebut diberikan nilai parameter yang berbeda.

Untuk lebih jelasnya, simak kode berikut:

• main.js

1

let PI = 3.14;

2

​

3

const hitungLuasLingkaran = (jariJari) => {

4

  return PI * (jariJari * jariJari); 

5

}

6

​

7

console.log(hitungLuasLingkaran(4)); // 50.24

8

​

9

PI = 5; // tidak sengaja nilai PI berubah

10

​

11

console.log(hitungLuasLingkaran(4)); // 80

 

Menurut Anda, apakah fungsi hitungLuasLingkaran merupakan pure function atau impure function (lawan dari pure function)? Jika Anda menjawab impure function, Anda tepat sekali!

Fungsi tersebut tidak bisa dikatakan pure function karena ia membutuhkan nilai yang berada di luar dari fungsinya, yakni nilai PI. Bila nilai PI berubah, maka penggunaan fungsi menghasilkan nilai yang berbeda walaupun diberikan nilai parameter yang sama.

Lantas, bagaimana cara membuat fungsi tersebut menjadi pure? Mudah!

• main.js

1

const hitungLuasLingkaran = (jariJari) => {

2

  return 3.14 * (jariJari * jariJari); 

3

}

4

​

5

console.log(hitungLuasLingkaran(4)); // 50.24

6

console.log(hitungLuasLingkaran(4)); // 50.24

7

console.log(hitungLuasLingkaran(8)); // 200.96

8

console.log(hitungLuasLingkaran(8)); // 200.96

 

Dengan memindahkan nilai PI secara konstan di dalam fungsi, maka dapat dipastikan nilai tersebut tidak akan berubah atau tak sengaja diubah. Dengan begitu fungsi selalu menghasilkan nilai yang sama bila nilai parameter yang diberikan sama.

Selain dilarang untuk bergantung terhadap nilai luar, pure function juga dilarang keras untuk mengubah nilai yang berada di luar baik secara sengaja atau tidak sengaja. Pure function tidak boleh menimbulkan efek samping (no side effect) ketika digunakan.

Untuk lebih jelasnya, coba lihat contoh kode berikut:

• main.js

1

const createPersonWithAge = (age, person) => {

2

  person.age = age;

3

  return person;

4

};

5

​

6

const person = {

7

  name: 'Bobo'

8

};

9

​

10

const newPerson = createPersonWithAge(18, person);

11

​

12

console.log({

13

  person,

14

  newPerson

15

});

16

​

17

/**

18

 * Output:

 

Fungsi createPersonWithAge bertujuan untuk membuat objek person baru dengan tambahan properti age dari objek person yang ada. Namun alih-alih hanya membuat objek baru, ia juga malah mengubah nilai dari objek lama. Nah, hal inilah yang menyebabkan fungsi createPersonWithAge bukanlah pure function.

Lalu bagaimana cara membuat fungsi tersebut menjadi pure? Mudah, kita manfaatkan destructuring object daripada mengubah objek tersebut secara langsung.

• main.js

1

const createPersonWithAge = (age, person) => {

2

  return { ...person, age };

3

};

4

​

5

const person = {

6

  name: 'Bobo'

7

};

8

​

9

const newPerson = createPersonWithAge(18, person);

10

​

11

console.log({

12

  person,

13

  newPerson

14

});

15

​

16

/**

17

 * Output:

18

 *  { 

 

Lihat! Lagi-lagi lebih mudah dan singkat bukan?

Agar lebih mudah dalam mengetahui apakah fungsi yang Anda buat sudah pure atau belum, pastikan 3 konsep ini ada pada fungsi yang Anda buat.

• Mengembalikan nilai yang sama bila inputannya (nilai parameter) sama.
• Hanya bergantung pada argumen yang diberikan.
• Tidak menimbulkan efek samping.

Bila 3 konsep di atas terpenuhi, maka bisa dipastikan Anda membuat sebuah pure function.

Immutability

Konsep yang kedua adalah immutability. Immutable berarti sebuah objek tidak boleh diubah setelah objek tersebut dibuat. Kontras dengan mutable yang artinya objek boleh diubah setelah objek tersebut dibuat.

Konsep immutability sangat kental pada paradigma FP. Anda bisa lihat sebelumnya pada contoh penggunaan array map. Ketika menggunakan array.map(), alih-alih ia mengubah nilai dari array itu sendiri, malah ia membuat atau menghasilkan array baru.

• main.js

1

const names = ['Harry', 'Ron', 'Jeff', 'Thomas'];

2

​

3

const newNamesWithExcMark = names.map((name) => `${name}!`);

4

​

5

console.log({

6

    names,

7

    newNamesWithExcMark,

8

});

9

​

10

/**

11

 * {

12

     names: [ 'Harry', 'Ron', 'Jeff', 'Thomas' ],

13

     newNamesWithExcMark: [ 'Harry!', 'Ron!', 'Jeff!', 'Thomas!' ]

14

   }

15

 */

16

​

17

​

 

Lantas, bagaimana bila kita benar-benar perlu mengubah nilai dari sebuah objek? Contohnya seperti ini:

• main.js

1

const user = {

2

    firstname: 'Harry',

3

    lastName: 'Protter', // ups, typo!

4

}

5

​

6

const renameLastNameUser = (newLastName, user) => {

7

    user.lastName = newLastName;

8

}

9

​

10

renameLastNameUser('Potter', user);

11

​

12

console.log(user);

13

​

14

/**

15

 * output:

16

 * { firstname: 'Harry', lastName: 'Potter' }

17

 * 

18

 */

 

Yup! Tujuan Anda memang tercapai namun itu bukanlah konsep dari paradigma FP. Bila Anda ingin menerapkan FP sepenuhnya, hindari cara seperti di atas. Lantas bagaimana solusinya? Sama seperti fungsi array map(), alih-alih mengubah nilai objek secara langsung, terapkan perubahan tersebut pada nilai return dalam objek baru.

• main.js

1

const user = {

2

    firstname: 'Harry',

3

    lastName: 'Protter', // ups, typo!

4

}

5

​

6

const createUserWithNewLastName = (newLastName, user) => {

7

    return { ...user, lastName: newLastName }

8

}

9

​

10

const newUser = createUserWithNewLastName('Potter', user);

11

​

12

console.log(newUser);

13

​

14

/**

15

 * output:

16

 * { firstname: 'Harry', lastName: 'Potter' }

17

 * 

18

 */

 

Hasilnya sama kan? Selain itu, Anda juga bisa menyesuaikan nama fungsinya dari renameLastNameUser menjadi createUserWithNewLastName. Hal itu perlu untuk mengindikasikan bahwa fungsi mengembalikan atau menghasilkan objek user baru.

Rekursif

Konsep selanjutnya yang ada di Functional Programming adalah rekursif. Apa itu rekursif? Rekursif merupakan teknik pada sebuah function yang memanggil dirinya sendiri.

Kita akan mencoba mengubah fungsi countDown yang biasanya kita buat menggunakan sintaksis iterasi seperti for, foreach, while seperti kode di bawah menjadi bentuk rekursif.

const countDown = start => {
  do {
    console.log(start);
    start -=1;
  }
  while(start > 0);
};
 
countDown(10);

Maka, bentuk rekursinya adalah sebagai berikut:

• main.js

1

const countDown = start => {

2

  console.log(start);

3

  if(start > 0) countDown(start-1);

4

};

5

​

6

countDown(10);

 

Dengan teknik rekursif ini, kita sebenarnya bisa menggantikan operasi iterasi dengan rekursi. Namun tidak sebatas itu saja, dengan rekursi ketika dapat membuat dan mengolah data structures seperti Tree dan Array.

Higher-Order Function

JavaScript memiliki kemampuan First Class Functions, karena itu fungsi pada JavaScript dapat diperlakukan layaknya sebuah data. Kita bisa menyimpan function dalam variabel, memberikan function sebagai parameter pada fungsi lainnya, hingga mengembalikan function di dalam function.

• main.js

1

const hello = () => {

2

  console.log('Hello!')

3

};

4

​

5

const say = (someFunction) => {

6

  someFunction();

7

}

8

​

9

const sayHello = () => {

10

    return () => {

11

        console.log('Hello!');

12

    }

13

}

14

​

15

hello();

16

say(hello);

17

sayHello()();

18

​

 

Karena dengan kemampuan First Class Functions-nya itu, kita dapat membuat Higher-Order Function secara mudah. Tunggu, tunggu. Apa itu Higher-Order Function?

Higher-Order Function menjadi bagian konsep pada paradigma FP. Higher-Order Function merupakan fungsi yang dapat menerima fungsi lainnya pada argumen; mengembalikan sebuah fungsi; atau bahkan keduanya.

Teknik Higher-Order Function biasanya digunakan untuk:

• Mengabstraksi atau mengisolasi sebuah aksi, event, atau menangani alur asynchronous menggunakan callback, promise, dan lainnya.
• Membuat utilities yang dapat digunakan diberbagai tipe data.
• Membuat teknik currying atau function composition.

Array map() merupakan salah satu contoh Higher-Order Function yang ada di JavaScript. Karena dalam penggunaanya, ia menerima satu buah argumen yang merupakan sebuah function.

Dengan mengetahui adanya Higher-Order Function, Anda bisa membuat fungsi map() versi Anda sendiri!

• main.js

1

const names = ['Harry', 'Ron', 'Jeff', 'Thomas'];

2

​

3

const arrayMap = (arr, action) => {

4

  const loopTrough = (arr, action, newArray = [], index = 0) => {

5

    const item = arr[index];

6

    if(!item) return newArray;

7

    return loopTrough(arr, action, [...newArray, action(arr[index])], index + 1);

8

  }

9

​

10

  return loopTrough(arr, action);

11

}

12

​

13

​

14

const newNames = arrayMap(names, (name) => `${name}!` );

15

​

16

console.log({

17

    names,

18

    newNames,

19

});

20

​

21

/**

22

 * output:

23

 * {

24

 *   names: [ 'Harry', 'Ron', 'Jeff', 'Thomas' ],

25

 *   newNames: [ 'Harry!', 'Ron!', 'Jeff!', 'Thomas!' ]

26

 * }

27

 */

Reusable Function

Dengan menerapkan konsep-konsep yang ada di dalam paradigma FP, fungsi yang Anda buat akan bersifat reusable. Karena fungsi yang Anda buat merupakan pure function, ia tidak akan dipengaruhi ataupun mempengaruhi keadaan di/dari luar. Hal ini tentu membuat fungsi dapat digunakan berkali-kali tanpa khawatir mendapatkan hasil di luar ekspektasi Anda.

Pada materi kali ini kita tidak berfokus untuk membuat banyak reusable function di JavaScript. Kami percaya, dengan memahami konsep functional programming secara matang, Anda dapat membuatnya sendiri sesuai kebutuhan.

Alih-alih membuatnya sendiri, kita akan coba membahas dan menggunakan beberapa reusable function yang sudah ada di JavaScript. Khususnya beberapa Higher-Order Function yang dimiliki array, seperti map, filter, dan forEach.

Array Map

Fungsi array.map() merupakan fungsi bawaan dari array yang sangat berguna dan banyak sekali digunakan. Fungsi ini dapat dipanggil dari sebuah data bertipe array dan menerima satu buah callback function.

['Harry', 'Ron', 'Jeff', 'Thomas'].map(() => { });

Callback function tersebut akan dipanggil sebanyak jumlah panjang array dan akan memiliki akses pada index array sesuai dengan iterasinya.

['Harry', 'Ron', 'Jeff', 'Thomas'].map((name) => { });

Seperti yang Anda ketahui di awal, fungsi map akan mengembalikan array baru. Nilai tiap item pada array yang dikembalikan, dihasilkan dari kembalian callback function-nya. Karena callback function dapat mengakses item array, biasanya developer menggunakannya untuk menghasilkan nilai baru.

• main.js

1

const newArray = ['Harry', 'Ron', 'Jeff', 'Thomas'].map((name) => { return `${name}!`});

2

​

3

console.log(newArray);

4

​

5

/**

6

 * [ 'Harry!', 'Ron!', 'Jeff!', 'Thomas!' ]

7

 * 

8

 */

 

Array Filter

Sama seperti array.map(), fungsi array.filter() merupakan fungsi bawaan dari data yang bertipe array di JavaScript. Sesuai namanya, fungsi ini sangat berguna untuk melakukan proses penyaringan (filtering) terhadap nilai array yang ada. Bila Anda memiliki kasus di mana Anda ingin menghilangkan beberapa item di array berdasarkan spesifikasi tertentu, fungsi ini sangatlah cocok Anda gunakan.

Cara kerja fungsi ini mirip seperti array.map(). Namun, callback function dari fungsi ini harus mengembalikan boolean. Di mana nilai boolean ini digunakan untuk menentukan apakah item array lolos saring atau tidak.

Sama seperti fungsi map(), fungsi filter() juga akan mengembalikan array yang telah disaring dalam bentuk array baru.

Contoh penggunaan ketika Anda ingin menghilangkan seluruh nilai falsy pada array:

• main.js

1

const truthyArray = [1, '', 'Hallo', 0, null, 'Harry', 14].filter((item) => Boolean(item));

2

​

3

console.log(truthyArray);

4

​

5

/**

6

 * output:

7

 * [ 1, 'Hallo', 'Harry', 14 ]

8

 * 

9

 */

 

Contoh lain, penggunaan filter untuk menyaring array dari objek siswa yang layak mendapatkan beasiswa berdasarkan nilai skor yang didapat.

• main.js

1

const students = [

2

  {

3

    name: 'Harry',

4

    score: 60,

5

  },

6

  {

7

    name: 'James',

8

    score: 88,

9

  },

10

  {

11

    name: 'Ron',

12

    score: 90,

13

  },

14

  {

15

    name: 'Bethy',

16

    score: 75,

17

  }

18

];

 

Array Reduce

Sama seperti array.map(), array.reduce() adalah fungsi bawaan dari data yang bertipe array yang digunakan untuk mengeksekusi nilai pada setiap elemen dan menampilkan dalam sebuah nilai saja.

arr.reduce(callback( accumulator, currentValue, [, index[, array]] )[, initialValue])

Callback function dari fungsi ini dapat diolah untuk manipulasi data currentValue dan menyimpannya pada accumulator. Selain itu, fungsi reduce juga memiliki nilai awal yang dapat didefinisikan pada bagian initialValue.

Contoh penggunaannya misalkan ketika kita ingin menjumlahkan total nilai siswa:

• main.js

1

const students = [

2

  {

3

    name: 'Harry',

4

    score: 60,

5

  },

6

  {

7

    name: 'James',

8

    score: 88,

9

  },

10

  {

11

    name: 'Ron',

12

    score: 90,

13

  },

14

  {

15

    name: 'Bethy',

16

    score: 75,

17

  }

18

];

 

Array some

array.some() merupakan fungsi bawaan dari array yang cukup sering digunakan. Fungsi ini akan menghasilkan nilai boolean.

arr.some(callback(element[, index[, array]])[, thisArg])

Nilai yang dihasilkan didasarkan pada pernyataan apakah ada setidaknya satu dari deretan nilai dalam array tersebut lolos berdasarkan kriteria yang kita tuliskan dalam callback function.

Contoh penggunaannya misalkan kita ingin mengetahui apakah dalam deretan angka terdapat angka genap.

• main.js

1

const array = [1, 2, 3, 4, 5];

2

const even = array.some(element => element % 2 === 0);

3

​

4

console.log(even);

5

​

6

/** 

7

output true

8

**/

 

Array find

Mirip dengan array.some(), array.find() sesuai namanya digunakan untuk mencari apakah di dalam deretan nilai terdapat nilai yang sesuai dengan kriteria yang kita definisikan pada callback function. 

Yang membedakan array.find() dengan array.some(), find akan menghasilkan satu nilai dari elemen yang pertama kali ditemukan berdasarkan kriteria tertentu dan akan menghasilkan nilai undefine bila tidak ada kriteria yang terpenuhi pada item array.

arr.find(callback(element[, index[, array]])[, thisArg])

Sebagai contoh, misalkan kita akan mencari siswa dengan nama `James`.

• main.js

1

const students = [

2

  {

3

    name: 'Harry',

4

    score: 60,

5

  },

6

  {

7

    name: 'James',

8

    score: 88,

9

  },

10

  {

11

    name: 'Ron',

12

    score: 90,

13

  },

14

  {

15

    name: 'Bethy',

16

    score: 75,

17

  }

18

];

 

Array sort

array.sort() merupakan fungsi bawaan dari array yang berguna untuk melakukan pengurutan nilai dari sebuah deretan nilai. Secara default, fungsi sort akan mengubah semua nilai dalam deretan menjadi bentuk string dan mengurutkannya secara ascending.

arr.sort([compareFunction])

Contoh sederhananya adalah sebagai berikut:

• main.js

1

const months = ['March', 'Jan', 'Feb', 'Dec'];

2

months.sort();

3

console.log(months);

4

// output: [ 'Dec', 'Feb', 'Jan', 'March' ]

5

​

6

const array1 = [1, 30, 4, 1000, 101, 121];

7

array1.sort();

8

console.log(array1);

9

// output: [ 1, 1000, 101, 121, 30, 4 ]

 

Contoh pengurutan di atas didasarkan pada pengurutan bentuk tipe data string. Oleh karena itu, ketika kita ingin mengurutkan sesuai dengan kriteria yang kita inginkan (berdasarkan tanggal ataupun berdasarkan nilai siswa) maka kita perlu membuat compare function tersendiri.

• main.js

1

const array1 = [1, 30, 4, 1000];

2

​

3

const compareNumber = (a, b) => {

4

  return a - b;

5

};

6

const sorting = array1.sort(compareNumber);

7

console.log(sorting);

8

​

9

/**

10

output

11

[ 1, 4, 30, 1000 ]

12

**/

 

Pada compare function, fungsi akan membandingkan 2 nilai yang akan menghasilkan 3 result yaitu negatif (-), 0, dan positif (+).

• Jika, negative maka `a` akan diletakan sebelum `b`
• Jika, positive maka `b` akan diletakan sebelum `a`
• Jika, 0 maka tidak ada perubahan posisi.

Array every

array.every() merupakan fungsi bawaan dari array yang digunakan untuk mengecheck apakah semua nilai dari sebuah array sesuai dengan kriteria yang didefinisikan. Kembalian dari array.every() adalah nilai Boolean.

arr.every(callback(element[, index[, array]])[, thisArg])

Sebagai contoh, kita akan mengecek apakah seorang siswa telah lulus semua uji materi:

• main.js

1

const scores = [70,85,90];

2

const minimumScore = 65;

3

​

4

const examPassed = scores.every(score => score >= minimumScore);

5

console.log(examPassed);

6

​

7

/**

8

output

9

true

10

**/

 

Array forEach

Array forEach merupakan fungsi bawaan dari array yang berfungsi untuk memanggil fungsi callback pada setiap iterasi index array. Berbeda dari fungsi array lain yang sudah kita bahas, fungsi ini tidak mengembalikan nilai apa pun. Jadi fungsi ini secara harfiah hanya berfungsi untuk memanggil fungsi callback-nya saja, tak lebih dari itu.

Melalui fungsi ini, Anda dapat mengubah sintaks perulangan berdasarkan jumlah array secara imperatif menjadi deklaratif.

• Cara imperatif
• Cara deklaratif

const names = ['Harry', 'Ron', 'Jeff', 'Thomas'];
 
for(let i = 0; i < names.length; i++) {
  console.log(`Hello, ${names[i]}!`);
}
 
/**
 * output:
 * Hello, Harry!
 * Hello, Ron!
 * Hello, Jeff!
 * Hello, Thomas!
 * 
 */

Namun, ketahuilah bahwa ketika menggunakan forEach, kita tidak bisa menggunakan operator break atau continue pada proses perulangan (Anda bisa melakukannya pada perulangan for). Hal ini juga berlaku ketika pada fungsi map dan filter.

const names = ['Harry', 'Ron', 'Jeff', 'Thomas'];
 
for(let i = 0; i < names.length; i++) {
  if(names[i] === 'Jeff') continue; // Bisa!
  
  console.log(`Hello, ${names[i]}!`);
}
 
names.forEach((name) => {
  if(names[i] === 'Jeff') continue; // Tidak Bisa!
  console.log(`Hello, ${name}`);
});

Rangkuman Materi

Anda berada di akhir dari modul Functional Programming. Mari kita uraikan materi yang sudah Anda pelajari untuk mempertajam pemahaman.

• Anda sudah mengenal paradigma Functional Programming.
• Anda sudah mengenal konsep Pure Function, Immutability, dan Higher-Order Function pada paradigma Functional Programming.
• Anda sudah mencoba beberapa reusable function yang ada di JavaScript seperti array map, array filter, dan array forEach.

Dengan ringkasan tersebut, diharapkan Anda dapat memahami semua materi yang telah disampaikan. Jika belum, Anda bisa ulas kembali materi yang diberikan pada modul ini. Untuk Anda yang sudah merasa mantap, yuk lanjut ke modul berikutnya!

Ref : [1]