תחומים
    • הרשמה
    • התחברות
    • חיפוש
    • קטגוריות
    • פוסטים אחרונים
    • משתמשים
    • חיפוש
    חוקי הפורום

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

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

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

      אפשר ליצור קשר dovid@tchumim.com

      תגובה 1 תגובה אחרונה תגובה ציטוט 1
      • zvizvi
        zvizvi נערך לאחרונה על ידי zvizvi

        [1, 2].includes(1)
        

        מהיר יותר מ

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

        https://zvizvi.xyz

        dovid תגובה 1 תגובה אחרונה תגובה ציטוט 1
        • א
          אהרן נערך לאחרונה על ידי

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

          dovid תגובה 1 תגובה אחרונה תגובה ציטוט 0
          • א
            אהרן @dovid נערך לאחרונה על ידי

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

            indexOf מהיר

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

            [1,2,3].forEach (key => isUpThree[key]: true)
            isUpThree[2]
            vs
            [1,2,3].indexOf(2)
            
            dovid תגובה 1 תגובה אחרונה תגובה ציטוט 0
            • dovid
              dovid ניהול @zvizvi נערך לאחרונה על ידי

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

              [1, 2].includes(1)
              

              מהיר יותר מ

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

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

              אפשר ליצור קשר dovid@tchumim.com

              zvizvi תגובה 1 תגובה אחרונה תגובה ציטוט 0
              • dovid
                dovid ניהול @אהרן נערך לאחרונה על ידי

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

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

                indexOf מהיר

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

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

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

                אפשר ליצור קשר dovid@tchumim.com

                א תגובה 1 תגובה אחרונה תגובה ציטוט 0
                • dovid
                  dovid ניהול @אהרן נערך לאחרונה על ידי

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

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

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

                  אפשר ליצור קשר dovid@tchumim.com

                  תגובה 1 תגובה אחרונה תגובה ציטוט 0
                  • א
                    אהרן @dovid נערך לאחרונה על ידי 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) {}
                    }
                    
                    תגובה 1 תגובה אחרונה תגובה ציטוט 0
                    • dovid
                      dovid ניהול נערך לאחרונה על ידי dovid

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

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

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

                      אפשר ליצור קשר dovid@tchumim.com

                      א תגובה 1 תגובה אחרונה תגובה ציטוט 0
                      • א
                        אהרן נערך לאחרונה על ידי אהרן

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

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

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

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

                        dovid תגובה 1 תגובה אחרונה תגובה ציטוט 0
                        • א
                          אהרן @dovid נערך לאחרונה על ידי

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

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

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

                          תגובה 1 תגובה אחרונה תגובה ציטוט 0
                          • dovid
                            dovid ניהול @אהרן נערך לאחרונה על ידי

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

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

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

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

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

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

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

                            אפשר ליצור קשר dovid@tchumim.com

                            dovid תגובה 1 תגובה אחרונה תגובה ציטוט 0
                            • zvizvi
                              zvizvi @dovid נערך לאחרונה על ידי 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 לא.

                              https://zvizvi.xyz

                              dovid תגובה 1 תגובה אחרונה תגובה ציטוט 1
                              • zvizvi
                                zvizvi נערך לאחרונה על ידי

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

                                https://zvizvi.xyz

                                dovid תגובה 1 תגובה אחרונה תגובה ציטוט 0
                                • dovid
                                  dovid ניהול @zvizvi נערך לאחרונה על ידי

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

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

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

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

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

                                  אפשר ליצור קשר dovid@tchumim.com

                                  א תגובה 1 תגובה אחרונה תגובה ציטוט 0
                                  • dovid
                                    dovid ניהול @zvizvi נערך לאחרונה על ידי

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

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

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

                                    אפשר ליצור קשר dovid@tchumim.com

                                    zvizvi תגובה 1 תגובה אחרונה תגובה ציטוט 0
                                    • zvizvi
                                      zvizvi @dovid נערך לאחרונה על ידי

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

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

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

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

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

                                      https://zvizvi.xyz

                                      תגובה 1 תגובה אחרונה תגובה ציטוט 0
                                      • dovid
                                        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@tchumim.com

                                        תגובה 1 תגובה אחרונה תגובה ציטוט 0
                                        • א
                                          אהרן @dovid נערך לאחרונה על ידי

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

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

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

                                          תגובה 1 תגובה אחרונה תגובה ציטוט 0
                                          • dovid
                                            dovid ניהול @dovid נערך לאחרונה על ידי

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

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

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

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

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

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

                                            אפשר ליצור קשר dovid@tchumim.com

                                            א תגובה 1 תגובה אחרונה תגובה ציטוט 0
                                            • א
                                              אהרן @dovid נערך לאחרונה על ידי

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

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

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

                                              dovid תגובה 1 תגובה אחרונה תגובה ציטוט 0
                                              • א
                                                אהרן נערך לאחרונה על ידי

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

                                                dovid תגובה 1 תגובה אחרונה תגובה ציטוט 1
                                                • dovid
                                                  dovid ניהול @אהרן נערך לאחרונה על ידי

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

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

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

                                                  אפשר ליצור קשר dovid@tchumim.com

                                                  תגובה 1 תגובה אחרונה תגובה ציטוט 1
                                                  • dovid
                                                    dovid ניהול @אהרן נערך לאחרונה על ידי

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

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

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

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

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

                                                    אפשר ליצור קשר dovid@tchumim.com

                                                    א תגובה 1 תגובה אחרונה תגובה ציטוט 0
                                                    • א
                                                      אהרן @dovid נערך לאחרונה על ידי

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

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

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

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

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

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

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

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

                                                      dovid תגובה 1 תגובה אחרונה תגובה ציטוט 0
                                                      • dovid
                                                        dovid ניהול @אהרן נערך לאחרונה על ידי

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

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

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

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

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

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

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

                                                        אפשר ליצור קשר dovid@tchumim.com

                                                        א תגובה 1 תגובה אחרונה תגובה ציטוט 0
                                                        • א
                                                          אהרן @dovid נערך לאחרונה על ידי אהרן

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

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

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

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

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

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

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

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

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

                                                          dovid תגובה 1 תגובה אחרונה תגובה ציטוט 0
                                                          • dovid
                                                            dovid ניהול @אהרן נערך לאחרונה על ידי

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

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

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

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

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

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

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

                                                            אפשר ליצור קשר dovid@tchumim.com

                                                            א תגובה 1 תגובה אחרונה תגובה ציטוט 0
                                                            • א
                                                              אהרן @dovid נערך לאחרונה על ידי

                                                              @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:

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

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

                                                              תגובה 1 תגובה אחרונה תגובה ציטוט 0
                                                              • א
                                                                אהרן נערך לאחרונה על ידי

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

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

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

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

                                                                תגובה 1 תגובה אחרונה תגובה ציטוט 0
                                                                • 1
                                                                • 2
                                                                • 1 / 2
                                                                • פוסט ראשון
                                                                  פוסט אחרון
                                                                בא תתחבר לדף היומי!