תוֹכֶן

• האם אני צריך להכיר את סוויפט?
• הגדר את ה- Xcode IDE של אפל
• תחילת העבודה: צור פרויקט Xcode חדש
• צוות פיתוח נדרש?
• הבנת ה- Xcode IDE של אפל
• AppleDelegate: בחינת קובץ המקור של סוויפט
• 1. צור נקודת כניסה
• 2. הגדר את ה- AppDelegate שלך
• 3. הגדר מאפיין חלון
• 4. יישומי Stub מגוון
• בדיקת הפרויקט שלך: הפעלת סימולטור iOS
• יצירת ממשק משתמש עם בונה הממשקים
• גישה לספריית האובייקטים של iOS
• התאמה אישית של אובייקטים באמצעות מפקח התכונות
• תצוגה מקדימה של ממשק המשתמש שלך
• חיבור ממשק המשתמש לקוד המקור שלך
• יצירת שיטת פעולה
• 1. ציין ששיטה זו היא פעולה
• 2. הצהירו על השיטה
• 3. הגדר כמה פרמטרים
• בדוק את החיבור
• יצירת דיאלוג התראה
• 1. הצהיר על קבוע
• 2. הגדר את תוכן התוכן
• 3. הגדר את הסגנון
• 4. הוסף פעולה
• 5. הצג את ההתראה
• בדיקת אפליקציית ה- iOS שהושלמה
• מסיימים

אנדרואיד היא אולי אחת ממערכות ההפעלה הפופולריות ביותר בעולם, אך היא רחוקה ממערכת ההפעלה היחידה לנייד!

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

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

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

זה מה שאתה צריך לדעת כדי להתחיל לפתח ל- iOS.

האם אני צריך להכיר את סוויפט?

כשאתה מתחיל להתפתח עבור iOS, בדרך כלל תוכל לבחור בין שתי שפות תכנות: Objekt-C או Swift. Swift הושק בשנת 2014, והיא השפה המודרנית יותר, ובנוסף נראה כי אפל דוחפת את סוויפט מעל Objekt-C לפיתוח iOS, כך שאשתמש בסוויפט לאורך כל הדרכות זה.

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

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

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

הגדר את ה- Xcode IDE של אפל

כדי לפתח עבור iPhone ו- iPad, תזדקק למחשבי Mac שמפעילים macOS 10.11.5 ומעלה. אם אינך בטוח איזו גרסה של macOS אתה מפעיל כעת, אז:

• בחר את הלוגו "Apple" בשורת התפריטים של ה- Mac שלך.
• בחר "אודות מק זה."
• ודא שבחרת בכרטיסייה "סקירה כללית"; הגרסה שלך ל- macOS אמורה להופיע בחלון זה.

תזדקק גם ל- Xcode, שהיא סביבת הפיתוח המשולבת של אפל (IDE). ל- Xcode יש את כל הכלים והתכונות הנדרשות לתכנון, פיתוח וניפוי של יישומים עבור macOS, watchOS, tvOS - ו iOS.

להורדת הגרסה האחרונה של Xcode:

• הפעל את חנות האפליקציות ב- Mac.
• בשדה "חיפוש", הזן את "Xcode."
• כאשר יישום Xcode מופיע, בחר "קבל" ואחריו "התקן אפליקציה."
• כשתתבקש, הזן את מזהה Apple וסיסמתך. אם אין לך מזהה של Apple, תוכל ליצור מזה בחינם. כעת תורד Xcode לתיקיית ה- "יישומים" של Mac שלך.
• לאחר סיום ההורדה של Xcode, הפעל אותה. קרא את התנאים, ואם אתה שמח להמשיך, לחץ על "מסכים".
• אם Xcode מבקש ממך להוריד תוכנה נוספת, עקוב אחר ההוראות שעל המסך כדי להוריד רכיבים חסרים אלה.

תחילת העבודה: צור פרויקט Xcode חדש

בדומה ל- Android Studio, Xcode מגיע עם מספר תבניות לקטגוריות נפוצות של יישומי iOS, כמו ניווט מבוסס טאב ומשחקים. תבניות אלה כוללות קוד של תבנית הקובץ וקבצים שיכולים לעזור להקפיץ את פרוייקטי iOS שלך. במאמר זה נשתמש באחת מהתבניות המוכנות הללו.

ליצירת פרויקט Xcode חדש:

• הפעל את ה- Xcode IDE, אם עדיין לא עשית זאת.
• לאחר מספר רגעים, יופיע מסך "ברוך הבא ל- Xcode"; בחר "צור פרויקט Xcode חדש." אם מסך הפתיחה לא מופיע, בחר "קובץ> חדש> פרויקט" בשורת התפריטים של Xcode.
• בחלון "בחר תבנית לפרוייקט החדש שלך", וודא כי הכרטיסייה "iOS" נבחרה.
• בחר בתבנית "יישום יחיד לתצוגה" ולחץ על "הבא".
• ב"שם מוצר ", הזן" HelloWorld. "Xcode ישתמש בזה כדי לתת שם לפרויקט שלך וליישום שלך.
• אם תרצה, הזן "שם ארגון" אופציונלי.
• הזן את "מזהה הארגון" שלך. אם אין לך מזהה, אתה יכול להשתמש ב- "com.example." שים לב ש"זהי הצרור "נוצר באופן אוטומטי על סמך שם המוצר שלך ומזהה הארגון שלך, כך שאתה לא צריך לדאוג בקשר לזה.
• פתח את התפריט הנפתח "שפות" ובחר "מהיר".
• מצא את תיבת הסימון "השתמש בנתוני ליבה" וודא שהם קיימים לא נבחר.
• בחר בתיבת הסימון "כלול בדיקות יחידה".
• מצא את תיבת הסימון "כלול בדיקות ממשק משתמש" וודא שהיא קיימת לא נבחר.
• הקש "הבא."
• בתיבת הדו-שיח שלאחר מכן בחר את המיקום בו ברצונך לשמור את הפרויקט ולחץ על "צור".

Xcode יטען כעת את הפרויקט בחלון סביבת העבודה שלה.

צוות פיתוח נדרש?

בשלב זה, Xcode עשוי להציג את השגיאה הבאה "חתימה ל- HelloWorld דורשת צוות פיתוח."

לפני שתוכל להריץ את הפרויקט שלך במכשיר iOS פיזי, תצטרך להקים צוות תקף ולחתום על בקשתך. מכיוון שאנחנו רק מבצעים ניסויים עם iOS, אינך צריך להשלים את תהליך החתימה כעת, אך יהיה עליך לחתום על היישום שלך לפני שהוא יוכל לפעול במכשיר פיזי או לגשת לשירותים מסוימים, כגון Game Center או In-App רכישות.

הבנת ה- Xcode IDE של אפל

סביבת העבודה של Xcode היא המקום בו תכתוב את כל קוד המקור של האפליקציה שלך, תכנן ותבנה את ממשק המשתמש שלך (UI) ותיצור את כל הקבצים והמשאבים הנוספים שבסופו של דבר יגיעו יחד ליצירת יישום ה- iOS שהושלם.

Xcode מלא בתכונות, אך כחדשה בפיתוח iOS, ישנם כמה תחומים שעליכם לדעת עליהם:

• (1) אזור ניווט. אזור זה מספק גישה מהירה וקלה לכל הקבצים והמשאבים השונים המרכיבים את הפרויקט שלך. ניתן לבחון את תוכן הקובץ על ידי בחירתו באזור הניווט. שים לב שאתה רק צריך בחר התיק המדובר; לחיצה כפולה על קובץ תפעיל אותו בחלון חיצוני חדש.
• (2) אזור העורכים. בהתאם לקובץ שתבחר באזור הניווט, Xcode יציג ממשקים שונים באזור העורך. לרוב, תשתמש באזור העורך כדי לכתוב את קוד המקור של היישום שלך ולבנות את ממשק המשתמש שלו.
• אזור השירות. אזור זה מחולק לשני חלקים. בחלקו העליון של אזור השירות (3) מוצג חלונית המפקח, שם תוכל להציג מידע על הפריט שבחרת באזור הניווט או העורך ולערוך את התכונות שלו. החלק התחתון של אזור השירות (4) מציג את חלונית הספרייה, המספקת גישה לכמה מרכיבי ממשק משתמש מוכנים, קטעי קוד ומשאבים אחרים.

AppleDelegate: בחינת קובץ המקור של סוויפט

תבנית היישום Single View כוללת את כל קוד ה- Swift והמשאבים הנדרשים ליצירת אפליקציית iOS פשוטה אך מתפקדת.

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

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

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

ייבוא ​​UIKit @UIApplication יישום מרכז כיתה ראשי: UIResponder, UIApplicationDelegate {var windows: UIWindow? // ב- Swift, אתה מצהיר שיטה באמצעות מילת המפתח "func" // יישום func (_ יישום: UIApplication, didFinishLaunchingWithOptions launchOptions:?) -> Bool {return true} // הגדר פרמטר "יישום" בסוג "UIApplication" "// func applicationWillResignActive (_ יישום: UIApplication) {} func applicationDidEnterBackground (_ יישום: UIApplication) {} func applicationWillEnterForeground (_ יישום: UIApplication) {} func applicationDidBecomeActive (_ יישום: UIApplication) ) {}}

בואו נסקור מקרוב את המתרחש בקובץ זה:

1. צור נקודת כניסה

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

@UIApplicationMain

2. הגדר את ה- AppDelegate שלך

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

יישום מחלקה בכיתה: UIResponder, UIA היישום Delegate {

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

3. הגדר מאפיין חלון

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

חלון var: UIWindow?

4. יישומי Stub מגוון

מחלקת AppDelegate מכילה גם יישומי גזע למספר שיטות נציג, כגון:

יישום funcDidEnterBackground (_ יישום: UIA היישום) {

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

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

בנוסף ל- ApplicationDidEnterBackground, AppleDelegate.swift מכיל את השיטות הבאות:

• didFinishLaunchingWithOptions. מודיע לנציג שתהליך ההשקה כמעט הושלם והבקשה שלך כמעט מוכנה להפעלה. עליך להשתמש בשיטה זו כדי להשלים את אתחול האפליקציה שלך ולבצע שינויים אחרונים לפני שממשק המשתמש של היישום שלך יוצג למשתמש.
• יישוםWillResignActive. אומר לנציג שהבקשה שלך עומדת לעבור ממצב פעיל למצב לא פעיל. שיטה זו יכולה להיות מופעלת על ידי הפרעה זמנית, כגון שיחת טלפון נכנסת, או כאשר היישום שלך מתחיל לעבור למצב רקע. כאשר האפליקציה שלכם במצב לא פעיל היא צריכה לבצע עבודה מינימלית, לכן עליכם להשתמש ב ApplicationWillResignActive כדי להשהות משימות מתמשכות ולהשבית כל טיימר. עליך לנצל הזדמנות זו גם כדי לשמור נתונים שלא נשמרו, כך שהם לא יאבדו אם המשתמש יבחר לפרוש מהבקשה שלך כשהיא ברקע.
• יישוםWillEnterForeground. ב- iOS 4.0 ואילך, שיטה זו נקראת כחלק מהמעבר של האפליקציה שלך מהרקע למצב פעיל בחזית. עליך להשתמש בשיטה זו כדי לבטל את כל השינויים שביצעת כאשר היישום שלך נכנס לרקע.
• יישוםDidBecomeActive. זה אומר לנציג שהאפליקציה שלך עברה ממצב לא פעיל למצב פעיל. בדרך כלל זה מתרחש כאשר המשתמש או המערכת משיקים את היישום שלך, אך זה יכול להתרחש גם אם המשתמש בוחר להתעלם מהפרעה שהעבירה את האפליקציה שלך למצב לא פעיל זמני, כמו שיחת טלפון נכנסת או SMS. עליך להשתמש בשיטת היישום ApplicationDidBecomeActive כדי להפעיל מחדש את כל המשימות שהושהו בזמן שהיישום שלך במצב לא פעיל.
• יישוםWillTerminate. שיטה זו מודיעה לנציג כי בקשתך עומדת להסתיים. עליך להשתמש בשיטה זו כדי לבצע ניקוי נחוץ, כגון שמירת נתוני משתמש או שחרור משאבים משותפים. רק שימו לב שלשיטה זו יש כחמש שניות לבצע את המשימות שלה ולחזור, ואם היא חורגת ממגבלת הזמן הזו המערכת עשויה להחליט להרוג את התהליך לחלוטין.

בדיקת הפרויקט שלך: הפעלת סימולטור iOS

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

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

בואו ננהל את הפרויקט שלנו בסימולטור iOS:

• בחר "קבע את הסכימה הפעילה" (היכן שהסמן ממוקם בתמונת המסך הבאה).

• בחר במכשיר שברצונך לחקות, כגון "iPhone 8", "iPad Air 2" או "iPhone X". הסימולטור מחקה את iPhone 8 Plus כברירת מחדל.
• בפינה השמאלית העליונה של סרגל הכלים Xcode, בחר בלחצן "הפעל" (שם הסמן ממוקם בתמונה המסך הבאה).

• אם זו הפעם הראשונה שאתה בוחן אפליקציית iOS, Xcode ישאל אם ברצונך לאפשר מצב מפתחים. מצב המפתח מאפשר ל- Xcode לגשת לתכונות מסוימות של ניפוי באגים מבלי לבקש את הסיסמה שלך בכל פעם, כך שלמרות שיש לך סיבה ספציפית לא, לרוב תרצה לאפשר את מצב המפתח.

לאחר ש- Xcode יסיים לבנות את הפרויקט שלך, סימולטור iOS ישיק ויתחיל לטעון את האפליקציה שלך. בדומה לאמולטור אנדרואיד, לפעמים זה יכול להיות תהליך איטי, כך שתצטרך להתאזר בסבלנות (אולי השתמש בזה כהזדמנות להכין לעצמך קפה!)

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

יצירת ממשק משתמש עם בונה הממשקים

בונה הממשקים של Xcode מספק דרך חזותית לעצב ולבנות את ממשק המשתמש של היישום שלך, בדומה לאופן בו עורך הפריסה מתפקד ב- Android Studio.

אם תסתכל על אזור הניווט, תראה שתבנית היישום 'תצוגה יחידה' כבר יצרה קובץ 'Main.storyboard', שהוא סיפור סיפורים קובץ. לוח סיפור הוא ייצוג חזותי של ממשק המשתמש של האפליקציה שלך, אותו אתה יכול לערוך ב- Builder Interface.

כדי להסתכל ב- Storyboard של היישום שלנו, בחר בקובץ Main.storyboard באזור הניווט. בונה הממשקים צריך להיפתח אוטומטית ולהציג את ממשק המשתמש של האפליקציה שלך, המורכב כרגע ממסך יחיד.

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

גישה לספריית האובייקטים של iOS

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

אנו ניצור כפתור שכשמופעל על הקשה מציג התראה. נתחיל בלחיצה על כפתור מספריית האובייקטים ולהוסיף אותו לאפליקציה שלנו:

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

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

התאמה אישית של אובייקטים באמצעות מפקח התכונות

בשלב הבא עלינו להוסיף טקסט לכפתור. אתה יכול להתאים אישית אובייקטים באמצעות מפקח התכונות של Xcode:

• בחר "תצוגה> כלי עזר> הצגת מפקח תכונות" מסרגל הכלים Xcode; על מפקח התכונות כעת להופיע לצד הימני של סביבת העבודה של Xcode.

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

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

תצוגה מקדימה של ממשק המשתמש שלך

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

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

• בחר "תצוגה> עריכה> הצג עורך עוזר" בשורת התפריטים של Xcode.
• בשורת התפריט של עורך העוזר, בחר "אוטומטי".

• בחר "תצוגה מקדימה> Main.storyboard (תצוגה מקדימה)." עורך העוזר יציג כעת תצוגה מקדימה של ממשק המשתמש של האפליקציה שלך לצד אזור העורך הרגיל.
• כדי להציג בתצוגה מקדימה את ממשק המשתמש של האפליקציה בכיוונים שונים, גלול לתחתית חלון התצוגה המקדימה ובחר בלחצן "סובב".

חיבור ממשק המשתמש לקוד המקור שלך

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

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

אם תפתח את קובץ ה- "ViewController.swift" של הפרויקט שלך, תראה שתבנית היישום 'תצוגה יחידה' כבר יצרה עבורנו בקר תצוגה:

class ViewController: UIViewController {

נכון לעכשיו, כיתת ViewController זו פשוט יורשת את כל ההתנהגות שהוגדרה על ידי UIViewController, אך באפשרותך להרחיב ולהתאים אישית את התנהגות ברירת המחדל על ידי ביטול השיטות שהוגדרו על ידי UIViewController.לדוגמה, נכון לעכשיו הקובץ ViewController.swift מבטל את שיטת viewDidLoad (), אך הוא לא ממש לעשות הכל למעט התקשר לגרסת UIViewController לשיטה זו:

לבטל את func viewDidLoad () {super.viewDidLoad () // בצע התקנה נוספת לאחר טעינת התצוגה //}

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

מאחורי הקלעים, תבנית היישום Single View יצרה אוטומטית חיבור בין הכיתה ViewController.swift לבין Main.storyboard. בזמן ריצה, ה- Storyboard שלך ייצור מופע של ViewController ותוכן ה- Storyboard שלך יופיע על המסך.

זה נותן לנו התחלה ראשונה, אך עדיין עלינו לקשר את האלמנטים האישיים בתוך ה- Storyboard שלנו, לקובץ ViewController.swift, כך שקוד המקור יוכל לתקשר עם אלמנטים בודדים אלה.

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

יצירת שיטת פעולה

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

כדי ליצור שיטת פעולה:

• באזור הניווט, וודא שקובץ Main.storyboard נבחר.
• פתח את עורך העוזרים של Xcode, על ידי בחירה 'תצוגה> עורך עוזר> הצג עורך עוזר.'
• בסרגל בורר העורך, לחץ על "אוטומטי" ואז בחר "אוטומטי> ViewController.swift."
• בשלב זה, גם קובץ ViewController.swift וגם לוח התכנון צריכים להיות גלויים על המסך. בקובץ ViewController.swift, מצא את השורה הבאה והוסף תחתיו כמה שורות של שטח ריק:

class ViewController: UIViewController {

• בלוח ה- Storyboard שלך, בחר בלחצן ממשק המשתמש של הכפתור כך שהוא מודגש בכחול.
• גרור שליטה בלחצן לחלל הריק שיצרת זה עתה בקובץ ViewController.swift. קו כחול אמור להופיע, המציין היכן תיווצר שיטת הפעולה.

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

Xcode תיצור כעת את שיטת ה- "alertController" הבאה:

@IBAction func alertController (_ שולח: כל) {}

בואו ונפרט את מה שקורה כאן:

1. ציין ששיטה זו היא פעולה

התכונה "IBAction" חושפת שיטה זו בפני בונה הממשקים כפעולה, המאפשרת לך לחבר שיטה זו לאובייקטים של ממשק המשתמש שלך:

@IBAction

2. הצהירו על השיטה

ב- Swift אנו מצהירים על שיטה באמצעות מילת המפתח "func", ואחריה שם השיטה:

func התראת קונטרול ()

3. הגדר כמה פרמטרים

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

לכל קבוצת פרמטרים צריך להיות שם וסוג, מופרדים על ידי מעי גס (:).

בקר func alert (_ שולח: כל) {

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

כעת, בכל פעם שהמשתמש מקיש על הכפתור, האפליקציה שלנו תפעיל את שיטת ה- alertController (_ שולח :).

בדוק את החיבור

לאחר יצירת שיטת ה- "alertController" שלנו, אנו יכולים לבדוק שהיא מחוברת כראוי לכפתור:

• באזור הניווט, בחר בקובץ "Main.storyboard".
• בשורת התפריטים של Xcode, בחר "תצוגה> כלי עזר> הצגת מפקח חיבורים." מפקח החיבורים אמור להיפתח כעת בצד ימין של סביבת העבודה של Xcode.
• באזור העורך, בחר בלחצן שלך.

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

אנו יכולים לראות שהאירוע "Touch Up Inside" מחובר לשיטת ה- "alertController" שלנו, כך שאנו יודעים שבכל פעם שהמשתמש מתקשר עם כפתור זה נקרא שיטת ה- "alertController".

עם זאת, יש בעיה: לא הגדרנו בפועל מה צריך לקרות כשנקראת שיטת "alertController"!

יצירת דיאלוג התראה

ב- iOS, באפשרותך ליצור התראה באמצעות UIAlertController, השווה בערך ל- AlertDialog של Android.

פתח את קובץ ViewController.swift והוסף את הדברים הבאים:

class ViewController: UIViewController {@IBAction func showAlert (_ שולח: כל) {let alertController = UIAlertController (כותרת: "כותרת",: "שלום, עולם!", מועדף סטייל: .alert) alertController.addAction (UIAlertAction (כותרת: "בטל) ", סגנון:. default)) self.present (alertController, אנימציה: true, השלמה: nil)}

בואו נסקור מקרוב את מה שקורה כאן:

1. הצהיר על קבוע

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

תן את בקר ההתראה

2. הגדר את תוכן התוכן

כעת אנו יכולים להגדיר את כותרת ההתראה ואת:

let alertController = UIAlertController (כותרת: "כותרת",: "שלום, עולם!")

3. הגדר את הסגנון

מכיוון שזו התראה, אני משתמש בסגנון "התראה":

let alertController = UIAlertController (כותרת: "כותרת",: "שלום, עולם!", מועדף סטייל: .alert)

4. הוסף פעולה

בשלב הבא אנו מוסיפים לחצן פעולה, בשיטת addAction ():

alertController.addAction (UIAlertAction (כותרת: "ביטול", סגנון:. default))

5. הצג את ההתראה

לאחר שנקבע את התצורה של אובייקט ה- UIAlertController שלנו, אנו מוכנים להציג אותו בפני המשתמש. בקטע הבא, אנו מבקשים מ- ViewController להציג את האובייקט alertController עם הנפשה:

self.present (alertController, אנימציה: true, השלמה: אפסי)}

בדיקת אפליקציית ה- iOS שהושלמה

עכשיו הגיע הזמן להעמיד את המבחן במבחן:

• בחר בלחצן "הפעל" בסרגל הכלים של Xcode.
• ברגע שהיישום שלך מופיע בסימולטור iOS, לחץ על לחצן לחיצה עליו - ההתראה שלך אמורה כעת להופיע על המסך!

מסיימים

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

האם יש לך תוכניות להתחיל לפתח אפליקציות לאייפון ולאייפד? או שאתה מעדיף כלי פיתוח חוצה פלטפורמות כמו פלאטר? ספר לנו בתגובות למטה!