פונקציות טהורות ב-JavaScript וכיצד ליצור אותן

פונקציות טהורות הן פונקציות שאינן מייצרות תופעות לוואי וכאשר הן נקראות עם אותם פרמטרי קלט, תמיד יחזירו את אותו פלט.

אתה יכול להשתמש בפונקציות טהורות כדי להבטיח שהקוד שלך נקי, ניתן לתחזוקה וניתן לבדיקה. פונקציות אלו אידיאליות עבור משימות אלו מכיוון שהן ניתנות לחיזוי ואינן משנות מצבים חיצוניים.

הם גם יותר קלים לניפוי באגים, מה שהופך אותם למועילים בפיתוח מערכות תוכנה מורכבות. כאן תוכלו לחקור פונקציות טהורות ב-JavaScript, המאפיינים שלהן ויתרונותיהן.

מאפיינים של פונקציה טהורה

ל תפקוד כדי להיות "טהור", זה צריך לעמוד בכמה דרישות.

ערך החזר קבוע

פונקציה טהורה צריכה תמיד להחזיר את אותו ערך בהינתן אותו קלט, ללא קשר למספר הפעמים שהיא נקראת.

לדוגמה, שקול את הפונקציה שלהלן:

פוּנקצִיָהלְהַכפִּיל(א, ב) {
לַחֲזוֹר a * ב;
}

ה לְהַכפִּיל הפונקציה בדוגמה למעלה תמיד תחזיר את המכפלה של שני הארגומנטים שלה. בהינתן אותה סט של ארגומנטים, יש לו ערך החזרה קבוע.

קריאה לפונקציה זו מספר פעמים עם אותם ארגומנטים תניב את אותו פלט בכל פעם. לדוגמה:

לְהַכפִּיל(2, 3); // מחזירה 6
לְהַכפִּיל(2, 3); // מחזירה 6
לְהַכפִּיל(2, 3); // מחזירה 6

לחלופין, שקול את הדוגמה שלהלן:

פוּנקצִיָהmultiplyRandomNumber(מספר) {
לַחֲזוֹר מספר * מתמטיקה.קוֹמָה(מתמטיקה.random() * 10);
}
multiplyRandomNumber(5); // תוצאות בלתי צפויות
multiplyRandomNumber(5); // תוצאות בלתי צפויות
multiplyRandomNumber(5); // תוצאות בלתי צפויות

ה multiplyRandomNumber הפונקציה למעלה תחזיר תוצאות שונות בכל פעם שתקרא לה, מה שהופך אותה לטמאה. התוצאות של פונקציה זו אינן ניתנות לחיזוי, ולכן קשה לבדוק רכיבים המסתמכים עליה.

ללא תופעות לוואי

אסור שתפקוד טהור ייצור תופעות לוואי. תופעת לוואי מתייחסת לכל שינוי של מצב או התנהגות מחוץ להיקף הפונקציה, כגון שינוי משתנים גלובליים, פלט מסוף, בקשות רשת או מניפולציה של DOM.

כאשר לתפקוד טהור יש תופעת לוואי, היא כבר לא טהורה מכיוון שהיא משפיעה על המצב החיצוני ומפרה את העיקרון של אין תופעות לוואי נצפות. לכן, פונקציות טהורות נמנעות מתופעות לוואי כדי להבטיח שהן לא משנות את מצב התוכנית.

לדוגמה, שקול את הדוגמה שלהלן:

לתת לספור = 0;
פוּנקצִיָהתוֹסֶפֶת() {
 count++;
לְנַחֵם.log (ספירה);
}
תוֹסֶפֶת(); // יומנים 1
תוֹסֶפֶת(); // יומנים 2
תוֹסֶפֶת(); // יומנים 3

ה תוֹסֶפֶת לפונקציה בדוגמה זו יש תופעת לוואי של שינוי ה- לספור משתנה מחוץ לתחום שלו. זה גם מתחבר לקונסולה.

פונקציה זו אינה טהורה מכיוון שיש לה תופעת לוואי, שעלולה להקשות על חיזוי התפוקה שלה ובדיקה במנותק. כדי להפוך אותו טהור, אתה יכול לשנות אותו כדי לקחת את לספור משתנה כארגומנט ולהחזיר את הערך המוגדל מבלי לשנות מצב חיצוני כלשהו.

ככה:

פוּנקצִיָהתוֹסֶפֶת(לספור) {
לַחֲזוֹר לספור + 1;
}
תוֹסֶפֶת(1); // מחזירה 2
תוֹסֶפֶת(1); // מחזירה 2
תוֹסֶפֶת(1); // מחזירה 2

הגרסה של תוֹסֶפֶת לפונקציה בדוגמה למעלה אין תופעות לוואי מכיוון שהיא לא משנה שום משתנה חיצוני או מתעדת שום ערך. בנוסף, לא משנה כמה פעמים תקרא לזה, זה מחזיר את אותו ערך עבור אותו קלט. לכן, זו פונקציה טהורה.

דמויות אחרות

בנוסף לכך שיש לך ערך החזר קבוע ואינו מייצר תופעות לוואי כלשהן, עליך להקפיד על הכללים הבאים כאשר אתה יצירת פונקציית JavaScript שאתה רוצה להיות טהור:

• אסור לפונקציה שלך לשנות אף אחד מהארגומנטים שלה. במקום זאת, אם פעולה כלשהי דורשת מוטציה, צור עותק של הארגומנט ושנה את העותק.
• לפונקציה שלך חייב להיות תמיד ערך החזרה. אם לפונקציה שלך אין ערך החזרה או תופעות לוואי כלשהן, היא לא יכולה לעשות כלום!
• אסור שהפונקציה שלך תהיה תלויה במצב חיצוני כלשהו.

היתרונות של Pure Functions

לפונקציות טהורות יש יתרונות מסוימים על פני פונקציות לא טהורות, שחלקן כוללות את הדברים הבאים.

יכולת בדיקה

קל לבדוק פונקציות טהורות מכיוון שהתנהגות הקלט/פלט שלהן מוגדרת היטב. כמו כן, פונקציות טהורות אינן תלויות במצב חיצוני או בתופעות לוואי. לכן, אתה יכול לבדוק אותם בבידוד מבלי לדאוג לגבי תלות או אינטראקציות עם חלקים אחרים של התוכנית.

לעומת זאת, בדיקת פונקציות לא טהורות התלויות במצב חיצוני או מייצרות תופעות לוואי יכולה להיות מאתגרת יותר מכיוון שהתנהגותן עשויה להיות תלויה במצב התוכנית או בגורמים חיצוניים אחרים. זה יכול להקשות על יצירת מקרי בדיקה מקיפים ולהבטיח שהפונקציה מתנהגת כהלכה בכל התרחישים.

שינון

מכיוון שפונקציות טהורות תמיד מייצרות את אותו פלט עבור אותו קלט ואינן מייצרות תופעות לוואי, אתה יכול בקלות לשנן אותן.

על ידי הסתמכות על מאפיינים אלה ושימוש בזיכרון, אתה יכול לשמור את התוצאה של קריאת פונקציה טהורה עבור קלט ספציפי. לאחר מכן, הפונקציה שלך יכולה להחזיר את התוצאה המאוחסנת במטמון בפעם הבאה שהיא תיקרא עם אותו קלט.

שינון פונקציות טהורות יכול לשפר את ביצועי התוכנית, במיוחד עבור חישובים יקרים שעוסקים שוב ושוב באותו קלט, מבלי לדאוג להפרעה למצב התוכנית.

לעומת זאת, פונקציות לא טהורות יכולות לייצר תוצאות שונות עבור אותו קלט, בהתאם למצב התוכנית או לגורמים חיצוניים. זה הופך אותם למאתגרים לזיכרון, מכיוון שהתוצאה המאוחסנת במטמון לא תהיה תקפה עוד אם התלות של הפונקציה או המצב החיצוני של הפונקציה משתנים בין שיחות.

במקביל

מכיוון שפונקציות טהורות אינן משנות שום מצב חיצוני או מייצרות תופעות לוואי כלשהן, הן בטוחות לחוט. אתה יכול להפעיל אותם במקביל מבלי לדאוג לתנאי מרוץ או בעיות סנכרון.

לעומת זאת, פונקציות לא טהורות יכולות להיות מאתגרות לביצוע במקביל מכיוון שהן עלולות להפריע זו לזו או לייצר התנהגות בלתי צפויה כאשר הן מבוצעות במקביל. לדוגמה, אם שני שרשורים ניגשים ומשנים את אותו משתנה גלובלי, הם עלולים לדרוס את השינויים של זה או להפיק תוצאות לא עקביות.

Pure Functions לעומת פונקציות לא טהורות

אתה יכול לכתוב תוכניות באמצעות שילוב של פונקציות טהורות ולא טהורות, מכיוון שלכל סוג יש את השימושים שלו.

קל לבצע אופטימיזציה, בדיקה והקבילה של פונקציות טהורות, מה שהופך אותן למתאימות למקרי שימוש כגון תכנות פונקציונלי, מטמון, בדיקה, תכנות מקביל ומשימות עיבוד נתונים.

עם זאת, פונקציות לא טהורות מציבות אתגרים בבדיקות ובמקבילות, אך מועילות כאשר עובדים עם מבני נתונים הניתנים לשינוי או אינטראקציה עם מערכות ומשאבים חיצוניים.