O selecție de cursuri, site-uri web și buletine informative care vă vor ajuta să stăpâniți Swift într-o lună.

Am început să învăț Swift acum exact 30 de zile. Acum trei zile, aplicația mea a fost aprobată de Apple pentru testare beta. Este clar că beta este încă departe de a fi ideală, dar pentru mine a fost o mare realizare.

Nu am o diplomă în informatică sau experiență ca dezvoltator, dar în ultimii 5 ani am fost manager de produs într-o echipă de dezvoltare software care scrie aplicații Ruby on Rails pentru distracție. Am vrut să fiu mai aproape de lucrurile cu care lucrez, așa că am început să codific.

De ce am ales iOS și Swift?

Popularitatea în continuă creștere a aplicațiilor mobile

Am vrut să lucrez la ceea ce au nevoie oamenii și mi-a plăcut întotdeauna intimitatea pe care utilizatorii o au cu smartphone-urile. Dispozitivele noastre știu totul despre noi: când ne trezim și când ne culcăm, unde suntem și cum am ajuns acolo, programul nostru, atitudinea noastră față de prieteni și familie și multe altele despre care nici măcar utilizatorul însuși nu știe. Imi place. De asemenea, sunt un fan Apple de mult timp, așa că a fost firesc să încep cu iOS. Am petrecut ceva timp învățând despre Objective-C, nu mi-a plăcut și am decis să învăț Swift.

Limitările sunt benefice

Dezvoltarea aplicațiilor în cadrul stabilit de Apple este destul de accesibilă unui începător și nu limitează foarte mult posibilitățile. Dar nu am fost tentat să fiu distras de nimic altceva și m-a forțat să mă gândesc mai mult la UX.

Swift este o limbă în creștere rapidă.

Îmi place să fiu la origini, să cresc și să mă dezvolt împreună, din acest motiv prefer să lucrez în startup-uri. Așa că aici, Swift nu este încă atât de popular și îmi place să fiu cu o comunitate de oameni care au aceleași idei.

Resurse pentru începători

Când am început să studiez, mi-a venit o idee pentru o aplicație simplă. Acest lucru m-a ajutat să rămân motivat și să învăț elementele de bază pas cu pas.

Am petrecut mult timp căutând resurse bune, instrucțiuni și cursuri online. Am găsit o mulțime de lucruri interesante pentru începători, pentru cei care nu au văzut o linie de cod și am decis că va fi prea lent. În același timp, articolele tehnice și materialele de referință (inclusiv de la Apple) s-au dovedit a fi destinate dezvoltatorilor mai experimentați.

La final am găsit o cale de mijloc, mai jos sunt materialele care mi s-au părut cele mai utile:

1. Curs Stanford de Paul Hegarty „Dezvoltarea aplicațiilor Swift pentru iOS 8”.

Disponibil gratuit pe iTunes U (inclusiv Windows). Mi-a luat aproximativ o săptămână să urmăresc primele cinci prelegeri și să-mi fac temele. În timpul procesului de învățare, am întâmpinat dificultăți și a trebuit să trec la alte resurse. Cu toate acestea, plănuiesc să-mi continui studiile în curând. Și acest site vă va ajuta să vă dați seama ce nu înțelegeți.

2. Curs de la Școala Superioară de Economie „Dezvoltarea aplicațiilor iOS în Swift”.

Cursul se bazează pe cartea „Swift: Limbajul de programare”. Pentru instruire, veți avea nevoie de experiență în dezvoltare în orice limbaj de programare (cel puțin la nivelul de bază). În general, cursul oferă o bună pregătire pentru a începe să lucrați la aplicațiile dvs.

3.RayWenderlich.com

Nu, acesta nu este site-ul personal al cuiva. Acesta este cel mai bun pe care l-am găsit vreodată. Daca abia esti la inceput, te sfatuiesc sa te abonezi la newsletter si sa folosesti tutorialul postat pe site. Datorită lui, am aflat pentru prima dată despre lucruri ciudate și am aflat cum să le fac. După ce ați citit, începeți să căutați idei. Dacă nu funcționează, caută-l pe google.

Planul meu de timp

Săptămâna 1. M-am cufundat în prelegerile și temele cursului Stanford, în timp ce citeam simultan cartea pe care s-a bazat cursul HSE și studiam resursele RayWenderlich.com. La sfârșitul primei săptămâni, am decis că sunt gata să încep să lucrez la aplicație.

Săptămânile 2 și 3. În acest timp am plecat într-o scurtă călătorie, în timpul călătoriei nu am avut acces la internet și am descărcat mai mult de 40 de file în avans. Acest lucru mi-a oferit oportunitatea de a lucra la aplicație fără distrageri. În fiecare zi mă gândeam cum să o fac mai bună.

Săptămâna 4: Am continuat să curăț codul inutil, să desenez o siglă în Sketch și am pregătit aplicația pentru a fi trimisă la Apple pentru revizuire. Am primit un raspuns in mai putin de 24 de ore.

Am petrecut 15 ore lucrând în Xcode, 3 ore în emulatorul iOS, mai mult de 4 ore citind tutoriale și aproximativ o oră căutând răspunsuri pe Stack Overflow. Am petrecut mult timp studiind materiale folosind smartphone-ul meu (nu am numărat acest timp).

miden16 10 iunie 2014 la 13:06

Limbajul de programare rapid. Versiunea rusă

• Dezvoltare pentru iOS,
• Rapid

Bună, Habr! Pe 2 iunie, cu toții am putut vedea cu ochii noștri cum Apple a început să creeze o revoluție în tabăra dezvoltatorilor Objective-C, prezentând lumii noul său limbaj de programare - Swift. Totodată, ea a pus la dispoziția publicului o mică documentație despre limbă, pe care am decis să o traducem dacă va fi cerere. Vă prezentăm atenției o traducere a primului capitol. Dacă subiectul este interesant, vom continua să publicăm traducerea în fiecare săptămână.

Ghid de limbă
Bazele
Operatori de bază
Șiruri și caractere
Tipuri de colecție
Controlul fluxului
Funcții
Închideri
Enumerări
Clase și Structuri
Proprietăți
Metode
Indicele
Moştenire
Inițializare
Deinițializarea
Numărarea automată a referințelor
Înlănțuire opțională
Tip Casting
Tipuri imbricate
Extensii
Protocoale
generice
Operatori avansati

Limbă de referință
Despre limbajul de referință
Structura lexicală
Tipuri
Expresii
Declarații
Declarații
Atribute
Modele
Parametri și argumente generice
Rezumatul Gramaticei
Mărci comerciale

Bun venit la Swift

Despre limba Swift

Swift este în dezvoltare de câțiva ani. Baza noului limbaj de programare a fost compilatorul, depanatorul și cadrele existente. Am simplificat gestionarea memoriei cu contorizarea automată a referințelor (ARC). Cadrele noastre au suferit, de asemenea, o modernizare majoră. Objective-C a început să susțină blocuri, literale și module - toate acestea au creat condiții favorabile pentru introducerea tehnologiilor moderne. Această lucrare pregătitoare a servit drept fundație pentru un nou limbaj de programare care va fi folosit pentru a dezvolta viitoare produse software pentru Apple.

Dezvoltatorii Objective-C vor găsi Swift familiar. Combină lizibilitatea parametrilor numiți cu puterea modelului de obiect dinamic al Objective-C. Deschide cadrele existente Cocoa și este compatibil cu codul scris în Objective-C. Construit pe această bază comună, limbajul oferă multe caracteristici noi și unifică aspectele procedurale și orientate pe obiecte ale limbajului de programare.

Nici Swift nu va speria programatorii începători. Este primul limbaj de programare puternic care este la fel de intuitiv și distractiv ca un limbaj de scripting. Acceptă așa-numitele locuri de joacă, care permit programatorilor să experimenteze cu codul, văzând rezultatul în timp real, fără a fi nevoiți să compileze și să ruleze aplicația.

Swift încorporează cele mai bune limbi moderne și este dezvoltat ținând cont de experiența vastă a Apple. Compilatorul nostru este sinonim cu performanța, iar limbajul nostru este optimizat pentru dezvoltare fără compromisuri. Este conceput astfel încât să puteți dezvolta cu ușurință prima dvs. aplicație „bună, lume!” și chiar un întreg sistem de operare. Toate acestea fac din Swift un instrument important pentru dezvoltatori și pentru Apple însuși.

Swift este o nouă modalitate fantastică de a crea aplicații pentru iOS și OS X și vom continua să o dezvoltăm adăugând noi funcționalități și introducând noi funcții. Scopul nostru este ambițios. Și abia așteptăm să vedem ce poți crea cu el.

Introducere în Swift

Println(„Bună ziua, lume”)
Dacă ați dezvoltat vreodată în C sau Objective-C, această sintaxă ar trebui să vă sune ciudat de familiară - în Swift, această linie de cod este un program complet. Nu mai trebuie să importați biblioteci separate pentru a oferi funcționalități de bază, cum ar fi I/O console sau manipularea șirurilor. Codul scris în domeniul global este punctul de intrare în program, astfel încât funcția principală nu mai este necesară. De asemenea, rețineți că nu există punct și virgulă la sfârșitul fiecărei linii.

Această introducere oferă suficiente informații pentru a începe să codificați în Swift. Nu vă faceți griji dacă nu înțelegeți ceva - vă vom explica totul în detaliu în capitolele următoare.

Comentariu
Pentru o mai bună înțelegere a materialului, vă recomandăm să folosiți modul loc de joacă în Xcode. Playground vă permite să vedeți rezultatele imediat pe măsură ce editați codul, fără a fi nevoie să compilați și să rulați aplicația.

Tipuri de date simple

Var myVariable = 42 myVariable = 50 las myConstant = 42
Tipurile unei constante și ale unei variabile trebuie să se potrivească cu tipurile valorilor corespunzătoare care le sunt atribuite. Cu toate acestea, acest lucru nu înseamnă că trebuie să specificați direct tipul lor. Compilatorul va determina automat tipul de constantă și variabilă atunci când le atribuie o valoare. Deci, în exemplul de mai sus, compilatorul va determina că myVariable este un tip întreg.

Dacă inițializatorul lipsește sau nu oferă suficiente informații, puteți specifica singur tipul după variabilă, separând numele și tipul cu două puncte:

Fie implicitInteger = 70 let inplicitDouble = 70.0 let inplicitDouble: Double = 70

Să experimentăm
Creați o constantă cu tipul Float și inițializați-o cu numărul 4.

Să experimentăm
Încercați să eliminați conversia explicită în String din ultima linie. Ce eroare vei primi?

Let apples = 3 let oranges = 5 let appleSummary = "Am \(mere) mere." let fruitSummary = "Am \(mere + portocale) bucăți de fructe."

Să experimentăm
Încercați să utilizați construcția \() și să imprimați un șir care include rezultatul sumei a două variabile întregi și numele cuiva.

Var shoppingList = ["somn", "apă", "lalele", "vopsea albastră"] shoppingList = "sticlă de apă" var ocupations = [ "Malcolm": "Căpitan", "Kaylee": "Mecanic", ] ocupații ["Jayne"] = "Relații publice"
Pentru a crea o matrice sau un dicționar gol, utilizați următoarea sintaxă:

Let emptyArray = String() let emptyDictionary = Dicţionar ()
Pentru a crea matrice și dicționare goale, utilizați și respectiv [:] - de exemplu, când atribuiți o nouă valoare unei variabile sau treceți un argument unei funcții.

ShoppingList = // A fost la cumpărături și a cumpărat totul.

Condiții și cicluri

Fiți individualScores = var teamScore = 0 pentru scor în individualScores ( dacă scor > 50 ( teamScore += 3 ) else ( teamScore += 1 ) ) teamScore
Condiția din interiorul instrucțiunii if trebuie să fie booleană, ceea ce înseamnă în mod specific că instrucțiunea if score (...) este o eroare deoarece nu există o comparație explicită (de exemplu, cu zero).

Declarația if poate fi utilizată împreună cu let și var pentru a lucra cu constante și variabile care pot avea o valoare zero. Astfel de constante și variabile sunt numite opționale (adică pot lua orice valoare sau pot fi egale cu zero). Pentru a crea o variabilă sau o constantă opțională, adăugați un semn de întrebare (?) după tip.

Var optionalString: String? = „Salut” optionalString == nil var optionalName: String? = "John Appleseed" var salut = "Bună ziua!" if let name = optionalName ( salut = "Bună ziua, \(nume)" )

Să experimentăm
Schimbați opționalName în nil . Ce vezi pe ecran? Adăugați un bloc else pentru a gestiona cazul în care optionalName este nil .

Comutatorul cu opțiuni multiple acceptă mulți alți operatori de comparație în sine și nu se limitează la comparații simple:

Let vegetable = "ardei roșu" comutați legume ( case "telina": let vegetableComment = "Adăugați niște stafide și faceți furnici pe un buștean." case "castraveți", "cresturel": let vegetableComment = "Asta ar fi un sandwich bun cu ceai ." case let x where x.hasSuffix("piper"): let vegetableComment = "Este un \(x) picant?" implicit: let vegetableComment = "Totul are gust bun în supă." )

Să experimentăm
Încercați să eliminați condiția implicită. Ce eroare vei primi?

Pentru a itera elementele unui tablou asociativ, utilizați instrucțiunea for-in împreună cu specificarea unei perechi de nume pentru fiecare pereche cheie-valoare.

Fie interestingNumbers = [ "Prime": , "Fibonacci": , "Square": , ] var cel mai mare = 0 pentru (tip, numere) în InteresingNumbers ( pentru numărul în numere ( dacă număr > cel mai mare ( cel mai mare = număr ) ) ) cel mai mare

Să experimentăm
Adăugați o altă variabilă care vă va permite să aflați care dintre cele trei tipuri este numărul maxim găsit.

Var n = 2 în timp ce n< 100 { n = n * 2 } n var m = 2 do { m = m * 2 } while m < 100 m
Instrucțiunea for poate fi folosită pentru a itera pe o secvență de numere folosind două puncte (..) sau folosind un inițializator, o condiție și un increment. Uite, aceste două bucle fac același lucru:

Var firstForLoop = 0 pentru i în 0..3 ( firstForLoop += i ) firstForLoop var secondForLoop = 0 pentru var i = 0; i< 3; ++i { secondForLoop += 1 } secondForLoop
Când creați o buclă, utilizați două puncte (..) dacă nu doriți să includeți valoarea mai mare în interval și trei puncte (...) pentru a include atât valorile mai mici, cât și cele mai mari.

Funcții și închideri.

Func greet(nume: String, day: String) -> String ( returnează "Bună ziua \(nume), astăzi este \(ziua)." ) greet("Bob", "Marți")

Să experimentăm
Eliminați parametrul zi. În schimb, adăugați o variabilă care indică numele felului de mâncare servit la prânz.

Func. getGasPrices() -> (dublu, dublu, dublu) ( return (3,59, 3,69, 3,79) ) getGasPrices()
Funcțiile pot avea, de asemenea, un număr nedefinit de argumente:

Func sumOf(numbers: Int...) -> Int ( var sum = 0 pentru numărul în numere ( sum += number ) return sum ) sumOf() sumOf(42, 597, 12)

Să experimentăm
Scrieți o funcție care vă permite să găsiți media aritmetică a unui număr arbitrar al argumentelor sale.

Func returnFifteen() -> Int ( var y = 10 func add() ( y += 5 ) add() return y ) returnFifteen()
Funcțiile sunt obiecte din prima clasă (tip de primă clasă), cu alte cuvinte, o funcție poate returna o altă funcție ca rezultat.

Func makeIncrementer() -> (Int -> Int) ( func addOne(number: Int) -> Int ( return 1 + number ) return addOne ) var increment = makeIncrementer() increment(7)
O funcție poate lua, de asemenea, o altă funcție ca unul dintre argumentele sale.

Func hasAnyMatches(listă: Int, condiție: Int -> Bool) -> Bool (pentru elementul din listă (dacă condiția (articolul) ( returnează adevărat ) ) returnează fals ) func lessThanTen (număr: Int) -> Bool ( returnează numărul< 10 } var numbers = hasAnyMatches(numbers, lessThanTen)
Funcțiile sunt un caz special de închidere. Puteți crea o închidere fără a specifica un nume și înconjurând corpul închiderii cu acolade (()). Pentru a separa argumentele și tipul de returnare din corpul închiderii, utilizați operatorul in.

Numbers.map(( (număr: Int) -> Int în let rezultat = 3 * număr returnează rezultat ))

Să experimentăm
Rescrieți închiderea astfel încât să returneze zero pentru toate numerele suplimentare.

Numbers.map(( număr în 3 * număr ))
Într-o închidere, în loc să specificați un nume de variabilă, puteți utiliza numărul său ordinal - acest lucru este util în special atunci când scrieți scurtcircuite. Închiderea, care este ultimul argument al funcției, îi poate fi transmisă imediat după paranteze cu o listă a parametrilor rămași.

Sortare() ($0 > $1)

Obiecte și clase

Forma clasei ( var numberOfSides = 0 func simpleDescription() ->

Să experimentăm
Adăugați o constantă de membru de clasă și o metodă de clasă care o ia drept argument.

Var shape = Shape() shape.numberOfSides = 7 var shapeDescription = shape.simpleDescription()
În acest exemplu, am omis un detaliu important - constructorul clasei, metoda init.

Clasa NamedShape ( var numberOfSides: Int = 0 var name: String init(name: String) ( self.name = name ) func simpleDescription() -> String ( returnează „O formă cu \(numberOfSides) laturi.” ) )
Observați cum membrul clasei nume este separat de argumentul constructorului de nume de către sine. Argumentele sunt transmise constructorului în mod normal, ca la orice altă metodă de clasă. Rețineți că fiecare membru al clasei trebuie să fie inițializat, fie atunci când este declarat (cum ar fi numberOfSides), fie în constructor (cum ar fi numele).

Destructorul de clasă este metoda deinit, care poate fi suprascrisă dacă este necesar.

Pentru a moșteni o clasă dintr-o clasă existentă, după ce ați specificat numele clasei copil, adăugați două puncte și indicați numele clasei părinte. În Swift nu există restricții privind moștenirea obligatorie a oricărei clase standard.

Metodele suprascrise de o clasă copil trebuie să fie marcate cu cuvântul cheie override - suprascrierea metodelor fără override va duce la o eroare. Compilatorul detectează, de asemenea, metodele care sunt marcate ca suprascrie, dar nu înlocuiesc nicio metodă din clasa lor părinte.
class Square: NamedShape ( var sideLength: Double init(sideLength: Double, nume: String) ( self.sideLength = sideLength super.init(name: name) numberOfSides = 4 ) func area() -> Double ( return sideLength * sideLength ) override func simpleDescription() -> String ( return "Un pătrat cu laturile lungimii \(sideLength)." ) ) let test = Square(sideLength: 5.2, nume: "pătratul meu de testare") test.area() test.simpleDescription ()

Să experimentăm
Creați o clasă Circle și moșteniți din clasa NamedShape. Constructorul clasei Circle are două argumente: rază și nume. Ignorați zona și descrieți metodele acestei clase.

Clasa Triunghi Echilateral: NamedShape ( var sideLength: Double = 0.0 init(sideLength: Double, nume: String) ( self.sideLength = sideLength super.init(name: name) numberOfSides = 3 ) var perimetru: Double ( get ( return 3.0 * sideLength ) ) set ( sideLength = newValue / 3.0 ) ) override func simpleDescription() -> String ( return "Un triunghi echilateral cu laturile de lungime \(sideLength)." ) ) var triangle = EquilateralTriangle(sideLength: 3.1, nume: "un triunghi ") triunghi.perimetru triunghi.perimetru = 9,9 triunghi.laturaLungime
În setatorul variabilei perimetru, noua valoare atribuită se numește implicit newValue . Puteți schimba numele acestei variabile punând-o între paranteze imediat după set .

Observați structura constructorului clasei EquilateralTriangle. Această metodă include trei pași succesivi:

1. inițializarea membrilor unei clase de copii;
2. apelarea constructorului clasei părinte;
3. modificarea valorilor membrilor clasei părinte.

Clasa TriunghiAndPătrat ( var triunghi: EquilateralTriangle ( willSet ( square.sideLength = newValue.sideLength ) ) var square: Square ( willSet ( triangle.sideLength = newValue.sideLength ) ) init(size: Double, nume: String) ( square = Square( sideLength: size, name: name) triangle = EquilateralTriangle(sideLength: size, name: name) ) var triangleAndSquare = TriangleAndSquare(size: 10, name: "other test shape") triangleAndSquare.square.sideLength triangleAndSquare.triangle.sideLength triangle.AndSquare pătrat = Square(sideLength: 50, nume: „pătrat mai mare”) triangleAndSquare.triangle.sideLength
Metodele de clasă au o diferență importantă față de funcții. Numele argumentelor unei funcții sunt folosite numai în cadrul acelei funcție, în timp ce într-o metodă de clasă, parametrii sunt utilizați și la apelarea acelei metode (cu excepția primului parametru). În mod implicit, o metodă de clasă are aceleași nume de parametri atât atunci când este apelată, cât și în ea însăși. Cu toate acestea, puteți specifica un nume diferit (în exemplul de mai jos - ori), care va fi folosit numai în cadrul acestei metode. În acest caz, pentru a apela această metodă, trebuie să utilizați prenumele (numberOfTimes).

Class Counter ( var count: Int = 0 func incrementBy(amount: Int, numberOfTimes ori: Int) (count += amount * times ) ) var counter = Counter() counter.incrementBy(2, numberOfTimes: 7)
Când lucrați cu valori opționale, adăugați un semn de întrebare (?) înaintea metodelor, a membrilor clasei etc. Dacă valoarea de dinaintea semnului de întrebare este zero, totul după (?) este ignorat și întreaga expresie este zero. În caz contrar, expresia este evaluată ca de obicei. În ambele cazuri, întreaga expresie va avea ca rezultat o valoare opțională.

Lăsați opționalSquare: Square? = Square(sideLength: 2,5, nume: "opțional pătrat") let sideLength = optionalSquare?.sideLength

Enumerări și structuri

Enum Rank: Int (case As = 1 case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten case Jack, Queen, King func simpleDescription() -> String ( switch self (case .Ace: return " ace" case .Jack: returnează "jack" case .Queen: return "queen" case .King: return "king" implicit: return String(self.toRaw()) ) ) ) let ace = Rank.Ace let aceRawValue = as .toRaw()

Să experimentăm
Scrieți o funcție care compară 2 enumerari de rang pe baza valorilor lor.

Pentru a converti tipul de valoare original într-un tip de enumerare, utilizați funcțiile toRaw și fromRaw.

Dacă lăsați convertedRank = Rank.fromRaw(3) ( lăsați threeDescription = convertedRank.simpleDescription() )
Rețineți că valorile elementelor de enumerare sunt reale și nu doar o altă reprezentare a valorilor lor originale. În general, nu trebuie să specificați valorile lor originale.

Enum Suit ( case Spades, Hearts, Diamonds, Clubs func simpleDescription() -> String ( switch self ( case .Spades: return "spades" case .Hearts: return "hearts" case .Diamonds: return "diamonds" case .Clubs: returnează „cluburi” ) ) ) let hearts = Costum.Hearts let heartsDescription = hearts.simpleDescription()

Să experimentăm
Adăugați o metodă Color care returnează șirul „negru” pentru Spades și Trece și „roșu” pentru Hearts and Diamonds.

Cuvântul cheie struct este folosit pentru a crea structuri. Structurile au multe asemănări cu clasele, inclusiv metode și constructori. Una dintre cele mai semnificative diferențe dintre structuri și clase este că instanțele de structuri, spre deosebire de instanțele de clase, sunt transmise funcțiilor prin valoare (adică este creată mai întâi o copie locală a acestora), în timp ce instanțele de clase sunt transmise prin referință.

Struct Card ( var rank: Rank var suit: Suit func simpleDescription() -> String ( return "The \(rank.simpleDescription()) of \(suit.simpleDescription())" ) ) let threeOfSpades = Card(rank: . Trei, costum: .Spades) let threeOfSpadesDescription = threeOfSpades.simpleDescription()

Să experimentăm
Adăugați o metodă la structura Cărților care creează un pachet complet de cărți.

Să luăm în considerare un exemplu de primire a orelor de răsărit și apus de la un server. Serverul răspunde fie cu informații relevante, fie cu un mesaj de eroare.

Enum ServerResponse ( case Result(String, String) case Error(String) ) let success = ServerResponse.Result("6:00 am", "8:09 pm") let failure = ServerResponse.Error("Out of cheese." ) switch success ( case let .Result(sunrise, sunset): let serverResponse = "Răsăritul este la \(răsăritul) și apusul este la \(apusul)." case let .Eroare (eroare): let serverResponse = "Eșec.. .\(eroare)" )

Să experimentăm
Adăugați o a treia opțiune la o declarație switch cu alegere multiplă

Protocoale și extensii.

Protocol ExempluProtocol ( var simpleDescription: String ( get ) mutating func adjust() )
Protocoalele pot fi susținute de clase, enumerări și structuri.

Clasa SimpleClass: ExampleProtocol ( var simpleDescription: String = "O clasă foarte simplă." var anotherProperty: Int = 69105 func adjust() ( simpleDescription += " Acum 100% ajustat." ) ) var a = SimpleClass() a.adjust( ) let aDescription = a.simpleDescription struct SimpleStructure: ExampleProtocol ( var simpleDescription: String = "O structură simplă" mutating func adjust() ( simpleDescription += " (ajustat)" ) ) var b = SimpleStructure() b.adjust() let bDescription = b.simpleDescription

Să experimentăm
Creați o enumerare care va implementa acest protocol.

Pentru a adăuga noi metode sau membri de clasă la un tip existent, trebuie să utilizați extensii. De asemenea, puteți utiliza extensii pentru a implementa un protocol cu ​​un tip existent, chiar dacă este importat dintr-o bibliotecă sau cadru.

Extensie Int: ExampleProtocol ( var simpleDescription: String ( return "The number \(self)") ) mutating func adjust() (self += 42 ) ) 7.simpleDescription

Să experimentăm
Creați o extensie de tip Double cu o variabilă membru absoluteValue .

Lăsați protocolValue: ExampleProtocol = a protocolValue.simpleDescription // protocolValue.anotherProperty // Anulați comentariul pentru a vedea eroarea
Chiar dacă variabila protocolValue este de tip SimpleClass în timpul rulării, compilatorul presupune că tipul ei este ExampleProtocol . Aceasta înseamnă că nu veți putea accesa accidental metode sau membri ai clasei care sunt implementate în afara ExampleProtocol.

Tipuri generice

Func repetare (articol: ItemType, ori: Int) -> ItemType ( var rezultat = ItemType() pentru i în 0.. ori ( rezultat += item ) returnează rezultat ) repeat("knock", 4)
Creați funcții generice, clase, enumerări și structuri.

// Reimplementați tipul opțional al bibliotecii standard Swift OptionalValue (case Niciun caz Some(T) ) var posibilInteger: OptionalValue = .Nimic posibilIntreg = .Celeva(100)
Dacă doriți să specificați cerințe specifice pentru un tip generic, cum ar fi implementarea unui protocol sau solicitarea acestuia să moștenească de la o anumită clasă, utilizați where .

Func anyCommonElements (lhs: T, rhs: U) -> Bool ( pentru lhsItem în lhs ( pentru rhsItem în rhs ( dacă lhsItem == rhsItem ( returnează adevărat ) ) ) ) return false ) anyCommonElements(, )

Să experimentăm
Modificați funcția anyCommonElements pentru a returna o matrice de elemente comune.