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

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

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

async function doSomthimg() {
  let a = 0;
  for (let i = 0; i < 100; i++) a++;
  return a;
}

router.get("/", async (req, res, next) => {
  let result = await doSomthimg();
  res.send(result);
});

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

לעומת

function doSomthimg() {
  let a = 0;
  for (let i = 0; i < 100; i++) a++;
  return a;
}

router.get("/", async (req, res, next) => {
  let result = doSomthimg();
  res.send(result);
});

(את הasync בשורה 7 בדוגמה האחרונה השארתי בכונה).

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

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

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

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

function a(cb){
    cb()
}
a(()=>console.log(1))
console.log('fast code win!!')

הפעם 1 יודפס לפני 'fast code win!!', למרות שהוא בתוך קולבק. היות שהוא לא כולל בתוכו שום פעולה שדורשת התנהגת סנכרונית, הקולבק מתבצע קודם.
כלומר לפרומיס יש התנהגות מיוחדת, זו לא סתם העברת כל הקוד אל תוך קולבק. הפרומיס זה אובייקט שכביכול מניח מראש שיש בתוכו פעולה סנכרונית, ולפיכך מריץ את הקלבק שלו ומתחיל להתבצע רק אחר סיום הקוד שאחריו.
אז בהחלט מובן שawait הוא סוכר תחבירי לקלבק, זה אני מבין. אבל פרומיס הוא לכאורה התנהגות אמיתית שונה. ואם זה נכון - זה מחזיר את השאלה האם כדאי להשתמש בו כשלא צריכים אותו. בהנחה שהוא מתנהג בצורה שונה בכך שהוא מפעיל את הקולבק שבתוכו רק בסיום הevent loop, ואם כן הוא מצריך להמתין לו אם רוצים לשמור על התזמון, שזה אומר בעצם להעתיק את כל הקוד שאחריו על תוך הקולבק של הפרומיס - שמופעל אחרי שכל קוד אחר שמחוץ לפרומיס מתבצע.

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

מקוה שהייתי מובן.

@dovid אמר בפרומיסים לוקחים זמן?:

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

חידה לי דבריך. לא להמתין - לא בגלל מהירות, אלא כדי לתת ללקוח תשובה כמה שיותר מהר??

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

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

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

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

async function getData(userData) {
  if (userData.type == undefined) {
    userData.type = await readFile(`path/to/${userData.id}`);
  }
  return userData.type == "manager" ? "secreet data" : "free data";
}

router.get("/", async (req, res, next) => {
  const userData = req.body.userData;
  let result = await getData(userData);
  res.send(result);
});

לעומת זאת, יכולתי לכתוב את הקוד בצורה כזו:

async function getData(userData) {
  return userData.type == "manager" ? "secreet data" : "free data";
}

async function getUnexpectedData(userData) {
  userData.type = await readFile(`path/to/${userData.id}`);
  return userType == "manager" ? "secreet data" : "free data";
}

router.get("/", async (req, res, next) => {
  const userData = req.body.userData;

  let result;

  if (userData.type == undefined) {
    result = await getUnexpectedData(userData);
  } else {
    result = getData(userData);
  }
  res.send(result);
});

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

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

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

אז לגוף השאלה:
אתה אומר שהמשמעות זניחה ולא אמורה להטריד אותי. היות שאני מדבר על מקרה שאמור להיות מאתגר מבחינת ביצועים והמהירות חשובה לי מאוד ברמת חלקי שניות (עשרות קריאות לפונקציה רקורסיבית שמורצת בסוף מאות פעמים, כשאני מצפה מהשרת לתשובה בזמן אפס או קרוב לכך), לא התעצלתי ועשיתי את הגוגל אליו שלחתי אותי, שהוביל אותי למאמר הבא:
https://madelinemiller.dev/blog/javascript-promise-overhead/

המאמר הזה מתמקד בדיוק בשאלתי, ובודק כמה מקרים. מסקנתה היא ששימוש מיותר בפונקציית async גורם לפונקציה להיות איטית בין 81-85 אחוז (כמעט חצי מהירות). ושימוש מיותר בפרומיס (לא ידעתי שיש הבדל בינו לפונקציית async) גורם לאיטיות של כ26%.

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

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

async function getData() {
  const res = await readFiles("path");
  return res;
}
async function run() {
  const res = await getData();
  console.log(res);
}

במקום קוד כזה:

function getData() {
  return readFiles("path");
}
async function run() {
  const res = await getData();
  console.log(res);
}

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

@dovid אמר בפרומיסים לוקחים זמן?:

@davidnead אני לא מבין מה שהוא כותב עם האחוזים, אבל זה לא נוגע לך, מבטיח לך.

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

וגם הV8 היה מחסל ממזמן את הבעיה ע"י אופטימיזציה שמתעלמת מהasync המזוייף.

אממ... הגיוני.

תודה גם לך