Swift From Scratch o introducere în funcții

Pentru a obține ceva de făcut în Swift, trebuie să înveți elementele de intrare și ieșire din funcții. Funcțiile sunt extrem de puternice și flexibile în Swift. Elementele de bază sunt simple, mai ales dacă ați mai lucrat cu alte limbi de programare înainte. Dar din cauza sintaxei flexibile a lui Swift, funcțiile pot deveni confuze dacă nu sunteți familiarizați cu elementele de bază. 

În acest articol, ne concentrăm mai întâi pe elementele de bază. Apoi vom continua să explorăm sintaxa mai complexă și cazurile de utilizare în următorul articol. Este important să nu schimbați elementele de bază, deoarece acestea sunt esențiale pentru a înțelege de unde provine puterea unei funcții. Să începem prin disecarea anatomiei unei funcții în Swift cu un exemplu.

1. Aflați prin exemplu

O funcție nu este altceva decât un bloc de cod care poate fi executat ori de câte ori este necesar. Să aruncăm o privire asupra unui exemplu de anatomie de bază a unei funcții Swift. Activați Xcode și creați un nou loc de joacă. Adăugați următoarea definiție a funcției la locul de joacă.

func printHelloWorld () print ("Hello World!")

O funcție începe cu FUNC și este urmată de numele funcției, printHelloWorld în exemplul nostru. Ca în multe alte limbi, numele funcției este urmat de o pereche de paranteze care conțin parametrii funcției - intrarea în funcție.

Corpul funcției este înfășurat într-o pereche de bretele curbate. printHelloWorld () funcția conține o singură instrucțiune care imprimă șirul Salut Lume! la ieșirea standard. Aceasta arata o functie de baza in Swift. Sintaxa este simplă, curată și minimalistă.

Puteți invoca funcția introducând numele funcției, urmată de o pereche de paranteze.

printHelloWorld ()

2. Parametrii

Să facem exemplul de mai sus un pic mai complex prin adăugarea de parametri la definiția funcției. Acest lucru înseamnă pur și simplu că oferim funcția cu valori de intrare pe care le poate utiliza în corpul funcției. În exemplul următor, definim printMessage (Mesaj :) care acceptă un parametru, mesaj, de tip Şir.

func printMessage (mesaj: String) print (mesaj)

O funcție poate accepta mai mulți parametri sau valori de intrare. Parametrii sunt înfășurați de parantezele care urmează numele funcției. Numele parametrului este urmat de un colon și de tipul parametrului. După cum vă amintiți, aceasta este foarte asemănătoare cu declararea unei variabile sau a unei constante. Pur și simplu spune că mesaj este parametrul de tip Şir.

În loc să tipărim un șir de coduri grele așa cum am făcut-o în printHelloWorld () funcția, imprimați mesaj parametru. Aceasta face ca funcția să fie flexibilă și mai utilă.

Invocarea funcției este foarte asemănătoare cu ceea ce am văzut mai devreme. Singura diferență este că noi introducem un argument când invocăm funcția.

printMessage (mesaj: "Hello World!")

Rețineți că termenii parametrii și argumente sunt adesea folosite interschimbabil, dar există o diferență subtilă, semantică în Swift. În Swift, parametrii sunt valorile specificate în definiția funcției, în timp ce argumentele sunt valorile transmise funcției atunci când este invocată.

Parametrii multipli

Așa cum am menționat mai devreme, sintaxa funcțiilor este foarte flexibilă și nu trebuie să vă surprindă că este perfect posibil să transmiteți mai multe argumente unei funcții. În exemplul următor, vom crea o variantă pe printMessage (mesaj: ori :) funcție care ne permite să imprimam mesajul de mai multe ori.

func printMessage (mesaj: String, Times: Int) pentru i în 0 ... 
În timp ce numele funcției este identic cu cel al originalului printMessage (Mesaj :) funcția, tipul funcției este diferit. 
Este important să înțelegeți propoziția anterioară. Citiți-o din nou.
Fiecare funcție are un tip, constând din tipurile de parametru și tipul de returnare. Vom explora tipurile de întoarcere într-un moment. Funcțiile pot avea același nume, atâta timp cât tipul lor este diferit, după cum arată ultimele două definiții ale funcțiilor.
Tipul primei funcții este (String) -> (), în timp ce tipul celei de-a doua funcții este(String, Int) -> (). Numele ambelor funcții este același. Nu vă faceți griji cu privire la -> simbol. Sensul său va deveni clar în câteva momente când vom discuta tipurile de întoarcere.
Al doilea printMessage (mesaj: ori :) funcție definește doi parametri, mesaj de tip Şir și ori de tip Int. Această definiție ilustrează una din trăsăturile pe care Swift le-a adoptat de la obiectivele C, funcțiile și metodele care pot fi citite. În timp ce numele funcției este printMessage, este ușor de înțeles ce înseamnă funcția prin citirea numelor parametrilor funcției.
In secunda printMessage (mesaj: ori :) funcția, vom crea o pentru-în buclă pentru a imprima mesaj şir ori ori. Folosim operatorul pentru intervalul semi-deschis, ... <, după cum am văzut mai devreme în această serie.
Când începem să tipăm printMessage în spațiul de joacă, Xcode afișează ambele funcții în meniul de completare automată. Datorită tipului funcției, este ușor să alegeți funcția de care suntem interesați. Apelați al doilea printMessage (mesaj: ori :) funcția este la fel de simplă:
printMessage (mesaj: "Hello World", ori: 3)
Valori implicite
Una dintre caracteristicile mele favorite este abilitatea de a defini valorile implicite pentru parametri. Acest lucru poate părea proastă dacă veniți dintr-o limbă care a avut această caracteristică de-a lungul vremurilor, dar acest lucru este destul de mare dacă ați lucrat cu C și Obiectiv-C de mai mulți ani.
Pe scurt, Swift permite dezvoltatorilor să definească valori implicite pentru parametrii unei funcții. Să definim o nouă funcție care imprimă data curentă într-un anumit format. Asigurați-vă că adăugați următoarea instrucțiune de import în partea de sus a locului de joacă pentru a importa cadrul UIKit.
import UIKit
Să definim mai întâi printDate (data: Format :) funcția fără a utiliza valorile implicite pentru oricare dintre parametri.
func printDate (data: data, formatul: String) let dateFormatter = dataFormatter () dateFormatter.dateFormat = format print (dateFormatter.string (de la: date)
Dacă nu sunteți familiarizat cu cadrul fundației și nu înțelegeți ce se întâmplă în corpul funcției, atunci este bine. Accentul acestui exemplu nu se referă la implementarea formatării unei date. În printDate (data: Format :), folosim valoarea lui format parametru pentru a formata valoarea Data. Dacă nu vom trece o valoare pentru format parametru, compilatorul aruncă o eroare.
Putem remedia acest lucru prin definirea unei valori implicite pentru al doilea parametru al funcției, așa cum se arată în definiția actualizată a funcției de mai jos.
func printDate (data: data, format: String = "YY / MM / dd")) dateFormatter = DateFormatter () dateFormatter.dateFormat = format print (dateFormatter.string
Definirea unei valori implicite este la fel de simplă ca specificarea unei valori în lista parametrilor din definiția funcției. Rezultatul este că compilatorul nu se mai plânge și eroarea dispare.
printDate (data: data ())
Chiar dacă am specificat o valoare implicită pentru format parametru, putem totuși să trecem printr-o valoare dacă vrem.
printDate (data: data (), format: "dd / MM / YY")
Rețineți că Apple recomandă parametrii de poziționare cu o valoare implicită la sfârșitul listei parametrilor. Aceasta este cu siguranță o idee bună și comună în cele mai multe limbi de programare care suportă parametrii opționali.
 3. Return Type
Funcțiile pe care le-am văzut până acum nu ne înapoiază nimic când le invocăm. Să facem asta printDate (data: Format :) funcția este mai utilă returnând data formatată ca șir, în loc să imprimați data formatată în corpul funcției. Acest lucru necesită două modificări, după cum puteți vedea mai jos.
func printDate (data: data, formatul: String = "YY / MM / dd") -> String let dateFormatter = DateFormatter () dateFormatter.dateFormat = format data returnareFormatter.string
Primul lucru pe care îl schimbăm este definiția funcției. După lista parametrilor, specificăm tipul returului, Şir. Tipul de returnare este precedat de -> simbol. Dacă ați lucrat cu CoffeeScript, atunci acest lucru va arăta familiar.
În loc să imprimați data formatată utilizând Print (_: separator: terminator :) funcția, vom folosi întoarcere pentru a returna valoarea din funcție. Asta e tot ce trebuie să facem. Să încercăm.
permiteți formattedDate = printDate (data: data (), format: "dd / MM / YY") print (formattedDate)
Invocăm printDate (data: Format :) funcția, stocați valoarea returnată în constanță formattedDate, și tipăriți valoarea formattedDate în ieșirea standard. Rețineți că numele printDate (data: Format :) funcția nu mai reflectă ceea ce face, deci vă recomandăm să o schimbați formatDate in schimb.
Nici un tip de retur
Celelalte funcții pe care le-am definit în acest tutorial nu au avut un tip de returnare. Atunci când o funcție nu are un tip de retur, nu este necesar să includeți -> simbol în definiția funcției.
Câteva paragrafe mai devreme, v-am spus că nici una dintre funcțiile pe care le-am definit ne-a adus o valoare. De fapt, nu este chiar adevărat. Permiteți-mi să vă explic detaliile cu un detaliu experimental. Adăugați următoarea linie la locul de joacă și vedeți ce se întâmplă.
Acest lucru este interesant. Swift nu are o problemă în care stocăm valoarea returnată a printHelloWorld () funcționează într-o constantă, dar ne avertizează că tipul de valoare returnată nu este ceea ce am putea crede că este.
Ce se intampla aici? Fiecare funcție din Swift returnează o valoare, chiar dacă nu definim un tip de retur în definiția funcției. Atunci când o funcție nu specifică în mod explicit un tip de retur, funcția se întoarce implicit neavenit, care este echivalentă cu o nucă goală sau () pe scurt. Puteți vedea acest lucru în panoul de ieșire al locului de joacă și este menționat, de asemenea, în avertismentul ieșirilor compilatorului.
Putem să scăpăm de avertismentul de mai sus prin declararea explicită a tipului de avertisment valoare, o nucă goală. Sunt de acord că nu este foarte util să stocați o tupă goală într-o constantă, dar vă arată că fiecare funcție are o valoare returnată.
lași valoarea: () = printHelloWorld ()
Perechile
O altă caracteristică importantă a lui Swift este abilitatea de a returna mai multe valori dintr-o funcție prin returnarea unei tuple. Următorul exemplu ilustrează modul în care funcționează acest lucru. Permiteți-mi să repet că nu este important să înțelegeți cum timeComponentsForDate (data :) funcționează. Focalizarea este valoarea returnată a funcției, o trupă cu trei elemente.
func timeComponentsForDate (_ date: Date) -> (ora: int, minut: int, a doua: Int) let dateComponents = Calendar.current.dateComponents ([. = dateComponents.hour lasa minute = dateComponents.minute let second = dataComponents.second return (ora 0, minutul 0, secunda? 0)
Funcția acceptă un argument, a Data instanță și returnează o tuplă cu trei valori etichetate. Etichetarea valorilor tuplei este doar pentru comoditate; este posibil să omiteți etichetele.
func timeComponentsForDate (_ date: Date) -> (Int, Int, Int) let dateComponents = Calendar.current.dateComponents ([oră, .minute, .second], from: date) hour hour = dateComponents.hour let minute = dateComponents.minute a doua secunda = dataComponents.second return (ora 0, minutul 0, a doua? 0)
Cu toate acestea, după cum ilustrează exemplul următor, etichetarea valorilor tuplei returnate din funcție este foarte convenabilă și face codul mai ușor de înțeles.
lăsați timeComponents = timeComponentsForDate (Date ()) print (timeComponents.hour) print (timeComponents.minute) print (timeComponents.second)
De asemenea, este posibil să returnați o valoare opțională dintr-o funcție dacă există scenarii în care funcția nu are nicio valoare pentru a reveni. Acest lucru este la fel de simplu ca definirea tipului de returnare a funcției ca opțional, după cum se arată mai jos.
func timeComponentsForDate (_ date: Date) -> (ora: Int, minut: Int, a doua: Int)? dateComponents = Calendar.current.dateComponents ([. ora, .minute, .second], de la: data) paza la ora ora = dataComponents.hour altceva return nil paza let minute = dateComponents.minute altceva return nil let second = dateComponents.second else returnați zero return (ora, minutul, a doua)
Concluzie
În acest tutorial, am explorat elementele de bază ale funcțiilor Swift. Este important să înțelegeți sintaxa funcțiilor, pentru că în următorul articol vom explora funcții mai avansate care se bazează pe ceea ce acoperim în acest tutorial.
Vă încurajez să citiți din nou articolul dacă este necesar și, mai important, să scrieți câteva funcții într-un loc de joacă pentru a vă familiariza cu sintaxa. Elementele de bază sunt ușor de înțeles, dar veți avea parte de ele doar prin practicare.
 
Dacă doriți să aflați cum să utilizați aplicația Swift 3 pentru a codifica aplicațiile din lumea reală, consultați cursul nostru Creați aplicații iOS cu Swift 3. Indiferent dacă sunteți nou în dezvoltarea de aplicații iOS sau căutați să treceți de la obiectivul C, curs va începe cu Swift pentru dezvoltarea de aplicații. 
  





		
			
	   
	




Cod