PracticU

Threads

בלי כתוביותעם כתוביות
PracticU › קורס Javascript כולל JQuery › Threads
מילון מושגים:
מעבד - יחידת העיבוד המרכזית של המחשב, שמבצעת את הפקודות של התוכניות ומנהלת את החישובים.
תגית - סימון בקוד, למשל ב-HTML, שתוחם רכיב ומגדיר את תפקידו או תכונותיו. גם תווית לסימון וקיטלוג פריטים.
אירוע - התרחשות שהמערכת מזהה ויכולה להגיב לה, כמו לחיצת עכבר, הקשה או סיום פעולה.
לולאה - מבנה בקרה שחוזר על קטע קוד שוב ושוב כל עוד תנאי מתקיים או עבור כל פריט באוסף.
אינדקס - מבנה במסד נתונים שמאיץ חיפוש ושליפה. גם מספר המציין מיקום של איבר במערך.
אופרטור - סימן בקוד שמבצע פעולה על ערכים, כמו חיבור, השוואה או פעולה לוגית.
CSS - שפת עיצוב שקובעת את המראה של דפי אינטרנט: צבעים, גופנים, מיקום וסידור הרכיבים.
מאפיין - תכונה שמצמידים לרכיב ומתארת אותו או את התנהגותו, למשל מאפיין של תגית HTML או שדה באובייקט.

Threads

בשיעור זה אנו לומדים על תהליכונים Threads בג'אווה סקריפט. אנו מכירים את הפונקציות setTimeout ו-clearTimeout להפעלת פונקציה פעם אחת בטרד נפרד וביטולה, את setInterval ו-clearInterval להפעלה חוזרת של פונקציה בכל פרק זמן, ובונים עם כלים אלה שעון חי ואנימציית תמונות מתחלפות עם טעינה מוקדמת.
נושאי הסיכום המוצגים בשיעור:
1. מהו טרד: טרד הוא תהליך נפרד מבחינת זמן ה-CPU שאנו יכולים להפעיל במקביל לכל חישוב או פעילות אחרת של הדפדפן. אנו יכולים לקחת פונקציה ולומר לדפדפן להפעיל אותה בעוד פרק זמן מסוים של מילי-שניות, אפילו בעוד 0 מילי-שניות, והיא תרוץ במקביל בלי לעכב את הדפדפן. זה שימושי כשיש חישוב מסיבי שרוצים להפריד, או כשרוצים לבצע פעולה בעוד פרק זמן.
2. הפונקציה window.setTimeout: הפונקציה מקבלת קוד, כלומר איזו פונקציה להפעיל, ו-delay, בעוד כמה זמן להפעיל אותה במילי-שניות. שיטה ראשונה לשלוח את הקוד היא פשוט לרשום את שם הפונקציה בלי סוגריים, כך שלא אנחנו קוראים לה אלא ה-setTimeout יקרא לה בעצמו בזמן המתאים.
3. הצגת תמונה בעוד שתי שניות: בונים לחצן שקורא לפונקציה showImageAsync, ובתוכה קוראים ל-window.setTimeout עם שם הפונקציה showImage ו-delay של 2000 מילי-שניות. הפונקציה showImage מקבלת בעזרת document.getElementById את התגית img עם ה-id שלה, ניגשת ל-src שלה ומכניסה את שם התמונה המלא. בלחיצה על הלחצן התמונה מוצגת אחרי שתי שניות, וגם אחרי שמגדילים לחמש שניות ההצגה מתבצעת בזמן המדויק.
4. ביטול טרד: כדי לבטל את פעילות הטרד מגדירים משתנה גלובלי שמקבל את מה שחוזר מהפונקציה setTimeout, ומשתנה זה מחזיק את הטרד האמיתי שרץ ברקע. פונקציה נוספת קוראת ל-window.clearTimeout ושולחת לה את המשתנה, ובכך הטרד מבוטל. בודקים שלחיצה על show ומיד לחיצה על cancel גורמת לכך שגם אחרי שתי השניות שום דבר לא קורה.
5. שני טרדים במקביל: יוצרים שני משתנים, tShow שמציג את התמונה אחרי שתי שניות, ו-tHide שמפעיל את הפונקציה hideImage אחרי חמש שניות ומנקה את ה-src. התוצאה היא שהתמונה מוצגת אחרי שתי שניות ונעלמת אחרי עוד שלוש שניות, וה-cancel מבטל את שני הטרדים יחד.
6. הגנה עם null: נהוג לאתחל את משתני הטרדים בערך null, ובפונקציית הביטול לבדוק קודם שהמשתנה שונה מ-null לפני קריאה ל-clearTimeout, ולאחר הביטול להכניס בו שוב null. כך מוודאים שמבצעים ביטול רק כשיש טרד פעיל, וזהו דגל נהוג בתכנות.
7. שיטה שנייה להעברת פרמטרים: שיטת השם בלבד לא מאפשרת לשלוח פרמטרים. שיטה שנייה היא לרשום טקסט שמתאר כאילו את הקריאה לפונקציה, למשל showImage עם מחרוזת שם התמונה בגרשיים. הפונקציה מקבלת את שם הקובץ לפרמטר imageFile ומכניסה אותו ל-src, וכך setTimeout מפעילה אותה עם הפרמטר המתאים.
8. הפונקציות שייכות לאובייקט window: setTimeout ו-clearTimeout שייכות לאובייקט window, וכפי שלמדנו בעבר אין חובה לרשום את המילה window, והקריאה עובדת גם בלעדיה.
9. הפונקציות setInterval ו-clearInterval: לאובייקט window יש עוד שתי פונקציות דומות: setInterval שמפעילה את הפונקציה שוב ושוב בכל פרק זמן מוגדר, ו-clearInterval שמבטלת אותה. בניגוד ל-timeout שמבצע את הפונקציה פעם אחת בלבד, ה-interval הוא טיימר חוזר שמריץ את הפונקציה מחדש בכל פרק זמן, למשל בכל 1000 מילי-שניות.
10. שעון חי עם interval: בונים עמוד חדש עם לחצן ו-span עם ה-id lblClock להצגת השעון. הפונקציה showCurrentTime יוצרת אובייקט Date חדש, מקבלת ממנו את השעה הנוכחית בעזרת toLocaleTimeString ומכניסה אותה ל-innerHTML של ה-span, שהוא המידע שבין תגית הפתיחה לתגית הסגירה. הפונקציה showClock קוראת ל-setInterval עם שם הפונקציה ופרק זמן של שנייה, וכך השעון מתעדכן כל שנייה.
11. טיפול בעיכוב ההופעה הראשונה: בלחיצה הראשונה עוברת שנייה שלמה עד שהפונקציה רצה בפעם הראשונה. פותרים זאת על ידי קריאה יזומה פעם אחת לפונקציה שלנו לפני הקריאה ל-setInterval, וכך השעון מוצג מיד בלחיצה.
12. כפתור toggle להצגה והסתרה: בונים פונקציה אחת showHideClock שבה משתנה גלובלי timer מאותחל ל-null. אם הטיימר שווה null אין שעון מוצג, מציגים אותו ומתחילים interval חדש, ואחרת מכניסים מחרוזת ריקה ל-innerHTML, קוראים ל-clearInterval עם הטיימר ומאפסים אותו ל-null. כך אנו רואים שלא רק הועלם הטקסט אלא האינטרוול עצמו הושמד ונעצר.
13. שינוי כיתוב הלחצן: נותנים ללחצן id ומשנים את ה-value שלו בהתאם למצב: כאשר השעון מוצג הכיתוב הופך ל-hide clock, וכאשר השעון מוסתר הכיתוב חוזר ל-show clock, וכך מקבלים כפתור שמציג ומסתיר את השעון לסירוגין.
14. אנימציית תמונות מתחלפות: בונים לחצן נוסף שמציג גרפיקה של תמונות מתחלפות בתוך תגית img עם ה-id myImage. יש לנו תיקיית sunflower עם 33 תמונות שמספרן 1 עד 33, התמונות שונות מעט זו מזו, והצגתן ברצף מהיר יוצרת אפקט של אנימציה, כאשר מדובר בגרפיקה של תמונות ולא בוידאו.
15. טעינה מוקדמת של כל התמונות: חשוב לבצע preloading כאשר עוסקים בגרפיקה, כדי שבמעבר המהיר בין תמונה לתמונה לא יילקח זמן טעינה בפעם הראשונה. באירוע onload של ה-body קוראים לפונקציה preloadImages, שבה מערך imageFiles מקבל בלולאה בעזרת push את כל שמות התמונות המורכבים מהשם, המספר והסיומת, ולולאה שנייה פותחת לכל תמונה אובייקט Image זמני ומכניסה ל-src שלו את השם מהמערך, וכך כולן נטענות לזיכרון.
16. מעבר על התמונות עם אינדקס: משתנה currentIndex מתחיל ב-0, והפונקציה showImage מכניסה ל-src של התמונה את האיבר מהמערך במיקום האינדקס הנוכחי, מקדמת את האינדקס באחד, וכאשר הוא מגיע לאורך המערך מאפסים אותו והרצף חוזר מההתחלה. אפשר לעשות את כל הפעילות הזאת בשורה אחת של השמה בעזרת אופרטור המודולו.
17. הפעלה וביטול של האנימציה: הפונקציה showGraphics מפעילה את הטיימר עם setInterval שמריץ את showImage כל 200 מילי-שניות, שהן 5 תמונות בשנייה, ולאחר מכן מקצרים ל-100 מילי-שניות שהן 10 תמונות בשנייה לאנימציה מהירה יותר. הפונקציה showHideGraphics מבצעת את אותו טריק של null והשוואה, מפסיקה את הטיימר עם clearInterval, משנה את כיתוב הלחצן, ובמקום לנקות את ה-src עדיף להסתיר את התמונה לגמרי בעזרת CSS דרך המאפיין style וה-hidden, ולהציג אותה שוב עם visible בלחיצה הבאה.
בסיום השיעור למדנו להפעיל פונקציות בטרדים נפרדים עם setTimeout ולבטל אותם עם clearTimeout, הכרנו את הטיימר החוזר setInterval עם clearInterval, ומימשנו בעזרתם שעון חי שמתעדכן כל שנייה ואנימציית תמונות מתחלפות עם טעינה מוקדמת, תוך שימוש במשתני null וכפתור toggle להפעלה והסתרה. תודה רבה, ולהתראות בשיעור הבא.
בשיעור הבא נעסוק בנושא Cookies.
SR626HE
מילון מושגים:
קוד מקור - הקוד שמפתחים כותבים בשפת תכנות, לפני הידור, המגדיר את פעולת התוכנה.
Java - שפת תכנות עילית ומונחית עצמים, הרצה על מכונה וירטואלית (JVM) ומשמשת לפיתוח מגוון יישומים.

להורדת קוד מקור של כל הדוגמאות בקורס  JAVA SCRIPT למתחילים -לחץ כאן לתלמידי המכללה בלבד

להורדת קוד מקור של כל הדוגמאות בקורס  JAVA SCRIPT למתקדמים- לחץ כאן לתלמידי המכללה בלבד

פרקי ההרצאה: Threads

  1. 00:00

    מהו thread והרצה מקבילה

  2. 01:25

    הפונקציה setTimeout

  3. 03:09

    הצגת תמונה בהשהיה

  4. 05:57

    ביטול thread עם clearTimeout

  5. 08:07

    הפעלת שני threads

תמלול ההרצאה: Threads

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

  1. 00:01

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

  2. 00:16

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

  3. 00:36

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

  4. 00:54

    אז בואו נניח שאנחנו רוצים להגדיר או בלחיצה על כפתור להציג תמונה אבל לא לא רוצים להציג אותה מיידית, אלא בעוד נניח שתי שניות מהלחיצה. ומה שאנחנו צריכים לעשות, קודם כל בואו נגדיר כפתור input type שווה button, value נגדיר כ-show image ו-on-click נקרא לפונקציה שנקרא לה show image async.

  5. 01:31

    async זה קיצור של אסינכרוני שזה אומר מקבילי, כלומר בנוי בטרד נפרד. אוקיי, אז בואו נבנה את הפונקציה הזאת, יש לנו פה function ב-JavaScript, ואנחנו רוצים להתחיל טרד נפרד.

  6. 01:56

    אז בעצם בשביל להתחיל טרד נפרד אנחנו צריכים לקרוא ל-window.settimeout. timeout מקבלת משהו שנקרא קוד ו-delay. הקוד זה בעצם איזו פונקציה להפעיל וה-delay זה בעוד כמה זמן להפעיל אותה.

  7. 02:20

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

  8. 02:37

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

  9. 03:03

    וזה אומר במילי שניות, אז 2,000 מילי שניות זה 2 שניות. מה אנחנו עושים בפונקציה show image? בואו נגדיר פה object image, אז יש לנו IMG, Alt לא מצביע על שום דבר, או לא מכיל שום דבר, כלומר הטקסט שמופיע מאחורי התמונה אין לי כרגע, וזאת התמונה שלי.

  10. 03:34

    ניתן לה ID, וכעת אנחנו יכולים על ידי document getElementByID לקבל את ה-ID של התמונה, לגשת ל-SRC שלה, ולהכניס לתוכו את השם המלא של התמונה.

  11. 03:56

    אז הכנתי בתיקייה שלנו איזושהי תמונה, בואו נפתח את התיקייה ונגיע לתמונה שנקראת סמיילי. אז יש לנו בעצם פה את התמונה smiley.jpeg ומה שקורה כאן זה בלחיצה על הלחצן אנחנו לא מציגים את התמונה אלא אנחנו הולכים לקרוא ל-window.settimeout לתת הוראה לקרוא לפונקציה show image בעוד

  12. 04:31

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

  13. 04:49

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

  14. 05:10

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

  15. 05:46

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

  16. 06:26

    דרך המשתנה הזה לבטל את הטרד אז בואו נבנה עוד לחצן לאורך ביטול הטרד נקרא לו cancel show נקרא לפונקציה cancel show נבנה את הפונקציה הזאת וכעת יש לנו את הפונקציה window.clear timeout clear timeout אומרת לי תביא לי בבקשה את ה timeout id וזה בעצם המשתנה שהתקבל מהפונקציה set timeout ואני יכול עכשיו לשלוח את הפונקציה הזאת את המשתנה הזה ובזה בעצם ביטלתי את הטרד אוקיי

  17. 07:23

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

  18. 07:40

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

  19. 08:06

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

  20. 08:23

    אז יש לנו טרד אחד נקרא לו t-show ונשתמש עם המשתנה t-show. אני רוצה פשוט ליצור שני טרדים ולכן אני אקח שני משתנים var t-hide תהייד יתחיל עוד טרד ווינדו נקודה סט טיים אאוט ונקרא לפונקציה אחרת שנקראת הייד אימג' אבל נפעיל אותה אחרי 5 שניות נבנה את הפונקציה הייד אימג' ובפונקציה הייד אימג' נבטל את מה שיש בתוך

  21. 09:19

    הsource בתוך cancel נבטל את שני הטרדים אוקיי בואו נראה איך זה מתנהג אז יש לנו show אימג' ואם אני מבצע show image התמונה מוצגת אחרי שתי שניות ואחרי עוד שלוש שניות היא נעלמת.

  22. 09:50

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

  23. 10:07

    זה בעצם דגל שנהוג לבצע. אז מה שנהוג לעשות זה באמת להכניס בתוך המשתנים

לקורס המלא: קורס Javascript אונליין

ההרצאה הקודמת: Images

ההרצאה הבאה: Cookies

הרצאות קשורות מקורסים אחרים

  • Threads - חלק 1

קורסים נוספים במסלול

  • קורס יסודות HTML - בניית אתר אינטרנט פשוט
  • קורס CSS 3 - בדגש על Flex & Grid
  • קורס ג'אווה סקריפט מעשי - JavaScript
  • קורס TypeScript
  • קורס ריאקט - React
  • קורס NodeJS