>> [השמעת מוסיקה]
>> דן AMRMENDARIZ: כולם, ברוכים הבאים לסמינר CS50,
iOS App פיתוח עם סוויפט.
אני דן Armendariz, ואני מוֹרֶה של מדעי מחשב, כאן בהרווארד.
>> והשעה הקרובה הולכת להיות סיור מערבולת של כמה שיותר דברים
על נושא זה כפי שאנו יכולים להתאים.
אני אפרסם את כל קוד המקור שאתה רואה היום באינטרנט.
אנחנו אולי לא נוכל בעצם ללכת על הכל
שאני שאני מראה לך בשעה זו.
אבל לפחות אני מקווה שדרך ההערות של קוד המקור,
תוכל לנסות להבין מה בדיוק קורה לדברים האלה
כי אנחנו לא די להגיע ל.
>> בסך הכל, את המבנה של השיחה של היום תהיה כדלקמן.
נתחיל את עושה קצת בסיסי תחביר בשפת סוויפט,
הולך לחלק ממתקדם יותר תחביר של שפת סוויפט.
בגלל השפה הוא באמת מודרני ו
יש הרבה ברמה הגבוהה תכונות, דברים שיש לנו לא
ראה בC ברחבי CS50, או אפילו כמה שפות האחרות
שאנחנו כבר התחלנו באמצעות בCS50 כמו PHP,
אז אני הולך לצריך לנסות להציג גם כמה נושאים ש
קשורים לשפות ברמה גבוהות יותר שייתכן שלא תראו בעומק בCS50,
אבל אתה תראה בהמשך כיתות מדעי מחשב.
אז זה הולך להיות צפוף שעה.
ואל תהסס לתת לי יודע אם יש לך שאלות.
אז אם אתה מעוניין בעושה פיתוח
עם סוויפט, או באמת כל פיתוח אפליקציה iOS,
יש כמה דרישות.
קודם כל, אתה צריך להיות באמצעות מק, פועל בדוגמאות
שאנחנו הולכים להיות באמצעות היום, גרסה חדשה יחסית של מערכת הפעלה
X. במקרה זה, אני רץ X 10.5.
אתה יכול להיות ריצת 10.11 אם אתה רוצה.
אבל כל מה שאתה הולך רואה הוא מעורב 7 Xcode ומאוחר יותר,
שבו יש את הגרסה האחרונה של סוויפט, שהוא 2.0 סוויפט.
זהו למעשה די הבחנה חשובה.
הרבה התחביר יש השתנה באופן משמעותי למדי
בחלק ממקרים מסוויפט 1.0, ששוחרר בשנה שעברה,
2.0 סוויפט, ש רק יצאתי בסתיו קרוב.
אז אנחנו הולכים להראות סוויפט 2.0.
הרבה מהדברים ש אתה מחפש באינטרנט
כאשר אתה מנסה להשיג נוסף מידע על מגוון רחב של דברים,
ייתכן שתרצה באופן מפורש לחפש את סוויפט 2
ולא סוויפט פשוט ישן לעשות בטוח שאתה מקבל נכון התחביר.
>> למעשה, זה בדרך כלל נכון.
יש כמות מהירה של פיתוח קורה בשפת סוויפט
מאז אפל פרסמה את זה, אני חושב ש מה, זה היה קצת יותר משנה
עַכשָׁיו.
ודברים השתנו באופן דרמטי בזמן הזה.
וכך לא להיות מתוסכל אם, כאשר אתה מסתכל מסביב
לנושאים על סוויפט או איך להשיג משהו באמצעות כמה דוגמא קוד
או משהו שזה לא ממש לעבוד על סוויפט 2.0.
ודא שאתה מחפש במיוחד עבור גרסה ש
כדי לנסות למזער את ההשפעות של שונה גרסאות ואלה מיני דברים.
>> אני אנסה להצביע רק כמה דברים כי הם שונים לגרסאות ישנות יותר.
אבל זה משהו שצריך להיזהר.
זה כנראה הולך להיות אחד מכאבי הראש הגדולים ביותר
שיהיה לך עם סוויפט הוא מציאת דוגמא קוד שהוא מבוגר, אפילו רק
בכמה חודשים, מנסה להשתמש זה בפרויקט המודרני יותר שלך.
וזה פשוט לא עובד.
אתה מקבל שגיאות מהדר, תחביר טעויות, כל מיני דברים מטורפים.
כל כך פשוט להיות סבלני עם זה, ואתה יהיה בתקווה
יש ניסיון די נחמד עם כולל סוויפט.
>> עכשיו אתה באמת יכול join-- ואני מקווה ש עדיין יש לנו בעצם year-- זה זה
האפליקציה של אפל CS 50 צוות פיתוח, ש
יאפשר לך להתקין את כל יישומים שאתה יוצר במכשירי iOS שלך.
אז תסתכל על כתובת אתר זו אם אתה מעוניין בכך.
>> אז רק כמה דברים על סוויפט עצמו.
זוהי שפה שנאספה.
אבל אתה תראה שחלק של התכונות שאנו משתמשים בי
לאפשר לו לשמש גם בקצת כמו פירש דרך גם כן.
>> הרבה התחביר מושאל מג הוא מבוסס ונכתב בג
וכך אנו רואים ש יש הרבה של מזון מהיר
מהידע הקיים שלך מC שאנחנו יכולים יציאה לסוויפט.
>> אבל יש דברים ש לעשות את זה שונה מאוד מג
זה מאוד מאוד הקליד.
יש ניהול זיכרון אוטומטי.
אתה לא תצטרך להשתמש malloc או בכל מקום בחינם.
זה מיועד לכלליות.
אז במילים אחרות, אתה יכול להשתמש בו ב כל מיני הקשרים, מבית Apple הצפייה
ל- iPhone כל הדרך עד לOS X, ו אפילו כמה שרתים, אפילו כמה scripting.
אבל נראה ש התמיכה scripting
לא ממש שם עדיין כ זה בשפות אחרות.
אז ככל הנראה תהיה באמצעות זה אך ורק לפיתוח
ב- Mac שלך או iPhone שלך.
>> ויש לו הרבה תכונות מודרניות.
והרבה מהדברים האלה הם דברים ש אנחנו הולכים לנסות לטפל היום,
אבל גם הנושאים שלנו, כי בכנות, אנחנו יכולים להקדיש את כל הקורסים.
למעשה, CS 51, שהוא הסמסטר הבא מוצע,
מתמקד הרבה בנושאים אלה שיתואר להלן.
אז אתה יכול להשקיע כל סמסטר הבנת הדברים האלה.
אבל אנחנו הולכים לנסות לעבור אותם
מספיק לפחות ש יכול להבין מה זה
קורה כאשר אתה מסתכל בתכנית סוויפט
ולהיות מסוגל לפרוץ את הדרך שלך דרכו לפרויקט הגמר.
>> עכשיו אחת הדרכים הטובות ביותר שאתה יכול לקבל מידע נוסף על זה
הוא בכנות פשוט דרך אפל של סיפק תיעוד לסוויפט.
יש הרבה של APIs שזמינים.
וזה בסיס טוב לביתך לחפש, דברים ספציפיים שאתה
רוצה לעשות עם ה- API מעורב iOS.
אם אתה רוצה להשתמש במצלמה ל למשל, אתה יכול להתחיל לחפש כאן,
וגם להשתמש ב- Google וסטאק גלישה באופן רגיל.
>> כל שאלות על זה לפני שאנחנו קופצים תקין ב?
בסדר.
בואו נעבור הלאה.
>> אז קודם כל, יש לי מספר קבצי דוגמא.
ואני הולך לנסות לשלב דרכם במהירות יחסית.
זהו קובץ שלום העולם לסוויפט.
זה פשוט מאוד.
יש דרך נוספת הערות מ יש קוד בפועל.
שים לב לקוד בפועל הוא ב מאוד תחתון בקו 14.
זה אומר הדפסה.
ואז זה קריאה לפונקציה.
אנחנו עוברים אליו מחרוזת נקראת cs50 שלום.
שים לב שאין נקודה-פסיק.
שים לב שאין עיקרי int.
יש אף אחד מ קראפט שהיה לנו עם ג
כאשר אנו משתמשים בסוויפט בדרך זו, שרק כתובה בקובץ טקסט
ומאוחסן במחשב שלי, אז אני יכול לקמפל אותו ולהפעיל אותו.
>> שים לב שאני כאן לא באמצעות IDE CS50.
זאת בהנחה שאני ריצה ושאני על OS X,
וכי יש לי Xcode כבר מותקן במחשב זה כדי שזה
בעצם פונקציה.
אבל זה רק קובץ טקסט רגיל כי אז אנחנו יכולים ללקט ולערוך.
אז בואו לראות איך זה באמת עובד.
מה אם אני רוצה לקמפל את זה?
1.swift swiftc.
אחרי רגע או שתיים, זה יראה שיש לנו עכשיו
הידור זה לקובץ בשם 1.
ועכשיו יש לנו מודפס CS50, יישום שלום העולם שלנו ולא.
>> שים לב דבר אחד אחר כ גם הוא כי כברירת מחדל,
לא היה לנו לקלט / n להדפיס קו חדש.
כברירת מחדל, פונקצית ההדפסה ב סוויפט יודפס שורה חדשה בשבילך.
אתה יכול לעבור נוסף אופציונאלי פרמטר לספר אותו שלא לעשות כן.
אבל גוגל לקבלת מידע נוסף על זה.
כברירת מחדל, זה יעשה את קו ההדפסה.
>> בסדר, אז בואו נעבור על אז לכמה דברים אחרים.
אז איך אנחנו יכולים למעשה להגדיר משתנים?
אנחנו יכולים לעשות את זה באמצעות אחת משתי שיטות.
ואת זה אני רוצה להגיד לך על הגדרה ראשונה הוא לתת לזה.
וזה חשוב בגלל יעילות
מה שאנחנו עושים הוא הגדרה קבועה.
אנחנו הולכים ליצור משתנים, או לייתר דיוק שם נקרא קבוע,
לספק לה כמה data-- ב מקרה זה, את המחרוזת דן.
אבל באמצעות לתת לזה מילת המפתח, אנחנו אומרים
כי זה variable-- או שוב constant-- נקרא
שם אף פעם לא הולך להיות שונה.
זה הולך להיות בלתי ניתן לשינוי בכל משך תכנית זו
או בכל משך ההקשר
שמשתנים כי הוא זמין.
>> זה באמת חשוב שכאשר יש לך כמה נתונים שאינם
הולך לשנות בתכנית שלך, ותראה מגוון רחב של דוגמאות
מתי אנחנו רוצים להשתמש תן לעומת התחביר האחר,
זה חשוב כי אתה משתמש בוא בכל מקום אפשרי, כי זו תודיע
השפה שזה לא הולך להיות שונה,
וזה באמת יכול לבצע הרבה אופטימיזציות
כדי לשפר את המהירות ו הבטיחות של התכנית שלך.
ועל ידי בטיחות, אני מתכוון לא נותן לי התרסקותו עם טעויות מטורפות
שאולי רגיל לראות בג
>> אז אנחנו יכולים להשתמש באינטרפולציה המחרוזת כדי לתמצת את זה במחרוזת.
אז אנחנו יכולים לראות בזה קו הדפסה, להדפיס שלום,
ולאחר מכן באמצעות סימני פתח סוגר קו נטוי, ולאחר מכן את השם שלי משתנה,
במקרה זה קבוע, לסגור את הסוגריים.
אני בעצם לאחר מכן לשים תוכן של שם משתנה בשם זה
בתוך המחרוזת ולאחר מכן הדפסת התוצאה שם.
>> יש שינוי אחר אחד בקובץ זה והוא שיש לי, בחלקו העליון,
להכניס לקו עֵסֶק, ש בעצם רק מציין
כי אני רוצה להשתמש ב מתורגמן סוויפט, ש
משמעות הדבר היא שאני כבר לא צריך לקמפל תכנית מסוימת זו.
אני רק יכול להפעיל אותו כמו תסריט משלו.
אבל זה, במקרה הזה, מאחורי הסצנות שלוקטו ולאחר מכן
להיות ארוך.
זה פשוט בלתי נראה לנו.
>> בסדר, אז בואו נמשיך הלאה.
אז יש קצת תחבולות שרק קרו בעבר.
הראיתי לך אני ש יכול להגדיר קבוע.
ואני יכול לספק כמה נתונים לעשות את זה.
אבל במקרה הזה, שם לב שאני לא למעשה לציין את סוג הנתונים
שזה.
וזה בגלל ש מהדר, סוויפט יכול
להסיק את סוג הנתונים מבוסס רק על נתונים שאני מכניס אותו.
כי הוא יודע שעל ידי הערכה זו משתנה ממש כאן, ממש נתונים זה
כאן, הוא יודע שזה הוא מחרוזת.
ולכן שם קבוע זה הוא אפוא הולך להיות מחרוזת, כמו גם.
>> אבל אנחנו גם יכולים להיות מפורשים על הסוג זה
אנחנו הולכים להשתמש ל קבועים או משתנה
על ידי שימוש בתחביר זה instead-- בואו מחרוזת שם מעי גס שווה
דן, אשר במקרה זה אומר שאנחנו הולך להגדיר שם בשם קבוע.
זה הולך להיות מטיפוס String.
והערך הולך להיות דן.
עכשיו הדרך אחרת ש אנחנו יכולים ליצור variables--
ואלה הם משתנים משתנים, ש משמעות הדבר היא שאנחנו, למעשה, הולכים
כדי לשנות את תוכנם מתישהו במשך ההקשר
שמשתנה שdefined-- להשתמש במילת מפתח var במקום לתת.
אבל שוב, כברירת מחדל, אלא אם כן אתה יודע כי אתה צריך לטפל נתונים ש,
מנסה להשתמש תן ל שיפורי ביצועים.
>> במקרה זה, אז אני יכול לציין את סוג הנתונים
שאנו מצפים להיות בתוך משתנה זה חדש בשם תווית.
זה הולך להיות מחרוזת.
ואז אנחנו הולכים ללשרשר יחד שתי מחרוזות, מחרוזת שלום,
והמחרוזת מיוצגת על ידי משתנה, או לייתר דיוק את השם הקבוע.
>> אז זה נחמד כי זה הוא קצת PHP כמו בנו ש
יש שרשור מחרוזת קל מאוד.
אין לנו באופן אוטומטי להשתמש בכל סוג של ניהול זיכרון
כדי להגדיל את הגודל ולעשות כל סוג של דברים מצחיקים שיש.
זה עובד כפי שהיינו מצפה דווקא.
>> בסדר, שאלות על זה?
>> עכשיו הסיבה אחרת ש אנחנו צריכים יש לך את היכולת
כדי להיות מסוגל להגדיר מה סוג של משתני הנתונים
הוא כי לפעמים אנחנו עושים לא רוצה לאתחל משתנים
עם כמה נתונים ב נקודה של הגדרה.
אז במקרה הזה, נניח כי אני רוצה להתחיל המזינים
כמה ציונים לספר בכיתה.
ובכן, אני יודע שאחד מ משתנים שאני רוצה להיות
הולך להיות בכיתה משתנה.
ואנחנו גם יודעים שאנחנו רוצה שזה יהיה מספר שלם.
אבל אולי אנחנו עושים עדיין לא יש כיתה שזמינה.
>> בסוויפט, שיש לך מגדיר את סוג הנתונים
המשויך ל משתנה או קבוע לתת
לפני למעשה אתה יכול להשתמש במשתנה ש.
בגלל זה הוא מסוג חזק, אתה צריך לשייך סוג
עם המשתנים הללו.
>> אז במקרה הזה, אם יש לי לא כראוי אותחל הראשון עם ערך כלשהו,
אז אני צריך לספר מה סוויפט אני מצפה לסוג הנתונים להיות.
וזה הולך להישאר שאותו סוג הנתונים
לאורך ההיסטוריה של תכנית זו.
>> עכשיו אתה עשוי להתפתות בהקדם אני יצרתי משתנה כיתה זו
ובלבד ש מספר שלם של 100, עכשיו אם אני
רוצה לנסות לשרשר מחרוזת עם מספר שלם ש,
עשוי להתפתות עדיין להשתמש שמפעיל שרשור מחרוזת
כמו שעשינו רק כמה שורות לפני.
אבל לרוע המזל, למעשה זה לא יהיה
לעבוד, בגלל שאתה בעצם ביצוע
ניתוח בשני סוגים שונים.
>> עכשיו זה שונה מאוד מאחר שפות כמו PHP שהם באמת
Goosey loosey עם הסוג של סוגיהם.
הם פשוט אוהבים, כן, מה, לא אכפת לי.
רק תן לי סוג אחד, ו אולי אני אעשה את הדבר הנכון.
>> במקרה זה, סוויפט הוא מאוד קפדן על הסוגים
שיש לך עסק.
מפעיל סיכום זה או מפעיל שרשור
יש בעצם שני אופציות אפשריות שונות.
אתה יכול לעשות את סיכום עם מספרים שלמים, או שאתה
יכול לעשות שרשור מחרוזת, ו אולי כמה דברים אחרים גם כן.
אבל אם המפעיל שאינו מכיר מה הוא משני צדיו,
או לייתר דיוק השילוב של אלה שני סוגים, זה לא מה שמצפה,
אז זה הולך לגרום לכישלון.
>> אז במקרה הזה, מה זה אומר יש מחרוזת בתוספת מספר שלם?
ובכן, בהקשר של זה, אנחנו כנראה רוצים
לעשות פעולת שרשור מחרוזת.
אבל כמובן המחשב אין סוג כזה של קשר.
ולכן אנחנו צריכים לספק כי מידע נוסף
לתת לו יודע מה זה הוא שאנחנו רוצים לעשות.
>> אז במילים אחרות, העובדה שסוויפט הוא מסוג חזק
אומר שאתה צריך לעשות קצת עבודה נוספת
כדי לקבל אותו לפעול דרך שאתה רוצה.
אבל כתוצאה מכך, זה בטוח יותר.
וברגע שיש לך לקחת בחשבון סוגים אלה,
דברים רק בכנות להתחיל לעובד די טוב.
>> אז במקרה הזה, אז אנחנו הייתם לבצע שרשור מחרוזת
על ידי במפורש ליהוק המספר השלם למחרוזת
על ידי לפפה אותו בזה הון פונקצית S מחרוזת,
ולאחר מכן באמצעות שרשור המחרוזת מפעיל לשנות משתנה התווית שלנו,
ואז להדפיס אותו.
>> בינתיים בסדר?
בסדר, בואו תמשיכו הלאה.
>> עכשיו יש מגוון של נתונים סוגים שאנחנו יכולים להשתמש בסוויפט.
כפי שאתה התרגלתם, אנחנו יכולים ליצור מערך משתנה.
ומערך שרק יכול מכיל סוג אחד.
>> אז במקרה הזה, אנחנו הולכים ליצור מערכים משתנים של מספרים שלמים, ש
אנו קוראים לציונים, ונוכל לאחסון שבסוגריים מרובעים זה
פורמט כמו שהתרגל במגוון רחב של שפות אחרות.
אבל שם לב שכאן אנחנו הגדרה כמה דברים.
ציונים הוא variable-- משתנה אנו לא להשתמש במילת המפתח בואו.
אז זה אומר שאנחנו יכולים לשנות ולאחר מכן התוכן של מערך זה.
זה של Int מערך הסוג, ואנחנו יכולים להגיד ש
המבוסס על סוגריים מרובעים אלה כאן.
>> עכשיו אחד הדברים נחמדים על זה הוא שאנחנו ש
יש להם גישה להרבה מידע נוסף
על המערך רק באמצעות כמה סימון נקודה פשוט.
כך למשל, grades.count מספק לנו
מספר הפריטים שקיימים שב מערך, שאותם אנו יכולים לגשת די
בקלות פשוט באמצעות שסימון הנקודה.
>> אם ברצונך להוסיף נוסף פריטים למערך זה,
אתה לא יכול לעשות את סגנון PHP שבו אתה רק במפורש להגדיר,
במדד נתון, ערך כלשהו שברצונך להוסיף.
במקום זאת, השתמש צרף שיטה בסוג המערך
לצרף פריט ש, 95, לרשימה זו.
>> אז עכשיו מערך זה יש הבא contents-- 100, 0, 90, 85.
ועכשיו אנחנו כבר צירפנו 95 גם לזה.
>> יש דרכים אחרות אנחנו יכולים לצרף את הדברים.
למעשה אתה יכול להשתמש מפעיל סיכום,
שיתפרש כ פעולת צרף מערך.
ואז אתה יכול לצרף עוד מערך, תוכן שהם 70 ו -80,
למערך זה.
אז עכשיו יש לנו את תוכן במשתנה זה
grades-- 100, 0, 90, 85, 95, 70, ו -80.
זוהי רק תחבירית קטנה ונחמדה סוכר שסוויפט מספק לנו.
>> אז אם אנחנו רוצים לסכם ציונים, אנחנו אולי
הולך רוצה לחזר על כל פריט בלולאה זה.
ויש לנו, בסוויפט, הרעיון של ללולאה כפי שהיית מצפה.
אבל האופן שבו אנחנו מצביעים מגוון הוא מעט שונה.
אז במקרה הזה, ל סיכום הכל, אנחנו
הולך ליצור זמני סכום משתנה בשם על מנת ש
כדי לשמור על ספירה זו.
>> ושים לב לנו בניית לולאה כאן.
למדד ב0 .. <grade.count.
אז בנייה זו, 0 .. <grades.count היא פעולת טווח שבו אנו נמצאים
אומר שאנחנו הולכים ליצור טווח של מספרים שלמים בין 0 עד
לאך למעט grades.count.
אז זה יהיה 0, 1, 2, 3, 4, 5, עד אולם רב אחד
לפני grades.count.
>> אז זה שונה מאופן בו אנו בדרך כלל היה משמש ללולאות
שבו היית צריך כמה מדד משתנה, להגדיר אותו שווה 0 בהתחלה,
ולאחר מכן לשלב שעד כמה ערך פחות מהספירה של פריטים
במערך זה.
>> אז יש שינוי לזה, למעשה,
אשר מאפשר לנו בקלות רבה להגדיר סוגים שונים של טווחים.
אם תשנה את הטווח הזה ל שלוש נקודות, 0 ... grade.count,
זה מייצג את מגוון 0 לgrades.count כלול,
כלומר מספר שהוא גם לאחר מכן נכלל בטווח זה.
>> אבל זה מאוד נוח לדברים המדויקים אלה,
כאשר אנו צריכים לבצע חזרות על לולאה
כי מדדים אלה אפס אינדקס, כפי שראינו בשפות אחרות
גם כן.
כל שאלות על זה ללולאה?
>> אז יש הגדרה משתמעת של משתנה מדד זה,
הערך שמתחיל ב 0, ו ממשיך בכל איטרציה לולאה
כדי להגדיל על ידי 1 עד נקודה כי הוא שווה לgrades.count,
ובשלב זה, לולאת ביטולים.
>> שים לב כי במחרוזת שלנו אינטרפולציה כאן,
אנחנו באמת יכולים לבצע כמה פשוט מניפולציות לערכים אלה.
אז מדד בתוספת 1 למעשה לבצע סיכום של ערך ש
כי מדד הוא, ב מקרה זה, מספר שלם.
ובשלב זה, זה יהיה להיות לאחר מכן להמיר למחרוזת
ואינטרפולציה למחרוזת זה כאן, והדפיס כפי שהיינו מצפה. .
>> והדבר נחמד על המערכים כאן הוא
כי אנחנו גם מסוגלים לקבל ערכים מקסים וערכי הגדרה
באמצעות סימון הסוגר המרובע כ שראינו בשפות אחרות גם כן.
>> בסדר, אז מכאן, אנחנו עכשיו לחשב הסכום של כל הציונים שלנו שלנו.
עכשיו סוג של הבא צעד הגיוני יהיה
לעשות פעולת החלוקה למצוא את הממוצע של ציונים אלה.
אבל משהו חשוב כאן קורה ש
הוא שסכום זה הוא אולי מספר שלם.
אבל אנחנו צריכים לבצע כמה סוג של חלוקה כפולה.
וזה הולך להיות חשוב מאוד כאשר
אנחנו רוצים לבצע פעולה זו, כי מה שאנחנו אומרים
הוא שאנחנו צריכים בעצם לבצע חלוקה בשני זוגות.
ושוב, כי סוויפט הוא מאוד חזק מאופיין,
עלינו להגדיר באופן מפורש כל פריטים לזוגות לפני שאנחנו באמת
לבצע את הפעולה ש.
>> אז כדי לנו לבצע חלוקה כפולה,
זה לא מספיק רק אחד של פריטים אלה להיות כפולים.
שניהם צריכים להיות כפול על מנת מהיר
כדי להיות בטוח שזה זה מה שאנחנו רוצים לעשות.
אז אנחנו אז חומר מודפס באופן מפורש הסכום שבו אנו כבר מחושבים מעל
והספירה של ציונים לזוגות, ו לאחר מכן לבצע פעולה ושחנות
כי למשתנה חדשה, או לייתר דיוק קבוע זה חדש בשם ממוצע,
שתהיה לי איזה סוג, אתה יכול לדמיין?
זוגי, כן.
אז במקרה הזה, אנחנו לא צריך לציין את זה
כי זה יכול להיות מוסק מ פעולה איזה סוג של נתונים ממוצע
יהיה.
וסוויפט הוא בדרך כלל די טוב על היכולת להסיק הסוגים.
>> האם אתה רוצה לראות את זה לרוץ, או שאני יכול להמשיך הלאה?
אני רוצה להמשיך.
כל שאלות על כל זה?
גדול.
>> עכשיו אנחנו הולכים להתחיל להגיע ל הפונקציות המגדירות stuff-- טובות,
וכמה סוגים אחרים, כי הם ייחודי לסוויפט שיש לך לא
ראה בשפות אחרות עד לנקודה זו,
אבל הם נמצאים באחרים שפות שאתה עלול למצוא בהמשך.
אז קודם כל, אם אתה רוצה להגדיר פונקציה,
אתה מגדיר את זה עם מילת פאנקי פונקציה, ולאחר מכן את שם הפונקציה,
ולאחר מכן בסוגריים, הטיעונים שאתה רוצה פונקציה שלקבל.
הטענות גם חייבת specify-- generally--
צריך גם לציין את סוג הנתונים ש הם, אלא אם כן הם יכולים להיות מוסק.
ואנו רואים שקטנים אזהרה בקצת.
>> אז במקרה הזה יש לנו פונקציה שנקראת printGradeCount.
אנחנו הולכים לקבל variable-- או לייתר דיוק במקרה הזה,
constant-- נקרא gradebook.
וזה הולך להיות של הקלד מערך של מספרים שלמים.
עכשיו יש משהו ש זה באמת חשוב כאן
כי אני רוצה שתבין.
זה שכברירת מחדל, טענות אלה כי הם תשומות לפונקציה זו
מוגדר עם מילת המפתח בואו משתמע, מה שאומר שאני לא יכול לשנות את זה
משתנה gradebook כאן.
וזה סוג של הגיוני, בגלל שאתה עובר בנתונים.
ואתה אולי לא רוצה אותו להיות שונה מתחתיך.
אפשר לדבר באופן מפורש שזה משתנה על ידי הצבת
מילת המפתח var כאן.
אבל זה תפסתי אותך שיש לנו אנשים שמו לב שעשו בעבר
הוא שהם הניחו שזה הולך להיות משתנה כאשר, למעשה, זה
הוא קבוע.
>> בסדר, אז הנה אז, במקרה זה, אנחנו לא מפרטים כל סוג תמורה.
אנחנו אראה לך איך לעשות את כי ברגע.
אבל שם לב שיש לנו כאן רק אם מצב פשוט.
אם gradebook הוא ריק, אשר במקרה זה
רק הרכוש של מספר שלם זה מערך, אז אנחנו להדפיס משהו.
אחרת אנו עושים משהו אחר.
>> די פשוט עד כה אני חושב.
אבל לעצור אותי אם יש לך שאלות.
>> עכשיו בפונקציה זו, ממוצעת, גם לוקחת כמה טיעונים, או לייתר דיוק ויכוח אחד,
אשר הוא gradebook, והפעם הוא הולך לחזור סוג כפול.
בגלל זה הוא מחשוב ממוצע וזה
הולך לחזור למעשה ש ממוצע מחושב לקו הקורא.
>> במקרה זה, אנו מגדירים את לחזור סוג לאחר חץ.
וזה עלול להרגיש קצת מוזר בהתחלה.
אתה כבר התרגל לקביעת התמורה
הקלד לפני השם של הפונקציה.
אבל אם אתה חושב על זה במונחים של מתמטיקה,
כמו כאשר יש לך מתמטיקה שמגדיר פונקציה,
יש לך פונקציה עם כמה תשומות, והיא מייצרת פלט.
וזה בדיוק מה ש זה אמור לחקות.
ויש כמה שפות אחרות שיש לי תחביר דומה, כמו גם,
אבל כנראה שאף אחד שראית בCS50.
אבל עדיין לא להתבלבל על ידי זה.
החץ מתכוון למה שהוא הולך ליוחזר במקרה זה.
אוקיי, אז איך אנחנו הולכים כדי לחשב ממוצע זה?
ובכן, אם gradebook הוא ריק, גם אז אנחנו
הולך לחזור 0, שאולי דרך סבירה לטיפול זה.
אני לא יודע, בואו נבוא אחזור לזה בקצת.
לא זו עשויה למעשה להיות דרך סבירה
כדי לחשב ממוצע אם יש לנו gradebook ריק.
>> אז פשוט לבצע הסיכום שלנו.
שימו לב שכאן אנחנו באמת יש גרסה חלופית של
ללולאה, אשר מאפשרת לנו לחזר על כל פריט יחיד במערך
ולמקם כל אלמנט למשתנה שלו.
על ידי ציון לכיתה ב gradebook, מה שאנחנו אומרים
הוא שאנחנו הולכים במשתמע ליצור קבוע חדש בשם
כיתה שהולכת לייצג כל פריט ייחודי בgradebook
בכל פעם שלסובב לולאה.
אז בפעם הראשונה ש זה לרוץ, תהיה כיתה
להיות הפריט הראשון בgradebook.
בפעם השנייה זה יהיה פריט שני, כן הלאה וכן הלאה
עד gradebook יש מיצה את עצמה מאלמנטים.
אז נוכל לסכם ש כיתה למשתנה הסיכום שלנו
ותשואה הממוצעת שלנו כפי שראינו בעבר.
אישור, כל שאלות?
כֵּן?
קהל: יש לי שתי שאלות.
מספר אחד, באופן היפותטי, יכול אתה מפעיל מספר שלם על זה?
לא צריך להיות כפול, האם זה נכון?
דן AMRMENDARIZ: האם אתה יכול לחזור על שאלה הזאת?
קהל: האם אני יכול לעשות מספר שלם כממוצע?
דן AMRMENDARIZ: האם אתה יכול לעשות שלם כממוצע?
אז לחזור שלם ממוצע במקום כפול?
>> קהל: Return-- יש לי שעכשיו מתחת.
דן AMRMENDARIZ: ממש כאן, לחזור 0.0?
קהל: כן, רק לחזור 0.
אז זה יהיה או 80 או 85, אבל לא 85.2.
>> דן AMRMENDARIZ: אז במקרה זה, כך שיש כמה דרכים שונות
לענות על זה.
תן לי לענות עליהן במטרה.
אז אם אני רק עושה תמורה זו 0, 0 הוא ערך שלם.
וכדי שיגרום ל טעות מסוג למקרה זה
משום שהוא מצפה כפול אבל אז הוא חוזר שלם.
אם אני רוצה לחזור שלם, שאני יכול.
אני יכול להגדיר את סוג ההחזרה לint, לחזור 0 כאן,
ולא לבצע חלוקה כפולה.
אבל אז נהיה עושה חלוקה של מספרים שלמים.
וכך אנו אז לא היינו מקבלים ממוצע שהיינו אולי מצפה.
אבל כן אנחנו יכולים לשנות הסוגים שבדרך.
>> קהל: ושנית, אתה יש אחד זוגית בחלק העליון.
אבל למטה, כאשר אתה לעשות לחזור זוגי זוגי,
זה כבר באופן אוטומטי חוזר פורמט זוגי.
למה אתה עדיין צריך להגדיר את זה עם חץ על גבי עם זוגי?
>> דן AMRMENDARIZ: אז במקרה, זה חלק
של כל-- כך לחזור על השאלה, כי זה משתמע מהתמורה
סוגים כאן, איזה סוג זה למעשה הוא, שאנחנו צריכים להיות מפורשים עם סוויפט
על מה שאנחנו רוצים לחזור מפונקציה זו
כך שכאשר הוא מבצע להקליד בדיקה, זה יכול לוודא
כי מה יש לנו בעצם נכתב למטה ממש תואם את זה.
אז זה קצת כמו צ'ק עם עצמך סוג של מצב.
אבל יש הן--
>> קהל: [לא ברור] חץ?
>> דן AMRMENDARIZ: יש מקרים שבם אנו יכולים לציין כי במובלע שאנחנו יכולים
להגדיר את סוג התמורה.
אבל במקרה הזה, אני לא חושב שזה יעבוד.
יש כמה תחביר אחר שנראה בהמשך.
>> בסדר, אז מקור זה הקוד הוא קצת שונה
בגלל זה מנתח טענות מ הפונקציה שאנחנו קוראים.
תן לי להראות לך איך זה עובד לפני שאנחנו באמת להעביר ב
לכמה דברים מעניינים שקורה בסוויפט.
>> אז במקרה הזה, אם אני רק להפעיל את זה קוד, תבחין כי מה שהיא עושה
הוא-- זמן, זה סוג של נותן לי שגיאה מוזרה.
אני צריך להעביר את זה כמה מספרים שלמים כטיעון שורת הפקודה.
אז בואו לראות, 150 ו -80, ופגעת הזן כדי לברר מה זה בעצם עושה.
זה לקבל כל אחד מ ערכים אלה כמספרים שלמים.
זה מזין אותם לgradebook.
ואז זה ביצוע כי חישוב ממוצע
ופלט שכפי שהיינו מצפה.
>> אבל ברור שיש משהו הולך על עם משהו דחייה זו
משהו כמו מספר שלם.
כפי שאתם אולי זוכרים מכשהיינו התמודדות עם טיעוני שורת הפקודה
ב- C ושפות אחרות, הראשון פריט 0-ה בטענת שורת הפקודה ש
רשימה היא השם של הפקודה שבוצענו בפועל.
אז במקרה הזה, אני רק לולאה על כל טיעוני שורת הפקודה.
אבל אני לא עושה את כל סוג של הזיה לבדוק לדלג על שראשון.
אני רק במפורש או במשתמע אני בדיקה שמהסוגים אלה
הם מספרים שלמים לפני שאני באמת לבצע חישוב זה.
>> וזה בעצם מה שקורה כאן.
לכל ויכוח ב טיעוניו של התהליך,
אני הולך לבצע כמה בדיקה.
ובמקרה הזה, אני הולך כדי לנסות להמיר ראשון
הטענה כי למספר שלם על ידי ביצוע הסבה מפורשת,
בגלל זה הוא, על קלט, מחרוזת ולא בעובדה מספר שלם.
>> אבל זה סוג של תחביר מוזר, אם כיתה תן שווה Int (טיעון).
מה שקורה בפועל כאן הוא מאוד
חשוב סוויפט באמצעותך.
זה משתמש מה נקרא סוג אופציונאלי.
>> אז פונקציה זו, Int (טיעון), חוזר לא רק שלם, אבל חוזר
מה שנקרא שלם אופציונלית.
ואז זה סוג של סוג על גבי סוג.
סוג של אתה יכול לדמיין את זה כמו זה חוזר כמו חבילה.
וכאשר אתה פותח ש חבילה, זה גם
יש מספר שלם, שהוא התוצאה, או יש לו שום דבר באופן מוחלט בכל.
וזה שימושי כמו בדיקת שגיאות מנגנון, כי במקרה זה
אנחנו יכולים לגלות, היה זה המרת סוג מוצלחת?
אם זה היה, אז זה למעשה הולך להיות מספר שלם בפנים.
אחרת זה הולך להיות קצת ערך שנתקשר אל אפסית, ש
הוא נציג של לא שלם בכל.
זה באמת נציג של דבר.
>> ולכן אם בנייה זו מאפשר לנו לגולל חבילה ש,
שאופציונלי מחייב.
ואם אנו יכולים לגולל ש חבילה ולמצוא מספר שלם בפנים,
אז מה שאנחנו אומרים כאן הוא שאנחנו אז יהיו
מאפשר ערך שכדי להיות מוגדר ל קבוע הזה שנקרא כיתה.
וחלק זה של אם ההצהרה, החלק העליון של אם ההצהרה
יפעל, כי זה לגולל היה מוצלח.
>> אם זה פשוט כל כך קורה ש הייתה שגיאה אולי
בהמרת סוג זה מפורש ממחרוזת למספר שלם, אולי
זה ABC הערך לדוגמא.
וזה ממש לא הולך להמיר למספר שלם.
ואז זה יחזור אפסי, שהוא לא שלם.
ואם הצהרה זו גם אז להיכשל.
כיתה לא קיימת כי אין לה תוכן שלם.
וזה יפעל לחסום אחר זה במקום.
כֵּן?
>> קהל: Nil הוא N-אני-L?
דן AMRMENDARIZ: אפסי הוא N-אני-L, כן.
>> אז זה אולי אחד מ הדברים הקשים ביותר על סוויפט,
במיוחד כאשר אתה ב העשבים על יישום iOS
ואתה בעצם מנסה כדי לעשות קצת פיתוח שם.
זה הולך להיות לצעוק בך על שמירת.
זה הולך להיות מבקש ממך סימני שאלה וסימני קריאה.
אבל ברגע שאתה להבין out-- אם אתה להקדיש קצת זמן כדי להבין
מה קורה עם סוגים אופציונליים, תוכל לחסוך לעצמך הרבה כאב ראש
כפי שאתה מנסה לכתוב אפליקציה בסוויפט.
>> זה בעצם תכונה חזקה מאוד.
ואתה רק צריך לקחת מילה על זה לעת עתה.
אבל נראה בנייה זו וכמה אחרים אוהבים את זה
בחלק מקוד המקור האחר ש אנחנו אראה לך בקצת.
>> האם יש שאלות ראשוניות כאן?
אז ממסעדה החשובה היא ש סוג אופציונאלי הוא סוג של metatype.
יש לו גם ערך, ואם כן, אז זה
יהיה אולי יש ערך שקשור עם זה, או שיש לו שהיא לא ערך,
והוא מיוצג על ידי אפסי.
שאר זה הוא אולי כפי שהיית מצפה.
>> אז בואו להגביר קושי שוב.
והפעם, בואו נסתכל על כמה סוגי נתונים אחרים שקיימים בפועל.
אחד מהם הוא מילונים, שהוא דומה מאוד למילונים פייתון.
זה קצת דומה לשולחן חשיש ב ג זה בעצם מיפוי של מקשים
איפה מפתחות יכולים להיות מחרוזות.
כאשר אתה מסתכל למעלה המפתחות האלה ו, מפתחות אלה יהיו ערך.
אז זה לא ממש מערך, אבל במקום זאת, קשור באופן הדוק יותר
למפת חשיש או שולחן חשיש.
>> בואו לראות איך זה אמור לעבודה לפני שאנחנו באמת
להיכנס לקוד המקור עצמו.
אם אני רק להפעיל את זה, שום דבר לא קורה באמת.
זה אומר לי שאני מצפה כמה פרמטרים מהסוג הבא.
אז אני הולך לספק ל זה כמה שמות בעיה להגדיר,
כך pset0, אולי יש לי 100.
וpset1, יש לי 5.
ולאחר מכן בבחינה, אני עשה ממש טוב ויש לי 30.
ואופס, אני מכה חלל כאן.
>> כשפגעתי הזן, אתה יכול לראות הוא מבצע כמה חישוב.
זה אומר gradebook הוא שלוש ציונים, pset1, pset0, בחינה.
ויש gradebook ממוצע ספציפי זה.
אז שוב, אנחנו עובדים עם רעיון gradebook זה,
אבל אנחנו הולכים להמשיך iterating עם המורכבות של הפונקציה שלנו.
>> אז בתחילת, אנחנו רק הולך ליצור פונקציה ש
הוא אחראי על הדפסת השימוש.
ויש יציאה זו פונקציה שתהיה רק
בכוח לצאת מהיישום.
זה לא משהו ש תוכל להשתמש באפליקציה iOS.
זה רק, במקרה זה, עם טיעון שורת הפקודה.
הבא נתחיל לנוע לכיוון Xcode.
אבל זה ספציפי לפקודה תכנית בסגנון קו בסוויפט.
>> בואו נסתכל על כמה מ הדברים המעניינים כאן.
בואו לראות, רק כמה דברים מעניינים להזכיר אולי
הוא שבתפקיד שלי הדפסת מספר הכיתות,
אולי אתה זוכר שהיה לי רשימה ש של pset1 items--, pset0, ובחינה.
למעשה אתה יכול במהירות ולעשות זאת בקלות
על ידי לקיחת gradebook, שהוא מילון שבו יש מפתחות וערכים.
מצא את כל המפתח הוא דרך שיטת מפתחות נקודה כאן,
ולאחר מכן להשתמש joinWithSeparator זה, אשר לאחר מכן לקחת את כל המפתחות
שהדפסנו ב, או pset1-- מצטער, pset0, pset1, וexam--
ולשרשר אותם יחד באמצעות פסיק וחלל
כדי ליצור מחרוזת אחת ארוכה.
פעולה להצטרף זוהי רק להדהים שימושי במגוון של הקשרים.
וכך הוא joinWithSeparator זה.
>> וזה דבר אחד שהוא השתנה מיום 1 בסוויפט לסוויפט 2.
בעבר היה style-- פייתון אם אתה
מכיר Python-- פייתון סגנון להצטרף שיטה על מיתרים.
אבל זה כבר לא המקרה בסוויפט 2.
אתה רוצה להשתמש בזה אם אתה רוצה ללשרשר מערך של דברים
יחד עם מחרוזת.
>> אז אולי אז בנו דיון בממוצע לפני,
זה עושה קצת יותר הגיוני לנו להגדיר את הפונקציה הממוצעת
להיות כפול אופציונאלי ולא מאשר רק כפול מפורש.
בגלל שהיו לנו ש מצב יוצא דופן שבו,
מה אם gradebook למעשה אין ערכים בתוכו?
מה צריך התשואה הממוצעת?
>> טוב, אולי בC היה עושה משהו
כמו סיפק ערך זקיף, כמו 0.0, או אולי מספר שלילי,
או משהו פשוט מייצג את העובדה שיש איזה מצב שגיאה
ואולי לא באמת יש לך היכולת לחשב ממוצע ש.
ובכן היופי של ציון סוג אופציונאלי יהיה לעשות את זה.
ועכשיו אני אומר את כל הדברים האלה, אבל זה בעצם לא להשתמש optionals.
אבל נראה שרק דקות שבו אנחנו יכולים להגדיר ממוצע
להיות סוג נתונים אופציונאלי כך ש אם זה באמת מחזיר חלק מנתונים, ולאחר מכן
נחזור נתונים ש.
אחרת נחזור אפסי, ואמר כי זו
אין חישוב משמעותי.
>> בואו נעבור למשהו אחר.
אז מכאן, אנחנו כבר מסתכלים על כל דוגמאות האלה בשורת הפקודה.
אבל באמת מה שאתה הולך להתמודדות עם היא Xcode.
ואחד הדברים נחמדים על Xcode הוא, ובמיוחד בסוויפט,
הוא שיש לנו זה דבר נקרא משחקים.
ומשחקים הוא לא בכל יישום iOS.
אבל זה מאפשר לך להתנסות עם סוויפט בצורה קלה מאוד.
ניתן להקליד כל הקוד שלך.
זה יפה תחביר מודגש כאן.
כאשר אתה יוצר קובץ חדש, הוא יבקש אם ברצונך ליצור משחקים.
אבל הדבר נחמד על משחקים הוא שמצד הימין של החלון שלך,
זה בעצם להראות לך פלט מהקוד שלך.
אז אם אני לגלול למטה, אנחנו יכולים לראות מה הפלט של קווים שונים של קוד
קורה בפועל להיות.
>> אז במקרה הזה, אנחנו הולכים לשנות כיוונים קצת
ולדבר על משהו שהוא באמת חשוב דרך רמה גבוהה זה
שסוויפט פועל, וזה הוא הרעיון הזה של סגרים.
ואתה כנראה כבר ראית את זה קצת ב- JavaScript.
לאלו מכם ש נמצא בCS50, סגרים
הם דרך פופולרית מאוד, טובה מאוד לעשות דברים ברמה גבוהה בשפות מודרניות.
אבל זה גם סוג של קשה ל לעטוף את הראש סביב בפעם הראשונה.
אז אם אתה מסתכל על זה פעם ראשונה, זה בסדר.
רק תסתכל על קוד המקור ולראות אם אתה יכול להבין את זה בבית.
>> אז במקרה הזה, נניח ש רוצה ליצור הרבה מעריכים
עם כמה ערך קבוע.
אז במקרה הזה אני יכול ליצור פונקציה.
אני הולך לקרוא לזה כוחו של 2 שמטרתו יחידה בחיים
הוא לקחת כמה קלט וכפול זה, ולהחזיר ערך ש.
שים לב שאני כאן קבלת סוג אחד של נתונים.
זה הולך להיות משתנה בשם x.
זה מסוג זוגי.
ואני הולך לחזור זוגי כאן.
ואני רק הולך לעשות מאוד, בכנות, די
דרך נאיבית של הכפלת ערך זה.
ואני אראה לך למה זה שימושי רק שני.
>> שים לב שכאן יש לנו מגוון זה שׁוּב. משהו ב1, נקודה
נקודת נקודה, 2, מה שאומר ש לולאה זו תפעל פעמיים.
אבל זה מייצג משתנה דמי.
זה אומר שאני לא באמת הולך אשתמש בכל מקום שמשתנה
בתוך לולאה זה.
אני רק רוצה את הקו הזה קוד לרוץ פעמיים,
ללא צורך לדעת הערך של טווח זה.
>> אז במקרה הזה אני רץ תוצאה פעמים x פעמיים, אשר למעשה
משמעות הדבר היא שאני מתישב ערך זה.
וזה קורה לי עובד כפי שהיינו מצפה.
כוחה של 2, עובר ערך של 2.0 נותן לנו תפוקה של 4.
3.2 עבודות ל10.24.
>> עכשיו אנחנו יכולים לעשות דומים דבר לכוח של 3.
אבל עכשיו לשנות רק את הטווח.
למשתנה דמי 1 דרך 3, להכפיל פי 3,
ולעשות את אותו הדבר.
>> אז זה עלול להרגיש קצת מאולץ.
אבל יש חשוב דבר כאן ש
הוא שמסתכל על אלה שתי פונקציות, יש
רק דבר אחד זה שונה, שערך זה בטווח.
הכל על שני אלה אחר פונקציות, עוצמה של 3 וכוח של 2,
הם, למעשה, זהים משום ש הם עובדים באותה הצורה.
>> לכן בשלב זה, קטן פעמון אזעקה צריך ללכת משם.
אני מקווה שמה שאתה אומר, אתה יודע, זה מרגיש קצת
כמו שכפול של מאמץ.
אולי יש דרך שאני היית עושה תוכל לתמצת את כל זה
ולספק פונקציה או ליצור פונקציה ש
עושה בדיוק מה שאני רוצה בלי צורך להקליד את זה באופן מפורש.
וזה מה שהכח של סגירה מאפשרת לנו לעשות.
אז בואו נסתכל על זה.
ואני לבלות כמה דקות על זה, כי זה
הוא די חשוב לסוויפט.
אנחנו רואים את זה כל הזמן.
אנחנו הולכים להגדיר פונקציה.
זה הולך להיקרא powerOf.
זה הולך לקבל פרמטר שנקרא y של Int הסוג.
אבל תסתכל על סוג התמורה.
סוג השיבה הוא, ב סוגריים, זוגיים חץ כפול.
מה שאומר שפונקציה זו, powerOf זה פונקציה,
חוזר לתפקד.
כי הוא מקבל זוגי וחוזר זוגי.
כך שאולי נשמעים סוג של משוגע, אבל בואו לגלול למטה קצת
ולחפש כדי לראות מה קורה.
אנחנו בתוך של powerOf פונקציה זו.
אנחנו יוצרים פונקציה חדשה נקרא exponentiator,
אבל זה לא משנה מה זה.
>> שימו לב שיש ל ערך קלט של x.
וזה לוקח בחדר זוגי וחוזר זוגי.
וזה אותו הקוד ש ראה לעיל, פרט לכך שהערך של 2
או את הערך של 3, ש הגבול העליון בטווח ש,
הוחלף ב ערך זה של y, ש
היה הפרמטר הראשוני של פונקצית powerOf.
ובשלב זה, אנחנו לחזור exponentiator.
אנחנו חוזרים לתפקד.
>> זה כמו סוג של תקיעת מוח קטנה.
אבל בואו נדמיין מה קורה כאשר אני קורא פונקציה זו powerOf
ותעבור לזה ערך כלשהו כמו 2.
מה שזה אומר הוא ש עכשיו יש לי הערך
2 לy, מה שאומר שערך זה y בפונקציה זו exponentiator
יהיה הערך ש2.
אבל אני חוזר זה פונקצית exponentiator.
>> אז שם לב מה סוויפט אומר אני יצר במקרה זה.
בואו הכיכר הגדרה, זה פונקציה שמקבלת זוגי
ומחזיר זוגי.
אני יצרתי פונקציה שמשהו ריבועים
באמצעות מנגנון זה ממש כאן.
ובאמת מה שקורה הוא שהוא חוזר בפונקציה זו
exponentiator, אבל ערך זה y הוא עטוף בתוכו.
אז עכשיו בכל פעם שאני משתמש בזה משתנה או קבוע הזה שנקרא
כיכר, זה שזה הולך להתנהג כפונקציה.
ואז אני יכול ואז להתקשר משתנה ש כמו שאני מכנה פונקציה,
ולהעביר לתוכו מספר, כמו במקרה זה 3.
ואז אני יהיה בריבוע ערך זה.
3 יהיו בריבוע אז הפך 9, כפי שניתן לראות כאן.
>> באמת מטורף, אבל זה עכשיו מאפשר לי את ההזדמנות
כדי ליצור פונקציות powerOf אחרות.
כמו שאני יכול להגיד, בסדר, גם עכשיו אני רוצה כדי ליצור פונקציה חדשה, powerOf (3),
ולאחסן את זה ב קובייה בשם קבועה.
ועכשיו קובייה הולכת להיות פונקציה נפרדת שאז תהיה
לקחת קצת ערך כקלט וקובייה ש ערך כפי שאנו יכולים לראות בשורה התחתונה
כאן.
קובייה של 2 הולכת לגרום 8.
>> דברים אני מקווה שדי מסודרים.
אף פעם לא ראו את זה קודם.
אני ממליץ לך לבדוק את הסגרים ולחקור את זה קצת יותר.
זה דברים ממש חזקים שאנו רואים הרבה ב- JavaScript וכמה שפות אחרות.
זה ממש חיוני ל הבנת ממשקי API, כמו גם
שנגיע במרחק שני.
כֵּן?
>> קהל: כאשר אתה עושה powerOf (2), סוגריים, ולאחר מכן
סוגריים אחר, input-- אחר אתה בעצם מחליף את הכיכר.
דן AMRMENDARIZ: אז לחפש בשורה האחרון כאן.
זה בעצם לגמרי אפשרי ל לעשות את זה כמו שאתה הציע שרשור.
אז powerOf (5) אומר שאנחנו הולכים יש exponentiator של 5 עד כאן.
אז זה בעצם הולך להיות אותו דבר כמו 4 לכח החמישי,
בגלל שיצרנו exponentiating לתפקד לכח החמישי,
ואנחנו עוברים ל המתפקד הערך 4.
ואנחנו מקבלים ערך ש שאנו מצפים, 1024.
קהל: וזה לא שם, כך שזה עושה את זה קל יותר
לקרוא, הכיכר מה.
>> דן AMRMENDARIZ: נכון, בדיוק.
אז לפני שאני פשוט לשים אותו לקבוע כאן כל כך
שזה עשה את זה קל להשתמש בשם זה.
כֵּן?
>> קהל: בהקשר זה powerOf, זה חלק
של שפת תכנות בניגוד לדרך בה אתה
חושב על powerOf ב[ לא ברור]?
דן AMRMENDARIZ: אז במקרה זה, powerOf
הוא פשוט השם פונקציה שהגדרתי כאן.
אז זה לא טבוע לשפה עצמה,
אך במקום זאת, זה רק פונקציה שיש
שם זה כי אני נותן לו את השם הזה.
כל שאלות אחרות?
בסדר.
>> עכשיו זה נהדר.
אבל אתה לא הולך לראות הרבה פונקציות סגר ש
הם כזה שבו אתה מגדיר, בתוך של פונקציה אחת, פונקציה אחרת.
ואתה יכול לעשות את זה.
אבל זה סוג של לא באמת הכרחי, נכון?
כמו למה אני מגדיר את זה exponentiator נקרא פונקציה
ולאחר מכן להחזיר אותו באופן מיידי.
למה אני לא יכול פשוט מייד לחזור בפונקציה זו?
>> ולמעשה, זה בדיוק הרעיון מאחורי מושג שנקרא
פונקציות אנונימי, שבו פונקציות אנונימי לא ממש
יש שם כי הם לא צריך להיות אחד.
ולכן במקרה זה, ב7 ב, אנחנו יכולים למצוא בדיוק את זה.
זה כל אותו הקוד, עושה בדיוק את אותו הדבר,
אבל עכשיו אנחנו כבר שינינו אותו מעט כל כך שפונקציה powerOf זה מייד
חוזר לתפקד.
שים לב שלאחר חזרה, יש הסוגר מסולסל פתוח.
זה מצפה קלט זה זוגי.
זה מצפה פלט שזוגי.
ולאחר מכן במילים מפתח מפריד את הקוד עצמו.
אז זה פונקציה אנונימית.
זה לא באמת יש שם, ואילו לפני שנקרא exponentiator.
אבל כפי שראינו, רק באמת לא התייחס לexponentiator
מחוץ לפונקציה ש.
אז זה לא משנה.
אז פונקציה אנונימית זה מה שנקרא כי זה חסר שם,
אבל זה עדיין בשימוש בהקשר של קוד זה.
>> זוג אלה הבאים אני הולך להמשיך בתקווה
נושבת הראש שלך קצת.
אנחנו יכולים לפשט את זה עוד יותר.
כי כפי שהיה בתבונה ציין קודם לכן,
אולי אנחנו באמת יודעים, על ידי הסיק מקוד זה, מה
הפלט של קוד זה הולך להיות.
ואכן, בפונקציה אנונימית זה, אנחנו יכולים למעשה להסיק את סוגי הנתונים.
>> אז בזה, אנחנו כבר לא צריך להגדיר במפורש
הסוג של נתונים זה להיות קלט ופלט מפונקציה זו
במשך כמה סיבות.
אחת מהן הוא שאנחנו כבר מוגדרים, עד ב אב טיפוס של פונקצית התוחם,
איזה סוג של מידע זה בעילום שם פונקציה צריכה קלט ופלט.
ומן הצד השני, אנחנו ניתן להסיק מהקוד
כאן שאנחנו מקבלים קלט שהוא מהסוג זוגי
וחוזר זוגי.
>> שים לב שכאן יש לנו לא באופן מפורש הגדיר את השמות של הטיעונים
פונקציה זו מקבלת.
וכך אנו רואים שאנו יכולים להתייחס ל פרמטרים אלו המשתמשים 0 $, $ 1,
כך הלאה וכך הלאה, בהתאם ל מספר הפרמטר שמשמש
בפונקציה זו.
>> זה משהו שאתה הולך לראות הרבה הוא הסוגר מסולסל פתוח זה
הגדרה ואחריו 0 $, ולאחר מכן כמה פעולה,
ולאחר מכן הסוגר מסולסל סגור.
כלומר פונקציה אנונימית שמבצע פעולה זו.
יש לו פרמטר שבו זה זה הסוג הוא מוסק.
כי הפרמטר הראשון הוא $ 0.
וכמה היא פעולה קורה שב$ 0.
>> קהל: אז סימן הדולר משמעות פרמטר בעצם,
ו0 פירוש הראשון?
דן ARMENDARIZ: זה נכון.
אז סימן הדולר בעצם אומר פרמטר, ו0 הפירוש ראשון.
אבל זה עובד באופן ספציפי ב מקרה זה שבו אני לא בשם
הטיעונים בפונקציה אנונימית שלי.
>> קהל: האם פרל או משהו שיש לי סימן זה דולר, דולר 0 שם?
דן ARMENDARIZ: האם ש, אני מצטער?
קהל: האם יש לי פרל דולר זה 0, דולר 1--
דן ARMENDARIZ: אני לא מוכר מדי עם פרל,
אבל PHP מה שמגדיר משתנים המבוסס על סימני דולר.
וייתכן שיש כמה שפות שתומכים בתכונות כמו זה.
למעשה, סוויפט לווה הרבה תכונות כמו זה
מהרבה שפות אחרות.
אנו רואים רמזים לפייתון בזה.
הגדרה זו של סוג נראה לבוא מOCaml.
ויש לנו רק חבורה של כל דברים מהרבה שפות שונות.
זה אחד נחמד דברים על סוויפט
הוא שזה לוקח הרבה הטוב ביותר רעיונות מחבורה של שפות
וכף נעליים כולם יחד לשפה אחת סופר.
למעשה, אם תרשה לי תמשיך נושבת הראש שלך,
אז אנחנו כבר עושים את כל זה.
אנחנו יכולים אולי לפשט את זה קצת קצת על ידי שהבין כי, כמובן,
יש סוויפט exponentiating פונקציה מובנית ב.
אם אני מייבא דרווין, ש רק הספרייה ש
תכונות pow פונקציה שנקראת זה, עכשיו אני יכול לפשט הכח של פונקציה שלי
להיות הבא.
זה הולך להיות חוזר פונקציה אנונימית זה.
>> אבל תסתכל על כמה פשוט זה עכשיו.
זה פונקציה אנונימית ש מקבל איזה סוג של נתונים,
וזה הולך להיות אחד טיעון במיוחד,
הפניה ב 0 $ שהם מהסוג זוגי.
זה הולך לחזור סוג זוגי.
אבל הצהרת התמורה עכשיו משתמע.
>> וזה סגנון מדויק זה ש מאוד, מאוד נפוץ בסוויפט,
בכל המקום.
אנחנו הולכים לראות את זה כל הזמן בסוויפט.
אז אני מראה את כל זה ל שלך בגלל תחביר זה.
זה נפוץ מאוד כדי לראות, מה שאומר ש
היא פונקציה אנונימית שמבצע
כמה ניתוח בטענות אלה.
ויש תמורה סמויה.
אז זה בהחלט אותו הדבר לנו להגיד את זה, ממש כאן.
>> בגלל זה מתולתל הסוגר הוא פונקציה,
אנחנו לבצע פעולה זו על הטענה הראשונה.
אנחנו הולכים לחזור ש.
אבל תמורה חיצונית זה חוזר שכל פונקציה,
שהפונקציה אנונימית כל כי אנחנו כבר עתה יצרנו.
כל שאלות אחרות?
בסדר, אני לא יודע אם אתם מוכנים לזה,
אבל אנחנו יכולים ללכת אפילו יותר מטורפים עם סוויפט.
אתה מוכן?
אישור, זה נהדר.
>> עכשיו יש לנו למעשה את היכולת ל, בסוויפט, בגלל איך מודולרי
ואיך המבוסס פרוטוקול זה, ל להגדיר המפעילים מפחיד שלנו.
כמו במקרה זה, לא היה לנו מפעיל לexponentiation-- גם,
לביצוע סמכויותיו של משהו.
אבל אני יכול, בסוויפט, להגדיר חדש מפעיל שעושה בדיוק את זה.
אז במקרה הזה יש חבורה של תחביר כאן.
ואני נאפשר לך להסתכל על זה בבית כשאתה מסתכל על זה.
אבל אנחנו מגדירים infix זה מפעיל, **, אשר לאחר מכן מאפשר לנו,
על ידי הגדרה מה ש פונקציה ** למעשה
אין, לקבל יד שמאל צד וצד ימין,
ולאחר מכן להחזיר את המעריך של ש צד שמאל לצד ימין.
>> אז עכשיו כולי פתאומי יצר מונה חדש.
אז 2 ** 3 פירוש 2 בחזקה השלישית.
[SOUND נושבת MIND] זה על ידי עצמו צריך לגרום לך להיות כמו,
אישור, ג הבורג אני הולך סוויפט כל הדרך.
זה נהדר.
זה די מדהים.
>> אמנם זה הוא דוגמא מצוינת.
אבל יש לי לא פעם אחת מחוץ של דוגמא זו למעשה
הגדרת המפעיל שלי.
אבל עדיין, זה מראה הרבה הכח של סוויפט
ולמה זה בעצם באמת מאוד מגניב.
אישור, כן?
קהל: אם אתה הגדרת המפעיל שלך,
איך אתה יודע שאתה לא בטעות לנסות וליצור מפעיל זה
במקום כלשהו ב- C, כמו חבוי אי שם בסוויפט,
כמו מעורפל אחד שאתה אולי לא ראיתי לפני כן.
>> דן ARMENDARIZ: אז אם אתה מנסה להגדיר מפעילים שלך,
יש את הסיכון של הגדרה אחד על מפעיל הקיים.
כי נכנס רמת הפירוט ש אני לא חושב שיש לנו זמן לעבור על.
אבל זה סיכון.
וכי היא למעשה הסיבה מדוע מאוד אני לא השתמשתי בסמל תו, ש
כאשר אנחנו מקלידים את כוח, אנחנו בדרך כלל להשתמש 4 תו קטן 5 או משהו
כמו ש, רק כשאנחנו Gchatting חברים או משהו כזה.
אבל במקרה זה, שלמעשה היה גורם להתנגשות.
וכך נמנעתי מזה רק בגלל ש יצאתי לי לדעת במקרה זה
שיגרום התנגשות ש.
>> בסדר.
עכשיו למרבה הצער, ל שבע דקות האחרונות,
אני צריך לשמור על תקיעה הדעה שלך קצת.
לאפשר אז אני אראה לך כמה דברים אחרים גם כן.
>> אנחנו כבר הראינו לך את הרעיון הזה של יש פונקציות אנונימי אלה,
סגרים אלה שמאפשרים לך סוג של פונקציות לעבור מסביב.
אתה יכול להחזיר אותם.
אתה יכול לתפעל אותם.
אתה יכול לעשות כל מיני דברים מטורפים.
>> אבל דבר אחד שאחר קורה להיות שימושי
היא היכולת, בניגוד לחוזר פונקציות אלה
בפונקציה, להעביר פונקציה כפרמטר לפונקציה אחרת.
ייתכן שאתה חושב גם מדוע על פני כדור הארץ הייתי רוצה לעשות משהו כזה?
>> ובכן, נניח שאני רוצה לקחת מפעיל זה שאני
עבד כל כך קשה כדי ליצור וליישם שלו לחבורה של מספרים שונים
במערך.
אז במקרה הזה יש לי מערך של integers-- 1, 4, 7, 2, 5, 10, 56.
ואני רוצה להכפיל את כולם.
הדרך שאנחנו בדרך כלל הייתם לעשות את זה הוא רק כדי לכתוב
פשוט ללולאה ש סובב מעל כולם
ולבצע איזשהו מבצע רבוע עליהם,
הזנת ערכים החדשים אלה לתוך חדשים משתנה, או לייתר דיוק, מערך חדש כאן.
וערך התפוקה של תוצאה היא אז כל מערכים אלה,
או לייתר דיוק את כל אלה אלמנטים עכשיו בריבוע.
>> ואנחנו יכולים לעשות את אותו הדבר דבר לעִקוּב זה,
אבל פעמון אזעקה קטן צריך ללכת מ
אומר שאולי יש הדרך שהיית חלק
תוכל לפשט את זה קצת.
ואכן יש.
מה אם היינו יכול ליצור פונקציה המאפשרת לנו
לקבל, כטורף, פונקציה?
אז במקרה הזה, לקחת מסתכל על טענות אלה.
אנחנו הולכים לקבל את הרשימה של זוגות.
ואז אנחנו הולכים לקבל פונקציה
במשתנה שנקראת F כי הוא הולך לקחת זוגי ולחזור זוגי.
וכל הפלט של כל פונקציה זו
ממפה נקראת הולכת להחזיר מערך שנקרא כפול.
>> מה זה אז יאפשר לי לעשות הוא לחזר על רשימה ש
ולעשות את אותו הדבר, אבל עכשיו תחול פונקציה שעל כל אחד
של הערכים הבודדים ברשימה ש.
אז אני לא ממש יודע מה הוא f.
זה לא משנה לי.
אבל כל עוד זה לוקח בחדר זוגי, מבצע פעולה מסוימת על זה,
ואז חוזר זוגי, הייתי אז
תוכל למפות פונקציה שפני כל אלמנט ברשימה.
>> וזה סוג של תכנות הוא פונקציות מסדר גבוהות יותר שנקראים,
לאן אנחנו עוברים פונקציות סביב כפרמטרים
ולעשות דברים עם פונקציות.
זה כמו סוג של לקיחה כל אלה רעיונות שלמדנו בCS50
ולוקח אותם סוג של לרמה הבאה.
וזה כל הדברים בסגנון CS51.
ואז נלך לעומק יותר בשיעורים כאלה.
>> אבל זה גם כי חשוב לנו כאן
רואה הרבה פונקציות המשמשים בסוויפט
כי בעצם עושה זה, שבו יש לנו
כמה מספרים, כמה מערך של מספרים.
אנחנו הולכים לעבור את זה מערך לממפתנו.
ואנחנו גם הולכים עובר כמה פונקציה, ש
אנחנו כבר הוגדרו כאן.
זה הולך להיות מרובע.
ואנחנו הולכים אז לרבע את כל המספרים האלה
ולאחסן את זה בתוצאה זו כאן.
>> אז המקרה הזה אנחנו כבר מוגדרים שלנו פונקציה שנקראת ממפה.
אבל הדבר הזה בדיוק הוא, למעשה, בנה לסוויפט.
יש מגוון של פונקציות הנקראות מפה.
יש פונקצית מפה, יש להפחית פונקציה,
ויש פונקצית מסנן, אשר למעשה להחיל פונקציות
לכל אלמנט ב רשימה לשנות אותם בדרך כלשהי.
>> קהל: אז מכיוון שאתה משנה הנתונים לפורמט אחר
דרך function--
דן ARMENDARIZ: ימין.
כן, אז הפונקציה שאנחנו מקבלים
משנה את המידע בדרך מסוימת.
במקרה זה, היינו גם מתישב זה, או שהיינו זה לפתור את קובייה,
או באמת, אנחנו יכולים לבצע אין פעולה על זה בכלל.
>> אבל תן לי להראות לך אז איך זה הולך להיראות בפועל.
ושוב, אני רץ קצת זמן. אז אני לא
הולך להיות מסוגל לעבור על כל של קוד המקור כאן בפירוט.
אבל אני ממליץ לך לעשות את זה.
אנחנו נפרסם אותו בהקדם אפשרי לאחר שיחה זו.
>> אבל אם אתה תסתכל על זה, תניח שיש לנו רשימה של מספרים,
מערך של מספרים בזה מספרים נקראים משתנה.
אז אנחנו רוצים לבצע את זה פעולת סינון על המספרים האלה.
אז המסנן הוא גבוה יותר פונקציה כדי ש
מקבל מערך וגם פונקציה.
ועל כל אלמנט שב מערך, הוא מבצע פונקציה ש.
>> אם זה חוזר פונקציה נכון, זה שומר פריט ש.
אם הפונקציה שמחזירה שווא, זה זורק פריט ש.
ואז זה מחזיר רשימה כי אז הוא עשה את כל
של אותם הפריטים שסוננו.
>> אז במילים אחרת, זה הוא אותו הרעיון, gradebook.
אולי יש לנו מגוון רחב של ציונים למספרי ערך נקרא זה.
יכול להיות 100, ו- 70, ו 40, כן הלאה וכן הלאה.
מה המשמעות של זה הוא מסנן הודעה כי זה הוא שסוכר תחבירי
לפונקציה אנונימית.
זה פונקציה אנונימית אומרת כי הפרמטר שאני מקבל
הולך להיות, אם זה הוא יותר מ -70,
אז זה יחזור אמיתי, כלומר, פריט שיישמר במסנן זה.
אז בואו יהיה קצת יותר קונקרטי על זה.
אם יש לי מערך של מספרים וזה כולל 100, 70, ו -40,
אני מופיע במסנן זה פעולה בכל אחד מאלה.
כך שראשון הוא ערך זה של 100.
100 גדול או שווה 70 הוא אמיתי, ש
משמעות הדבר היא כי 100 נשמר ב עותק חדש של מערך זה.
גם 70 עוברים.
אבל 40 לא.
אז מה הוא חזר בpassingCount הוא המערך של אלמנטים 100 ו70--
100, פסיק, 70.
אלה היו שני רק פריטים שנשמרו.
וכך הסיבה שעברתי במהירות הרבה סוג של סדר גבוה אלה
דברים בגלל זה הוא שנפוץ דבר שתראה בסוויפט יפה
לעתים קרובות, מבצע פעולה מסוימת באמצעות תחביר פונקציה אנונימית זה.
>> יש כמה דברים מגניבים.
מתגים הם באמת חזקים בסוויפט, אני מתכוון בדיוק כמו משוגע, חזק מטורף.
אתה יכול להשתמש במתג, ו למעשה אתה יכול ליישם אותם
לטווחים, שהוא סוג של משוגע, ולעשות דברים מפוארים כמו ש.
>> אבל בדקות האחרונות, אני רוצה לדלג קדימה די רחוק
ולהראות לך דוגמא ספציפית של איך אנחנו יכולים ליצור ביישום iOS באמצעות סוויפט.
לכן, כאשר אתה עושה זה, תצטרך לקחת
נראה at-- על אפל תיעוד, הם
יש לי הרבה הדרכות ממש טובות ליצירת היישום הראשון שלך.
ואני ממליץ לך לעשות כי הם ייקחו אותך
דרך כל השלבים של מה בדיוק ל לחץ על כדי ליצור יישום iOS.
>> אבל כאן יש לנו אפליקציה iOS זה.
וזה יישום די פשוט באמת.
אם אני מפעיל את זה, תן לי להראות שלך מה שזה נראה.
כל זה בעצם עושה זה מושך מהאינטרנט קובץ JSON
כי יש לי מאוחסן בשרת.
ושקובץ JSON מגדיר תמונות המאפשרות
לי ואז לעבור, עליי אפליקציה, תמונות מהשרת האינטרנט שלי.
>> אז יש לי כאן getNextImage.
הוא טוען תמונה מהאינטרנט, ואז מציג אותו על המסך.
>> אז זה די פשוט.
אבל המטרה כאן היא להראות לך איך אנחנו יכולים לשלב דברים
מהשבועות האחרונים של CS50 ליישום iOS בפועל.
במילים אחרות, אולי אחד מ דברים שאתה רוצה לעשות
הוא להיות יישום iOS ש יכול למשוך נתונים מהאינטרנט
ולהראות למשתמש קצת מידע.
זה לגמרי הנקודה של קוד מקור זה כאן.
>> אז יש הרבה מה לומר על איך לעשות את פיתוח iOS בפועל.
יש הרבה של תחביר מטורף שלא ראו עדיין די
כמו בכיתה, מה הוא בעצם מעמד.
אנחנו במידה רבה יכולים להתעלם כי לעת עתה.
>> אבל שם לב שיש לנו בי בתוך זה מגוון של דברים
שכבר ראו כמו פונקציות שיש לי שמות ספציפיים.
וכאשר אנחנו נותנים אותם מתפקד שמות הנכונים
כי צפויים ידי iOS, למעשה זה מרגיש קצת קסום.
אבל כאשר אתה יוצר יישום iOS, יש
שמות פונקציה מסוימים ש נקראים על ידי הטלפון עצמו
כבקשת טעינה לנסות כדי ליצור תהליך שלמעשה
פועל היישום שלך.
אז שוב, יש הרבה דברים שאני צריך לחפות על כאן על מנת ש
לדבר על זה באופן ספציפי.
אבל אני ממליץ לך להסתכל אולי סמינר iOS האחר, אבל גם כמה
של אינטרנט הדרכות שיעשו עבודה הרבה יותר טובה לתאר
המידע הספציפי.
>> אבל אנחנו יכולים לראות כמה דברים ש מעניינים מהקוד כאן.
שים לב שיש לנו, אם הצהרות.
אגב, אחד חשוב דבר על אם דוחות
הוא שהסוגריים סביב ביטוי בוליאני הוא אופציונליים.
אבל הסוגריים המסולסלים אינם אופציונליים, לא משנה כמה מעט או קווים רבים של קוד
יש לך באם הצהרה.
אתה לא יכול להיות אם דוחות ללא סוגריים מסולסלים בסוויפט.
>> וזה גם הוא,, קצת מטופש.
אבל יש סיבות היסטוריות לכך.
זה אמור להציל אותך מעצמך.
כמו זה למשל, אתה לא יכול לחסל את הסוגריים המסולסלים סביב ש
אם הצהרה.
אלה למעשה נדרשו.
אז אני ממליץ לך תסתכל על זה.
אבל יש אחד יותר לבנות שאני רוצה
כדי להראות לך על סוויפט ש חדש לסוויפט 2.0 בהשוואה
לגרסאות ישנות יותר של סוויפט, אשר הוא הבא.
בואו לראות איפה שמתי את זה כאן?
>> אז בפונקציה זו נקראת fetchJSON, פונקציה זו
הוא אחראי על משיכת שJSON קובץ מכתובת אתר, שפשוט כל כך קורה
להיות פועל על IDE CS50.
אני רק התחלתי אפאצ'י, לשים קובץ JSON שלי שם,
ואני יכול אז למשוך את זה נתונים מהאינטרנט באמצעות
פונקציה זו ואת כתובת האתר הזה, הניתן על ידי הטלפון.
זה ניתן על ידי ספרייה שאתה משתמש בי
אתה עושה קצת פיתוח האפליקציה iOS.
>> שים לב כאן שיש זה יוצא דופן מבנה תחבירי נקרא שומר.
ובאמת כל זה הוא ב סוויפט הוא דרך של אימות
כי יש כמה דברים כבר נפגש לפניך
להמשיך עם שאר הפונקציות.
אז אני יכול לקבל, באמצעות סוג זה אופציונאלי,
אני יכול למצוא את כתובת האתר על ידי ריצת פונקצית NSURL זה
ואחסון שלכתובת אתר קבוע, ולאחר מכן בדיקה
כדי לראות אם כתובת האתר היה אפסית, משום שהיא הולך לחזור סוג אופציונאלי.
ואם זה היה אפסי, אז הייתי להדפיס את שגיאה ולאחר מכן לחזור.
>> אבל במקום זה, מה שמאפשר לי השומר שלנו הוא שמאוד דבר,
אבל לוודא שהוא למעשה מקרה שכתובת אתר
נקבע כראוי על ידי NSURL.
ואם כן, אז זה מדלג על זה, וזה
יאפשר לך להמשיך ב כתובת אתר שהוגדר כראוי.
אבל אם זה המקרה ש כתובת אתר אינו מוגדר כהלכה,
אם פונקציה זו מחזירה שגיאה או משהו בלתי צפוי אחר
למעשה מתרחש, מבנה שומר זה מאפשר לנו אז פלט ששגיאה
ולחזור מייד.
כֵּן?
>> קהל: אז זה סוג כמו אם אז אחר?
דן ARMENDARIZ: זהו סוג של כמו אם לאחר מכן אחר, כן,
פרט לכך שכתובת אתר זו היא אז מוגדר לכל דבר מתחת לזה.
אם הוא עובר שומר זה, אז זה יהיה למעשה מלאים בנתונים
ושמיש שבנותר קוד מקור בתפקוד שלך.
אז אני חושד שאתה הולך מתחיל לראות שומר זה גם כן.
ולהיות מודע לכך.
>> אז פשוט מסתכל על כמה אחרים דברים, זכות זו הנה מה,
אתה חושב, רק על סמך מה ש אנחנו מדברים על לפני?
>> קהל: חושב שזה יהיה לרוץ ברשימה?
>> דן ARMENDARIZ: אז זה קרוב.
זוהי פונקציה שאנו מגדירים.
ואנחנו מזינים פונקציה ש כטיעון לפונקציה זו כאן.
>> קהל: [לא ברור] אם לא אפסי.
אז זה ברשימה, נכון?
>> דן ARMENDARIZ: אם השגיאה היא לא אפסית, כך שהוא-- אז אני צריך לגלול.
ובכן, בוא נראה, אני באמת לא יכול גלול לכאן.
שגיאה היא טענה שהוא להיות עבר לפונקציה אנונימית זה.
זה פונקציה אנונימית.
אין לה שם.
אבל אנחנו מקבלים את שלושה אלה טיעונים, נתונים, תגובה, ושגיאה.
וזה הולך לחזור חלל, כך זה לא הולך לחזור כל דבר.
וזה התוכן של פונקציה ש.
ואז יש לנו גישה בתוך ש פונקציה לכל אחת מטענות אלה.
>> אז זה סופה סיור בשפה.
אבל אני מקווה שעם זה, אני מקווה שאתה לוקח
תסתכל על חלק של הדרכות ספציפי לפיתוח iOS עם סוויפט,
במיוחד אם אתה הולך ל page-- מפתח האינטרנט של אפל
יש להם הרבה של ממש טוב הדרכות כדי להתחיל.
אבל אני מקווה שרק שעה זו של דיבור על התחביר עצמו נתן
שלך מספיק כדי להתחיל עם זה.
>> אנו נפרסם כל מקור זה קוד באתר האינטרנט של הסמינר
בהקדם האפשרי, וגם את השקופיות אז יש לך התייחסות לכל אלה.
אבל מזל טוב עם הפרויקטים שלך.
ותודה רבה לכולכם שבאתם.
>> [תְשׁוּאוֹת]