JavaScript Academy · บทเรียน

การประกอบฟังก์ชัน

รวมฟังก์ชันขนาดเล็กเข้าด้วยกันเป็นกระบวนการต่อเนื่อง

การประกอบฟังก์ชัน เป็นบทเรียน JavaScript Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน JavaScript Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส JavaScript Academy มีบทเรียนทั้งหมด 4 บทเรียน

การประกอบฟังก์ชันคืออะไร

การประกอบฟังก์ชันคือการรวมฟังก์ชันขนาดเล็กเข้าด้วยกันเป็นฟังก์ชันเดียว การประกอบ f และ g จะได้ฟังก์ชันที่ผลลัพธ์ของ g กลายเป็นข้อมูลเข้าของ f

ในทางคณิตศาสตร์ compose(f, g)(x) = f(g(x)) ข้อมูลจะไหลจากขวาไปซ้าย

ฟังก์ชันขนาดเล็กสองฟังก์ชัน

การประกอบฟังก์ชันเริ่มต้นจากฟังก์ชันง่าย ๆ ที่มีจุดประสงค์เดียว ต่อไปนี้คือตัวอย่างการแปลงสองแบบที่เราจะนำมารวมกัน

const double = x => x * 2;
const increment = x => x + 1;

console.log(double(5));
console.log(increment(5));

การประกอบด้วยตนเอง

การประกอบฟังก์ชันที่ชัดเจนที่สุดคือการเรียกใช้ฟังก์ชันหนึ่งกับผลลัพธ์ของอีกฟังก์ชันหนึ่ง อ่านจากด้านในออกด้านนอก: increment ทำงานก่อน แล้วจึงเป็น double

const double = x => x * 2;
const increment = x => x + 1;

const result = double(increment(5));
console.log(result);

ฟังก์ชัน compose สำหรับสองฟังก์ชัน

ห่อรูปแบบดังกล่าวไว้ใน compose ที่นำกลับมาใช้ซ้ำได้ ฟังก์ชันนี้รับ f และ g แล้วส่งกลับฟังก์ชันใหม่ที่ใช้ g ก่อน จากนั้นจึงใช้ f

const compose = (f, g) => x => f(g(x));

const double = x => x * 2;
const increment = x => x + 1;

const doubleThenAfterIncrement = compose(double, increment);
console.log(doubleThenAfterIncrement(5));

ลำดับมีความสำคัญ

การประกอบฟังก์ชัน ไม่ใช่การสลับที่ได้ compose(f, g) แตกต่างจาก compose(g, f) เพราะฟังก์ชันทางขวาจะทำงานก่อน

const compose = (f, g) => x => f(g(x));

const double = x => x * 2;
const increment = x => x + 1;

console.log(compose(double, increment)(5));
console.log(compose(increment, double)(5));

การอ่านจากขวาไปซ้าย

ใน compose(a, b, c)(x) การเรียกใช้จะประเมินผลเป็น a(b(c(x))) ฟังก์ชันขวาสุดจะรับข้อมูลเข้าก่อน โปรดจำทิศทางนี้ไว้เพื่อหลีกเลี่ยงข้อผิดพลาด

const compose = (f, g) => x => f(g(x));

const shout = s => s.toUpperCase();
const exclaim = s => s + '!';

const loud = compose(shout, exclaim);
console.log(loud('hello'));

การประกอบฟังก์ชันแปลงข้อความ

การประกอบฟังก์ชันเหมาะอย่างยิ่งกับสายการประมวลผลข้อความ โดยเริ่มจาก trim ตามด้วยการแปลงเป็นตัวพิมพ์เล็ก แล้วจึงแทนที่ช่องว่าง แต่ละขั้นตอนเป็นฟังก์ชันขนาดเล็ก

const compose = (f, g) => x => f(g(x));

const trim = s => s.trim();
const lower = s => s.toLowerCase();

const clean = compose(lower, trim);
console.log(clean('   HELLO World  '));

การประกอบฟังก์ชันกับตัวเลข

การต่อการดำเนินการทางคณิตศาสตร์เป็นตัวอย่างคลาสสิก แต่ละฟังก์ชันยังคงสามารถทดสอบแยกกันได้อย่างง่ายดาย

const compose = (f, g) => x => f(g(x));

const square = x => x * x;
const negate = x => -x;

const negativeSquare = compose(negate, square);
console.log(negativeSquare(4));

เหตุใดจึงต้องใช้ compose

การประกอบฟังก์ชันช่วยให้แต่ละฟังก์ชันมุ่งเน้นงานของตนเองและนำกลับมาใช้ซ้ำได้ อีกทั้งลดความรกจากการเรียกใช้ซ้อนกัน แทนที่จะมี f(g(h(x))) กระจายอยู่ทั่วโค้ด คุณสามารถสร้างสายการประมวลผลที่ตั้งชื่อไว้ครั้งเดียวแล้วนำกลับมาใช้ซ้ำได้

const compose = (f, g) => x => f(g(x));

const toCents = d => Math.round(d * 100);
const addLabel = c => c + ' cents';

const priceLabel = compose(addLabel, toCents);
console.log(priceLabel(2.5));

การประกอบฟังก์ชันและการทำเคอร์รีร่วมกัน

ฟังก์ชัน curried ประกอบเข้าด้วยกันได้อย่างลงตัว เพราะแต่ละฟังก์ชันให้ผลเป็นฟังก์ชันที่รับอาร์กิวเมนต์เดียว ซึ่งตรงกับสิ่งที่การประกอบฟังก์ชันต้องการ

const compose = (f, g) => x => f(g(x));
const add = a => b => a + b;
const multiply = a => b => a * b;

const addThenDouble = compose(multiply(2), add(3));
console.log(addThenDouble(5));

ก้าวสู่ฟังก์ชันจำนวนมาก

จนถึงตอนนี้ compose รองรับฟังก์ชันสองตัว การประกอบฟังก์ชันจริงรองรับฟังก์ชันจำนวนเท่าใดก็ได้ ในบทเรียนถัดไป คุณจะสร้าง compose ทั่วไปและ pipe ซึ่งเป็นรูปแบบจากซ้ายไปขวา โดยใช้ reduce

const compose = (f, g) => x => f(g(x));
const a = x => x + 1;
const b = x => x * 2;
const c = x => x - 3;

const combined = compose(a, compose(b, c));
console.log(combined(10));

ตรวจสอบความเข้าใจอย่างรวดเร็ว

หาก compose = (f, g) => x => f(g(x)) แล้ว compose(double, increment)(5) จะส่งกลับค่าใด เมื่อ double คูณด้วย 2 และ increment บวก 1

ทบทวน: การประกอบฟังก์ชัน

คุณได้เรียนรู้การรวมฟังก์ชันเข้าด้วยกัน ดังนี้

compose(f, g)(x) เท่ากับ f(g(x)) โดยประเมินผลจากขวาไปซ้าย
ลำดับมีความสำคัญ การประกอบฟังก์ชันไม่ใช่การสลับที่ได้
การประกอบฟังก์ชันช่วยให้ฟังก์ชันมีขนาดเล็ก ตั้งชื่อได้ และนำกลับมาใช้ซ้ำได้
ฟังก์ชัน curried ประกอบเข้าด้วยกันได้อย่างเรียบร้อย ต่อไปคุณจะขยายให้รองรับฟังก์ชันจำนวนเท่าใดก็ได้

คำถามที่พบบ่อย

บทเรียน “การประกอบฟังก์ชัน” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การประกอบฟังก์ชัน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส JavaScript Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส JavaScript Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การประกอบฟังก์ชัน”

รวมฟังก์ชันขนาดเล็กเข้าด้วยกันเป็นกระบวนการต่อเนื่อง คุณปฏิบัติ JavaScript Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน JavaScript Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน JavaScript Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน

บทเรียน “การประกอบฟังก์ชัน” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน JavaScript Academy นี้ได้ไหม

ได้ บทเรียน JavaScript Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ JavaScript Academy