1. Pure Functions

คือฟังก์ชันแบบมาตราฐาน น่าจะเป็นฟังก์ชันแบบแรกที่ทุกคนเรียนกัน โดยกฎของ Pure Function (ภาษาไทยเรียก "ฟังก์ชันพิสุทธิ์") มีอยู่คอนเซ็ปหลักๆ เลยคือ "Pure Function จะรับค่า Input (ที่เรียกว่า parameter) ไปจำนวนหนึ่ง แล้วส่งผลลัพท์ออกมาเป็น output 1 ค่า" ... อ่ะ ดูตัวอย่าง

//ฟังก์ชันแบบรับ parameter 1 ตัว
function plusOne(x){
    return x + 1
}

//ฟังก์ชันแบบรับ parameter 2 ตัว
function add(a, b){
    return a + b
}

//ฟังก์ชั่นแบบไม่รับ parameter แบบนี้ไม่ค่อยมีประโยชน์เท่าไหร่
function gravity(){
    return 9.8
}

//ฟังก์ชันที่ไม่มีการ return ค่ากลับมา แบบนี้ไม่ถือว่าเขียนตามคอนเซ็ปของ pure function
function display(name){
    console.log(name)
}

ซึ่งโดยส่วนใหญ่แล้วฟังก์ชันที่รับค่า input เดิมมักจะให้ค่า output เหมือนเดิม เช่น add(1,2) = 3 ถ้าเราเรียกใช้ add(1,2) อีกครั้งคำตอบที่ได้ก็สมควรจะได้ 3 เท่าเดิม

แต่ก็ไม่จำเป็นนะว่ามันจะต้องเป็นแบบนี้ทุกฟังก์ชัน เช่น ฟังก์ชันสร้าง hash-key หรือ token แบบ "one-time use" และฟังก์ชันที่อิงกับการ random

สำหรับภาษา JavaScript เราอนุญาตให้ function หยิบตัวแปรข้างนอก (global) เข้ามาใช้ได้ เช่น

let sum = 0;
function accumulate(x){
    sum = sum + x;
    return sum;
}

สังเกตว่าฟังก์ชันนี้ถึงจะใส่ input เป็นค่าเดิมก็อาจจะได้ output ที่เปลี่ยนไปทุกรอบ เพราะการทำงานของฟังก์ชันได้รับผลจากค่าภายนอกฟังก์ชัน หรือ External Factor

แปลว่าค่า output ของฟังก์ชันเราอันนี้ ไม่ได้ขึ้นอยู่กับตัวเอง (คือโปรเซสภายใน หรือ input) แต่อิงตามค่าภายนอกด้วย แบบนี้ไม่เรียกว่า pure function นะ!

มาถึงตอนนี้อาจจะสงสัยว่า แต่มันเขียนได้ไม่ใช่เหรอ?

ใช่แล้ว มันเขียนได้ แต่ถือว่าไม่ใช่ pure function ไงล่ะ

ถ้าเลื่ยงได้ ก็ควรจะเลียงกัน แล้วเขียนในรูปแบบ pure function จะดีกว่านะ

2. First-Class Functions

First-Class หมายถึงการเป็นประชากรชั้นหนึ่ง (คล้ายๆ คำว่า First-Class Citizen ที่หมายถึงพลเมืองชั้นหนึ่งของประเทศ ไม่ใช่คนต่างด้าว)

หมายถึงการที่เราสามารถจับฟังก์ชันยัดลงไปเป็นตัวแปรได้ (ปกติเวลาเราสร้างตัวแปรก็มีแค่ int double string object อะไรประมาณนั้นใช่มั้ยล่ะ) ทีนี้ถ้าเรามองว่าฟังก์ชันก็เป็นตัวแปรได้ล่ะ จะออกมาเป็นยังไง

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

อันนี้คือฟังก์ชันจากข้อที่แล้ว ปกติเวลาเราจะใช้งานฟังก์ชัน add เราก็ต้องเรียกผ่าน add(x,y) งั้นลองมาดูขั้นต่อไป

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

let addIt = add

add(1,2) //3
addIt(1,2) //3

นั่นคือเราสามารถสร้างตัวแปร addIt เอามาเก็บค่า add (ความจริงคือไม่ได้เก็บค่า แต่เป็นการ pointer ไปที่ฟังก์ชั่นนั้น) สังเกตดีๆ ว่าเราไม่ได้สั่งว่า addIt = add() เพราะแบบนั้นจะเป็นการสั่งให้ฟังก์ชั่นทำงาน addIt จะไม่ได้เก็บค่าฟังก์ชัน แต่เก็บผลลัพธ์แทน

ส่วนการใช้งาน เราสามารถสั่งให้ addIt ทำงานได้เช่นเดียวกับการสั่ง add() นั่นคือการเติม () ลงไปข้างหลัง

หรือแบบนี้เลยก็ได้

const addIt = function add(a, b){
    return a + b
}

add(1,2) //3
addIt(1,2) //3

อันนี้ เราสร้างตัวแปร addIt มารับฟังก์ชันเมื่อกี้อีกที แล้วเราก็สามารถเรียกใช้งาน addIt(1,2) แบบนี้ได้เลย! ว้าว!

หรือแม้แต่ลดรูปให้เหลือแค่นี้ก็ได้ เพราะชื่อฟังก์ชัน add ไม่ได้ใช้งานเลย เลยไม่ต้องไปตั้งชื่อให้มันก็ได้

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

//เลยเป็นที่มาของการเขียนให้อยู่ในรูปของ Arrow Function แบบนี้แทน

const add = (a, b) => a + b;

การสร้างฟังก์ชันแบบนี้เราเรียกว่า anonymous function หรือฟังก์ชันนิรนาม และเพราะมันไม่มีชื่อ เราเลยต้องจับมันใส่ลงในตัวแปรยังไงล่ะ และใช้ตัวแปรนั้นแทนฟังก์ชันตัวนี้เลย

(และเนื่องจากฟังก์ชันนั้นไม่ควรเปลี่ยนวิธีการทำงานได้ ดังนั้นเขาเลยใช้ const แทน let นะ)

การมองฟังก์ชันเป็นตัวแปร สามารถเปลี่ยนค่าได้แบบนี้เราเรียกว่าคุณสมบัติแบบ First-Class ซึ่งเป็นการล้อกับคำว่า First-Class Citizen หรือประชากรชั้นหนึ่งของสังคม ถ้าฟังก์ชันเป็นประชากรชั้นหนึ่ง มันก็สามารถเก็บลงในตัวแปรได้เหมือนยังประมาณนั้นล่ะ