Bli en iOS-utvecklare: Hur man börjar utveckla för iPad och iPhone

Innehåll

Behöver jag veta Swift?
Installera Apples Xcode IDE
Komma igång: Skapa ett nytt Xcode-projekt
Utvecklingsteam krävs?
Förstå Apples Xcode IDE
AppleDelegate: Undersöker Swift-källfilen
1. Skapa en startpunkt
2. Definiera din AppDelegate
3. Definiera en fönsteregenskap
4. Blandade Stub-implementationer
Testa ditt projekt: Kör iOS Simulator
Skapa ett användargränssnitt med Interface Builder
Åtkomst till iOS-objektbiblioteket
Anpassa objekt med attributinspektören
Förhandsgranska ditt användargränssnitt
Ansluta din UI till din källkod
Skapa en handlingsmetod
1. Ange att denna metod är en åtgärd
2. Förklara metoden
3. Definiera några parametrar
Kontrollera anslutningen
Skapa en varningsdialog
1. Förklara en konstant
2. Ställ in innehållet
3. Ställ in stilen
4. Lägg till en åtgärd
5. Visa varningen
Testa din färdiga iOS-app
Avslutar

Android är kanske ett av de mest populära operativsystemen i världen, men det är långt ifrån det enda mobila operativsystemet!

Om du vill att din mobilapplikation ska nå största möjliga målgrupp måste du rikta in sig på flera plattformar. Medan du skulle kunna välja ett verktyg för plattformsutveckling som Flutter, du kan också skapa flera kodbaser, vilket gör att du kan leverera en användarupplevelse som är designad och skräddarsydd för varje mobilplattform.

Du kanske vill släppa din senaste mobilapp på Android och iOS, kanske du funderar på att hoppa till Apple, eller kanske du bara är nyfiken på hur utvecklingen för iOS jämförs med att utveckla för Android. Oavsett din motivation, i den här artikeln visar jag dig hur du börjar utveckla för iOS genom att skapa en enkel app för iPad och iPhone.

Längs vägen kommer jag att ge en introduktion till kärnbegreppen i Apples Swift-programmeringsspråk, leda dig genom de viktigaste områdena i den Xcode integrerade utvecklingsmiljön och visa dig hur du testar dina projekt i iOS Simulator - bara för att du har inte åtagit sig att köpa en iPad eller iPhone ännu!

Här är vad du behöver veta för att börja utveckla för iOS.

Behöver jag veta Swift?

När du börjar utveckla för iOS kommer du vanligtvis att välja mellan två programmeringsspråk: Objekt-C eller Swift. Swift, som lanserades 2014, är det mer moderna språket, plus Apple verkar driva Swift över Objekt-C för iOS-utveckling, så jag kommer att använda Swift under hela denna tutorial.

Om du är en erfaren Swift-proffs, har du ett försprång. Men även om du aldrig har gjort det sett en enda rad Swift tidigare, kommer du fortfarande att kunna följa med, och i slutet av den här artikeln har du skapat en fungerande iOS-applikation, skriven helt i Swift.

När vi bygger vår iOS-app förklarar jag kärnbegreppen för detta programmeringsspråk, så du får en grundläggande översikt av Swift och kommer att förstå exakt vad som händer i varje kodrad, även om du är helt ny i Swift.

Tyvärr har du inte behärskat ett helt nytt programmeringsspråk när du kommer till botten på denna sida, men om du väljer att fortsätta iOS-utveckling rekommenderar jag att du tittar på appen Swift Playgrounds. Denna applikation innehåller övningar om att lära sig kod, presenterade som interaktiva pussel som hjälper dig att bekanta dig med de Swift-nödvändigheter du behöver för att fortsätta utforska iOS-utvecklingen.

Installera Apples Xcode IDE

För att utveckla för iPhone och iPad behöver du en Mac som kör macOS 10.11.5 eller senare. Om du är osäker på vilken version av macOS du kör just nu:

Välj "Apple" -logotypen på Mac-menyn.
Välj "Om den här Macen."
Se till att fliken "Översikt" är vald. din version av macOS ska visas i det här fönstret.

Du behöver också Xcode, som är Apples integrerade utvecklingsmiljö (IDE). Xcode har alla verktyg och funktioner som krävs för att designa, utveckla och felsöka applikationer för macOS, watchOS, tvOS - och iOS.

För att ladda ner den senaste versionen av Xcode:

Starta App Store på din Mac.
I fältet "Sök" anger du "Xcode."
När Xcode-applikationen visas väljer du "Hämta" följt av "Installera app."
Ange ditt Apple-ID och lösenord när du uppmanas. Om du inte har ett Apple-ID kan du skapa ett gratis. Xcode kommer nu att laddas ner till din Mac-mapp “Applications”.
När Xcode är klar med nedladdningen startar du den. Läs villkoren och klicka på "Godkänn." Om du gärna fortsätter.
Om Xcode uppmanar dig att ladda ner lite extra programvara, följ sedan instruktionerna på skärmen för att ladda ner dessa saknade komponenter.

Komma igång: Skapa ett nytt Xcode-projekt

I likhet med Android Studio kommer Xcode med ett antal mallar för vanliga kategorier av iOS-applikationer, till exempel flikbaserad navigering och spel. Dessa mallar inkluderar pannkodskod och filer som kan hjälpa till att starta dina iOS-projekt. I den här artikeln kommer vi att använda en av dessa färdiga mallar.

Så här skapar du ett nytt Xcode-projekt:

Starta Xcode IDE om du inte redan har gjort det.
Efter några ögonblick kommer skärmen "Välkommen till Xcode" att visas; välj "Skapa ett nytt Xcode-projekt." Om välkomstskärmen inte visas väljer du "Arkiv> Nytt> Projekt" från menyfältet Xcode.
I fönstret "Välj en mall för ditt nya projekt", se till att fliken "iOS" är vald.
Välj mallen "Enkelvy-app" och klicka sedan på "Nästa."
I "Produktnamn" anger du "HelloWorld." Xcode kommer att använda detta för att namnge ditt projekt och din applikation.
Ange eventuellt ett valfritt "Organisationsnamn."
Ange din "Organisationsidentifierare." Om du inte har en identifierare kan du använda "com.example." Observera att "Bundle Identifier" genereras automatiskt baserat på ditt produktnamn och organisationsidentifierare, så att du inte behöver oroa dig för detta.
Öppna rullgardinsmenyn "Språk" och välj "Snabb."
Hitta kryssrutan "Använd kärndata" och se till att den är det inte vald.
Markera kryssrutan "Inkludera enhetstester".
Hitta kryssrutan "Inkludera UI-test" och se till att det är det inte vald.
Klicka på "Nästa."
I den följande dialogrutan väljer du platsen där du vill spara ditt projekt och klickar sedan på "Skapa."

Xcode laddar nu ditt projekt i arbetsytans fönster.

Utvecklingsteam krävs?

Just nu kan Xcode visa följande fel "Att registrera sig för HelloWorld kräver ett utvecklingsteam."

Innan du kan köra ditt projekt på en fysisk iOS-enhet måste du ställa in ett giltigt team och underteckna din ansökan. Eftersom vi bara experimenterar med iOS behöver du inte slutföra signeringsprocessen nu, men du måste underteckna din ansökan innan den kan köras på en fysisk enhet eller komma åt vissa tjänster, till exempel Game Center eller In-App inköp.

Förstå Apples Xcode IDE

Xcodes arbetsyta är där du kommer att skriva hela appens källkod, designa och bygga ditt användargränssnitt (UI) och skapa alla ytterligare filer och resurser som så småningom kommer att samlas för att bilda din färdiga iOS-applikation.

Xcode är fullpakad med funktioner, men som en nykomling i iOS-utvecklingen finns det några områden du behöver veta om:

(1) Navigationsområde. Det här området ger snabb och enkel åtkomst till alla olika filer och resurser som utgör ditt projekt. Du kan undersöka innehållet i en fil genom att välja den i navigeringsområdet. Observera att du bara behöver göra det Välj filen i fråga; genom att dubbelklicka på en fil startar den i ett nytt, externt fönster.
(2) Editorområde. Beroende på vilken fil du väljer i navigeringsområdet kommer Xcode att visa olika gränssnitt i området Editor. Vanligtvis använder du området Editor för att skriva programmets källkod och bygga dess användargränssnitt.
Verktygsområdet. Detta område är indelat i två sektioner. Överst i verktygsområdet (3) visar inspektionsfönstret, där du kan visa information om objektet du har valt i området Navigering eller redigerare och redigera dess attribut. Längst ner i verktygsområdet (4) visas bibliotekfönstret, som ger åtkomst till vissa färdiga UI-element, kodavsnitt och andra resurser.

AppleDelegate: Undersöker Swift-källfilen

Enkeltvy-appmallen innehåller all Swift-kod och resurser som krävs för att skapa en enkel men fungerande iOS-applikation.

Du kan se alla dessa automatiskt genererade filer och resurser i navigeringsområdet (mot vänster om Xcode-arbetsområdet).

Om navigeringsområdet inte är synligt kan du koppla det ur gömningen genom att välja "Visa> Navigatorer> Visa projektnavigator" i Xcode-menyfältet.

Simple View-applikationsmallen genererar automatiskt flera filer, men låt oss börja med att undersöka "AppleDelegate.swift." Välj den här filen i navigationsområdet, och redigeringsområdet bör uppdateras för att visa filens innehåll.

importera UIKit @UIApplicationMain class AppDelegate: UIResponder, UIApplicationDelegate {var fönster: UIWindow? // I Swift förklarar du en metod med hjälp av nyckelordet "func" // func-applikation (_applikation: UIApplication, didFinishLaunchingWithOptions launchOptions:?) -> Bool {return true} // Definiera en "applikations" -parameter med typen "UIApplication" ”// func-applikationWillResignActive (_-applikation: UIApplication) {} func-applikationDidEnterBackground (_-applikation: UIApplication) {} func-applikationWillEnterForeground (_-applikation: UIApplication) {} func-applikationDidBecomeActive (_applikation: UIApplication) {} func-applikation: ) {}}

Låt oss titta närmare på vad som händer i den här filen:

1. Skapa en startpunkt

@UIApplicationMain-attributet skapar en startpunkt i din app och en körslinga, som är en händelsebehandlingsslinga som låter dig schemalägga arbete och koordinera inmatningshändelser i din applikation.

@UIApplicationMain

2. Definiera din AppDelegate

AppDelegate.swift-filen definierar en AppleDelegate-klass, som skapar fönstret där appens innehåll ritas och ger en plats att svara på tillståndsövergångar, till exempel när din app övergår till bakgrunden eller tas i förgrunden.

klass AppDelegate: UIResponder, UIApplicationDelegate {

I ovanstående kod antar vi också UIApplicationDelegate-protokollet, som definierar flera metoder som du kan använda för att konfigurera din app och hantera olika händelser på appnivå.

3. Definiera en fönsteregenskap

AppDelegate-klassen innehåller en "fönster" -egenskap som lagrar en referens till applikationsfönstret. Den här egenskapen representerar roten till din apps visningshierarki och är där allt innehåll i din app dras.

var fönster: UIWindow?

4. Blandade Stub-implementationer

AppDelegate-klassen innehåller också stubimplementeringar för flera delegatmetoder, till exempel:

func-applikationDidEnterBackground (_-applikation: UIA-ansökan) {

Dessa metoder gör det möjligt för appobjektet att kommunicera med appens delegat. Varje gång din applikation ändras, kommer appobjektet att ringa motsvarande delegatmetod, till exempel när appen övergår till bakgrunden kommer det att ringa ovanstående applikationDidEnterBackground-metod.

Var och en av dessa delegerade metoder har ett standardbeteende, men du kan definiera anpassade beteenden genom att lägga till din egen kod. Till exempel kan du vanligtvis utvidga implementeringen av applikationenDidEnterBackground-stubben genom att lägga till kod för att frigöra delade resurser. ApplicationDidEnterBackground-metoden är också där du bör lagra tillräckligt med tillståndsinformation för att återställa din applikation till dess nuvarande tillstånd, bara om din app avslutas medan den är i bakgrunden.

Förutom ApplicationDidEnterBackground innehåller AppleDelegate.swift följande metoder:

didFinishLaunchingWithOptions. Informerar delegaten att startprocessen är nästan färdig och att din ansökan är nästan redo att köras. Du bör använda den här metoden för att slutföra din apps initialisering och göra eventuella finjusteringar innan applikationens användargränssnitt presenteras för användaren.
applicationWillResignActive. Berättar för delegaten att din ansökan håller på att gå från ett aktivt till ett inaktivt tillstånd. Den här metoden kan utlösas av ett tillfälligt avbrott, till exempel ett inkommande telefonsamtal, eller när din applikation börjar övergå till ett bakgrundsläge. När din app är i inaktivt tillstånd bör den utföra minimalt arbete, så du bör använda applicationWillResignActive för att pausa pågående uppgifter och inaktivera eventuella tidtagare. Du bör också ta tillfället i akt att spara data som inte är sparade, så att den inte går förlorad om användaren väljer att avsluta din ansökan medan den är i bakgrunden.
applicationWillEnterForeground. I iOS 4.0 och senare kallas den här metoden som en del av appens övergång från bakgrunden till ett aktivt förgrundsläge. Du bör använda den här metoden för att ångra alla ändringar du gjorde när din ansökan angav bakgrunden.
applicationDidBecomeActive. Detta berättar för delegaten att din app har flyttat från ett inaktivt till ett aktivt tillstånd. Vanligtvis inträffar detta när användaren eller systemet startar din applikation, men det kan också uppstå om användaren väljer att ignorera ett avbrott som flyttade din app till ett tillfälligt inaktivt tillstånd, till exempel ett inkommande telefonsamtal eller SMS. Du bör använda metoden applicationDidBecomeActive för att starta om alla uppgifter som har pausats medan din applikation var i inaktivt tillstånd.
applicationWillTerminate. Denna metod informerar delegaten att din ansökan håller på att avsluta. Du bör använda den här metoden för att utföra nödvändig sanering, till exempel att spara användardata eller frigöra delade resurser. Tänk bara på att den här metoden har cirka fem sekunder att utföra sina uppgifter och återvända, och om den överskrider denna tidsgräns kan systemet besluta att döda processen helt.

Testa ditt projekt: Kör iOS Simulator

Eftersom vi använde mallen för en enda app har vårt projekt redan tillräckligt med kod för att kunna köras på iOS.

Du kan testa ditt iOS-projekt med hjälp av iOS Simulator som levereras förpackad med Xcode. I likhet med Android Studios emulator låter iOS Simulator dig testa hur din app ser ut och fungerar på olika enheter, inklusive enheter med olika skärmstorlekar och upplösningar.

Låt oss köra vårt projekt i iOS Simulator:

Välj "Ställ in det aktiva schemat" (där markören är placerad i följande skärmdump).

Välj den enhet du vill emulera, till exempel “iPhone 8,” “iPad Air 2” eller “iPhone X.” Simulatorn emulerar som standard iPhone 8 Plus.
Överst till vänster på Xcode-verktygsfältet väljer du knappen "Kör" (där markören är placerad i följande skärmdump).

Om det här är första gången du testar en iOS-app kommer Xcode att fråga om du vill aktivera utvecklarläge. Utvecklarläge tillåter Xcode att få åtkomst till vissa felsökningsfunktioner utan att begära ditt lösenord varje gång, så om du inte har en specifik anledning till det, kommer du vanligtvis att vill aktivera utvecklarläge.

När Xcode är klar med att bygga ditt projekt kommer iOS Simulator att starta och börja ladda din app. I likhet med Android-emulatorn kan detta ibland vara en långsam process, så du kan behöva vara tålamod (kanske använd detta som en möjlighet att ta dig en kaffe!)

När din ansökan har laddats konfronteras du med en vanlig vit skärm. Enkelvy-appmallen kan vara en fungerande iOS-applikation, men den är inte exakt en spännande applikation, så låt oss lägga till några UI-element.

Skapa ett användargränssnitt med Interface Builder

Xcodes Interface Builder tillhandahåller ett visuellt sätt för dig att designa och bygga programmets användargränssnitt, liknande hur Layout Editor fungerar i Android Studio.

Om du tittar på navigeringsområdet ser du att App-mallen för enskild vy redan har genererat en "Main.storyboard" -fil, som är en Storyboard fil. En Storyboard är en visuell representation av appens användargränssnitt, som du kan redigera i Interface Builder.

Om du vill titta på vår app Storyboard väljer du Main.storyboard-filen i navigationsområdet. Interface Builder bör öppnas automatiskt och visa appens användargränssnitt, som för närvarande består av en enda skärm.

Den här skärmen innehåller en enda vy med en pil som pekar mot vänster sida av skärmen. Denna pil representerar storyboardens startpunkt, som är den första skärmen som användaren ser när de startar din app.

Åtkomst till iOS-objektbiblioteket

Det enklaste sättet att bygga ditt användargränssnitt är att använda objekt från Xcodes Objektbibliotek. Detta bibliotek innehåller objekt som har en synlig närvaro på skärmen, till exempel bildvyer, navigeringsfält och switchar, och objekt som definierar beteende men inte har en synlig närvaro, till exempel gestigenkännare och containervyer.

Vi kommer att skapa en knapp som, när du trycker på, visar en varning. Låt oss börja med att ta en knapp från Objektbiblioteket och lägga till den i vår app:

Längst ner till höger om Xcode-arbetsområdet väljer du knappen "Visa objektbibliotek". Alternativt kan du välja "Visa> Verktyg> Visa objektbibliotek" från Xcodes meny.

Objektbiblioteket ska nu visa en lista med alla olika objekt du kan lägga till i ditt användargränssnitt. Bläddra igenom den här listan för att se vilka alternativ som finns tillgängliga.
Vi vill lägga till en knapp, så skriv "knapp" i textfältet "Filter" och välj sedan knappen när den visas i listan.
Dra knappobjektet på din duk. När du drar visas en uppsättning horisontella och vertikala guider som hjälper dig att placera knappen. När du är nöjd med placeringen släpper du musen för att lägga till knappen i ditt användargränssnitt.

Anpassa objekt med attributinspektören

Därefter måste vi lägga till lite text på knappen. Du kan anpassa objekt med Xcodes attributinspektör:

Välj "Visa> Verktyg> Visa attributinspektör" från Xcode-verktygsfältet; Attributinspektören bör nu visas till höger om Xcode-arbetsytan.

Välj knappobjektet i din duk.
I attributinspektören hittar du avsnittet "Titel" och ersätter standard "Knapp" -texten med egen text.
Tryck på "Retur" -tangenten på tangentbordet, och Interface Builder kommer att uppdatera knappen så att din nya text visas.

För närvarande kanske du vill experimentera med några av knappens andra attribut, till exempel kan du ändra knappens bakgrundsfärg eller teckensnittet som används för dess text.

Förhandsgranska ditt användargränssnitt

Även om du kan testa dina applikationer genom att köra dem på iOS Simulator, är detta inte alltid det enklaste sättet att övervaka hur din applikation utformas.

När du bygger ditt användargränssnitt kan du spara dig lite tid genom att förhandsgranska dina ändringar i Xcodes "Preview" -fönster, som är en sekundärredigerare som visas som en del av det vanliga Xcode-arbetsområdet.

Välj "Visa> Redigera> Visa assistentredigerare" från Xcodes menyfält.
Välj "Automatisk" i assistentredigerarens menyfält.

Välj "Förhandsgranska> Main.storyboard (Förhandsgranska)." Assistant Editor kommer nu att visa en förhandsgranskning av appens användargränssnitt längs det vanliga Editor-området.
Om du vill förhandsgranska appens användargränssnitt i olika riktningar bläddrar du till botten av förhandsgranskningsfönstret och väljer knappen "Rotera".

Ansluta din UI till din källkod

I iOS-utvecklingen är appkoden och ditt användargränssnitt separata, till den punkt där vi har skapat ett grundläggande användargränssnitt utan att behöva skriva en enda kodrad. Det finns emellertid en nackdel med att hålla kod och UI åtskilda: du måste uttryckligen upprätta en relation mellan din källkod och ditt användargränssnitt genom att gå in i projektets klasser UIViewController och ViewController.

UIViewController är en grundläggande byggsten av iOS-applikationer, som ansvarar för att hålla UI-element som knappar, reglage och textfält. Som standard har UIViewController en tom vy, så vi måste skapa en anpassad klass som utvidgar UIViewController, känd som en View Controller.

Om du öppnar projektets "ViewController.swift" -fil ser du att appen för singelvy-appen redan har genererat en View Controller för oss:

klass ViewController: UIViewController {

För närvarande ärver denna ViewController-klass helt enkelt allt beteende som definieras av UIViewController, men du kan utöka och anpassa detta standardbeteende genom att åsidosätta metoderna som definieras av UIViewController.Till exempel åsidosätter ViewController.swift-filen för närvarande metoden viewDidLoad (), men den verkar inte do allt annat än ring UIViewControllers version av denna metod:

åsidosätta func viewDidLoad () {super.viewDidLoad () // Gör någon ytterligare installation efter att du har laddat vyn //}

Även om det ligger utanför denna tutorials räckvidd, kan du anpassa View Controllers svar på den här händelsen genom att lägga till din egen kod till metoden viewDidLoad (), till exempel är det här du vanligtvis skulle utföra någon ytterligare installation som krävs av din app.

Bakom kulisserna skapade enkelvisnings-appmallen automatiskt en anslutning mellan klassen ViewController.swift och Main.storyboard. Under körning skapar din Storyboard en instans av ViewController och innehållet på ditt Storyboard visas på skärmen.

Detta ger oss ett försprång, men vi måste fortfarande länka de enskilda elementen i vårt Storyboard, till vår ViewController.swift-fil, så att källkoden kan kommunicera med dessa enskilda element.

Vår uppgift är att skapa en anslutning mellan vår knapp och rätt avsnitt i vår källkod, så att vår applikation visar en varning varje gång användaren trycker på knappen.

Skapa en handlingsmetod

Att trycka på en knapp är en händelse, så vi måste skapa en handlingsmetod, som är ett kodavsnitt som definierar hur din ansökan ska svara på en viss händelse.

Så här skapar du en handlingsmetod:

Kontrollera att Main.storyboard-filen är vald i navigeringsområdet.
Öppna Xcodes Assistant Editor genom att välja "Visa> Assistant Editor> Visa Assistant Editor."
Klicka på “Automatic” i Editor-väljarfältet och välj sedan “Automatic> ViewController.swift.”
Vid denna punkt bör både ViewController.swift-filen och Storyboard vara synliga på skärmen. I filen ViewController.swift, hitta följande rad och lägg till några rader med tomt utrymme under den:

klass ViewController: UIViewController {

I ditt Storyboard väljer du knappen UI-element så att det är markerat blått.
Kontrollera och dra knappen till det tomma utrymmet som du just skapade i filen ViewController.swift. En blå linje bör visas, vilket anger var åtgärdsmetoden skapas.

När du är nöjd med metodens position, släpp knappen och en popup ska visas.
Öppna rullgardinsmenyn "Anslutning" i popup-fönstret och välj "Åtgärd".
Därefter öppnar du rullgardinsmenyn "Händelse" och väljer "Peka upp inuti", som är en händelse som kommer att triggas när användaren lyfter fingret inuti knappen.
Ge denna åtgärd namnet "alertController."
Klicka på "Anslut."

Xcode skapar nu följande "alertController" -metod:

@IBAction func alertController (_ avsändare: Alla) {}

Låt oss fördela exakt vad som händer här:

1. Ange att denna metod är en åtgärd

Attributet "IBAction" visar denna metod för Interface Builder som en åtgärd, vilket gör att du kan ansluta den här metoden till dina UI-objekt:

@IBAction

2. Förklara metoden

I Swift förklarar vi en metod med hjälp av nyckelordet "func" följt av metodens namn:

func alertControlle ()

3. Definiera några parametrar

Därefter definierar vi några valfria parametrar i en uppsättning parenteser, som vår metod sedan kommer att använda som input.

Varje parameteruppsättning ska ha ett namn och en typ, åtskilda av en kolon (:).

func alertController (_ avsändare: Alla) {

Här accepterar metoden en "avsändar" -parameter, som avser objektet som var ansvarigt för att utlösa handlingen, dvs vår knapp. Vi säger också att denna parameter kan vara av typen "Vilken som helst."

Varje gång användaren trycker på knappen kommer vår app att anropa metoden alertController (_ avsändare).

Kontrollera anslutningen

Efter att ha skapat vår "alertController" -metod kan vi kontrollera att den är korrekt ansluten till knappen:

I navigeringsområdet väljer du filen "Main.storyboard".
I Xcodes menyfält väljer du "Visa> Verktyg> Visa anslutningsinspektör." Anslutningsinspektören bör nu öppnas längs höger sida av Xcode-arbetsytan.
Välj din knapp i Editor-området.

Anslutningsinspektören bör nu visa lite information om den här knappen, inklusive ett avsnitt "Skickade händelser", som innehåller en lista över tillgängliga händelser och motsvarande metod som kommer att anropas när varje händelse inträffar.

Vi kan se att "Touch Up Inside" -händelsen är ansluten till vår "alertController" -metod, så vi vet att varje gång användaren interagerar med den här knappen kommer "alertController" -metoden att kallas.

Det finns emellertid ett problem: vi har inte definierat vad som ska hända när "alertController" -metoden kallas!

Skapa en varningsdialog

I iOS kan du skapa en varning med UIAlertController, vilket ungefär motsvarar Android: s AlertDialog.

Öppna filen ViewController.swift och lägg till följande:

klass ViewController: UIViewController {@IBAction func showAlert (_ avsändare: Alla) {let alertController = UIAlertController (titel: "Titel",: "Hej, världen!", föredragStyle: .alert) alertController.addAction (UIAlertAction (titel: "Avbryt) ", style: .default)) self.present (alertController, animerad: true, slutförande: noll)}

Låt oss se närmare på vad som händer här:

1. Förklara en konstant

I Swift förklarar du konstanter med nyckelordet "låt", så vi börjar med att förklara en konstant som kallas alertController:

låt alarmController

2. Ställ in innehållet

Vi kan nu definiera varningens titel och:

let alertController = UIAlertController (titel: "Titel",: "Hej, världen!")

3. Ställ in stilen

Eftersom detta är en varning använder jag stilen "Alert":

let alertController = UIAlertController (titel: "Titel",: "Hej, världen!", prefererstyle: .alert)

4. Lägg till en åtgärd

Därefter lägger vi till en åtgärdsknapp med metoden addAction ():

alertController.addAction (UIAlertAction (titel: "Cancel", stil: .default))

5. Visa varningen

När vi har konfigurerat vårt UIAlertController-objekt är vi redo att visa det för användaren. I följande avsnitt ber vi ViewController att presentera alertController-objektet med en animering:

self.present (alertController, animerad: true, slutförande: noll)}

Testa din färdiga iOS-app

Nu är det dags att testa vårt projekt:

Välj "Kör" -knappen i Xcodes verktygsfält.
När din ansökan visas i iOS-simulatorn, ge dess knapp ett klick - din varning ska nu visas på skärmen!

Avslutar

I denna handledning fick vi lite praktisk erfarenhet av att utveckla för iOS. Vi skapade en enkel applikation, bestående av en knapp och en varning, samtidigt som vi bekanta oss med Xcode IDE och Swift-programmeringsspråket.

Har du några planer på att börja utveckla appar för iPhone och iPad? Eller föredrar du verktyg för plattformsutveckling som Flutter? Låt oss veta i kommentarerna nedan!