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

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

בתוכנית הזאת יש פונקציית drawWinston שיודעת לצייר את ווינסטון במיקום X ו-Y מסוים.

ואז כאן למטה, אנחנו קוראים ל-drawWinston ארבע פעמים, כל פעם עם קואורדינטות X ו-Y שונות.

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

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

אז, כדי לעשות את זה, אנחנו צריכים למצוא דרך לשמור את מיקומי ה-X וה-Y במערך כדי שנוכל לעבור עליו בלולאה.

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

עבור מיקומי X יהיו לנו למשל, 99, 294, 101, ו-294, ועבור מיקומי Y יהיו לנו 117, 117, 316, 316.

אוקיי, עכשיו נוכל לעבור עם לולאה על המערכים האלו עם לולאת for. נרשום: var i = 0;
i < xPositions.length;
i++

אז אנחנו עוברים על כל איבר במערך xPositions והפקודה שנרשום היא
drawWinston(xPositions[i], yPositions[i])

אוקיי, אז, בואו נראה אם זה עבד, נחמק את זה...

בסדר, זה עבד.

עכשיו יש לנו שורת קוד אחת שקוראת לפונקציה drawWinston, והיא מתבצעת עבור כל מיקום במערך xPosition.

אנחנו יכולים להוסיף עוד... (10,1) ואז (1,1), ו-(100,1).

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

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

אני רוצה למצוא דרך אחרת לשמור את המיקומים האלו.

רעיון אחד הוא לשמור אותם בתור אובייקטים.

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

ואז יכול להיות לנו מערך של אובייקטים עם כל מיקומי ה-X וה-Y.

בואו נעשה את זה.

נרשום: var positions שווה.. וכאן יהיה לנו מערך גם.

אבל, כל איבר, במקום להיות מספר, הולך להיות אובייקט.

אז, כאן הסוגריים המסלוסלים שלנו, ואז נרשום פשוט: X: 99, Y: 117.

אוקיי, אז עכשיו יש לנו את אחד המיקומים שלנו, נוסיף עוד אחד.

אוקיי, X צריך להיות 294, 117, השלישי הולך להיות 101, 316, והאחרון 294, 316.

אוקיי, עכשיו יש לנו מערך של אובייקטים, וכל אובייקט מכיל מאפייני X ו-Y.

כאן למטה, בלולאת ה-for שלנו, נשנה את הלולאה כך שתרוץ מספר פעמים כאורך המערך positions.length

אז נעביר את האובייקט

עכשיו זה מעביר את כל האובייקט, אבל אנחנו רוצים להעביר את ה-X וה-Y, אז אנחנו צריכים לרשום: positions[i].X ו-positions[i].Y.

טה-דה!

עכשיו, אנחנו יכולים להיפטר מהמערכים הישנים.

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

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

מגניב.

עכשיו אני רוצה להראות לכם משהו אפילו יותר יפה.

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

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

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

בואו ננסה את זה.

נעביר את האובייקט, עכשיו זה לא עובד.

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

נרשום שהיא מקבלת facePosition, ועכשיו אנחנו מקבלים עוד שגיאה, ש-faceX לא מוגדר

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

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

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

אנחנו יכולים לעשות את אותו הדבר עם Y, אז faceY = facePosition.y.

טה-דה!

ואז, שאר הפונקציה משתמשת ב-faceX וב-faceY.

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

במערך האובייקטים שלנו - זה צריך להתאים.

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

ואתם תגלו שלתוכניות שלכם יכול להיות הרבה כוח עם הדרך שבה אובייקטים מארגנים מידע

בייחוד כי זה מאוד נפוץ לרצות לצמד את X ו-Y יחד, אני חושבת שתמצאו את זה

מאוד שימושי בכל תוכניות הציור והאנימציה.

אז תמשיכו עם זה ותהנו!