Swift oktatóanyag: Az iOS fejlesztésének kezdete a Swift használatával

Ebben a Swift Tutorial blogban bemutatom Önöknek a Swift néhány alapfogalmát. De mielőtt továbblépnék, megismertetném veletek a „Mi az a Swift” című cikket, és hogyan lehet a Swiftet telepíteni a rendszerre. Tehát, kezdjük most !!

Ebben a Swift Tutorial blogban a következő témákkal foglalkoznék:

• Mi a Swift?
• Hogyan kell telepíteni a Swift-et?
• Alapszintaktika
• Változók, adattípusok és TypeCasting
• Operátorok
• Feltételes nyilatkozatok
• Iteratív hurkok
• Tömbök és tömbök
• Készletek és szótárak
• Funkciók
• Zárások és szerkezetek
• Osztály és öröklés
• Jegyzőkönyvek
• Hosszabbítások
• Generikusok
• Felsorolás

Swift oktatóanyag: Mi a Swift?

A Swift egy olyan programozási nyelv, amely a C és az Objective-C legjobbjait használja, és amelyet az Apple Inc. fejlesztett ki iOS / OS X fejlesztésre, hogy számos létező iOS 6 és OS X 10.8 platformon fusson.

Gyors bemutató: Hogyan kell telepíteni a Swift-et?

A Swift használatához Xcode szoftverre van szükség a Swift kódolás futtatásához a Játszótéren, és miután jól érzi magát a Swift, használhatja az Xcode IDE-t az iOS / OS x alkalmazások fejlesztéséhez.

Tehát, ha feltételezzük, hogy van fiókja az Apple Developer webhelyén, akkor csak el kell mennie Letöltés az Apple fejlesztőknek.

Ha egyszer a linkre lép, válassza ki az Xcode legfrissebb elérhető verzióját, és töltse le a lemezkép közelében található adott linkre kattintva.

A dmg fájl letöltése után telepítheti egyszerűen duplán kattintva.

Rendben!! Tehát, ha megvan az xCode, kattintson duplán rá a megnyitáshoz, majd lépjen a Fájl -> Új és válaszd Játszótér . Ezután válassza az iOS-t, és említse meg a játszótér nevét. Ha végzett ezzel, kattintson a gombra Teremt.

1. ábra: Játszótér létrehozása Xcode IDE-ben - gyors bemutató

Tehát, most, hogy a játszótér készen áll, kezdjük el a kódolást!

Tehát kezdetben kezdjük az alapvető szintaxissal, majd írjunk egy hello world programot.

Gyors bemutató: Alapszintaktika

• Tokenek - A token vagy kulcsszó , azonosító, konstans, karakterlánc vagy szimbólum.
• Pontosvesszők - A Swift-ben nem kell pontosvesszőt () begépelnie a kód minden egyes mondata után. Csak abban az esetben, ha több utasítást használ ugyanazon sorban, pontosvesszőt használunk elválasztóként.
• Kulcsszavak - A kulcsszavak a kódoló nyelvekben fenntartott szavak, amelyeket nem lehet konstansként vagy változóként vagy bármilyen más azonosító névként használni, hacsak nem kerülik el őket backtickekkel (`& hellip`).
• Literals - A literál főleg egy egész szám, lebegőpontos szám vagy karakterlánc típusának forráskód ábrázolása. Tehát a literál lehet egész szám, lebegő literál, húr literál vagy logikai literál.
• Hozzászólások - A megjegyzések segítik a fordítókat abban, hogy figyelmen kívül hagyják a nem összeállítandó szövegeket. A többsoros megjegyzések kezdődnek / * és azzal fejezd be * / mivel az egysoros megjegyzéseket a // a megjegyzés elején.
• Azonosítók - A Swift a kis- és nagybetűk különbözõ nyelv, és nem engedélyez különleges karaktereket, például @, $ és% az azonosítókban. Az azonosító A-tól Z-ig vagy a-tól Z-ig vagy egy aláhúzással _ kezdődik, amelyet további betűk, aláhúzások és számjegyek követnek (0 és 9 között).
• Fehér terek - A szóköz a Swiftben üres, lapok, újsoros karakterek, megjegyzések leírására szolgál, valamint a kijelentés egyik részét elválasztja a másiktól. Ez segít a fordítónak abban, hogy azonosítsa egy utasítás egyik elemét, hol fejeződik be, és hol kezdődik a következő elem.

Hello World program

/ * Hello World Program * / import UIKit // Mivel az iOS játszótérhez készítjük a programot, be kell importálnunk az UiKit var myString = 'Hello World!' Print (myString) // pontosvesszőt, mivel 2 állítást együtt használnak

Kimenet :

Helló Világ!

Most, hogy megírta az első programját, értsen meg többet a változókról és az adattípusokról.

Gyors bemutató: Változók, adattípusok és TypeCasting

Változók

A változók nem más, mint fenntartott memóriahelyek az értékek tárolásához. Ez azt jelenti, hogy amikor egy változót létrehoz, akkor helyet foglal a memóriában.

var a = 42 // var a változó deklarálása: Int = 42 // A változó deklarálható az adattípus megadásával is. legyen b = 32 // Állandó nyomtatás deklarálása (varA)

Adattípusok

Mint minden más programozási nyelv, a Swift is biztosítja a beépített adattípusokat, amelyekre a következő táblázat hivatkozhat:

Most hadd mondjak el egy érdekes tényt itt.

A Swiftben nem kell feltétlenül meghatároznia az adattípust, amikor egy változót deklarál.

Tehát tegyük fel, hogy deklarál egy változót var b = 'Szia' , akkor Swift ezt automatikusan meg fogja érteni b egy Húr típusú változó, az Ön által megadott bemenet alapján.

Típus Casting

Most akár típusátalakítást vagy tipizálást is végezhet.

Például átalakíthatja az egész értéket lebegő értékre és fordítva.

Tekintsük az ex-etbőven alább:

legyen a: Int = 5679 // Nyújtson be 2 konstansot b: Float = 2.9999 // Float konvertálása Int nyomtatássá („Ez a szám most Int (Int (b))”) // // Int Converting Float nyomtatássá („Ez a szám most úszó (úszó (a)) ”)

Kimenet:

Ez a szám Int most 2 Ez a szám Float most 5679.0

Gyors bemutató: Operátorok

Az operátorok azok a konstrukciók, amelyek manipulálni tudják az operandusok értékeit. Tekintsük a 7 + 3 = 10 kifejezést, itt a 7 és a 3 operandus, a + -t pedig operátornak hívjuk.A Swift a következő típusú operátorokat támogatja:

c c # c ++

2. ábra: Különböző üzemeltetők gyors - gyors bemutató

Most nem fogok elmélyülni a srácokban, de hadd mutassak meg néhány egyszerű műveletet a Swift-ben. Tekintsük az alábbi példát:

print ('5 + 3 = (5 + 3)') // Kiegészítő nyomtatás ('5 - 3 = (5 - 3)') // Kivonás nyomtatása ('5 * 3 = (5 * 3)') // Szorzási nyomtatás ('5/3 = (5/3)') // Osztott nyomtatás ('5% 3 = (5% 3)') // Modulus

Kimenet:

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

Rendben!! Most, hogy ismeritek az alapvető operátorokat, kezdjük a feltételes állításokkal.

Gyors bemutató: Feltételes nyilatkozatok

A feltételes utasításokat egy utasítás vagy egy állításcsoport végrehajtására használják, ha valamilyen feltétel teljesül.Három feltételes állítás létezik - Ha, Ha más és Kapcsoló nyilatkozatok.

Tehát kezdjük most az If állítással.

Ha állítás

Az if utasítás lehet akár egyszerű if, akár beágyazott if utasítás.

Szóval, egy egyszerű Ha utasítás az a legegyszerűbb döntéshozó utasítás, amely eldönti, hogy egy bizonyos utasítás vagy utasításblokk végrehajtásra kerül-e vagy sem.

3. ábra: Folyamatábra a feltételes nyilatkozatról - gyors bemutató

Tekintsük az alábbi példát:

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

Kimenet:

x kisebb, mint 20 Az x változó értéke 10

Beágyazott-Ha

Most, fészkel, ha egy if utasítás vagy egy if-else utasítás az if utasításon belül.

4. ábra: A beágyazott, ha feltételes nyilatkozat folyamatábra - gyors bemutató

Tekintsük az alábbi példát:

var x: Int = 100 var y: Int = 200, ha x == 100 {print ('Az első feltétel teljesül'), ha y == 200 {print ('A második feltétel is teljesül')}} print (' x változó (x) ') print (' y változó értéke (y) ')

Kimenet:

Az első feltétel teljesül A második feltétel teljesül Az x változó értéke 100 Az y változó értéke 200

If-Egyéb nyilatkozat

Az If-else utasítás teszteli a feltételt, és ha a feltétel hamis, akkor az „else” utasítás végrehajtásra kerül.

5. ábra: Az if folyamatábrája - egyéb feltételes nyilatkozat - gyors bemutató

Tekintsük az alábbi példát:

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

Kimenet:

x kisebb, mint 20

If-else..if-else (If-else létra)

Most már egy ha más létra.Tehát az If-else-if létra lehetővé teszi a felhasználó számára, hogy sok if else utasítást használjon egy cikluson belül, és ha az egyik feltétel teljesül, akkor a többi ciklust megkerülik.

6. ábra: Az if folyamatábrája - más létra feltételes nyilatkozata - gyors bemutató

Tekintsük az alábbi példát:

var x: Int = 100 var y: Int = 200, ha xy {/ * Ha a feltétel igaz, akkor nyomtassa ki a következő * / print ('x nagyobb, mint y')} else {/ * Ha a feltétel hamis, akkor a következőt nyomtassa ki: * / print ('x egyenlő y-vel')} print ('Az x és y változó értéke: (x) és (y)')

Kimenet:

x kisebb, mint y Az x és y változó értéke: 100 és 200

S boszorkány

A switch utasítás egyszerű módot kínál a feltételek végrehajtására a kód különböző részeihez.

7. ábra: A kapcsoló feltételes állításának folyamatábrája - gyors bemutató

Tekintsük az alábbi példát:

var a = 20 index váltása {eset 10: print ('Az index értéke 10') áteséses eset 15,20: print ('Az index értéke 15 vagy 20') áteséses eset 30: print ('Az index értéke 30 ') alapértelmezett: print (' alapértelmezett eset ')}

Kimenet:

Az index értéke 15 vagy 20 Az index értéke 30

Most, ha megfigyeli a kimenetet, akkor is, ha feltételünk teljesül, a következő állítást is kinyomtatjuk. Ez azért van, mert az állítást használjuk kudarcba fullad . Tehát, ha nem használja a kudarcba fullad utasítás, akkor a program kijön a kapcsoló utasítás az egyező eset kimutatás végrehajtása után.

Most térjünk át az iteratív ciklusokra.

Gyors bemutató: Iteratív hurkok

Az utasításokat általában egymás után hajtják végre. A függvény első utasítását hajtják végre először, majd a másodikat és így tovább.Előfordulhat olyan helyzet, amikor többször kell végrehajtania egy kódblokkot.

A ciklusos utasítás lehetővé teszi számunkra, hogy egy állítást vagy utasításcsoportot többször is végrehajtsunk. Tehát az iteratív ciklusok főleg Be , Míg és Csinálni, miközben hurok.

For-In hurok

A bejövő hurok ismétli az elemek gyűjteményét, például a számtartományokat, a tömbben lévő elemeket vagy a karakterláncokat.

8. ábra: A be-hurok folyamatábrája - gyors bemutató

Tekintsük az alábbi példát:

mert i in 1 ... 3 {print ('Hello világ! és i értéke (i)')}}

Kimenet:

Helló Világ! és i értéke 1 Helló Világ! és az i értéke 2 Hello world! és i értéke 3

Míg a hurok

Egy darab ciklus utasítás a Swift programozási nyelven ismételten végrehajt egy cél utasítást, amíg egy adott feltétel igaz.

9. ábra: Folyamatábra a hurok közben - gyors bemutató

Tekintsük az alábbi példát:

var current: Int = 0 // Változók inicializálása var final: Int = 3 let Completed = true while (current<= 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 

Kimenet:

Túllépte a 0. szintet Átmented az 1. szintet Átmented a 2. szintet Átmented a 3. szintet A while hurok véget ér

Do-while / Ismételje meg a hurok közben

A ciklusoktól és a ciklusoktól eltérően, amelyek a hurok tetején tesztelik a hurok állapotát, az ismétlés… míg a hurok állapotát a hurok alján ellenőrzi.

10. ábra: A folyamat közbeni hurok folyamatábra - gyors bemutató

Tekintsük az alábbi példát:

var val = 5 ismételje meg az {print ('Value is (val)') val = val + 1} indexet<10 

Kimenet:

Az érték 5 Az érték 6 Az érték 7 Az érték 8 Az érték 9

Rendben, Srácok! Ezzel vége a huroknak, most ugorjunk gyorsan az Arrays & Tuples-be.

Gyors bemutató: Tömbök és tömbök

Tömbök

A tömb egy adatstruktúra, amely elemek listáját tartalmazza. Ezek az elemek mindegyike azonos típusú, például egész szám vagy karakterlánc.Tehát tegyük fel, ha tárolni szeretné a barátai nevét. Programot a következőképpen írhat:

különböző barátok: Array = ['Akash', 'Sanjana', 'Avinash', 'Swatee']

Új elemeket is hozzáadhat a tömbhöz az append () metódus használatával. Lásd az alábbi példát:

friends.append ('Aayushi') print (barátok)

Kimenet:

Akash Sanjana Avinash Swatee Aayushi

Tollok

A sorrendeket arra használják, hogy több értéket egyetlen vegyület értékébe csoportosítsanak. Tekintsük az alábbi példát:

var hiba404 = (404, „Átjáró nem található”) print („A kód (hiba404.0)”)) nyomtatás („A hiba meghatározása (hiba404.1)”) var hiba404 = (hibaKód: 404, leírás: “Gateway not found”) print (fail404.faliureCode) // 404-et nyomtat.

Kimenet

A kód 404 A hiba meghatározása a Gateway nem található 404

Rendben, most, hogy megértettétek a tömböket, itt az ideje elkezdeni a készleteket és a szótárakat.

Gyors bemutató: Készletek és szótárak

Készletek

A készleteket ugyanazon típusú különálló értékek tárolására használják, anélkül, hogy a tömbökhöz hasonló sorrendet kellene beállítani. Tehát használhat halmazokat tömbök helyett, ha meg akarja győződni arról, hogy nincsenek ismétlődő értékek, vagy ha az elemek sorrendje nem kérdés .
A készlet úgy jön létre, hogy az összes elemet (elemet) vesszővel elválasztva göndör zárójelbe helyezi []. Tekintsük az alábbi példát:

Legyen páros: Set = [2,4,6,8,12]

Most hadd mondjam el, hogy a beállított műveleteket is elvégezheti, mint például Union, Metszéspont, Kivonás.

Unió: Az A és B egyesítése mindkét halmaz összes elemének halmaza. Az uniót a .unió() módszer.

én keresztmetszet: A és B metszéspontja olyan elemek halmaza, amelyek mindkét halmazban közösek. A metszéspontot a .útkereszteződés() módszer.

Kivonás: Az A és B különbsége (A - B) olyan elemek összessége, amelyek csak A-ban vannak, de B-ben nincsenek. Hasonlóképpen, B - A elemek halmaza, azaz B-ben, de nem A-ban.Lásd az alábbi kódot:

legyen páros: Set = [10,12,14,16,18,20] let páratlan szám: Set = [5,7,9,11,13,15] let primeNumber: Set = [2,3,5,7, 13,17,19] páratlan szám.union (páros szám). Rendezve () páratlan szám.interszekció (páros szám). Rendezett () páratlan szám.vonás (elsődleges szám). Rendezve ()

Kimenet:

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

Szótárak

A szótárak az azonos típusú értékek rendezetlen listáinak tárolására szolgálnak, és a Swift nem teszi lehetővé, hogy rossz szót írjon be egy szótárba.Tekintsük az alábbi példát.

var exampleDict: [Int: String] = [1: 'One', 2: 'Two', 3: 'Three'] // Szótárak létrehozása var accessval = exampleDict [1] // A szótárértékek elérése print ('Key értéke = 1 is (accessVal ') print (' A kulcs = 2 értéke (exampleDict [2]) ') print (' A kulcs = 3 értéke (exampleDict [3]) ')

Kimenet:

A kulcs = 1 értéke Opcionális ('Egy') A kulcs = 2 értéke opcionális ('kettő') A kulcs = 3 értéke opcionális ('három')

Gyors bemutató: Funkciók

A függvény alapvetően egy adott feladat elvégzésére szervezett utasítások halmaza. Meghívhat egy függvényt, rendelkezhet funkcióval paraméterekkel vagy azok nélkül, rendelkezhet funkcióval visszatérési értékekkel / nélkül, rendelkezhet függvénytípusokkal és beágyazott funkciókat is használhat.A funkciók definiálásának és hívásának megértéséhez lásd az alábbi példát. Tekintsük az alábbi példát:

func Employee (empname: String) -> String {// Funkció definiálása return empname} print (Employee (empname: 'Sayantini')) // Funkció nyomtatása (Employee (empname: 'Kislay'))

Kimenet:

Sayantini Kislay

Most térjünk át a blog következő szakaszára, azaz Zárások és struktúrák.

Gyors bemutató: Zárások és szerkezetek

Zárások

A bezárások általában mindenkit összezavarnak, de ezek csak önálló kódok, mint például a blokkokként rendezett funkciók. Lehetnek névtelenek, míg a függvénynek függvénynévvel kell rendelkeznie. Tekintsük az alábbi példát.

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

Kimenet:

Üdvözöljük a Bezárások oldalon

Szerkezetek

struct workerDetails {// Struktúra meghatározása var name = 'Bob' var id = 11021 varphonenumber = 9876543210} let details = workerDetails () // A szerkezet és tulajdonságok elérése print ('Az alkalmazott neve (részletek.név)') print ('Az alkalmazott azonosítója (részletek.id)') nyomtatás ('Az alkalmazott telefonszáma: (részletek.telefonszám)')

Kimenet:

Az alkalmazott neve Bob Az alkalmazott azonosítója 11021 Az alkalmazott telefonszáma 9876543210

Most, hogy srácok megértették a struktúrákat, értsük meg az Osztályok és Öröklés című cikket.

Gyors bemutató: Osztályok és öröklés

Osztályok

A Swift osztályai alapvetően a rugalmas konstrukciók építőelemei. Tehát az állandókhoz, változókhoz és függvényekhez hasonlóan a felhasználó meghatározhatja az osztály tulajdonságait és metódusait.

class DetailsStruct {// osztályváltozat meghatározása: Int init (id: Int) {self.id = id}} class studentDetails {var id = 125612} hagyja, hogy studentid = studentDetails () nyomtasson ('Student id is (studentid.id ) ')

Kimenet:

A diák azonosítója: 125612

Öröklés

c ++ -ba egyesül

Az öröklés az új osztályok létrehozásának folyamata, a meglévő osztályokból. A levezetett osztály örököl az alaposztály összes képességét, és hozzáadhatja saját funkcióit is.

Az osztályok további kategóriákba sorolhatók alosztály és szuperosztály .

Alosztály: Ha egy osztály tulajdonságokat, módszereket és függvényeket örököl egy másik osztálytól, akkor alosztályként hívják meg.

Szuperosztály : Olyan osztályt, amely tulajdonságokat, módszereket és funkciókat tartalmaz ahhoz, hogy a többi osztály önmagától örökölhessen, szuperosztálynak nevezzük. Tekintsük az alábbi példát.

class EmployeeDetails {var id: Int var var number: Int init (detail1: Int, detail2: Int) {id = detail1 number = detail2} func print () {print ('Alkalmazói azonosító: (id), az alkalmazott telefonszáma: (szám) ')}} osztálymegjelenítés: EmployeeDetails {init () {super.init (detail1: 94567, detail2: 9876543210) // a super kulcsszót a paraméterek és metódusok szuper osztályból történő meghívására használják}} let workerinformation = display ( ) munkavállalói információk.print ()

Kimenet:

Munkavállalói azonosító:94567, alkalmazott telefonszáma9876543210

Most, hogy önöknek van ötlete a Swift fő fogalmairól. Most kezdjük el megtanulni a kibővített témákat, mint például a protokollok, a kiterjesztések, az általános és a felsorolás.

Gyors bemutató: Jegyzőkönyvek

protokoll Fly {var legyek: Bool {get set} func flyable (milesCovered: Double) -> String} osztály Jármű: Fly {var legyek: Bool = false var név: String = 'Alapértelmezett név' func flyable (mérföldTakarva: Double) - > Karaktersorozat {if (self.flies) {return '(self.name) repül (milesCovered) mérföld'} else {return '(self.name) nem tud repülni'}}} var BMWX1 = Jármű () BMWX1.name = ' BMW X1 'BMWX1.flies = hamis nyomtatás (BMWX1.flyable (34))

A BMW X1 nem tud repülni

Gyors bemutató: Hosszabbítások

A kiterjesztéseket alapvetően egy meglévő osztály, szerkezet vagy felsorolási típus funkcióinak hozzáadására használják. A kiterjesztésekkel hozzáadhatja a kiszámított tulajdonságokat és a számított típus tulajdonságait, meghatározhat és használhat új beágyazott típusokat, meghatározhatja a példány- és típusmódszereket, új inicializálókat adhat meg, meghatározhatja az előfizetéseket, és egy meglévő típust is megfelelővé tehet a protokollal.

Tekintsük az alábbi példát:

kiterjesztés Int {var add: Int {returnself + 10} varsubtract: Int {returnself- 34} var szoroz: Int {returnself * 5} var divide: Int {returnself / 5}} let add = 3.add print ('Az érték összeadás után legyen (add) ') hagyjuk kivonás = 120. kivonat nyomtatása (' Kivonás utáni érték (kivonás) ') legyen szorzás = 25. szorozzuk meg a nyomtatást (' Az érték megegyezik (szorzás) ') hadd legyen osztás = 55 .divide print ('Az osztás utáni érték (osztás)') legyen mix = 10.add + 34. nyomtatás kivonása ('A kiszámított érték (mix)')

Kimenet:

Az összeadás utáni érték 13 Kivonás után az érték 86 A szorzó értéke 125 Az osztás utáni érték 11: A kiszámított érték 20

Gyors bemutató: Generikusok

Az általános típusokat rugalmas és újrafelhasználható függvények és típusok megírásához használják. Tehát alapvetően használhatja a generikus gyógyszereket az ismétlés elkerülése érdekében. Tekintsük az alábbi példát:

func swap (x: inout T, y: inout T) {let temp = xx = yy = temp} var str1 = 'Hello' var str2 = 'Edureka' print ('Csere előtt String értékek: (str1) és (str2 ) ') swap (x: & str1, y: & str2) print (' Csere után a karakterlánc értékei: (str1) és (str2) ') var num1 = 1996 var num2 = 1865 print (' Az Int cseréje előtt a következők: (num1 ) és (num2) ') csere (x: & num1, y: & num2) nyomtatás (' Az Int cseréje után: (num1) és (num2) ')

Kimenet:

A karakterlánc cseréje előtt a következők: Hello és Edureka A karakterlánc cseréje után az értékek a következők: Edureka és Hello A karakterláncok cseréje előtt: 1996 és 1865 A karakterlánc cseréje után: 1865 és 1996

Gyors bemutató: Felsorolás

Az egyszerű felsorolás egy felhasználó által definiált adattípus, amely kapcsolódó értékek halmazából áll. A kulcsszó enum a felsorolt ​​adattípus meghatározására szolgál. Tekintsük az alábbi példát:

enum Szín: Int {tok kék tok zöld ügy piros eset sárga init () {self = .red} func getDetails () -> String {kapcsoló (self) {ügy .kék: return 'Szín kék' eset .zöld: visszatér 'A szín zöld' eset .red: return 'A szín piros' eset. Sárga: return 'A szín sárga' alapértelmezett: return 'Szín nem található'}}} var selectColor = Színes nyomtatás (selectColor.rawValue) var favColor = Szín .green print (favColor.rawValue) if (favColor == Color.green) {print ('A kedvenc színe zöld')} print (favColor.getDetails ())

Kimenet:

2 egy Kedvenc színe a zöld zöld

Remélem, hogy élvezettel olvasta ezt a Swift oktatóanyagot. Áttekintettük a Swift minden alapját, így már most elkezdheti a gyakorlást.

Ha mélyreható ismereteket szeretne szerezni a Swift-ről és annak különböző alkalmazásokról, megteheti élő online képzéshez 24/7 támogatással és egész életen át elérhető hozzáféréssel.

Van egy kérdésünk? Említse meg őket a “ Gyors bemutató ”És visszajövünk.