Swift From Scratch En introduktion till funktioner

För att få något gjort i Swift måste du lära känna insatserna och funktionerna. Funktionerna är exceptionellt kraftfulla och flexibla i Swift. Grunderna är enkla, särskilt om du tidigare har arbetat med andra programmeringsspråk. Men på grund av Swifts flexibla syntax kan funktioner bli förvirrande om du inte är bekant med grunderna. 

I den här artikeln fokuserar vi på grunderna först. Då fortsätter vi att utforska den mer komplexa syntaxen och använda fall i nästa artikel. Det är viktigt att du inte skummer på grunderna eftersom de är viktiga för att förstå var en funktion kommer från. Låt oss börja med att dissekera anatomin för en funktion i Swift med ett exempel.

1. Lär dig genom exempel

En funktion är inget mer än ett block av kod som kan utföras när det behövs. Låt oss titta på ett exempel på den grundläggande anatomin för en Swift-funktion. Avfyra Xcode och skapa en ny lekplats. Lägg till följande funktionsdefinition på lekplatsen.

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

En funktion börjar med func sökord och följs av namnet på funktionen, printHelloWorld i vårt exempel. Som på många andra språk följer namnet på funktionen ett par parenteser som innehåller funktionens parametrar-ingången till funktionen.

Funktionens kropp är inslaget i ett par lockiga hängslen. De printHelloWorld () funktionen innehåller ett enda uttalande som skriver ut strängen Hej världen! till standardutgången. Så här ser en grundläggande funktion ut i Swift. Syntaxen är enkel, ren och minimalistisk.

Du kan aktivera funktionen genom att skriva namnet på funktionen, följt av ett par parenteser.

printHelloWorld ()

2. Parametrar

Låt oss göra det ovanstående exemplet lite mer komplext genom att lägga till parametrar i funktionsdefinitionen. Detta betyder helt enkelt att vi tillhandahåller funktionen med inmatningsvärden som den kan använda i funktionens kropp. I det följande exemplet definierar vi printMessage (meddelande :) funktion, som accepterar en parameter, meddelande, av typ Sträng.

func printMessage (meddelande: String) skriv ut (meddelande)

En funktion kan acceptera flera parametrar eller ingångsvärden. Parametrarna är inslagna av parenteserna som följer funktionens namn. Parameterns namn följs av en kolon och parameterns typ. Som du kommer ihåg, är det mycket som att de förklarar en variabel eller konstant. Det säger helt enkelt att meddelande parametern är av typ Sträng.

I stället för att skriva ut en hårdkodad sträng som vi gjorde i printHelloWorld () funktion, vi skriver ut meddelande parameterns värde. Detta gör funktionen flexibel och mer användbar.

Uppkalla funktionen är mycket lik den som vi såg tidigare. Den enda skillnaden är att vi passerar i ett argument när vi anropar funktionen.

printMessage (meddelande: "Hello World!")

Observera att villkoren parametrar och argument används ofta omväxlande, men det finns en subtil, semantisk skillnad i Swift. I Swift är parametrarna de värden som anges i funktionsdefinitionen, medan argument är värdena som överförs till funktionen när den påkallas.

Flera parametrar

Som jag nämnde tidigare är funktionens syntax mycket flexibel, och det ska inte överraska dig att det är fullt möjligt att skicka flera argument till en funktion. I nästa exempel skapar vi en variant på printMessage (message: gånger :) funktion som tillåter oss att skriva ut meddelandet flera gånger.

func printMessage (meddelande: String, tider: Int) för jag i 0 ... 
Medan namnet på funktionen är identiskt med det ursprungliga printMessage (meddelande :) funktionen är funktionens typ annorlunda. 
Det är viktigt att du förstår den tidigare meningen. Läs det igen.
Varje funktion har en typ som består av parametertyperna och returtypen. Vi kommer att utforska returtyper på ett ögonblick. Funktioner kan ha samma namn så länge som deras typ är annorlunda, vilket visas av de tidigare två funktionsdefinitionerna.
Typen av den första funktionen är (String) -> (), medan typen av den andra funktionen är(String, Int) -> (). Namnet på båda funktionerna är detsamma. Oroa dig inte för -> symbol. Dess mening kommer att bli tydlig om några minuter när vi diskuterar returtyper.
Den andra printMessage (message: gånger :) funktionen definierar två parametrar, meddelande av typ Sträng och gånger av typ int. Denna definition illustrerar ett av de funktioner som Swift har antagit från Objective-C, läsbar funktion och metodnamn. Medan namnet på funktionen är printMessage, Det är lätt att förstå vad funktionen ska göra genom att läsa namnen på funktionens parametrar.
På sekunden printMessage (message: gånger :) funktion skapar vi en för-i slinga för att skriva ut meddelande sträng gånger gånger. Vi använder halvoperatörsoperatören, ... <, som vi såg tidigare i denna serie.
När vi börjar skriva printMessage På lekplatsen visar Xcode båda funktionerna i autokompletionsmenyn. Tack vare funktionens typ är det enkelt att välja den funktion som vi är intresserade av. Ring den andra printMessage (message: gånger :) funktionen är så enkel som:
printMessage (meddelande: "Hello World", gånger: 3)
Ursprungliga värden
En av mina favoritfunktioner är möjligheten att definiera standardvärden för parametrar. Det här låter dumt om du kommer från ett språk som har haft denna funktion i många åldrar, men det här är ganska bra om du har arbetat med C och Objective-C i många år.
Kort sagt, tillåter Swift utvecklare att definiera standardvärden för parametrarna för en funktion. Låt oss definiera en ny funktion som skriver ut det aktuella datumet i ett visst format. Se till att du lägger till följande import uttalande högst upp på din lekplats för att importera UIKIT-ramverket.
importera UIKit
Låt oss först definiera printDate (datum: format :) funktion utan att använda standardvärden för någon av parametrarna.
func printDate (datum: Datum, format: String) let dateFormatter = DateFormatter () dateFormatter.dateFormat = format print (dateFormatter.string (från: datum))
Om du inte är bekant med stiftelsens ramverk och du inte förstår vad som händer i funktionskroppen, så är det bra. Inriktningen i detta exempel handlar inte om genomförandet av formatering av ett datum. I printDate (datum: format :), vi använder värdet av formatera parameter för att formatera värdet på datum. Om vi ​​inte skickar in ett värde för formatera parametern kastar kompilatorn ett fel.
Vi kan åtgärda detta genom att definiera ett standardvärde för funktionens andra parameter, som visas i den uppdaterade funktionsdefinitionen nedan.
func printDate (datum: Datum, format: String = "YY / MM / dd") let dateFormatter = DateFormatter () dateFormatter.dateFormat = format print (dateFormatter.string (från: datum))
Definiera ett standardvärde är lika enkelt som att ange ett värde i listan med parametrar i funktionens definition. Resultatet är att kompilatorn inte längre klagar och felet försvinner.
printDate (datum: Datum ())
Även om vi har angett ett standardvärde för formatera parameter, kan vi fortfarande passera i ett värde om vi vill.
printDate (datum: Datum (), format: "dd / MM / YY")
Observera att Apple rekommenderar positioneringsparametrar med ett standardvärde i slutet av listan med parametrar. Det här är verkligen en bra idé och vanligt i de flesta andra programmeringsspråk som stöder valfria parametrar.
 3. Retur typ
De funktioner vi hittills hittat returnerar inte någonting till oss när vi åberopar dem. Låt oss göra printDate (datum: format :) funktionen är mer användbar genom att returnera det formaterade datumet som en sträng istället för att skriva ut det formaterade datumet i funktionens kropp. Detta kräver två ändringar, som du kan se nedan.
func printDate (datum: Datum, format: String = "YY / MM / dd") -> String let dateFormatter = DateFormatter () dateFormatter.dateFormat = format returneringsdatumFormatter.string (från: datum)
Det första vi byter är funktionens definition. Efter parametervärden anger vi returtypen, Sträng. Returtypen föregås av -> symbol. Om du har arbetat med CoffeeScript så kommer det att bli bekant.
I stället för att skriva ut det formaterade datumet med hjälp av trycket (_: separator: terminator :) funktion använder vi lämna tillbaka sökord för att returnera värdet från funktionen. Det är allt vi behöver göra. Låt oss prova det.
låt formateradDate = printDate (datum: Datum (), format: "dd / MM / YY") print (formaterad datum)
Vi åberopar printDate (datum: format :) funktion, lagra returvärdet i konstanten formattedDate, och skriv ut värdet på formattedDate i standardutgången. Observera att namnet på printDate (datum: format :) funktionen speglar inte längre vad det gör, så du kanske vill ändra den till formatDate istället.
Ingen returtyp
De andra funktionerna som vi har definierat i den här handledningen har inte någon returtyp. När en funktion inte har en returtyp är det inte nödvändigt att inkludera -> symbol i funktionsdefinitionen.
Några stycken tidigare berättade jag att ingen av de funktioner vi definierade gav oss ett värde. Det är faktiskt inte helt sant. Låt mig förklara nitty-gritty detaljer med ett experiment. Lägg till följande rad på din lekplats och se vad som händer.
Det här är intressant. Swift har inga problem att vi lagrar återgångsvärdet för printHelloWorld () funktion i en konstant, men det varnar oss om att typen av det returnerade värdet inte är vad vi kanske tror det är.
Vad händer här? Varje funktion i Swift returnerar ett värde, även om vi inte definierar en returtyp i funktionsdefinitionen. När en funktion inte explicit anger en returtyp returnerar funktionen implicit Ogiltig, vilket motsvarar en tom tupel, eller () för korta. Du kan se detta i lekplatsens utgångspanel och det nämns också i varningen i kompilatorns utgångar.
Vi kan bli av med ovanstående varning genom att uttryckligen förklara typen av värde, en tom tupel. Jag håller med om att det inte är mycket användbart att lagra en tom tupel i en konstant, men det illustrerar för dig att varje funktion har ett returvärde.
låt värdet: () = printHelloWorld ()
tupler
En annan stor egenskap hos Swift är möjligheten att returnera flera värden från en funktion genom att returnera en tupel. Följande exempel illustrerar hur detta fungerar. Låt mig upprepa att det inte är viktigt att du förstår hur timeComponentsForDate (datum :) funktion gör sitt jobb. Fokus är funktionens returvärde, en tupel med tre element.
func timeComponentsForDate (_ datum: Date) -> (timme: Int, minut: Int, sekund: Int) let dateComponents = Calendar.current.dateComponents ([. timme, .minute, .second], från: datum) = dateComponents.hour leta minut = dateComponents.minute let second = dateComponents.second returnera (timme ?? 0, minut ?? 0, andra ?? 0)
Funktionen accepterar ett argument, a Datum instans och returnerar en tupel med tre märkta värden. Märkning av tupelns värden är endast av bekvämlighet; det går att släppa ut etiketterna.
func timeComponentsForDate (_ date: Date) -> (Int, Int, Int) let dateComponents = Calendar.current.dateComponents ([. timme, .minute, .second], från: datum) låt timme = datumComponents.hour låt minut = dateComponents.minute let second = dateComponents.second returnera (timme ?? 0, minut ?? 0, andra ?? 0)
Men som följande exempel illustrerar är märkning av värdena på tupeln som returneras från funktionen väldigt bekväm och gör din kod lättare att förstå.
låt timeComponents = timeComponentsForDate (Date ()) print (timeComponents.hour) print (timeComponents.minute) print (timeComponents.second)
Det är också möjligt att returnera ett valfritt värde från en funktion om det finns scenarier där funktionen har inget värde att returnera. Detta är lika enkelt som att definiera funktionens returtyp som valfri, som visas nedan.
func timeComponentsForDate (_ datum: Date) -> (timme: Int, minut: Int, sekund: Int)? let dateComponents = Calendar.current.dateComponents ([. timme, .minute, .second], från: datum) guard let hour = dateComponents.hour else return nil guard let minut = dateComponents.minute else return nil guard låt andra = dateComponents.second else return nil returnera (timme, minut, sekund)
Slutsats
I denna handledning undersökte vi grunderna för funktioner i Swift. Det är viktigt att du förstår funktionens syntax, eftersom vi i nästa artikel utforskar mer avancerade funktioner som bygger på vad vi täckte i denna handledning.
Jag uppmanar dig att läsa artikeln igen om det behövs och, viktigare, skriva några funktioner på en lekplats för att bli bekant med syntaxen. Grunderna är lätta att förstå, men du får bara hänga på dem genom att öva.
 
Om du vill lära dig hur du använder Swift 3 för att koda i verkliga applikationer, kolla in vår kurs Skapa iOS Apps With Swift 3. Om du är ny i iOS-apputveckling eller letar efter att göra omkopplaren från Objective-C, så här Kursen kommer att komma igång med Swift för apputveckling. 
  





		
			
	   
	




Koda