מדריך סוויפט: תחילת העבודה עם פיתוח iOS באמצעות סוויפט

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

בבלוג זה במדריך Swift, אעסוק בנושאים הבאים:

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

מדריך סוויפט: מהי סוויפט?

סוויפט היא שפת תכנות המאמצת את מיטב C ו- Objective-C והיא פותחה על ידי Apple Inc. לפיתוח iOS / OS X להפעלה בפלטפורמות קיימות רבות של iOS 6 ו- OS X 10.8.

מדריך מהיר: כיצד להתקין את סוויפט?

כדי להשתמש ב- Swift, אתה זקוק לתוכנת Xcode כדי להריץ את קידוד ה- Swift שלך ב- Playground וברגע שתרגיש בנוח עם Swift, תוכל להשתמש ב- Xcode IDE לפיתוח יישומים של iOS / OS x.

אז בהנחה שיש לך חשבון באתר Apple Developer, אתה פשוט צריך ללכת הורדה למפתחי אפל.

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

לאחר הורדת קובץ ה- dmg, ניתן להתקין אותו על ידי לחיצה כפולה עליו.

בְּסֵדֶר!! אז ברגע שיש לך את ה- xCode שלך, פשוט לחץ עליו פעמיים כדי לפתוח ואז עבור אל קובץ -> חדש ולבחור מגרש משחקים . לאחר מכן בחר ב- iOS וציין את שם מגרש המשחקים. לאחר שתסיים עם זה לחץ על לִיצוֹר.

איור 1: יצירת מגרש משחקים ב- Xcode IDE - מדריך סוויפט

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

אז, בתחילה נתחיל בתחביר בסיסי ואז בואו נכתוב תוכנית שלום עולמית.

מדריך מהיר: תחביר בסיסי

• אסימונים - אסימון הוא מילת מפתח , מזהה, קבוע, מילולי מחרוזת או סמל.
• נקודה-פסיק - ב- Swift אינך צריך להקליד נקודה-פסיק () אחרי כל משפט בקוד. רק במקרה של שימוש במספר משפטים באותה שורה, נקודה-פסיק משמש כמפריד.
• מילות מפתח - מילות מפתח הן מילים שמורות בשפות הקידוד, אשר אינן יכולות לשמש כקבועים או משתנים או כל שמות מזהים אחרים אלא אם כן הם נמלטים עם תיקים אחוריים (`& hellip`).
• ספרות - מילולית היא בעיקר ייצוג קוד המקור של ערך של מספר שלם, נקודה צפה או סוג מחרוזת. אז מילולית יכולה להיות מילולית שלמה, מילולית צפה, מילולית מחרוזת או מילולית בוליאנית.
• הערות - הערות עוזרות למהדרים להתעלם מהטקסטים שלא אמורים להיערך. הערות מרובות שורות מתחילות ב / * ולהפסיק עם * / ואילו הערות בשורה אחת נכתבות באמצעות // בתחילת ההערה.
• מזהים - סוויפט היא שפה תלוית רישיות ואינה מאפשרת תווים מיוחדים כגון @, $ ו-% בתוך מזהים. מזהה מתחיל באלף בית A עד Z או a עד z או קו תחתון _ ואחריו עוד אותיות, קו תחתון וספרות (0 עד 9).
• חללים לבנים - רווח לבן משמש בסוויפט לתיאור ריקים, כרטיסיות, תווים בשורה חדשה, הערות וגם הפרדה של חלק אחד מהצהרה לאחר. זה עוזר למהדר לזהות היכן אלמנט אחד במשפט, מסתיים והאלמנט הבא מתחיל.

שלום עולם התוכנית

/ * שלום עולם התוכנית * / ייבוא ​​UIKit // מכיוון שאנו יוצרים את התוכנית עבור מגרש המשחקים של iOS, עלינו לייבא את UiKit var myString = 'שלום עולם!' הדפס (myString) // נקודה-פסיק המשמשת מאז שתי הצהרות משמשות יחד

תְפוּקָה :

שלום עולם!

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

שיבוט עמוק ושיבוט רדוד בג'אווה

מדריך מהיר: משתנים, סוגי נתונים וסוג יציקה

משתנים

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

var a = 42 // משתנה מצהיר var a: Int = 42 // ניתן גם להכריז על משתנה על ידי ציון סוג הנתונים. let b = 32 // הכרזת הדפסה קבועה (varA)

סוגי מידע

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

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

ב- Swift, אינך צריך להגדיר בהכרח את סוג הנתונים כאשר אתה מצהיר על משתנה.

אז, נניח שאתה מכריז על משתנה var b = 'היי' ואז סוויפט יבין זאת באופן אוטומטי ב הוא חוּט משתנה סוג, בהתבסס על הקלט שמסרת.

סוג ליהוק

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

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

שקול את האקסמספיק למטה:

let a: Int = 5679 // הכריזו על 2 קבועים בואו: Float = 2.9999 // המרת Float להדפסה Int ('המספר הזה הוא Int עכשיו (Int (b))') // המרת Int לדפוס Float ('This מספר הוא צף עכשיו (צף (א)) ')

תְפוּקָה:

המספר הזה הוא Int עכשיו 2 המספר הזה הוא Float עכשיו 5679.0

מדריך מהיר: מפעילים

מפעילים הם המבנים שיכולים לתפעל את ערכי האופנדות. שקול את הביטוי 7 + 3 = 10, כאן 7 ו- 3 הם אופרנדים ו- + נקרא אופרטור.סוויפט תומכת בסוגים הבאים של מפעילים:

איור 2: מפעילים שונים בסוויפט - מדריך סוויפט

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

הדפס ('5 + 3 = (5 + 3)') // תוספת הדפסה ('5 - 3 = (5 - 3)') // הדפסת חיסור ('5 * 3 = (5 * 3)') // הדפסת כפל ('5/3 = (5/3)') // הדפסת חלוקה ('5% 3 = (5% 3)') // מודולוס

תְפוּקָה:

5 + 3 = 8 5 - 3 = 2 5 * 3 = 15 5/3 = 1 5% 3 = 2.3 

בְּסֵדֶר!! עכשיו, מכיוון שאתם מכירים את המפעילים הבסיסיים, בואו נתחיל עם ההצהרות המותנות.

מדריך מהיר: הצהרות מותנות

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

אז בואו נתחיל בהצהרת אם עכשיו.

הצהרה אם

משפט, אם יכול להיות רק אם פשוט, או הצהרה מקוננת אם.

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

איור 3: תרשים זרימה של הצהרה אם מותנה - מדריך מהיר

שקול את הדוגמה הבאה:

var x: Int = 10 אם x<20 { print('x is less than 20') } print('Value of variable x is (x)') 

תְפוּקָה:

הערך של המשתנה x הוא 10

מקונן אם

עַכשָׁיו, מקונן אם הוא הצהרת if או הצהרת if-else בתוך הצהרת if.

איור 4: תרשים זרימה של הצהרה מקוננת אם מותנית - מדריך מהיר

שקול את הדוגמה הבאה:

var x: Int = 100 var y: Int = 200 אם x == 100 {הדפס ('התנאי הראשון מתקיים') אם y == 200 {הדפס ('התנאי השני מתקיים גם הוא')}} הדפס ('ערך של משתנה x הוא (x) ') הדפס (' ערך המשתנה y הוא (y) ')

תְפוּקָה:

התנאי הראשון מתקיים התנאי השני הוא מספק הערך של המשתנה x הוא 100 הערך של המשתנה y הוא 200

הצהרה אם-אחרת

הצהרת אם-אחרת בודקת את התנאי ואם התנאי כוזב אז הצהרת 'אחר' מבוצעת.

איור 5: תרשים זרימה של הצהרה על תנאי אחר - הדרכה מהירה

שקול את הדוגמה הבאה:

var x: Int = 10 אם x<20 { print('x is less than 20') } else { print('x is not less than 20')} print('Value of variable x is (x)') 

תְפוּקָה:

x הוא פחות מ -20

If-else..if-else (אם-אחר סולם)

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

איור 6: תרשים זרימה של הצהרה מותנית בסולם אם - אחרת - הדרכה מהירה

שקול את הדוגמה הבאה:

var x: Int = 100 var y: Int = 200 אם xy {/ * אם התנאי נכון אז הדפס את הבא * / הדפס ('x גדול מ- y')} אחר {/ * אם התנאי אינו נכון הדפס את הדברים הבאים * / print ('x שווה ל- y')} print ('ערך המשתנה x ו- y הם: (x) ו- (y)')

תְפוּקָה:

הערך של המשתנה x ו- y הוא: 100 ו- 200

ס מְכַשֵׁפָה

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

איור 7: תרשים זרימה של הצהרה מותנית על מתג - מדריך מהיר

שקול את הדוגמה הבאה:

var a = 20 switch index {case 10: print ('Value of index is 10') casethrough case 15,20: print ('Value of index is or 15 or 20') Fallthrough case 30: print ('Value of index is 30 ') ברירת מחדל: הדפס (' מקרה ברירת מחדל ')}

תְפוּקָה:

ערך המדד הוא 15 או 20 ערך המדד הוא 30

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

עכשיו, בואו נעבור לולאות איטרטיביות.

מדריך מהיר: לולאות איטרטיביות

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

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

לולאה ב- For-In

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

איור 8: תרשים זרימה של לולאה בכניסה - מדריך מהיר

שקול את הדוגמה הבאה:

עבור i ב 1 ... 3 {הדפס ('שלום עולם! והערך של i הוא (i)')}

תְפוּקָה:

שלום עולם! והערך של i הוא 1 שלום עולם! והערך של i הוא 2 שלום עולם! והערך של i הוא 3

בעוד לולאה

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

איור 9: תרשים זרימה בזמן לולאה - מדריך מהיר

שקול את הדוגמה הבאה:

var current: Int = 0 // אתחל את המשתנים var final: Int = 3 let הושלם = true while (הנוכחי<= final) // condition { //play game if Completed { print('You have passed the level (current)') current = current + 1 //statement to be executed if the condition is satisfied } } print('The while loop ends') //Statement executed after the loop ends 

תְפוּקָה:

עברת את דרגה 0 עברת את דרגה 1 עברת את דרגה 2 עברת את דרגה 3 לולאת ה- while מסתיימת

עשה בזמן / חזור תוך כדי לולאה

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

איור 10: תרשים זרימה של לולאה תוך כדי - מדריך מהיר

שקול את הדוגמה הבאה:

var val = 5 חזור על {print ('Value is (val)') val = val + 1} תוך כדי אינדקס<10 

תְפוּקָה:

הערך הוא 5 הערך הוא 6 הערך הוא 7 הערך הוא 8 הערך הוא 9

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

מדריך מהיר: מערכים וצמדים

מערכים

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

חברים חברים: Array = ['Akash', 'Sanjana', 'Avinash', 'Swatee']

ניתן גם להוסיף אלמנטים חדשים למערך באמצעות שיטת append (). עיין בדוגמה שלהלן:

friends.append ('Aayushi') הדפס (חברים)

תְפוּקָה:

אקש סנג'אנה אבינאש סוויטי אייושי

צינורות

טופלס משמשים לקיבוץ ערכים מרובים בערך מורכב יחיד. שקול את הדוגמה הבאה:

var failure404 = (404, 'השער לא נמצא') הדפס ('הקוד הוא (failure404.0)') הדפס ('הגדרת השגיאה היא (failure404.1)') var failure404 = (failureCode: 404, תיאור: 'שער לא נמצא') הדפס (failure404.faliureCode) // הדפסים 404.

תְפוּקָה

הקוד הוא 404 הגדרת השגיאה היא שער לא נמצא 404

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

מדריך מהיר: סטים ומילונים

סטים

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

תן evenNumber: Set = [2,4,6,8,12]

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

הִתאַחֲדוּת: איחוד של A ו- B הוא קבוצה של כל האלמנטים משני הסטים. האיחוד מתבצע באמצעות .הִתאַחֲדוּת() שיטה.

אני חתך: צומת A ו- B הוא קבוצה של אלמנטים הנפוצים בשתי המערכות. צומת מתבצע באמצעות ה- .הִצטַלְבוּת() שיטה.

מְחַסֵר: ההבדל בין A ו- B (A - B) הוא קבוצה של אלמנטים שנמצאים רק ב- A אך לא ב- B. באופן דומה, B - A הוא מערכת של אלמנטים, כלומר ב- B אך לא ב- A.עיין בקוד להלן:

let evenNumber: Set = [10,12,14,16,18,20] let oddNumber: Set = [5,7,9,11,13,15] let primeNumber: Set = [2,3,5,7, 13,17,19] oddNumber.union (evenNumber) .sorted () oddNumber.intersection (evenNumber) .sorted () oddNumber.subtracting (primeNumber) .sorted ()

תְפוּקָה:

[5,7,9,10,11,12,13,14,15,16,18,20] [] [9, 11, 15]

מילונים

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

שיטת tostring () java

var exampleDict: [Int: String] = [1: 'One', 2: 'Two', 3: 'Three'] // יצירת מילונים var accessval = exampleDict [1] // גישה לדפוס ערכי מילון ('ערך המפתח = 1 הוא (accessVal ') הדפס (' ערך של מפתח = 2 הוא (exampleDict [2]) ') הדפס (' ערך של מפתח = 3 הוא (exampleDict [3]) ')

תְפוּקָה:

ערך המפתח = 1 הוא אופציונלי ('אחד') ערך המפתח = 2 הוא אופציונלי ('שניים') ערך המפתח = 3 הוא אופציונלי ('שלוש')

מדריך מהיר: פונקציות

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

func עובד (empname: String) -> String {// הגדרת פונקציה return empname} הדפסה (עובד (empname: 'Sayantini')) // קורא הדפסת פונקציה (עובד (empname: 'Kislay'))

תְפוּקָה:

סאינטיני קיסליי

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

מדריך מהיר: סגרים ומבנים

סגירות

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

let name = {print ('Welcome to Swift Closures')} name ()

תְפוּקָה:

ברוכים הבאים לסגירות

מבנים

struct employeeDetails {// הגדרת שם של מבנה var = 'Bob' var id = 11021 varphonenumber = 9876543210} let details = employeeDetails () // גישה למבנה והמאפיינים מודפסים ('שם העובד הוא (details.name)') ('זיהוי העובד הוא (details.id)') הדפס ('מספר הטלפון של העובד הוא (details.phonenumber)')

תְפוּקָה:

שם העובד הוא בוב מזהה העובד הוא 11021 מספר הטלפון של העובד הוא 9876543210

עכשיו, מכיוון שאתם הבנתם את המבנים, בואו נבין שיעורים וירושה.

מדריך מהיר: שיעורים וירושה

שיעורים

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

מחלקת DetailsStruct {// הגדרת מזהה var בכיתה: Int init (id: Int) {self.id = id}} מחלקה studentDetails {var id = 125612} let studentid = studentDetails () print ('מזהה התלמיד is (studentid.id) ) ')

תְפוּקָה:

תעודת סטודנט היא 125612

יְרוּשָׁה

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

ניתן לסווג עוד שיעורים ל תת מחלקה ו מעמד-על .

מחלקה משנה: אם מחלקה יורשת מאפיינים, שיטות ופונקציות ממחלקה אחרת, אז היא נקראת כתת-מחלקה.

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

class EmployeeDetails {var id: Int var number: Int init (detail1: Int, detail2: Int) {id = detail1 number = detail2} func print () {print ('מזהה עובד הוא: (id), מספר הטלפון של העובד הוא: (number) ')}} תצוגת מחלקה: EmployeeDetails {init () {super.init (detail1: 94567, detail2: 9876543210) // מילת מפתח סופר משמשת לכינוי הפרמטרים והשיטות ממחלקה super}} תן לעובד מידע = להציג ( ) מידע עובדים.דפוס ()

תְפוּקָה:

מזהה עובד הוא94567, מספר הטלפון של העובד הוא9876543210

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

מדריך מהיר: פרוטוקולים

פרוטוקול טוס {var flies: Bool {get set} func flyable (milesCovered: Double) -> String} class רכב: Fly {var flies: Bool = false var name: String = 'שם ברירת מחדל' func flyable (milesCovered: Double) - > מחרוזת {if (self.flies) {return '(self.name) זבובים (milesCovered) מיילים'} אחר {return '(self.name) לא יכול לטוס'}}} var BMWX1 = רכב () BMWX1.name = ' BMW X1 'BMWX1.flies = הדפסה שגויה (BMWX1.flyable (34))

BMW X1 לא יכול לעוף

מדריך מהיר: הרחבות

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

שקול את הדוגמה הבאה:

סיומת Int {var הוסף: Int {מחזיר את עצמו + 10} varsubtract: Int {מחזיר את עצמי- 34} var מכפיל: Int {מחזיר את עצמי * 5} var מחלק: Int {מחזיר את עצמי / 5}} תן תוספת = 3. הוסף את ההדפסה ('הערך לאחר ההוספה הוא (הוסף) ') בוא לחיסור = 120. הפחת הדפסה (' הערך לאחר החיסור הוא (חיסור) ') בוא הכפל = 25. הדפסה כפולה (' הערך שמכפל הוא (כפל) ') בואו לחלק = 55 .חלק את ההדפסה ('הערך אחרי החלוקה הוא (חלוקה)') בוא לערבב = 10. הוסף + 34. הדפסה מופחתת ('הערך המחושב הוא (mix)')

תְפוּקָה:

הערך לאחר ההוספה הוא 13 הערך לאחר חיסור הוא 86 הערך המכפיל הוא 125 הערך לאחר החלוקה הוא 11 הערך המחושב הוא 20

מדריך מהיר: גנריות

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

החלפת פונקציות (x: inout T, y: inout T) {let temp = xx = yy = temp} var str1 = 'שלום' var str2 = 'Edureka' הדפסה ('לפני החלפת ערכי מחרוזות הם: (str1) ו- (str2 ) ') החלפה (x: & str1, y: & str2) הדפסה (' לאחר החלפת ערכי מחרוזת הם: (str1) ו- (str2) ') var num1 = 1996 var num2 = 1865 print (' לפני החלפת ערכי Int הם: (num1 ) ו- (num2) ') החלפה (x: & num1, y: & num2) הדפסה (' לאחר החלפת ערכי Int הם: (num1) ו- (num2) ')

תְפוּקָה:

לפני החלפת ערכי מחרוזת הם: שלום ואדורקה לאחר החלפת ערכי מחרוזת הם: אדוריקה ו שלום לפני החלפת ערכי מחרוזת הם: 1996 ו- 1865 לאחר החלפת ערכי מחרוזת הם: 1865 ו- 1996

מדריך מהיר: ספירות

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

enum צבע: Int {case blue case ירוק case אדום מקרה צהוב init () {self = .red} func getDetails () -> מחרוזת {switch (עצמי) {case .blue: return 'Color is blue' case .green: return מקרה 'צבע הוא ירוק'. אדום: חזרה 'צבע הוא אדום' מקרה. צהוב: החזרה 'צבע צהוב' ברירת מחדל: החזרה 'צבע לא נמצא'}}} var selectColor = הדפסת צבע (בחרColor.rawValue) var favColor = צבע הדפסה ירוקה (favColor.rawValue) אם (favColor == Color.green) {הדפס ('הצבע המועדף הוא ירוק')} הדפסה (favColor.getDetails ())

תְפוּקָה:

2 אחד הצבע האהוב הוא ירוק ירוק

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

כדי לקבל ידע מעמיק על סוויפט יחד עם היישומים השונים שלה, אתה יכול לאימונים מקוונים חיים עם תמיכה 24/7 וגישה לכל החיים.

יש לך שאלה עבורנו? ציין אותם בסעיף ההערות של ' הדרכה מהירה ונחזור אליך.