ในบทความนี้ เราจะมาสำรวจว่าฟังก์ชันบริสุทธิ์/ไม่บริสุทธิ์คืออะไร และความแตกต่างใน JavaScript มาดำดิ่งกัน..
ฟังก์ชั่นคืออะไร?
ในมหาสมุทรแห่ง JavaScript ฟังก์ชันต่างๆ เป็นส่วนสำคัญในการสร้างแอปที่ซับซ้อนและโต้ตอบได้
การใช้ฟังก์ชันที่พบบ่อยที่สุดประการหนึ่งคือการแมป โดยที่ฟังก์ชันจะรับค่าอินพุตและสร้างค่าเอาต์พุตที่สอดคล้องกัน สิ่งนี้ทำให้เกิดการเปลี่ยนแปลงและการจัดการข้อมูล ซึ่งเป็นสิ่งสำคัญในการสร้างประสบการณ์ผู้ใช้แบบไดนามิก
ฟังก์ชั่นบริสุทธิ์คืออะไร?
ฟังก์ชันแท้คือฟังก์ชันที่ค่าส่งคืนถูกกำหนดโดยอาร์กิวเมนต์เท่านั้นโดยไม่มีผลข้างเคียง สมมติว่า หากคุณเรียกใช้ฟังก์ชันที่มีอาร์กิวเมนต์เดียวกัน n จำนวนครั้งและ n จำนวนตำแหน่งในแอปพลิเคชัน ฟังก์ชันจะส่งกลับค่าเดียวกันเสมอ ฟังก์ชัน Pure จะไม่แก้ไขสถานะภายนอกใดๆ เช่น ตัวแปรหรืออ็อบเจ็กต์ที่อยู่ภายนอกฟังก์ชัน พวกเขาใช้เฉพาะอาร์กิวเมนต์อินพุตเพื่อทำการคำนวณและส่งกลับผลลัพธ์
เพื่อแสดงให้คุณเห็นว่าฉันหมายถึงอะไร ..
ฟังก์ชันด้านล่างใช้ตัวเลขสองตัว a และ b เป็นอาร์กิวเมนต์อินพุตและส่งกลับผลรวม ฟังก์ชันนี้เป็นฟังก์ชันล้วนๆ เนื่องจากจะสร้างเอาต์พุตเดียวกันสำหรับอินพุตเดียวกันเสมอ และไม่มีผลข้างเคียงใดๆ
function add(a, b) {
return a + b;
}
ฟังก์ชั่นไม่บริสุทธิ์คืออะไร?
ฟังก์ชันที่ไม่บริสุทธิ์เป็นฟังก์ชันประเภทหนึ่งซึ่งมีอินพุตเดียวกัน และอาจให้เอาต์พุตต่างกันในเวลาที่ต่างกัน เนื่องจากฟังก์ชันที่ไม่บริสุทธิ์อาจขึ้นอยู่กับปัจจัยภายนอก เช่น การเปลี่ยนแปลงของตัวแปรร่วมหรือฟังก์ชันอื่นๆ ที่ส่งผลต่อพฤติกรรมและเอาต์พุตของฟังก์ชันเหล่านั้น
ฟังก์ชันด้านล่างจะปรับเปลี่ยนตัวนับตัวแปรภายนอกโดยเพิ่มค่าของมันทีละตัวทุกครั้งที่มีการเรียก ซึ่งหมายความว่ามีผลข้างเคียงและไม่ใช่ฟังก์ชันที่บริสุทธิ์
let counter = 0;
function increment() {
counter++;
return counter;
}
เหตุใดฟังก์ชันเพียวจึงมีประโยชน์
ฟังก์ชัน Pure มีข้อดีมากกว่าฟังก์ชันที่ไม่บริสุทธิ์หลายประการ:
1) ความสามารถในการคาดการณ์
เนื่องจากฟังก์ชันล้วนๆ จะสร้างเอาต์พุตเดียวกันเสมอสำหรับอินพุตที่กำหนด จึงสามารถคาดเดาได้และง่ายต่อการให้เหตุผล ง่ายต่อการทดสอบและแก้ไขข้อบกพร่องและลดโอกาสที่จะเกิดพฤติกรรมที่ไม่คาดคิดในโค้ดของคุณ
2) การนำกลับมาใช้ใหม่ได้
ฟังก์ชัน Pure เป็นแบบโมดูลาร์และมีอยู่ในตัวเอง ซึ่งหมายความว่าสามารถนำกลับมาใช้ใหม่ในส่วนต่างๆ ของโค้ดเบสของคุณได้ โดยไม่กระทบต่อส่วนอื่นๆ วิธีนี้จะช่วยประหยัดเวลาและลดจำนวนโค้ดที่คุณต้องเขียน
3) การทำงานแบบขนาน
เนื่องจากฟังก์ชันล้วนๆ ไม่ได้ปรับเปลี่ยนสถานะภายนอก จึงสามารถดำเนินการพร้อมกันได้โดยไม่ต้องกังวลกับสภาพการแข่งขันหรือปัญหาการซิงโครไนซ์อื่นๆ สิ่งนี้สามารถนำไปสู่โค้ดที่เร็วขึ้นและมีประสิทธิภาพยิ่งขึ้น
จะสร้างฟังก์ชั่นล้วนๆใน JavaScript ได้อย่างไร?
1) ใช้เฉพาะอาร์กิวเมนต์อินพุตเท่านั้น
ฟังก์ชัน Pure ควรใช้เฉพาะอาร์กิวเมนต์อินพุตในการคำนวณและส่งกลับผลลัพธ์ ไม่ควรแก้ไขสถานะภายนอกใดๆ หรืออาศัยตัวแปรภายนอก
2) หลีกเลี่ยงผลข้างเคียง
ฟังก์ชั่นบริสุทธิ์ไม่ควรมีผลข้างเคียงใดๆ เช่น การปรับเปลี่ยนตัวแปรภายนอกหรือวัตถุ ควรส่งคืนค่าตามอาร์กิวเมนต์อินพุตเท่านั้น
3) หลีกเลี่ยงสถานะโกลบอล
ฟังก์ชันเฉพาะควรหลีกเลี่ยงการใช้สถานะโกลบอล เช่น ตัวแปรหรืออ็อบเจ็กต์โกลบอล ซึ่งจะทำให้โค้ดของคุณคาดเดาได้น้อยลงและแก้ไขจุดบกพร่องได้ยากขึ้น
4) ส่งคืนค่า
ฟังก์ชัน Pure ควรส่งคืนค่าตามอาร์กิวเมนต์อินพุตเสมอ พวกเขาไม่ควรพึ่งพาตัวแปรภายนอกหรือวัตถุเพื่อสร้างผลลัพธ์
ฟังก์ชั่นบริสุทธิ์เทียบกับไม่บริสุทธิ์
ฟังก์ชั่นบริสุทธิ์ Inbuilt ใน JavaScript:
Math.abs(): ส่งกลับค่าสัมบูรณ์ของตัวเลข
Math.ceil(): ส่งกลับจำนวนเต็มที่น้อยที่สุดที่มากกว่าหรือเท่ากับตัวเลขที่กำหนด
Math.floor(): ส่งกลับจำนวนเต็มที่ใหญ่ที่สุดที่น้อยกว่าหรือเท่ากับตัวเลขที่กำหนด
Math.max(): ส่งกลับค่าสูงสุดจากชุดตัวเลข
Math.min(): ส่งคืนค่าต่ำสุดจากชุดตัวเลข
Math.round(): ส่งกลับจำนวนเต็มที่ใกล้เคียงที่สุดกับตัวเลขที่กำหนด
Math.sqrt(): ส่งคืนค่ารากที่สองของตัวเลขที่กำหนด
parseInt(): แปลงสตริงให้เป็นจำนวนเต็ม
parseFloat(): แปลงสตริงให้เป็นตัวเลขทศนิยม
JSON.parse(): แปลงสตริง JSON เป็นวัตถุ JavaScript
Array.prototype.concat(): ส่งกลับอาร์เรย์ใหม่ที่มีองค์ประกอบของอาร์เรย์เดิมบวกกับองค์ประกอบเพิ่มเติมใดๆ ที่ถูกส่งผ่านเป็นอาร์กิวเมนต์
Array.prototype.slice(): ส่งกลับอาร์เรย์ใหม่ที่มีส่วนหนึ่งของอาร์เรย์เดิม ที่ระบุโดยดัชนีเริ่มต้นและสิ้นสุด
Array.prototype.map(): ส่งกลับอาร์เรย์ใหม่ที่เป็นผลลัพธ์ของการเรียกใช้ฟังก์ชันที่มีให้ในแต่ละองค์ประกอบของอาร์เรย์เดิม
Array.prototype.filter(): ส่งคืนอาร์เรย์ใหม่ที่มีเฉพาะองค์ประกอบของอาร์เรย์ดั้งเดิมที่ตรงตามฟังก์ชันการทดสอบที่ให้มา
Array.prototype.reduce(): ส่งคืนค่าเดียวที่เป็นผลลัพธ์ของการใช้ฟังก์ชันที่มีให้กับแต่ละองค์ประกอบของอาร์เรย์
String.prototype.toUpperCase(): ส่งกลับสตริงใหม่ที่มีสตริงเดิมเป็นตัวพิมพ์ใหญ่ทั้งหมด
String.prototype.toLowerCase(): ส่งกลับสตริงใหม่ที่มีสตริงต้นฉบับเป็นตัวอักษรตัวพิมพ์เล็กทั้งหมด
ฟังก์ชั่นที่ไม่บริสุทธิ์ในตัวใน JavaScript:
Math.random(): ส่งกลับตัวเลขสุ่มระหว่าง 0 ถึง 1 ฟังก์ชันนี้อาศัยสถานะภายนอกซึ่งเป็นสถานะปัจจุบันของเครื่องกำเนิดตัวเลขสุ่มและเอาต์พุตจะเปลี่ยนแปลงทุกครั้งที่มีการเรียก
Date.now(): ส่งกลับการประทับเวลาปัจจุบันซึ่งเป็นจำนวนมิลลิวินาทีที่ผ่านไปนับตั้งแต่ January 1, 1970 ฟังก์ชันนี้อาศัยสถานะภายนอกซึ่งเป็นเวลาปัจจุบันและเอาต์พุตจะเปลี่ยนทุกครั้งที่มีการเรียกใช้
console.log(): เขียนข้อความไปยังคอนโซล ไม่ส่งคืนค่า แต่มีผลข้างเคียงจากการบันทึกข้อมูลไปยังคอนโซล
setTimeout(): เรียกใช้ฟังก์ชันหลังจากการหน่วงเวลาที่ระบุซึ่งระบุเป็นมิลลิวินาที ฟังก์ชันนี้มีผลข้างเคียงจากการตั้งเวลาฟังก์ชันที่จะดำเนินการในอนาคต
setInterval(): เรียกใช้ฟังก์ชันตามช่วงเวลาที่ระบุซึ่งระบุเป็นมิลลิวินาที ฟังก์ชันนี้มีผลข้างเคียงจากการตั้งเวลาฟังก์ชันให้ดำเนินการซ้ำๆ ในช่วงเวลาที่กำหนด
document.write(): เขียนเนื้อหา HTML ลงในเอกสาร ไม่ส่งคืนค่า แต่มีผลข้างเคียงจากการแก้ไขเอกสาร
Math.floor(Math.random() * (max — min + 1) + min): ส่งกลับจำนวนเต็มแบบสุ่มระหว่างช่วงที่กำหนด ฟังก์ชันนี้อาศัยสถานะภายนอกซึ่งเป็นสถานะปัจจุบันของเครื่องกำเนิดตัวเลขสุ่มและเอาต์พุตจะเปลี่ยนทุกครั้งที่มีการเรียก
Math.pow(): ส่งกลับผลลัพธ์ของการเพิ่มตัวเลขเป็นกำลังที่กำหนด แม้ว่าฟังก์ชันนี้จะบริสุทธิ์ทางคณิตศาสตร์ แต่ก็อาจส่งผลให้เกิดข้อผิดพลาดในการปัดเศษจุดทศนิยมซึ่งอาจทำให้เอาต์พุตไม่บริสุทธิ์ได้
❤ แรงจูงใจ:
🍀สนับสนุน
โปรดพิจารณาติดตามและสนับสนุนเราโดยสมัครรับข้อมูลช่องของเรา การสนับสนุนของคุณได้รับการชื่นชมอย่างมากและจะช่วยให้เราสร้างเนื้อหาเพื่อให้คุณเพลิดเพลินต่อไป ขอขอบคุณล่วงหน้าสำหรับการสนับสนุนของคุณ!
