דילוג לתוכן
  • דף הבית
  • קטגוריות
  • פוסטים אחרונים
  • משתמשים
  • חיפוש
  • חוקי הפורום
כיווץ
תחומים

תחומים - פורום חרדי מקצועי

💡 רוצה לזכור קריאת שמע בזמן? לחץ כאן!
  1. דף הבית
  2. תכנות
  3. דיון בנושא הביצועים בJS

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

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

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

    dovidD תגובה 1 תגובה אחרונה
    0
    • dovidD dovid

      המשך להקדמה:
      כל נושא הביצועים בJS ברמות העדינות שנדבר פה הם לא רלוונטיים לדפדפן אלא לסביבת שרת (בה כל עיכוב CPU הוא יקר). מכיון שסביבות צד שרת כמעט ואין חוץ מnode אז הדגש שלנו יהיה על V8 שזה המנוע של כרום ונוד.
      המקורות שלי מגוונים: מאמרים, פורומים, וגם טסטים אישיים. קצת קשה למצוא כלי בדיקה קל ומדוייק. אני משתמש בעיקר בו http://jsbench.github.io/.

      טוב נתחיל עם מערכים ואובייקטים.

      א. מערך באופן כללי מהיר מאובייקט, למשל:

      1. אתחול זול (זיכרון) ומהיר יותר ([] VS {}).
      2. גישה לפי אינדקס מהירה יותר במערך, מאשר גישה לאיבר של אובייקט (arr[1] VS obj.key או obj[key]).
      3. בחיפוש לפי ערך, במערך יש indexOf שמהר בהרבה מלולאה.
      4. דחיפת איברים חדשים מהירה יותר במערך (טסט).

      ב. פרקטיקות לשימוש נכון במערכים:

      • אם אפשר לאתחל מייד עם ערכים, מהר יותר מאשר הכנסה בהמשך.
      • כשידוע האורך מראש, יש לאתחל את המערך עם Array(length) (טסט).
      • push איטי מגישה ישירות לאינדקס הבא (טסט, דיון בסטאק).
      • להימנע מקריאת תאים ריקים (empty). לכן גם לא כדאי למחוק תאים עם delete אם זה לא הכרחי, null יותר טוב (טסט).
      • חיפוש:
        • לבדוק אם קיים, arr.includes. באם לא נתמך (ES5) אז arr.indexOf(x) > -1.
        • למצוא לפי קריטריון, find. אם הקיריטריון הוא ערך כל שהוא, כדאי לבנות מילון מאובייקט שמפתחותיו הם הערכים.
        • מיקום בהינתן הערך עצמו (במקרה של אובייקט אז המופע), indexOf. בשביל ספירת הופעות במערך, לולאה של indexOf מהירה מfilter ואז length.
      • לולאת for עובדת כמו טיל במערך (אבל יותר לאט מindexOf!), יש גם לשים את המאפיין length במשתנה (קשינג) ולא לפנות אליו בכל איטרציה. forEach נח יותר ובריא לקריאות - אבל במקומות קריטיים השתמשו תמיד בfor.
      • מנועי JS מבצעים אופטימיזציה למערכים בעלי אותו סוג (ניחוש הסוג מבוצע ע"י האתחול או ההשמה הראשונה). כלומר אם יש לכם מערך שכולו מספרים, עדיף לא לשים שם אובייקט. אם מדובר במספרים שלמים ישנה אופטימיזציה גדולה אף יותר, ועדיך לא "לשבור" את זה עם איבר עם מספר בעל שבר.
      א מנותק
      א מנותק
      אהרן
      כתב ב נערך לאחרונה על ידי
      #4

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

      indexOf מהיר

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

      [1,2,3].forEach (key => isUpThree[key]: true)
      isUpThree[2]
      vs
      [1,2,3].indexOf(2)
      
      dovidD תגובה 1 תגובה אחרונה
      0
      • zvizviZ zvizvi
        [1, 2].includes(1)
        

        מהיר יותר מ

        [1, 2].indexOf(1) >= 0
        
        dovidD מחובר
        dovidD מחובר
        dovid
        ניהול
        כתב ב נערך לאחרונה על ידי
        #5

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

        [1, 2].includes(1)
        

        מהיר יותר מ

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

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

        • מנטור אישי בתכנות והמסתעף – להתקדם לשלב הבא!
        • בכל נושא אפשר ליצור קשר dovid@tchumim.com
        zvizviZ תגובה 1 תגובה אחרונה
        0
        • א אהרן

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

          indexOf מהיר

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

          [1,2,3].forEach (key => isUpThree[key]: true)
          isUpThree[2]
          vs
          [1,2,3].indexOf(2)
          
          dovidD מחובר
          dovidD מחובר
          dovid
          ניהול
          כתב ב נערך לאחרונה על ידי
          #6

          @אהרן אמר בדיון בנושא הביצועים ב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
            מאוד אודה לך, אם תהפוך את הקטעים ללינקים (לכאורה עדיף ישר לדף הטסט, אם לא אז למאמר).

            dovidD מחובר
            dovidD מחובר
            dovid
            ניהול
            כתב ב נערך לאחרונה על ידי
            #7

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

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

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

            • מנטור אישי בתכנות והמסתעף – להתקדם לשלב הבא!
            • בכל נושא אפשר ליצור קשר dovid@tchumim.com
            תגובה 1 תגובה אחרונה
            0
            • dovidD dovid

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

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

              indexOf מהיר

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

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

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

              א מנותק
              א מנותק
              אהרן
              כתב ב נערך לאחרונה על ידי dovid
              #8

              @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
              • dovidD מחובר
                dovidD מחובר
                dovid
                ניהול
                כתב ב נערך לאחרונה על ידי dovid
                #9

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

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

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

                • מנטור אישי בתכנות והמסתעף – להתקדם לשלב הבא!
                • בכל נושא אפשר ליצור קשר dovid@tchumim.com
                א תגובה 1 תגובה אחרונה
                0
                • א מנותק
                  א מנותק
                  אהרן
                  כתב ב נערך לאחרונה על ידי אהרן
                  #10

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

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

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

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

                  dovidD תגובה 1 תגובה אחרונה
                  0
                  • dovidD dovid

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

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

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

                    א מנותק
                    א מנותק
                    אהרן
                    כתב ב נערך לאחרונה על ידי
                    #11

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

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

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

                    תגובה 1 תגובה אחרונה
                    0
                    • א אהרן

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

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

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

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

                      dovidD מחובר
                      dovidD מחובר
                      dovid
                      ניהול
                      כתב ב נערך לאחרונה על ידי
                      #12

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

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

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

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

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

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

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

                      • מנטור אישי בתכנות והמסתעף – להתקדם לשלב הבא!
                      • בכל נושא אפשר ליצור קשר dovid@tchumim.com
                      dovidD תגובה 1 תגובה אחרונה
                      0
                      • dovidD dovid

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

                        [1, 2].includes(1)
                        

                        מהיר יותר מ

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

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

                        zvizviZ מנותק
                        zvizviZ מנותק
                        zvizvi
                        כתב ב נערך לאחרונה על ידי zvizvi
                        #13

                        @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

                        dovidD תגובה 1 תגובה אחרונה
                        1
                        • zvizviZ מנותק
                          zvizviZ מנותק
                          zvizvi
                          כתב ב נערך לאחרונה על ידי
                          #14

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

                          https://zvizvi.xyz

                          dovidD תגובה 1 תגובה אחרונה
                          0
                          • zvizviZ 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 לא.

                            dovidD מחובר
                            dovidD מחובר
                            dovid
                            ניהול
                            כתב ב נערך לאחרונה על ידי
                            #15

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

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

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

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

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

                            • מנטור אישי בתכנות והמסתעף – להתקדם לשלב הבא!
                            • בכל נושא אפשר ליצור קשר dovid@tchumim.com
                            א תגובה 1 תגובה אחרונה
                            0
                            • zvizviZ zvizvi

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

                              dovidD מחובר
                              dovidD מחובר
                              dovid
                              ניהול
                              כתב ב נערך לאחרונה על ידי
                              #16

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

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

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

                              • מנטור אישי בתכנות והמסתעף – להתקדם לשלב הבא!
                              • בכל נושא אפשר ליצור קשר dovid@tchumim.com
                              zvizviZ תגובה 1 תגובה אחרונה
                              0
                              • dovidD dovid

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

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

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

                                zvizviZ מנותק
                                zvizviZ מנותק
                                zvizvi
                                כתב ב נערך לאחרונה על ידי
                                #17

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

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

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

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

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

                                https://zvizvi.xyz

                                תגובה 1 תגובה אחרונה
                                0
                                • dovidD מחובר
                                  dovidD מחובר
                                  dovid
                                  ניהול
                                  כתב ב נערך לאחרונה על ידי
                                  #18

                                  @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
                                  • dovidD dovid

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

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

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

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

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

                                    א מנותק
                                    א מנותק
                                    אהרן
                                    כתב ב נערך לאחרונה על ידי
                                    #19

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

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

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

                                    תגובה 1 תגובה אחרונה
                                    0
                                    • dovidD dovid

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

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

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

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

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

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

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

                                      dovidD מחובר
                                      dovidD מחובר
                                      dovid
                                      ניהול
                                      כתב ב נערך לאחרונה על ידי
                                      #20

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

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

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

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

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

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

                                      • מנטור אישי בתכנות והמסתעף – להתקדם לשלב הבא!
                                      • בכל נושא אפשר ליצור קשר dovid@tchumim.com
                                      א תגובה 1 תגובה אחרונה
                                      0
                                      • dovidD dovid

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

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

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

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

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

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

                                        א מנותק
                                        א מנותק
                                        אהרן
                                        כתב ב נערך לאחרונה על ידי
                                        #21

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

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

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

                                        dovidD תגובה 1 תגובה אחרונה
                                        0
                                        • א מנותק
                                          א מנותק
                                          אהרן
                                          כתב ב נערך לאחרונה על ידי
                                          #22

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

                                          dovidD תגובה 1 תגובה אחרונה
                                          1
                                          תגובה
                                          • תגובה כנושא
                                          התחברו כדי לפרסם תגובה
                                          • מהישן לחדש
                                          • מהחדש לישן
                                          • הכי הרבה הצבעות


                                          • 1
                                          • 2
                                          בא תתחבר לדף היומי!
                                          • התחברות

                                          • אין לך חשבון עדיין? הרשמה

                                          • התחברו או הירשמו כדי לחפש.
                                          • פוסט ראשון
                                            פוסט אחרון
                                          0
                                          • דף הבית
                                          • קטגוריות
                                          • פוסטים אחרונים
                                          • משתמשים
                                          • חיפוש
                                          • חוקי הפורום