การประกอบฟังก์ชันด้วยชนิดข้อมูล
ประกอบฟังก์ชันโดยยังคงความปลอดภัยด้านชนิดข้อมูล
การประกอบฟังก์ชันด้วยชนิดข้อมูล เป็นบทเรียน TypeScript Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน TypeScript Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส TypeScript Academy มีบทเรียนทั้งหมด 4 บทเรียน
การประกอบคืออะไร
การประกอบฟังก์ชัน รวมฟังก์ชันขนาดเล็กเข้าด้วยกันเป็นฟังก์ชันที่ใหญ่ขึ้น compose(f, g) จะสร้างฟังก์ชันที่เรียกใช้ g ก่อน แล้วส่งผลลัพธ์ต่อให้ f
คำจำกัดความหลัก
ในทางคณิตศาสตร์ compose(f, g)(x) = f(g(x)) ฟังก์ชันจะทำงาน จากขวาไปซ้าย โดยฟังก์ชันที่อยู่ขวาสุดจะทำงานก่อน
const compose = (f: (n: number) => number, g: (n: number) => number) =>
(x: number) => f(g(x));
const inc = (n: number) => n + 1;
const dbl = (n: number) => n * 2;
console.log(compose(inc, dbl)(5)); // 11 (5*2 then +1)ลำดับจากขวาไปซ้าย
ลำดับมีความสำคัญ compose(inc, dbl) จะคูณสองก่อนแล้วจึงเพิ่มค่า ส่วน compose(dbl, inc) จะเพิ่มค่าก่อนแล้วจึงคูณสอง ให้อ่านการประกอบจากด้านในออกด้านนอก
console.log(compose(dbl, inc)(5)); // 12 (5+1 then *2)การระบุชนิดของการประกอบด้วยเจเนอริก
เจเนอริกทำให้ชนิดข้อมูลอินพุตและเอาต์พุตแตกต่างกันได้ g แปลง A เป็น B ส่วน f แปลง B เป็น C ดังนั้นผลลัพธ์จึงแปลง A เป็น C
function compose<A, B, C>(f: (b: B) => C, g: (a: A) => B): (a: A) => C {
return a => f(g(a));
}การเปลี่ยนชนิดข้อมูลระหว่างทาง
เนื่องจากเจเนอริกเชื่อมต่อกันเป็น A -> B -> C การประกอบจึงสามารถแปลงค่าผ่านรูปแบบข้อมูลหลายแบบได้ เช่น จากสตริงเป็นตัวเลขแล้วกลับเป็นสตริง
const length = (s: string) => s.length;
const toStr = (n: number) => "len=" + n;
const describe = compose(toStr, length);
console.log(describe("hello")); // len=5ขอบเขตชนิดข้อมูลต้องตรงกัน
เอาต์พุตของ g ต้องตรงกับอินพุตของ f หากไม่ตรงกัน คอมไพเลอร์จะปฏิเสธการประกอบและตรวจพบข้อผิดพลาดในการเชื่อมต่อได้ตั้งแต่เนิ่น ๆ
// compose(length, toStr) would error:
// toStr returns string, length expects string -> ok here,
// but mismatched pairs are flagged by the compiler.การประกอบฟังก์ชันสามตัว
คุณสามารถซ้อนการประกอบหรือเขียนเวอร์ชันที่รับอาร์กิวเมนต์สามตัวได้ กฎจากขวาไปซ้ายยังคงใช้กับทุกกรณี
const compose3 = <A, B, C, D>(
f: (c: C) => D, g: (b: B) => C, h: (a: A) => B
) => (a: A): D => f(g(h(a)));
const inc = (n: number) => n + 1;
const dbl = (n: number) => n * 2;
const neg = (n: number) => -n;
console.log(compose3(neg, dbl, inc)(3)); // -8การประกอบสร้างสายการประมวลผล
เมื่อประกอบฟังก์ชันบริสุทธิ์ขนาดเล็กเข้าด้วยกัน คุณจะสร้างการแปลงข้อมูลที่ซับซ้อนได้แบบประกาศ แต่ละส่วนยังสามารถทดสอบแยกกันได้
const trim = (s: string) => s.trim();
const upper = (s: string) => s.toUpperCase();
const clean = compose(upper, trim);
console.log(clean(" hi ")); // HIเหตุใดฟังก์ชันบริสุทธิ์จึงเหมาะกับการประกอบที่สุด
การประกอบตั้งอยู่บนสมมติฐานว่าแต่ละฟังก์ชันขึ้นอยู่กับอินพุตของตนเท่านั้น ฟังก์ชันบริสุทธิ์รับประกันคุณสมบัตินี้ ดังนั้นการประกอบฟังก์ชันเหล่านี้จึงได้ฟังก์ชันบริสุทธิ์ที่คาดเดาผลลัพธ์ได้อีกหนึ่งฟังก์ชัน
compose เทียบกับ pipe
compose ทำงานจากขวาไปซ้ายและสอดคล้องกับสัญกรณ์ทางคณิตศาสตร์ หลายคนชอบอ่านจากซ้ายไปขวามากกว่า ซึ่งเป็นรูปแบบที่ pipe มีให้ และจะกล่าวถึงในหัวข้อถัดไป
แบ่งส่วนประกอบให้เล็ก
การประกอบจะแสดงจุดเด่นได้เต็มที่เมื่อแต่ละฟังก์ชันทำงานเล็ก ๆ เพียงอย่างเดียว ขั้นตอนที่เล็ก ตั้งชื่อไว้ และบริสุทธิ์ จะทำให้สายการประมวลผลที่ประกอบแล้วอธิบายตัวเองได้และจัดลำดับใหม่ได้ง่าย
ตรวจสอบความเข้าใจ
ตรวจสอบความเข้าใจสั้น ๆ เกี่ยวกับบทเรียนนี้
สรุปทบทวน
compose(f, g)(x) = f(g(x)) ทำงานจากขวาไปซ้าย การระบุชนิดแบบเจเนอริกเชื่อมต่อกันเป็น A -> B -> C ดังนั้นเอาต์พุตของ g ต้องตรงกับอินพุตของ f ทำให้คอมไพเลอร์ตรวจสอบสายการประมวลผลของฟังก์ชันบริสุทธิ์ขนาดเล็กได้
คำถามที่พบบ่อย
บทเรียน “การประกอบฟังก์ชันด้วยชนิดข้อมูล” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “การประกอบฟังก์ชันด้วยชนิดข้อมูล” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส TypeScript Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส TypeScript Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “การประกอบฟังก์ชันด้วยชนิดข้อมูล”
ประกอบฟังก์ชันโดยยังคงความปลอดภัยด้านชนิดข้อมูล คุณปฏิบัติ TypeScript Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน TypeScript Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน TypeScript Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน
บทเรียน “การประกอบฟังก์ชันด้วยชนิดข้อมูล” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน TypeScript Academy นี้ได้ไหม
ได้ บทเรียน TypeScript Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ฟังก์ชันบริสุทธิ์และการไม่เปลี่ยนแปลงข้อมูล
- การทำเคอร์รีและการประยุกต์ใช้บางส่วน
- การประกอบฟังก์ชันด้วยชนิดข้อมูล
- ยูทิลิตี pipe และ flow แบบมีชนิดข้อมูล