דיון בנושא הביצועים בJS

dovid

העברתי לפה דיון כדי שיהיה מדריך נקי.

zvizvi

[1, 2].includes(1)

מהיר יותר מ

[1, 2].indexOf(1) >= 0

אהרן

@dovid
מאוד אודה לך, אם תהפוך את הקטעים ללינקים (לכאורה עדיף ישר לדף הטסט, אם לא אז למאמר).

אהרן

@dovid אמר בתכנות יעיל וביצועים, בJS (בפרט):

indexOf מהיר

עם זאת, חיפוש ע"י גישה למאפיין, מהיר יותר.

[1,2,3].forEach (key => isUpThree[key]: true)
isUpThree[2]
vs
[1,2,3].indexOf(2)

dovid

@zvizvi אמר בדיון בנושא הביצועים בJS:

[1, 2].includes(1)
מהיר יותר מ
[1, 2].indexOf(1) > 0

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

dovid

@אהרן אמר בדיון בנושא הביצועים בJS:

@dovid אמר בתכנות יעיל וביצועים, בJS (בפרט):

indexOf מהיר

עם זאת, חיפוש ע"י גישה למאפיין, מהיר יותר.
[1,2,3].forEach (key => isUpThree[key]: true)
isUpThree[2]
vs
[1,2,3].indexOf(2)

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

dovid

@אהרן אמר בדיון בנושא הביצועים בJS:

@dovid
מאוד אודה לך, אם תהפוך את הקטעים ללינקים (לכאורה עדיף ישר לדף הטסט, אם לא אז למאמר).

בל"נ אשתדל בהמשך.

אהרן

@dovid אמר בדיון בנושא הביצועים בJS:

@אהרן אמר בדיון בנושא הביצועים בJS:
@dovid אמר בתכנות יעיל וביצועים, בJS (בפרט):

indexOf מהיר

עם זאת, חיפוש ע"י גישה למאפיין, מהיר יותר.
[1,2,3].forEach (key => isUpThree[key]: true)
isUpThree[2]
vs
[1,2,3].indexOf(2)
גם אתה ציינת עובדה נכונה, אבל השוואה של שני דברים שונים:
בין איתור ערך לגישה ע"י מפתח.
ברור שגישה לאינדקס של אובייקט מנצחת איתור ערך של מערך.

אכן, אתקן א"ע
זה שווה ללבנות אינדקס ל-DB, או לשימוש במצביע.

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

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

obj['eliezer'] = {8: true, 549: true, 155895: true}

(למה הקוד מתחרבש??)
אז בודקים

Object.keys(ovj['eliezer']).forEach( (startPos) => {
   if(obj['eat'].startPos+1) {}
}

dovid

אתם צודקים.
יש שלושה אפשרויות באיתור ערך באוסף:

לדעת אם ישנו (includes)
לקבל אותו לפי קריטריון (find אבל עדיך לבנות מילון)
לדעת את מיקומו - indexOf.

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

אהרן

@dovid אמר בתכנות יעיל וביצועים, בJS (בפרט):

אני משתמש בעיקר בו http://jsbench.github.io/.

איך עובדים עם האתר הזה?
איפה שמים את הקוד המקדים?

תסתכל ע"ז
http://jsbench.github.io/#13fd0426ba617c8d0e58d87d3f23675b

אהרן

@dovid אמר בדיון בנושא הביצועים בJS:

אני מסכים שלבנות מילון תמיד יותר טוב (חוץ מהזיכרון שב"כ זה שולי).

זה ברור
לא תמיד ברור איך כותבים את המילון הזה.

dovid

@אהרן אמר בדיון בנושא הביצועים בJS:

@dovid אמר בתכנות יעיל וביצועים, בJS (בפרט):

אני משתמש בעיקר בו http://jsbench.github.io/.

איך עובדים עם האתר הזה?
איפה שמים את הקוד המקדים?

למטה בצד שמאל Setup.

תסתכל ע"ז
http://jsbench.github.io/#13fd0426ba617c8d0e58d87d3f23675b

אנחנו עוד בArray עוד לא בString.

zvizvi

@dovid אמר בדיון בנושא הביצועים בJS:

@zvizvi אמר בדיון בנושא הביצועים בJS:
[1, 2].includes(1)
מהיר יותר מ
[1, 2].indexOf(1) > 0
זה נכון אבל שים לב שזה שתי פעולות שונות.
למעשה הindexOf מהיר באותה מידה, רק שאתה מוסיף פעולה של בדיקת התוצאה.
המסקנא הנכונה היא שלבדוק אם איבר קיים, לא חכם להשתמש בindexOf. נכון, אוסיף זאת בע"ה, תודה!

הסיבה שהבאתי את זה, כי עד לאחרונה לא היתה האפשרות לבדוק ב includes וכולם השתמשו ב indexOf >= 0
כאשר הוסיפו את includes חשבתי לתומי שזה סה"כ קיצור דרך ל indexOf >= 0 ואין הבדל בביצועים. לכן בדקתי וזה לא נכון.

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

zvizvi

https://coderwall.com/p/_ggh2w/the-array-native-every-filter-map-some-foreach-methods

dovid

@zvizvi אמר בדיון בנושא הביצועים בJS:

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

מבדיקה שלי זה לא הצלחתי למצוא הבדל של ממש, ראה http://jsbench.github.io/#82277a913ae25629ce943346c7ce8183
אכן ממה שאנשים אומרים https://stackoverflow.com/q/47659972/1271037 נראה שבגירסאות כרום האחרונות זה מהר יותר.

בנוסף includes יכול לעצור ברגע שהוא מצא התאמה, indexOf לא.

למה? שניהם עוצרים ברגע שהם מוצאים.

dovid

@zvizvi אמר בדיון בנושא הביצועים בJS:

https://coderwall.com/p/_ggh2w/the-array-native-every-filter-map-some-foreach-methods

מה יש במובאה זו?

zvizvi

@dovid אמר בדיון בנושא הביצועים בJS:

@zvizvi אמר בדיון בנושא הביצועים בJS:

https://coderwall.com/p/_ggh2w/the-array-native-every-filter-map-some-foreach-methods

מה יש במובאה זו?

השוואה בין כל סוגי האיטרציות על מערכים

dovid

@zvizvi אמר בדיון בנושא הביצועים בJS:

@dovid אמר בדיון בנושא הביצועים בJS:

@zvizvi אמר בדיון בנושא הביצועים בJS:

https://coderwall.com/p/_ggh2w/the-array-native-every-filter-map-some-foreach-methods

מה יש במובאה זו?

השוואה בין כל סוגי האיטרציות על מערכים

אבל לא במובן של ביצועים.
פה יש https://github.com/dg92/Performance-Analysis-JS

אהרן

@dovid אמר בדיון בנושא הביצועים בJS:

ראה http://jsbench.github.io/#82277a913ae25629ce943346c7ce8183

איפה רשום מה מכיל ARR?

dovid

@dovid אמר בדיון בנושא הביצועים בJS:

@אהרן אמר בדיון בנושא הביצועים בJS:

@dovid אמר בתכנות יעיל וביצועים, בJS (בפרט):

אני משתמש בעיקר בו http://jsbench.github.io/.

איך עובדים עם האתר הזה?
איפה שמים את הקוד המקדים?

למטה בצד שמאל Setup.

אהרן

@dovid
יהיה נוח אם תכניס כאן לינק לדיון פה

בנוגע ל:
כשידוע האורך מראש (ובמערכים לא גדולים במיוחד), יש לאתחל את המערך עם Array(length).

הטסט הזה מראה שזה משתלם גם בטווח גדול של טעות.

אהרן

בנוגע ל-PUSH
זה מראה להיפך.

dovid

@אהרן אמר בדיון בנושא הביצועים בJS:

בנוגע ל-PUSH
זה מראה להיפך.

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

dovid

@אהרן אמר בדיון בנושא הביצועים בJS:

@dovid
יהיה נוח אם תכניס כאן לינק לדיון פה

בנוגע ל:
כשידוע האורך מראש (ובמערכים לא גדולים במיוחד), יש לאתחל את המערך עם Array(length).

הטסט הזה מראה שזה משתלם גם בטווח גדול של טעות.

תודה גם לזאת!
כעת בדקתי, והמקרה היחיד בו הייתה עדיפות על Array הייתה במקרה של 100000000 ערכים... מעדכן גם את זה.

אהרן

@dovid אמר בדיון בנושא הביצועים בJS:

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

אתה כנראה מתכוון למקרה ומשתמשים בכל הנו.. התיבות.

אני נסיתי לבדוק האם כדאי להשתמש בקביעות בהערכה גסה.

התשובה היא אולי

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

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

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

dovid

@אהרן אמר בדיון בנושא הביצועים בJS:

אני נסיתי לבדוק האם כדאי להשתמש בקביעות בהערכה גסה.

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

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

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

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

למה זה כה מורכב? כל ערך פרימיטיבי = לא אובייקט (number, string, bool), מועבר כעותק. כל אובייקט (שזה כולל פונקציה ומערך שכן הם גם אובייקטים) מועברים כמצביע.

אהרן

@dovid אמר בדיון בנושא הביצועים בJS:

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

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

@dovid אמר בדיון בנושא הביצועים בJS:

יש פה שתי חלקים:

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

@dovid אמר בדיון בנושא הביצועים בJS:

למה זה כה מורכב? כל ערך פרימיטיבי = לא אובייקט (number, string, bool), מועבר כעותק. כל אובייקט (שזה כולל פונקציה ומערך שכן הם גם אובייקטים) מועברים כמצביע.

ומה קורה אם אתה מתאחל את האוביקט, מגדיל את המערך ע"י concat (הגיוני לרצות לחסוך לולאה)?

dovid

@אהרן אמר בדיון בנושא הביצועים בJS:

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

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

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

נבון, אם זה לא הרגל לא שווה להתאמץ לחשוב על זה.

ומה קורה אם אתה מתאחל את האוביקט, מגדיל את המערך ע"י concat (הגיוני לרצות לחסוך לולאה)?

כל פעם שאתה עושה = למשתנה, תוכנו מחלף לחלוטין בין אם הוא מצביע בין אם הוא ערך.
השאלה עם contact לא הבנתי.

אהרן

@dovid אמר בדיון בנושא הביצועים בJS:

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

NO

@dovid אמר בדיון בנושא הביצועים בJS:

כל פעם שאתה עושה = למשתנה, תוכנו מחלף לחלוטין בין אם הוא מצביע בין אם הוא ערך.
השאלה עם contact לא הבנתי.

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

var arr = []
var obj = {} / or newArr
obj.arr = arr
arr.push('hi')

obj.arr[0] == 'hi'
--
arr = ['test']
obj.arr[0] != 'test'
אותו דבר
arr.contact(nreArr)
obj.arr[0] != 'test'

@dovid אמר בדיון בנושא הביצועים בJS:

דחיפת איברים חדשים מהירה יותר במערך (טסט).

הטסט מפנה לטסט obj vs arr insertion.

@dovid אמר בדיון בנושא הביצועים בJS:

תודה רבה רבה! עדכנתי את הפוסט.

עדיין כתוב שזה מהיר יותר.

אהרן

כאן יש דיון מרתק על שימוש מאסיווי ב-CPU בנוד (זה מרתק כי לא הבנתי שם מילה).

וכמו שכתוב שם כאן יש השוואה בין שיתוף פרוססים לשיתוף תהליכים.

מישהו ניסה א"ז?

דבר נוסף קראתי איפשהו לא מזמן (לא מוצא עכשיו)
שבקוד שמשתמש בעיקרו רק ב-CPU (ובפועל סינכרוני) לא נכון להשתמש בפרומיס. יש לכם תובנות? אשמח לכל הרחבה.